From 01b92d759072b3375e2d4500a8d1dac8d699f369 Mon Sep 17 00:00:00 2001 From: Andrew Moore Date: Thu, 12 Jul 2018 15:37:13 -0300 Subject: [PATCH 01/15] Updating version for esdoc. --- package-lock.json | 398 ++++++++++++++++++++++++---------------------- package.json | 2 +- 2 files changed, 212 insertions(+), 188 deletions(-) diff --git a/package-lock.json b/package-lock.json index b301f25..02e8704 100644 --- a/package-lock.json +++ b/package-lock.json @@ -4,6 +4,12 @@ "lockfileVersion": 1, "requires": true, "dependencies": { + "@types/node": { + "version": "10.5.2", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.5.2.tgz", + "integrity": "sha512-m9zXmifkZsMHZBOyxZWilMwmTlpC8x5Ty360JKTiXvlXZfBWYpsg9ZZvP/Ye+iZUh+Q+MxDLjItVTWIsfwz+8Q==", + "dev": true + }, "JSONStream": { "version": "1.3.3", "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.3.tgz", @@ -14,6 +20,10 @@ "through": ">=2.2.7 <3" } }, + "ReconnectingWebSocket": { + "version": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", + "from": "git+https://github.com/svk31/reconnecting-websocket.git" + }, "abab": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/abab/-/abab-1.0.4.tgz", @@ -79,13 +89,6 @@ "json-schema-traverse": "^0.3.0" } }, - "amdefine": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", - "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=", - "dev": true, - "optional": true - }, "ansi-regex": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", @@ -1190,17 +1193,17 @@ } }, "cheerio": { - "version": "0.20.0", - "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.20.0.tgz", - "integrity": "sha1-XHEPK6uVZTJyhCugHG6mGzVF7DU=", + "version": "1.0.0-rc.2", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.2.tgz", + "integrity": "sha1-S59TqBsn5NXawxwP/Qz6A8xoMNs=", "dev": true, "requires": { "css-select": "~1.2.0", "dom-serializer": "~0.1.0", "entities": "~1.1.1", - "htmlparser2": "~3.8.1", - "jsdom": "^7.0.2", - "lodash": "^4.1.0" + "htmlparser2": "^3.9.1", + "lodash": "^4.15.0", + "parse5": "^3.0.1" } }, "chokidar": { @@ -1238,9 +1241,9 @@ "optional": true }, "color-logger": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/color-logger/-/color-logger-0.0.3.tgz", - "integrity": "sha1-2bIt0dlz4Waxi/MT+fSBu6TfIBg=", + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/color-logger/-/color-logger-0.0.6.tgz", + "integrity": "sha1-5WJF7ymCJlcRDHy3WpzXhstp7Rs=", "dev": true }, "combine-source-map": { @@ -1491,7 +1494,8 @@ "version": "0.1.3", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", - "dev": true + "dev": true, + "optional": true }, "defined": { "version": "1.0.0", @@ -1594,9 +1598,9 @@ "dev": true }, "domhandler": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.3.0.tgz", - "integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=", + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.4.2.tgz", + "integrity": "sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==", "dev": true, "requires": { "domelementtype": "1" @@ -1691,9 +1695,9 @@ } }, "escape-html": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.2.tgz", - "integrity": "sha1-130y+pjjjC9BroXpJ44ODmuhAiw=", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=", "dev": true }, "escape-string-regexp": { @@ -1703,87 +1707,68 @@ "dev": true }, "escodegen": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.7.0.tgz", - "integrity": "sha1-TimdjMMwh7fynBniuehDYqvjVFM=", + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.10.0.tgz", + "integrity": "sha512-fjUOf8johsv23WuIKdNQU4P9t9jhQ4Qzx6pC2uW890OloK3Zs1ZAoCNpg/2larNF501jLl3UNy0kIRcF6VI22g==", "dev": true, + "optional": true, "requires": { - "esprima": "^1.2.2", - "estraverse": "^1.9.1", + "esprima": "^3.1.3", + "estraverse": "^4.2.0", "esutils": "^2.0.2", - "optionator": "^0.5.0", - "source-map": "~0.2.0" + "optionator": "^0.8.1", + "source-map": "~0.6.1" }, "dependencies": { - "esprima": { - "version": "1.2.5", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.2.5.tgz", - "integrity": "sha1-CZNQL+r2aBODJXVvMPmlH+7sEek=", - "dev": true - }, - "estraverse": { - "version": "1.9.3", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz", - "integrity": "sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=", - "dev": true - }, "source-map": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz", - "integrity": "sha1-2rc/vPwrqBm03gO9b26qSBZLP50=", + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", "dev": true, - "optional": true, - "requires": { - "amdefine": ">=0.0.4" - } + "optional": true } } }, "esdoc": { - "version": "0.4.8", - "resolved": "https://registry.npmjs.org/esdoc/-/esdoc-0.4.8.tgz", - "integrity": "sha1-SXLitt6F4rkpozDtVLjF8/3OvTM=", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/esdoc/-/esdoc-1.1.0.tgz", + "integrity": "sha512-vsUcp52XJkOWg9m1vDYplGZN2iDzvmjDL5M/Mp8qkoDG3p2s0yIQCIjKR5wfPBaM3eV14a6zhQNYiNTCVzPnxA==", "dev": true, "requires": { - "cheerio": "0.20.0", - "color-logger": "0.0.3", - "core-js": "0.9.18", - "escape-html": "1.0.2", - "escodegen": "1.7.0", - "espree": "2.2.0", - "estraverse": "4.1.0", - "fs-extra": "0.26.5", + "babel-generator": "6.26.1", + "babel-traverse": "6.26.0", + "babylon": "6.18.0", + "cheerio": "1.0.0-rc.2", + "color-logger": "0.0.6", + "escape-html": "1.0.3", + "fs-extra": "5.0.0", "ice-cap": "0.0.4", - "marked": "0.3.5", - "minimist": "1.1.1", - "taffydb": "2.7.2" + "marked": "0.3.19", + "minimist": "1.2.0", + "taffydb": "2.7.3" }, "dependencies": { - "core-js": { - "version": "0.9.18", - "resolved": "https://registry.npmjs.org/core-js/-/core-js-0.9.18.tgz", - "integrity": "sha1-E/RY5DAjKw9OwfSA2nwvUojp0JU=", - "dev": true - }, "minimist": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.1.1.tgz", - "integrity": "sha1-G8K8cWWM3KVxJHVoQ2NhWwtPaVs=", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", "dev": true } } }, - "espree": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/espree/-/espree-2.2.0.tgz", - "integrity": "sha1-AdySen6lCB0ae21hAknmJOf+89Y=", - "dev": true + "esprima": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", + "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=", + "dev": true, + "optional": true }, "estraverse": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.1.0.tgz", - "integrity": "sha1-QPI6dgkgQb5kZ9fyNckztnB2bgU=", - "dev": true + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", + "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=", + "dev": true, + "optional": true }, "esutils": { "version": "2.0.2", @@ -1874,10 +1859,11 @@ "optional": true }, "fast-levenshtein": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.0.7.tgz", - "integrity": "sha1-AXjc3uAjuSkFGTrwlZ6KdjnP3Lk=", - "dev": true + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "dev": true, + "optional": true }, "filename-regex": { "version": "2.0.1", @@ -1937,16 +1923,14 @@ } }, "fs-extra": { - "version": "0.26.5", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.26.5.tgz", - "integrity": "sha1-U6x0Znygg/0twXEsgTA5yjLWmn8=", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-5.0.0.tgz", + "integrity": "sha512-66Pm4RYbjzdyeuqudYqhFiNBbCIuI9kgRqLPSHIlXHidW8NIQtVdkM1yeZ4lXwuhbTETv3EUGMNHAAw6hiundQ==", "dev": true, "requires": { "graceful-fs": "^4.1.2", - "jsonfile": "^2.1.0", - "klaw": "^1.0.0", - "path-is-absolute": "^1.0.0", - "rimraf": "^2.2.8" + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" } }, "fs-readdir-recursive": { @@ -2647,48 +2631,17 @@ "dev": true }, "htmlparser2": { - "version": "3.8.3", - "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.8.3.tgz", - "integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=", + "version": "3.9.2", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.9.2.tgz", + "integrity": "sha1-G9+HrMoPP55T+k/M6w9LTLsAszg=", "dev": true, "requires": { - "domelementtype": "1", - "domhandler": "2.3", - "domutils": "1.5", - "entities": "1.0", - "readable-stream": "1.1" - }, - "dependencies": { - "entities": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-1.0.0.tgz", - "integrity": "sha1-sph6o4ITR/zeZCsk/fyeT7cSvyY=", - "dev": true - }, - "isarray": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", - "dev": true - }, - "readable-stream": { - "version": "1.1.14", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", - "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", - "dev": true, - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.1", - "isarray": "0.0.1", - "string_decoder": "~0.10.x" - } - }, - "string_decoder": { - "version": "0.10.31", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", - "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", - "dev": true - } + "domelementtype": "^1.3.0", + "domhandler": "^2.3.0", + "domutils": "^1.5.1", + "entities": "^1.1.1", + "inherits": "^2.0.1", + "readable-stream": "^2.0.2" } }, "http-signature": { @@ -2717,6 +2670,82 @@ "requires": { "cheerio": "0.20.0", "color-logger": "0.0.3" + }, + "dependencies": { + "cheerio": { + "version": "0.20.0", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.20.0.tgz", + "integrity": "sha1-XHEPK6uVZTJyhCugHG6mGzVF7DU=", + "dev": true, + "requires": { + "css-select": "~1.2.0", + "dom-serializer": "~0.1.0", + "entities": "~1.1.1", + "htmlparser2": "~3.8.1", + "jsdom": "^7.0.2", + "lodash": "^4.1.0" + } + }, + "color-logger": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/color-logger/-/color-logger-0.0.3.tgz", + "integrity": "sha1-2bIt0dlz4Waxi/MT+fSBu6TfIBg=", + "dev": true + }, + "domhandler": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.3.0.tgz", + "integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=", + "dev": true, + "requires": { + "domelementtype": "1" + } + }, + "htmlparser2": { + "version": "3.8.3", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.8.3.tgz", + "integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=", + "dev": true, + "requires": { + "domelementtype": "1", + "domhandler": "2.3", + "domutils": "1.5", + "entities": "1.0", + "readable-stream": "1.1" + }, + "dependencies": { + "entities": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-1.0.0.tgz", + "integrity": "sha1-sph6o4ITR/zeZCsk/fyeT7cSvyY=", + "dev": true + } + } + }, + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "dev": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + } } }, "ieee754": { @@ -2986,6 +3015,13 @@ "integrity": "sha1-q259nYhqrKiwhbwzEreaGYQz8Oc=", "dev": true, "optional": true + }, + "parse5": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-1.5.1.tgz", + "integrity": "sha1-m387DeMr543CQBsXVzzK8Pb1nZQ=", + "dev": true, + "optional": true } } }, @@ -3032,9 +3068,9 @@ "dev": true }, "jsonfile": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", - "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=", "dev": true, "requires": { "graceful-fs": "^4.1.6" @@ -3074,15 +3110,6 @@ "is-buffer": "^1.1.5" } }, - "klaw": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", - "integrity": "sha1-QIhDO0azsbolnXh4XY6W9zugJDk=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.9" - } - }, "labeled-stream-splicer": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.1.tgz", @@ -3103,13 +3130,14 @@ } }, "levn": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.2.5.tgz", - "integrity": "sha1-uo0znQykphDjo/FFucr0iAcVUFQ=", + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", "dev": true, + "optional": true, "requires": { - "prelude-ls": "~1.1.0", - "type-check": "~0.3.1" + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" } }, "lodash": { @@ -3157,9 +3185,9 @@ "dev": true }, "marked": { - "version": "0.3.5", - "resolved": "https://registry.npmjs.org/marked/-/marked-0.3.5.tgz", - "integrity": "sha1-QROhWsXXvKFYpargciRYe5+hW5Q=", + "version": "0.3.19", + "resolved": "https://registry.npmjs.org/marked/-/marked-0.3.19.tgz", + "integrity": "sha512-ea2eGWOqNxPcXv8dyERdSr/6FmzvWwzjMxpfGB/sbMccXoct+xY+YukPD+QTUZwyvK7BZwcr4m21WBOW41pAkg==", "dev": true }, "math-random": { @@ -3440,17 +3468,18 @@ } }, "optionator": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.5.0.tgz", - "integrity": "sha1-t1qJlaLUF98ltuTjhi9QqohlE2g=", + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", "dev": true, + "optional": true, "requires": { - "deep-is": "~0.1.2", - "fast-levenshtein": "~1.0.0", - "levn": "~0.2.5", - "prelude-ls": "~1.1.1", - "type-check": "~0.3.1", - "wordwrap": "~0.0.2" + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.4", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "wordwrap": "~1.0.0" } }, "options": { @@ -3529,11 +3558,13 @@ } }, "parse5": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-1.5.1.tgz", - "integrity": "sha1-m387DeMr543CQBsXVzzK8Pb1nZQ=", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-3.0.3.tgz", + "integrity": "sha512-rgO9Zg5LLLkfJF9E6CCmXlSE4UVceloys8JrFqCcHloC3usd/kJCyPDwH2SOlzix2j3xaP9sUX3e8+kvkuleAA==", "dev": true, - "optional": true + "requires": { + "@types/node": "*" + } }, "path-browserify": { "version": "0.0.1", @@ -3577,13 +3608,8 @@ "resolved": "https://registry.npmjs.org/peerplaysjs-ws/-/peerplaysjs-ws-0.1.11.tgz", "integrity": "sha1-6q6x5yXurfWcpgJ8Zx8yDXAlG+8=", "requires": { + "ReconnectingWebSocket": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", "ws": "^1.1.4" - }, - "dependencies": { - "ReconnectingWebSocket": { - "version": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", - "from": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148" - } } }, "performance-now": { @@ -3898,15 +3924,6 @@ "path-parse": "^1.0.5" } }, - "rimraf": { - "version": "2.6.2", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", - "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", - "dev": true, - "requires": { - "glob": "^7.0.5" - } - }, "ripemd160": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", @@ -4130,9 +4147,9 @@ } }, "taffydb": { - "version": "2.7.2", - "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.7.2.tgz", - "integrity": "sha1-e/gQalwaSCUbPjvAoOFzJIn9Dcg=", + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.7.3.tgz", + "integrity": "sha1-KtNxaWKUmPylvIQkMJbTzeDsOjQ=", "dev": true }, "through": { @@ -4269,6 +4286,12 @@ "xtend": "^4.0.1" } }, + "universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true + }, "url": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", @@ -4371,10 +4394,11 @@ } }, "wordwrap": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", - "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=", - "dev": true + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", + "dev": true, + "optional": true }, "wrappy": { "version": "1.0.2", diff --git a/package.json b/package.json index 689ed0c..e89293c 100644 --- a/package.json +++ b/package.json @@ -64,7 +64,7 @@ "babel-preset-es2015": "^6.24.1", "babel-preset-es2015-generators-async": "^6.3.13", "browserify": "^13.1.0", - "esdoc": "^0.4.3", + "esdoc": "^1.1.0", "mocha": "^2.5.3", "uglifyjs": "^2.4.10" } From 6248ea80e6f13327f99b138cbed4a67b7f5d34ef Mon Sep 17 00:00:00 2001 From: Andrew Moore Date: Thu, 12 Jul 2018 15:38:21 -0300 Subject: [PATCH 02/15] Fixing typo, sorry jcalfee! --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8939118..014fb81 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Pure JavaScript Bitshares/Graphene library for node.js and browsers. Can be used to construct, sign and broadcast transactions in JavaScript, and to easily obtain data from the blockchain via public apis. -Most of this code was written by [jcalfeee](https://github.com/jcalfee), my work was mostly just repackaging to a discrete npm package. +Most of this code was written by [jcalfee](https://github.com/jcalfee), my work was mostly just repackaging to a discrete npm package. ## Setup From a6f93ba3204f3369ad1735844a37376583ae94b4 Mon Sep 17 00:00:00 2001 From: Andrew Moore Date: Thu, 12 Jul 2018 15:41:47 -0300 Subject: [PATCH 03/15] 0.4.20 --- package-lock.json | 2 +- package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/package-lock.json b/package-lock.json index 02e8704..24fe245 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "peerplaysjs-lib", - "version": "0.4.19", + "version": "0.4.20", "lockfileVersion": 1, "requires": true, "dependencies": { diff --git a/package.json b/package.json index e89293c..9b521be 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "peerplaysjs-lib", - "version": "0.4.19", + "version": "0.4.20", "description": "Pure JavaScript Peerplays/Graphene library for node.js and browsers.", "browser": { "ws": false, From 5b560e33f8c6d694459e76afa4b7042f0520e617 Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 14:40:04 -0400 Subject: [PATCH 04/15] Use last known version of ppjs-lib and add function. --- lib/chain/src/ChainStore.js | 28 +++++++++++++++++++++++++++- package-lock.json | 23 ++++++++++++----------- 2 files changed, 39 insertions(+), 12 deletions(-) diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index 9dc0d16..180b156 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -735,7 +735,33 @@ class ChainStore { } return null } - + + /** + * + * @returns a promise with a list of all witness ids. Regardless of if they have been voted in or not. + * @memberof ChainStore + */ + fetchWitnessAccounts() { + var _this24 = this; + return new Promise((resolve, reject) => { + Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then(function (w) { + if (w) { + let witnessArr = []; + + for (let i = 0, length = w.length; i < length; i++) { + witnessArr.push(w[i][1]); // ids only + } + + _this24.witnesses = _this24.witnesses.merge(witnessArr); + _this24._updateObject(witnessArr, true); + resolve(_this24.witnesses); + } else { + resolve(null); + } + }); + }); + } + /** * * @return a promise with the witness object diff --git a/package-lock.json b/package-lock.json index 24fe245..38f6962 100644 --- a/package-lock.json +++ b/package-lock.json @@ -20,10 +20,6 @@ "through": ">=2.2.7 <3" } }, - "ReconnectingWebSocket": { - "version": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", - "from": "git+https://github.com/svk31/reconnecting-websocket.git" - }, "abab": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/abab/-/abab-1.0.4.tgz", @@ -880,7 +876,7 @@ }, "base-x": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/base-x/-/base-x-1.1.0.tgz", + "resolved": "http://registry.npmjs.org/base-x/-/base-x-1.1.0.tgz", "integrity": "sha1-QtPXF0dPnqAiB/bRqh9CaRPut6w=" }, "base64-js": { @@ -1371,7 +1367,7 @@ }, "create-hash": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "resolved": "http://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", "requires": { "cipher-base": "^1.0.1", @@ -1383,7 +1379,7 @@ }, "create-hmac": { "version": "1.1.7", - "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "resolved": "http://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", "requires": { "cipher-base": "^1.0.3", @@ -1454,7 +1450,7 @@ }, "d": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz", + "resolved": "http://registry.npmjs.org/d/-/d-1.0.0.tgz", "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", "requires": { "es5-ext": "^0.10.9" @@ -3400,7 +3396,7 @@ }, "next-tick": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz", + "resolved": "http://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz", "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=" }, "normalize-path": { @@ -3608,8 +3604,13 @@ "resolved": "https://registry.npmjs.org/peerplaysjs-ws/-/peerplaysjs-ws-0.1.11.tgz", "integrity": "sha1-6q6x5yXurfWcpgJ8Zx8yDXAlG+8=", "requires": { - "ReconnectingWebSocket": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", "ws": "^1.1.4" + }, + "dependencies": { + "ReconnectingWebSocket": { + "version": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", + "from": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148" + } } }, "performance-now": { @@ -3966,7 +3967,7 @@ }, "sha.js": { "version": "2.4.11", - "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "resolved": "http://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", "requires": { "inherits": "^2.0.1", From 702d4c051b1759ff313908e35d17949c2799d21d Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 14:54:21 -0400 Subject: [PATCH 05/15] Uodate scripts --- package.json | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/package.json b/package.json index 9b521be..8f1dc30 100644 --- a/package.json +++ b/package.json @@ -7,20 +7,23 @@ "crypto": false }, "scripts": { - "test": "mocha --compilers js:babel-core/register --recursive", - "test:chain": "mocha --compilers js:babel-core/register ./test/chain --recursive", - "test:ecc": "mocha --compilers js:babel-core/register ./test/ecc --recursive", - "test:serializer": "mocha --compilers js:babel-core/register ./test/serializer --recursive", - "test:watch": "npm test -- --watch", - "clean": "rm -rf ./dist/* & rm -rf ./build/*", - "prebuild": "npm run clean", - "build": "babel lib --presets es2015-generators-async --plugins transform-async-to-generator --out-dir dist", - "build:watch": "babel lib --presets es2015-generators-async --out-dir dist --watch", - "prebrowserify": "rm -rf ./build/*", - "browserify": "browserify --full-paths dist/browser.js --standalone steemJS -o build/peerplaysjs-lib.js -d", - "postbrowserify": "uglifyjs --compress --mangle --sequences --drop_console --output build/peerplaysjs-lib.min.js -- build/peerplaysjs-lib.js", - "prepublish": "npm run build", - "doc": "esdoc -c esdoc.json" + "test": "BABEL_ENV=test mocha --compilers js:babel-register --recursive", + "test:chain": "BABEL_ENV=test mocha --compilers js:babel-register ./test/chain --recursive", + "test:ecc": "BABEL_ENV=test mocha --compilers js:babel-register ./test/ecc --recursive", + "test:serializer": "BABEL_ENV=test mocha --compilers js:babel-register ./test/serializer --recursive", + "test:watch": "npm test -- --watch", + "clean": "rm -rf ./dist/* & rm -rf ./build/*", + "prebuild": "npm run clean", + "build": "babel lib -d dist", + "postbuild": "npm run browserify", + "build:watch": "babel lib -d dist --watch", + "prebrowserify": "rm -rf ./build/*", + "browserify": "browserify -t [browserify-package-json --global=true] -p [bundle-collapser/plugin] dist/browser.js --full-path=false --standalone peerplays_js -o build/peerplaysjs-lib.js -d", + "postbrowserify": "uglifyjs --compress --mangle --sequences --drop_console --output build/peerplaysjs-lib.min.js -- build/peerplaysjs-lib.js", + "doc": "esdoc -c esdoc.json", + "example:transfer": "babel-node examples/transfer", + "example:chainStore": "babel-node examples/chainStore", + "example:privKey": "babel-node examples/privKey" }, "repository": { "type": "git", From 6dd1c9d3b9bbbcf0385844d18cf3c0bbc7955592 Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 15:18:10 -0400 Subject: [PATCH 06/15] Modify scripts --- build/peerplaysjs-lib.js | 26144 +++++++++++++++++++++++++++++++++ build/peerplaysjs-lib.min.js | 1 + package-lock.json | 2052 ++- package.json | 154 +- 4 files changed, 28062 insertions(+), 289 deletions(-) create mode 100644 build/peerplaysjs-lib.js create mode 100644 build/peerplaysjs-lib.min.js diff --git a/build/peerplaysjs-lib.js b/build/peerplaysjs-lib.js new file mode 100644 index 0000000..d42ed5e --- /dev/null +++ b/build/peerplaysjs-lib.js @@ -0,0 +1,26144 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.peerplays_js = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i} [signer_pubkeys = null] - Optional ["GPHAbc9Def0...", ...]. These are + additional signing keys. Some balance claims require propritary address formats, the + witness node can't tell us which ones are needed so they must be passed in. If the + witness node can figure out a signing key (mostly all other transactions), it should + not be passed in here. + @arg {boolean} [broadcast = false] + */ + + + TransactionBuilder.prototype.process_transaction = function process_transaction(cwallet) { + var _this = this; + + var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var wallet_object = cwallet.wallet.wallet_object; + + + if (_peerplaysjsWs.Apis.instance().chain_id !== wallet_object.get('chain_id')) { + var wallet_chain_id = wallet_object.get('chain_id'); + var api_chain_id = _peerplaysjsWs.Apis.instance().chain_id; + + var error = new Error('Mismatched chain_id; expecting ' + wallet_chain_id + ', but got ' + api_chain_id); + + return Promise.reject(error); + } + + return this.set_required_fees().then(function () { + var signer_pubkeys_added = {}; + + if (signer_pubkeys) { + // Balance claims are by address, only the private + // key holder can know about these additional + // potential keys. + var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys); + + if (!pubkeys.length) { + throw new Error('Missing signing key'); + } + + var keys = Object.keys(pubkeys); + + for (var i = 0, len = keys.length; i < len; i++) { + var pubkey_string = pubkeys[i]; + var private_key = cwallet.getPrivateKey(pubkey_string); + _this.add_signer(private_key, pubkey_string); + signer_pubkeys_added[pubkey_string] = true; + } + } + + return _this.get_potential_signatures().then(function (_ref) { + var pubkeys = _ref.pubkeys, + addys = _ref.addys; + + var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys); + + return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) { + var keys = Object.keys(required_pubkeys); + + for (var _i = 0, _len = keys.length; _i < _len; _i++) { + var _pubkey_string = keys[_i]; + + if (!signer_pubkeys_added[_pubkey_string]) { + var _private_key = cwallet.getPrivateKey(_pubkey_string); + + // This should not happen, get_required_signatures will only + // returned keys from my_pubkeys + if (!_private_key) { + throw new Error('Missing signing key for ' + _pubkey_string); + } + + _this.add_signer(_private_key, _pubkey_string); + } + } + }); + }).then(function () { + return broadcast ? _this.broadcast() : _this.serialize(); + }); + }); + }; + + /** Typically this is called automatically just prior to signing. + * Once finalized this transaction can not be changed. */ + + + TransactionBuilder.prototype.finalize = function finalize() { + var _this2 = this; + + return new Promise(function (resolve) { + if (_this2.tr_buffer) { + throw new Error('already finalized'); + } + + resolve(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.1.0']]).then(function (r) { + _this2.head_block_time_string = r[0].time; + + if (_this2.expiration === 0) { + _this2.expiration = _this2.base_expiration_sec() + _peerplaysjsWs.ChainConfig.expire_in_secs; + } + + _this2.ref_block_num = r[0].head_block_number & 0xffff; // eslint-disable-line + _this2.ref_block_prefix = Buffer.from(r[0].head_block_id, 'hex').readUInt32LE(4); + // DEBUG console.log("ref_block",@ref_block_num,@ref_block_prefix,r) + + var iterable = _this2.operations; + + for (var i = 0, len = iterable.length; i < len; i++) { + var op = iterable[i]; + + if (op[1].finalize) { + op[1].finalize(); + } + + var _type = _serializer.ops.operation.st_operations[op[0]]; + var hexBuffer = _type.toBuffer(op[1]).toString('hex'); + console.log('Operation %s: %O => %s (%d bytes)', _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2); + } + + _this2.tr_buffer = _serializer.ops.transaction.toBuffer(_this2); + })); + }); + }; + + /** @return {string} hex transaction ID */ + + + TransactionBuilder.prototype.id = function id() { + if (!this.tr_buffer) { + throw new Error('not finalized'); + } + + return _ecc.hash.sha256(this.tr_buffer).toString('hex').substring(0, 40); + }; + + /** + Typically one will use {@link this.add_type_operation} instead. + @arg {array} operation - [operation_id, operation] + */ + + + TransactionBuilder.prototype.add_operation = function add_operation(operation) { + if (this.tr_buffer) { + throw new Error('already finalized'); + } + + (0, _assert2.default)(operation, 'operation'); + + if (!Array.isArray(operation)) { + throw new Error('Expecting array [operation_id, operation]'); + } + + this.operations.push(operation); + }; + + TransactionBuilder.prototype.get_type_operation = function get_type_operation(name, operation) { + if (this.tr_buffer) { + throw new Error('already finalized'); + } + + (0, _assert2.default)(name, 'name'); + (0, _assert2.default)(operation, 'operation'); + var _type = _serializer.ops[name]; + (0, _assert2.default)(_type, 'Unknown operation ' + name); + var operation_id = _ChainTypes2.default.operations[_type.operation_name]; + + if (operation_id === undefined) { + throw new Error('unknown operation: ' + _type.operation_name); + } + + if (!operation.fee) { + operation.fee = { amount: 0, asset_id: 0 }; + } + + if (name === 'proposal_create') { + /* + * Proposals involving the committee account require a review + * period to be set, look for them here + */ + var requiresReview = false; + var extraReview = 0; + + operation.proposed_ops.forEach(function (op) { + var COMMITTE_ACCOUNT = 0; + var key = void 0; + + switch (op.op[0]) { + case 0: + // transfer + key = 'from'; + break; + + case 6: // account_update + case 17: + // asset_settle + key = 'account'; + break; + + case 10: // asset_create + case 11: // asset_update + case 12: // asset_update_bitasset + case 13: // asset_update_feed_producers + case 14: // asset_issue + case 18: // asset_global_settle + case 43: + // asset_claim_fees + key = 'issuer'; + break; + + case 15: + // asset_reserve + key = 'payer'; + break; + + case 16: + // asset_fund_fee_pool + key = 'from_account'; + break; + + case 22: // proposal_create + case 23: // proposal_update + case 24: + // proposal_delete + key = 'fee_paying_account'; + break; + + case 31: + // committee_member_update_global_parameters + requiresReview = true; + extraReview = 60 * 60 * 24 * 13; // Make the review period 2 weeks total + break; + default: + break; + } + + if (key in op.op[1] && op.op[1][key] === COMMITTE_ACCOUNT) { + requiresReview = true; + } + }); + + if (!operation.expiration_time) { + var experationTime = this.base_expiration_sec(); + operation.expiration_time = experationTime + _peerplaysjsWs.ChainConfig.expire_in_secs_proposal; + } + + if (requiresReview) { + var one_day = 24 * 60 * 60; // One day in seconds + var max = Math.max(this.commitee_min_review, one_day, _peerplaysjsWs.ChainConfig.review_in_secs_committee); + + operation.review_period_seconds = extraReview + max; + /* + * Expiration time must be at least equal to + * now + review_period_seconds, so we add one hour to make sure + */ + operation.expiration_time += 60 * 60 + extraReview; + } + } + + var operation_instance = _type.fromObject(operation); + return [operation_id, operation_instance]; + }; + + /* optional: fetch the current head block */ + + TransactionBuilder.prototype.update_head_block = function update_head_block() { + var _this3 = this; + + return _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.0.0', '2.1.0']]).then(function (res) { + var g = res[0], + r = res[1]; + + _this3.head_block_time_string = r[0].time; + _this3.committee_min_review = g[0].parameters.committee_proposal_review_period; + }); + }; + + /** optional: there is a deafult expiration */ + + + TransactionBuilder.prototype.set_expire_seconds = function set_expire_seconds(sec) { + if (this.tr_buffer) { + throw new Error('already finalized'); + } + + this.expiration = this.base_expiration_sec() + sec; + + return this.expiration; + }; + + /* Wraps this transaction in a proposal_create transaction */ + + + TransactionBuilder.prototype.propose = function propose(proposal_create_options) { + if (this.tr_buffer) { + throw new Error('already finalized'); + } + + if (!this.operations.length) { + throw new Error('add operation first'); + } + + (0, _assert2.default)(proposal_create_options, 'proposal_create_options'); + (0, _assert2.default)(proposal_create_options.fee_paying_account, 'proposal_create_options.fee_paying_account'); + + var proposed_ops = this.operations.map(function (op) { + return { op: op }; + }); + + this.operations = []; + this.signatures = []; + this.signer_private_keys = []; + proposal_create_options.proposed_ops = proposed_ops; + this.add_type_operation('proposal_create', proposal_create_options); + return this; + }; + + TransactionBuilder.prototype.has_proposed_operation = function has_proposed_operation() { + var hasProposed = false; + + for (var i = 0; i < this.operations.length; i++) { + if ('proposed_ops' in this.operations[i][1]) { + hasProposed = true; + break; + } + } + + return hasProposed; + }; + + /** optional: the fees can be obtained from the witness node */ + + + TransactionBuilder.prototype.set_required_fees = function set_required_fees(asset_id) { + var _this4 = this; + + var fee_pool = void 0; + + if (this.tr_buffer) { + throw new Error('already finalized'); + } + + if (!this.operations.length) { + throw new Error('add operations first'); + } + + var operations = []; + + for (var i = 0, len = this.operations.length; i < len; i++) { + var op = this.operations[i]; + operations.push(_serializer.ops.operation.toObject(op)); + } + + if (!asset_id) { + var op1_fee = operations[0][1].fee; + + if (op1_fee && op1_fee.asset_id !== null) { + asset_id = op1_fee.asset_id; + } else { + asset_id = '1.3.0'; + } + } + + var promises = [_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, asset_id])]; + + if (asset_id !== '1.3.0') { + // This handles the fallback to paying fees in BTS if the fee pool is empty. + promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, '1.3.0'])); + promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset_id]])); + } + + return Promise.all(promises).then(function (results) { + var fees = results[0], + coreFees = results[1], + asset = results[2]; + + asset = asset ? asset[0] : null; + + var dynamicPromise = asset_id !== '1.3.0' && asset ? _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve) { + resolve(); + }); + + return dynamicPromise.then(function (dynamicObject) { + if (asset_id !== '1.3.0') { + fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0; + var totalFees = 0; + + for (var j = 0, fee; j < coreFees.length; j++) { + fee = coreFees[j]; + totalFees += fee.amount; + } + + if (totalFees > parseInt(fee_pool, 10)) { + fees = coreFees; + asset_id = '1.3.0'; + } + } + + // Proposed transactions need to be flattened + var flat_assets = []; + + var flatten = function flatten(obj) { + if (Array.isArray(obj)) { + for (var k = 0, _len2 = obj.length; k < _len2; k++) { + var item = obj[k]; + flatten(item); + } + } else { + flat_assets.push(obj); + } + }; + + flatten(fees); + + var asset_index = 0; + + var set_fee = function set_fee(operation) { + if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === '0' // Long + ) { + operation.fee = flat_assets[asset_index]; + // console.log("new operation.fee", operation.fee) + } else { + // console.log("old operation.fee", operation.fee) + } + + asset_index++; + + if (operation.proposed_ops) { + var result = []; + + for (var y = 0; y < operation.proposed_ops.length; y++) { + result.push(set_fee(operation.proposed_ops[y].op[1])); + } + + return result; + } + }; + + for (var _i2 = 0; _i2 < _this4.operations.length; _i2++) { + set_fee(_this4.operations[_i2][1]); + } + }); + // DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets) + }); + }; + + TransactionBuilder.prototype.get_potential_signatures = function get_potential_signatures() { + var tr_object = _serializer.ops.signed_transaction.toObject(this); + return Promise.all([_peerplaysjsWs.Apis.instance().db_api().exec('get_potential_signatures', [tr_object]), _peerplaysjsWs.Apis.instance().db_api().exec('get_potential_address_signatures', [tr_object])]).then(function (results) { + return { pubkeys: results[0], addys: results[1] }; + }); + }; + + TransactionBuilder.prototype.get_required_signatures = function get_required_signatures(available_keys) { + if (!available_keys.length) { + return Promise.resolve([]); + } + + var tr_object = _serializer.ops.signed_transaction.toObject(this); + // DEBUG console.log('... tr_object',tr_object) + return _peerplaysjsWs.Apis.instance().db_api().exec('get_required_signatures', [tr_object, available_keys]).then(function (required_public_keys) { + return required_public_keys; + }); + }; + + TransactionBuilder.prototype.add_signer = function add_signer(private_key) { + var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey(); + + (0, _assert2.default)(private_key.d, 'required PrivateKey object'); + + if (this.signed) { + throw new Error('already signed'); + } + + if (!public_key.Q) { + public_key = _ecc.PublicKey.fromPublicKeyString(public_key); + } + + // prevent duplicates + var spHex = private_key.toHex(); + + var keys = Object.keys(this.signer_private_keys); + + for (var i = 0, len = keys.length; i < len; i++) { + var sp = this.signer_private_keys[keys[i]]; + + if (sp[0].toHex() === spHex) { + return; + } + } + + this.signer_private_keys.push([private_key, public_key]); + }; + + TransactionBuilder.prototype.sign = function sign() { + var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.Apis.instance().chain_id; + + if (!this.tr_buffer) { + throw new Error('not finalized'); + } + + if (this.signed) { + throw new Error('already signed'); + } + + if (!this.signer_private_keys.length) { + throw new Error('Transaction was not signed. Do you have a private key? [no_signers]'); + } + + var end = this.signer_private_keys.length; + + for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) { + var _signer_private_keys$ = this.signer_private_keys[i], + private_key = _signer_private_keys$[0], + public_key = _signer_private_keys$[1]; + + var sig = _ecc.Signature.signBuffer(Buffer.concat([Buffer.from(chain_id, 'hex'), this.tr_buffer]), private_key, public_key); + this.signatures.push(sig.toBuffer()); + } + + this.signer_private_keys = []; + this.signed = true; + }; + + TransactionBuilder.prototype.serialize = function serialize() { + return _serializer.ops.signed_transaction.toObject(this); + }; + + TransactionBuilder.prototype.toObject = function toObject() { + return _serializer.ops.signed_transaction.toObject(this); + }; + + TransactionBuilder.prototype.broadcast = function broadcast(was_broadcast_callback) { + var _this5 = this; + + if (this.tr_buffer) { + return this._broadcast(was_broadcast_callback); + } + + return this.finalize().then(function () { + return _this5._broadcast(was_broadcast_callback); + }); + }; + + TransactionBuilder.prototype._broadcast = function _broadcast(was_broadcast_callback) { + var _this6 = this; + + return new Promise(function (resolve, reject) { + if (!_this6.signed) { + _this6.sign(); + } + + if (!_this6.tr_buffer) { + throw new Error('not finalized'); + } + + if (!_this6.signatures.length) { + throw new Error('not signed'); + } + + if (!_this6.operations.length) { + throw new Error('no operations'); + } + + var tr_object = _serializer.ops.signed_transaction.toObject(_this6); + // console.log('... broadcast_transaction_with_callback !!!') + _peerplaysjsWs.Apis.instance().network_api().exec('broadcast_transaction_with_callback', [function (res) { + return resolve(res); + }, tr_object]).then(function () { + // console.log('... broadcast success, waiting for callback') + if (was_broadcast_callback) { + was_broadcast_callback(); + } + }).catch(function (error) { + // console.log may be redundant for network errors, other errors could occur + console.log(error); + var message = error.message; + + + if (!message) { + message = ''; + } + + reject(new Error(message + '\n' + 'peerplays-crypto ' + (' digest ' + _ecc.hash.sha256(_this6.tr_buffer).toString('hex') + ' transaction ' + _this6.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object)))); + }); + }); + }; + + TransactionBuilder.timeStringToDate = function timeStringToDate(time_string) { + if (!time_string) { + time_string = '1970-01-01T00:00:00.000Z'; + } + + if (!/Z$/.test(time_string)) { + // does not end in Z + // https://github.com/cryptonomex/graphene/issues/368 + time_string += 'Z'; + } + + return new Date(time_string); + }; + + TransactionBuilder.prototype.getHeadBlockDate = function getHeadBlockDate() { + return TransactionBuilder.timeStringToDate(this.head_block_time_string); + }; + + TransactionBuilder.prototype.base_expiration_sec = function base_expiration_sec() { + var head_block_sec = Math.ceil(this.getHeadBlockDate().getTime() / 1000); + var now_sec = Math.ceil(Date.now() / 1000); + + // The head block time should be updated every 3 seconds. If it isn't + // then help the transaction to expire (use head_block_sec) + if (now_sec - head_block_sec > 30) { + return head_block_sec; + } + + // If the user's clock is very far behind, use the head block time. + return Math.max(now_sec, head_block_sec); + }; + + return TransactionBuilder; +}(); + +exports.default = TransactionBuilder; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"19":19,"27":27,"3":3,"35":35,"7":7,"70":70}],6:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +function get(state) { + return function (key) { + return state[key] || ''; + }; +} + +function set(state) { + var _this = this; + + return function (key, value) { + state[key] = value; + return _this; + }; +} + +exports.get = get; +exports.set = set; +},{}],7:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +exports.key = exports.hash = exports.brainKey = exports.Signature = exports.PublicKey = exports.PrivateKey = exports.Aes = exports.Address = undefined; + +var _address = require(12); + +var _address2 = _interopRequireDefault(_address); + +var _aes = require(13); + +var _aes2 = _interopRequireDefault(_aes); + +var _PrivateKey = require(10); + +var _PrivateKey2 = _interopRequireDefault(_PrivateKey); + +var _PublicKey = require(11); + +var _PublicKey2 = _interopRequireDefault(_PublicKey); + +var _signature = require(18); + +var _signature2 = _interopRequireDefault(_signature); + +var _BrainKey = require(8); + +var _BrainKey2 = _interopRequireDefault(_BrainKey); + +var _hash = require(17); + +var hash = _interopRequireWildcard(_hash); + +var _KeyUtils = require(9); + +var _KeyUtils2 = _interopRequireDefault(_KeyUtils); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.Address = _address2.default; +exports.Aes = _aes2.default; +exports.PrivateKey = _PrivateKey2.default; +exports.PublicKey = _PublicKey2.default; +exports.Signature = _signature2.default; +exports.brainKey = _BrainKey2.default; +exports.hash = hash; +exports.key = _KeyUtils2.default; +},{"10":10,"11":11,"12":12,"13":13,"17":17,"18":18,"8":8,"9":9}],8:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +exports.default = normalize; +function normalize(brainKey) { + if (typeof brainKey !== 'string') { + throw new Error('string required for brainKey'); + } + + brainKey = brainKey.trim(); + return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); +} +module.exports = exports['default']; +},{}],9:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _secureRandom = require(94); + +var _secureRandom2 = _interopRequireDefault(_secureRandom); + +var _peerplaysjsWs = require(70); + +var _PrivateKey = require(10); + +var _PrivateKey2 = _interopRequireDefault(_PrivateKey); + +var _PublicKey = require(11); + +var _PublicKey2 = _interopRequireDefault(_PublicKey); + +var _address = require(12); + +var _address2 = _interopRequireDefault(_address); + +var _aes = require(13); + +var _aes2 = _interopRequireDefault(_aes); + +var _hash = require(17); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// import dictionary from './dictionary_en'; + +// hash for .25 second +var HASH_POWER_MILLS = 250; + +var key = { + /** Uses 1 second of hashing power to create a key/password checksum. An + implementation can re-call this method with the same password to re-match + the strength of the CPU (either after moving from a desktop to a mobile, + mobile to desktop, or N years from now when CPUs are presumably stronger). + A salt is used for all the normal reasons... + @return object { + aes_private: Aes, + checksum: "{hash_iteration_count},{salt},{checksum}" + } + */ + aes_checksum: function aes_checksum(password) { + if (!(typeof password === 'string')) { + throw new 'password string required'(); + } + + var salt = _secureRandom2.default.randomBuffer(4).toString('hex'); + var iterations = 0; + var secret = salt + password; + // hash for .1 second + var start_t = Date.now(); + + while (Date.now() - start_t < HASH_POWER_MILLS) { + secret = (0, _hash.sha256)(secret); + iterations += 1; + } + + var checksum = (0, _hash.sha256)(secret); + var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(','); + + return { + aes_private: _aes2.default.fromSeed(secret), + checksum: checksum_string + }; + }, + + + /** Provide a matching password and key_checksum. A "wrong password" + error is thrown if the password does not match. If this method takes + much more or less than 1 second to return, one should consider updating + all encyrpted fields using a new key.key_checksum. + */ + aes_private: function aes_private(password, key_checksum) { + var _key_checksum$split = key_checksum.split(','), + iterations = _key_checksum$split[0], + salt = _key_checksum$split[1], + checksum = _key_checksum$split[2]; + + var secret = salt + password; + + for (var i = 0; iterations > 0 ? i < iterations : i > iterations; iterations > 0 ? i++ : i++) { + secret = (0, _hash.sha256)(secret); + } + + var new_checksum = (0, _hash.sha256)(secret); + + if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) { + throw new Error('wrong password'); + } + + return _aes2.default.fromSeed(secret); + }, + + + /** + A week random number generator can run out of entropy. + This should ensure even the worst random number implementation will be reasonably safe. + @param1 string entropy of at least 32 bytes + */ + random32ByteBuffer: function random32ByteBuffer() { + var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy(); + + if (!(typeof entropy === 'string')) { + throw new Error('string required for entropy'); + } + + if (entropy.length < 32) { + throw new Error('expecting at least 32 bytes of entropy'); + } + + var start_t = Date.now(); + + while (Date.now() - start_t < HASH_POWER_MILLS) { + entropy = (0, _hash.sha256)(entropy); + } + + var hash_array = []; + hash_array.push(entropy); + + // Hashing for 1 second may helps the computer is not low on entropy + // (this method may be called back-to-back). + hash_array.push(_secureRandom2.default.randomBuffer(32)); + + return (0, _hash.sha256)(Buffer.concat(hash_array)); + }, + suggest_brain_key: function suggest_brain_key() { + var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ','; + var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy(); + + var randomBuffer = this.random32ByteBuffer(entropy); + + var word_count = 16; + var dictionary_lines = dictionary.split(','); + + if (!(dictionary_lines.length === 49744)) { + throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words'); + } + + var brainkey = []; + var end = word_count * 2; + + for (var i = 0; i < end; i += 2) { + // randomBuffer has 256 bits / 16 bits per word == 16 words + var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; // eslint-disable-line + + // convert into a number between 0 and 1 (inclusive) + var rndMultiplier = num / Math.pow(2, 16); + var wordIndex = Math.round(dictionary_lines.length * rndMultiplier); + + brainkey.push(dictionary_lines[wordIndex]); + } + + return this.normalize_brainKey(brainkey.join(' ')); + }, + get_random_key: function get_random_key(entropy) { + return _PrivateKey2.default.fromBuffer(this.random32ByteBuffer(entropy)); + }, + get_brainPrivateKey: function get_brainPrivateKey(brainKey) { + var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + + if (sequence < 0) { + throw new Error('invalid sequence'); + } + + brainKey = key.normalize_brainKey(brainKey); + return _PrivateKey2.default.fromBuffer((0, _hash.sha256)((0, _hash.sha512)(brainKey + ' ' + sequence))); + }, + + + // Turn invisible space like characters into a single space + normalize_brainKey: function normalize_brainKey(brainKey) { + if (!(typeof brainKey === 'string')) { + throw new Error('string required for brainKey'); + } + + brainKey = brainKey.trim(); + return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); + }, + browserEntropy: function browserEntropy() { + var entropyStr = ''; + + try { + entropyStr = new Date().toString() + ' ' + window.screen.height + ' ' + window.screen.width; + entropyStr = entropyStr + ' ' + window.screen.colorDepth + ' ' + window.screen.availHeight; + entropyStr = entropyStr + ' ' + window.screen.availWidth + ' ' + window.screen.pixelDepth; + entropyStr = entropyStr + ' ' + navigator.language + ' ' + window.location; + entropyStr = entropyStr + ' ' + window.history.length; + + for (var i = 0, len = navigator.mimeTypes.length; i < len; i++) { + var mimeType = navigator.mimeTypes[i]; + entropyStr += mimeType.description + ' ' + mimeType.type + ' ' + mimeType.suffixes + ' '; + } + + console.log('INFO\tbrowserEntropy gathered'); + } catch (error) { + // nodejs:ReferenceError: window is not defined + entropyStr = (0, _hash.sha256)(new Date().toString()); + } + + var b = Buffer.from(entropyStr); + entropyStr += b.toString('binary') + ' ' + new Date().toString(); + return entropyStr; + }, + + + // @return array of 5 legacy addresses for a pubkey string parameter. + addresses: function addresses(pubkey) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; + + var public_key = _PublicKey2.default.fromPublicKeyString(pubkey, address_prefix); + // S L O W + var address_string = [_address2.default.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed + _address2.default.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed + _address2.default.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed + _address2.default.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed + public_key.toAddressString(address_prefix) // bts_short, most recent format + ]; + return address_string; + } +}; + +exports.default = key; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"10":10,"11":11,"12":12,"13":13,"17":17,"35":35,"70":70,"94":94}],10:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _ecurve = require(59); + +var _bigi = require(32); + +var _bigi2 = _interopRequireDefault(_bigi); + +var _bs = require(37); + +var _deepEqual = require(54); + +var _deepEqual2 = _interopRequireDefault(_deepEqual); + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _hash = require(17); + +var _PublicKey = require(11); + +var _PublicKey2 = _interopRequireDefault(_PublicKey); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* global ByteBuffer */ + + +var secp256k1 = (0, _ecurve.getCurveByName)('secp256k1'); +var n = secp256k1.n; + + +function toPublic(data) { + if (!data || data.Q) { + return data; + } + + return _PublicKey2.default.fromStringOrThrow(data); +} + +var PrivateKey = function () { + /** + @private see static functions + @param {BigInteger} + */ + function PrivateKey(d) { + _classCallCheck(this, PrivateKey); + + this.d = d; + } + + PrivateKey.fromBuffer = function fromBuffer(buf) { + if (!Buffer.isBuffer(buf)) { + throw new Error('Expecting paramter to be a Buffer type'); + } + + if (buf.length !== 32) { + console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack); + } + + if (buf.length === 0) { + throw new Error('Empty buffer'); + } + + return new PrivateKey(_bigi2.default.fromBuffer(buf)); + }; + + /** @arg {string} seed - any length string. This is private, + * the same seed produces the same private key every time. */ + + + PrivateKey.fromSeed = function fromSeed(seed) { + // generate_private_key + if (!(typeof seed === 'string')) { + throw new Error('seed must be of type string'); + } + + return PrivateKey.fromBuffer((0, _hash.sha256)(seed)); + }; + + /** @return {string} Wallet Import Format (still a secret, Not encrypted) */ + + + PrivateKey.fromWif = function fromWif(_private_wif) { + var private_wif = Buffer.from((0, _bs.decode)(_private_wif)); + var version = private_wif.readUInt8(0); + _assert2.default.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version); + // checksum includes the version + var private_key = private_wif.slice(0, -4); + var checksum = private_wif.slice(-4); + var new_checksum = (0, _hash.sha256)(private_key); + new_checksum = (0, _hash.sha256)(new_checksum); + new_checksum = new_checksum.slice(0, 4); + var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum' + + if (!isEqual) { + throw new Error('Checksum did not match'); + } + + private_key = private_key.slice(1); + private_key = private_key.slice(0, 32); + return PrivateKey.fromBuffer(private_key); + }; + + PrivateKey.prototype.toWif = function toWif() { + var private_key = this.toBuffer(); + // checksum includes the version + private_key = Buffer.concat([Buffer.from([0x80]), private_key]); + var checksum = (0, _hash.sha256)(private_key); + checksum = (0, _hash.sha256)(checksum); + checksum = checksum.slice(0, 4); + var private_wif = Buffer.concat([private_key, checksum]); + return (0, _bs.encode)(private_wif); + }; + + /** + @return {Point} + */ + + + PrivateKey.prototype.toPublicKeyPoint = function toPublicKeyPoint() { + var Q = secp256k1.G.multiply(this.d); + return Q; + }; + + PrivateKey.prototype.toPublicKey = function toPublicKey() { + if (this.public_key) { + return this.public_key; + } + + this.public_key = _PublicKey2.default.fromPoint(this.toPublicKeyPoint()); + + return this.public_key; + }; + + PrivateKey.prototype.toBuffer = function toBuffer() { + return this.d.toBuffer(32); + }; + + /** ECIES */ + + + PrivateKey.prototype.get_shared_secret = function get_shared_secret(public_key) { + var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + public_key = toPublic(public_key); + var KB = public_key.toUncompressed().toBuffer(); + var KBP = _ecurve.Point.fromAffine(secp256k1, _bigi2.default.fromBuffer(KB.slice(1, 33)), // x + _bigi2.default.fromBuffer(KB.slice(33, 65)) // y + ); + var r = this.toBuffer(); + var P = KBP.multiply(_bigi2.default.fromBuffer(r)); + var S = P.affineX.toBuffer({ size: 32 }); + + /* + the input to sha512 must be exactly 32-bytes, to match the c++ implementation + of get_shared_secret. Right now S will be shorter if the most significant + byte(s) is zero. Pad it back to the full 32-bytes + */ + if (!legacy && S.length < 32) { + var pad = Buffer.alloc(32 - S.length, 0); + S = Buffer.concat([pad, S]); + } + + // SHA512 used in ECIES + return (0, _hash.sha512)(S); + }; + + // /** ECIES (does not always match the Point.fromAffine version above) */ + // get_shared_secret(public_key){ + // public_key = toPublic(public_key) + // var P = public_key.Q.multiply( this.d ); + // var S = P.affineX.toBuffer({size: 32}); + // // ECIES, adds an extra sha512 + // return sha512(S); + // } + + /** @throws {Error} - overflow of the key could not be derived */ + + + PrivateKey.prototype.child = function child(offset) { + offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]); + offset = (0, _hash.sha256)(offset); + var c = _bigi2.default.fromBuffer(offset); + + if (c.compareTo(n) >= 0) { + throw new Error('Child offset went out of bounds, try again'); + } + + var derived = this.d.add(c); // .mod(n) + + if (derived.signum() === 0) { + throw new Error('Child offset derived to an invalid key, try again'); + } + + return new PrivateKey(derived); + }; + + /* */ + + PrivateKey.prototype.toByteBuffer = function toByteBuffer() { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + }; + + PrivateKey.fromHex = function fromHex(hex) { + return PrivateKey.fromBuffer(Buffer.from(hex, 'hex')); + }; + + PrivateKey.prototype.toHex = function toHex() { + return this.toBuffer().toString('hex'); + }; + + /* */ + + + return PrivateKey; +}(); + +exports.default = PrivateKey; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"11":11,"17":17,"27":27,"32":32,"35":35,"37":37,"54":54,"59":59}],11:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _bigi = require(32); + +var _bigi2 = _interopRequireDefault(_bigi); + +var _ecurve = require(59); + +var _bs = require(37); + +var _peerplaysjsWs = require(70); + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _deepEqual = require(54); + +var _deepEqual2 = _interopRequireDefault(_deepEqual); + +var _hash = require(17); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* global ByteBuffer */ + + +var secp256k1 = (0, _ecurve.getCurveByName)('secp256k1'); + +var G = secp256k1.G, + n = secp256k1.n; + +var PublicKey = function () { + /** @param {Point} public key */ + function PublicKey(Q) { + _classCallCheck(this, PublicKey); + + this.Q = Q; + } + + PublicKey.fromBinary = function fromBinary(bin) { + return PublicKey.fromBuffer(Buffer.from(bin, 'binary')); + }; + + PublicKey.fromBuffer = function fromBuffer(buffer) { + if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') { + return new PublicKey(null); + } + + return new PublicKey(_ecurve.Point.decodeFrom(secp256k1, buffer)); + }; + + PublicKey.prototype.toBuffer = function toBuffer() { + var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null; + + if (this.Q === null) { + return Buffer.from('000000000000000000000000000000000000000000000000000000000000000000', 'hex'); + } + + return this.Q.getEncoded(compressed); + }; + + PublicKey.fromPoint = function fromPoint(point) { + return new PublicKey(point); + }; + + PublicKey.prototype.toUncompressed = function toUncompressed() { + var buf = this.Q.getEncoded(false); + var point = _ecurve.Point.decodeFrom(secp256k1, buf); + return PublicKey.fromPoint(point); + }; + + /** bts::blockchain::address (unique but not a full public key) */ + + + PublicKey.prototype.toBlockchainAddress = function toBlockchainAddress() { + var pub_buf = this.toBuffer(); + var pub_sha = (0, _hash.sha512)(pub_buf); + return (0, _hash.ripemd160)(pub_sha); + }; + + /** Alias for {@link toPublicKeyString} */ + + + PublicKey.prototype.toString = function toString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + + return this.toPublicKeyString(address_prefix); + }; + + /** + Full public key + {return} string + */ + + + PublicKey.prototype.toPublicKeyString = function toPublicKeyString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + + var pub_buf = this.toBuffer(); + var checksum = (0, _hash.ripemd160)(pub_buf); + // Slice from the buffer directly, slicing from the checksum + // Uint8array will return the entire array each time. + var sliced = new Uint8Array(checksum.buffer.slice(0, 4)); + + // concat only accepts buffers so initialize the sliced Uint8array as a Buffer. + var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]); + return address_prefix + (0, _bs.encode)(addy); + }; + + /** + @arg {string} public_key - like GPHXyz... + @arg {string} address_prefix - like GPH + @return PublicKey or `null` (if the public_key string is invalid) + */ + + + PublicKey.fromPublicKeyString = function fromPublicKeyString(public_key) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; + + try { + return PublicKey.fromStringOrThrow(public_key, address_prefix); + } catch (e) { + return null; + } + }; + + /** + @arg {string} public_key - like GPHXyz... + @arg {string} address_prefix - like GPH + @throws {Error} if public key is invalid + @return PublicKey + */ + + + PublicKey.fromStringOrThrow = function fromStringOrThrow(public_key) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; + + var prefix = public_key.slice(0, address_prefix.length); + _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); + public_key = public_key.slice(address_prefix.length); + + public_key = Buffer.from((0, _bs.decode)(public_key), 'binary'); + var checksum = public_key.slice(-4); + public_key = public_key.slice(0, -4); + var new_checksum = (0, _hash.ripemd160)(public_key); + new_checksum = new_checksum.slice(0, 4); + var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum' + + if (!isEqual) { + throw new Error('Checksum did not match'); + } + + return PublicKey.fromBuffer(public_key); + }; + + PublicKey.prototype.toAddressString = function toAddressString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + + var pub_buf = this.toBuffer(); + var pub_sha = (0, _hash.sha512)(pub_buf); + var addy = (0, _hash.ripemd160)(pub_sha); + var checksum = (0, _hash.ripemd160)(addy); + addy = Buffer.concat([addy, checksum.slice(0, 4)]); + return address_prefix + (0, _bs.encode)(addy); + }; + + PublicKey.prototype.toPtsAddy = function toPtsAddy() { + var pub_buf = this.toBuffer(); + var pub_sha = (0, _hash.sha256)(pub_buf); + var addy = (0, _hash.ripemd160)(pub_sha); + addy = Buffer.concat([Buffer.from([0x38]), addy]); // version 56(decimal) + + var checksum = (0, _hash.sha256)(addy); + checksum = (0, _hash.sha256)(checksum); + + addy = Buffer.concat([addy, checksum.slice(0, 4)]); + return (0, _bs.encode)(addy); + }; + + PublicKey.prototype.child = function child(offset) { + (0, _assert2.default)(Buffer.isBuffer(offset), 'Buffer required: offset'); + _assert2.default.equal(offset.length, 32, 'offset length'); + + offset = Buffer.concat([this.toBuffer(), offset]); + offset = (0, _hash.sha256)(offset); + + var c = _bigi2.default.fromBuffer(offset); + + if (c.compareTo(n) >= 0) { + throw new Error('Child offset went out of bounds, try again'); + } + + var cG = G.multiply(c); + var Qprime = this.Q.add(cG); + + if (secp256k1.isInfinity(Qprime)) { + throw new Error('Child offset derived to an invalid key, try again'); + } + + return PublicKey.fromPoint(Qprime); + }; + + /* */ + + PublicKey.prototype.toByteBuffer = function toByteBuffer() { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + }; + + PublicKey.fromHex = function fromHex(hex) { + return PublicKey.fromBuffer(Buffer.from(hex, 'hex')); + }; + + PublicKey.prototype.toHex = function toHex() { + return this.toBuffer().toString('hex'); + }; + + PublicKey.fromPublicKeyStringHex = function fromPublicKeyStringHex(hex) { + return PublicKey.fromPublicKeyString(Buffer.from(hex, 'hex')); + }; + + /* */ + + + return PublicKey; +}(); + +exports.default = PublicKey; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"17":17,"27":27,"32":32,"35":35,"37":37,"54":54,"59":59,"70":70}],12:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _peerplaysjsWs = require(70); + +var _bs = require(37); + +var _deepEqual = require(54); + +var _deepEqual2 = _interopRequireDefault(_deepEqual); + +var _hash2 = require(17); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** Addresses are shortened non-reversable hashes of a public key. The full PublicKey is preferred. + @deprecated +*/ +var Address = function () { + function Address(addy) { + _classCallCheck(this, Address); + + this.addy = addy; + } + + Address.fromBuffer = function fromBuffer(buffer) { + var _hash = (0, _hash2.sha512)(buffer); + var addy = (0, _hash2.ripemd160)(_hash); + return new Address(addy); + }; + + Address.fromString = function fromString(string) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; + + var prefix = string.slice(0, address_prefix.length); + _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); + var addy = string.slice(address_prefix.length); + addy = Buffer.from((0, _bs.decode)(addy), 'binary'); + var checksum = addy.slice(-4); + addy = addy.slice(0, -4); + var new_checksum = (0, _hash2.ripemd160)(addy); + new_checksum = new_checksum.slice(0, 4); + var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum' + + if (!isEqual) { + throw new Error('Checksum did not match'); + } + + return new Address(addy); + }; + + /** @return Address - Compressed PTS format (by default) */ + + + Address.fromPublic = function fromPublic(public_key) { + var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56; + + var sha2 = (0, _hash2.sha256)(public_key.toBuffer(compressed)); + var rep = (0, _hash2.ripemd160)(sha2); + var versionBuffer = Buffer.alloc(1); + versionBuffer.writeUInt8(0xff & version, 0); // eslint-disable-line + var addr = Buffer.concat([versionBuffer, rep]); + var check = (0, _hash2.sha256)(addr); + check = (0, _hash2.sha256)(check); + var buffer = Buffer.concat([addr, check.slice(0, 4)]); + return new Address((0, _hash2.ripemd160)(buffer)); + }; + + Address.prototype.toBuffer = function toBuffer() { + return this.addy; + }; + + Address.prototype.toString = function toString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + + var checksum = (0, _hash2.ripemd160)(this.addy); + var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]); + return address_prefix + (0, _bs.encode)(addy); + }; + + return Address; +}(); + +exports.default = Address; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"17":17,"27":27,"35":35,"37":37,"54":54,"70":70}],13:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _aes = require(45); + +var _aes2 = _interopRequireDefault(_aes); + +var _encHex = require(49); + +var _encHex2 = _interopRequireDefault(_encHex); + +var _encBase = require(48); + +var _encBase2 = _interopRequireDefault(_encBase); + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _hash2 = require(17); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // https://code.google.com/p/crypto-js + + +/** Provides symetric encrypt and decrypt via AES. */ +var Aes = function () { + /** @private */ + function Aes(iv, key) { + _classCallCheck(this, Aes); + + this.iv = iv; + this.key = key; + } + + /** This is an excellent way to ensure that all references to Aes can not operate anymore + * (example: a wallet becomes locked). An application should ensure there is only one + * Aes object instance for a given secret `seed`. */ + + + Aes.prototype.clear = function clear() { + this.iv = undefined; + this.key = undefined; + return undefined; + }; + + /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */ + + + Aes.fromSeed = function fromSeed(seed) { + if (seed === undefined) { + throw new Error('seed is required'); + } + + var _hash = (0, _hash2.sha512)(seed); + _hash = _hash.toString('hex'); + // DEBUG console.log('... fromSeed _hash',_hash) + return Aes.fromSha512(_hash); + }; + + /** @arg {string} hash - A 128 byte hex string, typically one + * would call {@link fromSeed} instead. */ + + + Aes.fromSha512 = function fromSha512(hash) { + _assert2.default.equal(hash.length, 128, 'A Sha512 in HEX should be 128 characters long, instead got ' + hash.length); + var iv = _encHex2.default.parse(hash.substring(64, 96)); + var key = _encHex2.default.parse(hash.substring(0, 64)); + return new Aes(iv, key); + }; + + Aes.fromBuffer = function fromBuffer(buf) { + (0, _assert2.default)(Buffer.isBuffer(buf), 'Expecting Buffer'); + _assert2.default.equal(buf.length, 64, 'A Sha512 Buffer should be 64 characters long, instead got ' + buf.length); + return Aes.fromSha512(buf.toString('hex')); + }; + + /** + @throws {Error} - "Invalid Key, ..." + @arg {PrivateKey} private_key - required and used for decryption + @arg {PublicKey} public_key - required and used to calcualte the shared secret + @arg {string} [nonce = ""] optional but should always be provided and be unique + when re-using the same private/public keys more than once. This nonce is not a secret. + @arg {string|Buffer} message - Encrypted message containing a checksum + @return {Buffer} + */ + + + Aes.decrypt_with_checksum = function decrypt_with_checksum(private_key, public_key, nonce, message) { + var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + + // Warning: Do not put `nonce = ""` in the arguments, in es6 this will + // not convert "null" into an emtpy string + if (nonce == null) { + nonce = ''; + } + + if (!Buffer.isBuffer(message)) { + message = Buffer.from(message, 'hex'); + } + + var S = private_key.get_shared_secret(public_key, legacy); + // D E B U G + // console.log('decrypt_with_checksum', { + // priv_to_pub: private_key.toPublicKey().toString(), + // pub: public_key.toPublicKeyString(), + // nonce: nonce, + // message: message.length, + // S: S.toString('hex') + // }) + + var aes = Aes.fromSeed(Buffer.concat([ + // A null or empty string nonce will not effect the hash + Buffer.from('' + nonce), Buffer.from(S.toString('hex'))])); + + var planebuffer = aes.decrypt(message); + + if (!(planebuffer.length >= 4)) { + throw new Error('Invalid key, could not decrypt message(1)'); + } + + // DEBUG console.log('... planebuffer',planebuffer) + var checksum = planebuffer.slice(0, 4); + var plaintext = planebuffer.slice(4); + + // console.log('... checksum',checksum.toString('hex')) + // console.log('... plaintext',plaintext.toString()) + + var new_checksum = (0, _hash2.sha256)(plaintext); + new_checksum = new_checksum.slice(0, 4); + new_checksum = new_checksum.toString('hex'); + + if (!(checksum.toString('hex') === new_checksum)) { + throw new Error('Invalid key, could not decrypt message(2)'); + } + + return plaintext; + }; + + /** Identical to {@link decrypt_with_checksum} but used to encrypt. Should not throw an error. + @return {Buffer} message - Encrypted message which includes a checksum + */ + + + Aes.encrypt_with_checksum = function encrypt_with_checksum(private_key, public_key, nonce, message) { + // Warning: Do not put `nonce = ""` in the arguments, in es6 this will + // not convert "null" into an emtpy string + + if (nonce == null) { + nonce = ''; + } + + if (!Buffer.isBuffer(message)) { + message = Buffer.from(message, 'binary'); + } + + var S = private_key.get_shared_secret(public_key); + + // D E B U G + // console.log('encrypt_with_checksum', { + // priv_to_pub: private_key.toPublicKey().toString() + // pub: public_key.toPublicKeyString() + // nonce: nonce + // message: message.length + // S: S.toString('hex') + // }) + + var aes = Aes.fromSeed(Buffer.concat([ + // A null or empty string nonce will not effect the hash + Buffer.from('' + nonce), Buffer.from(S.toString('hex'))])); + // DEBUG console.log('... S',S.toString('hex')) + var checksum = (0, _hash2.sha256)(message).slice(0, 4); + var payload = Buffer.concat([checksum, message]); + // DEBUG console.log('... payload',payload.toString()) + return aes.encrypt(payload); + }; + + /** @private */ + + + Aes.prototype._decrypt_word_array = function _decrypt_word_array(cipher) { + // https://code.google.com/p/crypto-js/#Custom_Key_and_IV + // see wallet_records.cpp master_key::decrypt_key + return _aes2.default.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv }); + }; + + /** @private */ + + + Aes.prototype._encrypt_word_array = function _encrypt_word_array(plaintext) { + // https://code.google.com/p/crypto-js/issues/detail?id=85 + var cipher = _aes2.default.encrypt(plaintext, this.key, { iv: this.iv }); + return _encBase2.default.parse(cipher.toString()); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} ciphertext + @return {Buffer} binary + */ + + + Aes.prototype.decrypt = function decrypt(ciphertext) { + if (typeof ciphertext === 'string') { + ciphertext = Buffer.from(ciphertext, 'binary'); + } + + if (!Buffer.isBuffer(ciphertext)) { + throw new Error('buffer required'); + } + + (0, _assert2.default)(ciphertext, 'Missing cipher text'); + // hex is the only common format + var hex = this.decryptHex(ciphertext.toString('hex')); + return Buffer.from(hex, 'hex'); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} plaintext + @return {Buffer} binary + */ + + + Aes.prototype.encrypt = function encrypt(plaintext) { + if (typeof plaintext === 'string') { + plaintext = Buffer.from(plaintext, 'binary'); + } + + if (!Buffer.isBuffer(plaintext)) { + throw new Error('buffer required'); + } + + // assert plaintext, "Missing plain text" + // hex is the only common format + var hex = this.encryptHex(plaintext.toString('hex')); + return Buffer.from(hex, 'hex'); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string|Buffer} plaintext + @return {string} hex + */ + + + Aes.prototype.encryptToHex = function encryptToHex(plaintext) { + if (typeof plaintext === 'string') { + plaintext = Buffer.from(plaintext, 'binary'); + } + + if (!Buffer.isBuffer(plaintext)) { + throw new Error('buffer required'); + } + + // assert plaintext, "Missing plain text" + // hex is the only common format + return this.encryptHex(plaintext.toString('hex')); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @return {string} binary (could easily be readable text) + */ + + + Aes.prototype.decryptHex = function decryptHex(cipher) { + (0, _assert2.default)(cipher, 'Missing cipher text'); + // Convert data into word arrays (used by Crypto) + var cipher_array = _encHex2.default.parse(cipher); + var plainwords = this._decrypt_word_array(cipher_array); + return _encHex2.default.stringify(plainwords); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @return {Buffer} encoded as specified by the parameter + */ + + + Aes.prototype.decryptHexToBuffer = function decryptHexToBuffer(cipher) { + (0, _assert2.default)(cipher, 'Missing cipher text'); + // Convert data into word arrays (used by Crypto) + var cipher_array = _encHex2.default.parse(cipher); + var plainwords = this._decrypt_word_array(cipher_array); + var plainhex = _encHex2.default.stringify(plainwords); + return Buffer.from(plainhex, 'hex'); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @arg {string} [encoding = 'binary'] - a valid Buffer encoding + @return {String} encoded as specified by the parameter + */ + + + Aes.prototype.decryptHexToText = function decryptHexToText(cipher) { + var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary'; + + return this.decryptHexToBuffer(cipher).toString(encoding); + }; + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} plainhex - hex format + @return {String} hex + */ + + + Aes.prototype.encryptHex = function encryptHex(plainhex) { + var plain_array = _encHex2.default.parse(plainhex); + var cipher_array = this._encrypt_word_array(plain_array); + return _encHex2.default.stringify(cipher_array); + }; + + return Aes; +}(); + +exports.default = Aes; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"17":17,"27":27,"35":35,"45":45,"48":48,"49":49}],14:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; +exports.verifyRaw = exports.verify = exports.sign = exports.recoverPubKey = exports.deterministicGenerateK = exports.calcPubKeyRecoveryParam = undefined; + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _bigi = require(32); + +var _bigi2 = _interopRequireDefault(_bigi); + +var _hash = require(17); + +var _enforce_types = require(16); + +var _enforce_types2 = _interopRequireDefault(_enforce_types); + +var _ecsignature = require(15); + +var _ecsignature2 = _interopRequireDefault(_ecsignature); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// https://tools.ietf.org/html/rfc6979#section-3.2 + +// from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa +function deterministicGenerateK(curve, hash, d, checkSig, nonce) { + (0, _enforce_types2.default)('Buffer', hash); + (0, _enforce_types2.default)(_bigi2.default, d); + + if (nonce) { + hash = (0, _hash.sha256)(Buffer.concat([hash, Buffer.alloc(nonce)])); + } + + // sanity check + _assert2.default.equal(hash.length, 32, 'Hash must be 256 bit'); + + var x = d.toBuffer(32); + var k = Buffer.alloc(32); + var v = Buffer.alloc(32); + + // Step B + v.fill(1); + + // Step C + k.fill(0); + + // Step D + k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0]), x, hash]), k); + + // Step E + v = (0, _hash.HmacSHA256)(v, k); + + // Step F + k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([1]), x, hash]), k); + + // Step G + v = (0, _hash.HmacSHA256)(v, k); + + // Step H1/H2a, ignored as tlen === qlen (256 bit) + // Step H2b + v = (0, _hash.HmacSHA256)(v, k); + + var T = _bigi2.default.fromBuffer(v); + + // Step H3, repeat until T is within the interval [1, n - 1] + while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) { + k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0])]), k); + v = (0, _hash.HmacSHA256)(v, k); + + // Step H1/H2a, again, ignored as tlen === qlen (256 bit) + // Step H2b again + v = (0, _hash.HmacSHA256)(v, k); + + T = _bigi2.default.fromBuffer(v); + } + + return T; +} + +function sign(curve, hash, d, nonce) { + var e = _bigi2.default.fromBuffer(hash); + var n = curve.n; + var G = curve.G; + + var r = void 0; + var s = void 0; + + deterministicGenerateK(curve, hash, d, function (key) { + // find canonically valid signature + var Q = G.multiply(key); + + if (curve.isInfinity(Q)) { + return false; + } + + r = Q.affineX.mod(n); + + if (r.signum() === 0) { + return false; + } + + s = key.modInverse(n).multiply(e.add(d.multiply(r))).mod(n); + + if (s.signum() === 0) { + return false; + } + + return true; + }, nonce); + + var N_OVER_TWO = n.shiftRight(1); + + // enforce low S values, see bip62: 'low s values in signatures' + if (s.compareTo(N_OVER_TWO) > 0) { + s = n.subtract(s); + } + + return new _ecsignature2.default(r, s); +} + +function verifyRaw(curve, e, signature, Q) { + var n = curve.n; + var G = curve.G; + + var r = signature.r; + var s = signature.s; + + // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1] + if (r.signum() <= 0 || r.compareTo(n) >= 0) { + return false; + } + + if (s.signum() <= 0 || s.compareTo(n) >= 0) { + return false; + } + + // c = s^-1 mod n + var c = s.modInverse(n); + + // 1.4.4 Compute u1 = es^−1 mod n + // u2 = rs^−1 mod n + var u1 = e.multiply(c).mod(n); + var u2 = r.multiply(c).mod(n); + + // 1.4.5 Compute R = (xR, yR) = u1G + u2Q + var R = G.multiplyTwo(u1, Q, u2); + + // 1.4.5 (cont.) Enforce R is not at infinity + if (curve.isInfinity(R)) { + return false; + } + + // 1.4.6 Convert the field element R.x to an integer + var xR = R.affineX; + + // 1.4.7 Set v = xR mod n + var v = xR.mod(n); + + // 1.4.8 If v = r, output "valid", and if v != r, output "invalid" + return v.equals(r); +} + +function verify(curve, hash, signature, Q) { + // 1.4.2 H = Hash(M), already done by the user + // 1.4.3 e = H + var e = _bigi2.default.fromBuffer(hash); + return verifyRaw(curve, e, signature, Q); +} + +/** + * Recover a public key from a signature. + * + * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public + * Key Recovery Operation". + * + * http://www.secg.org/download/aid-780/sec1-v2.pdf + */ +function recoverPubKey(curve, e, signature, i) { + _assert2.default.strictEqual(i & 3, i, 'Recovery param is more than two bits'); // eslint-disable-line + + var n = curve.n; + var G = curve.G; + + var r = signature.r; + var s = signature.s; + + (0, _assert2.default)(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value'); + (0, _assert2.default)(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value'); + + // A set LSB signifies that the y-coordinate is odd + var isYOdd = i & 1; // eslint-disable-line + + // The more significant bit specifies whether we should use the + // first or second candidate key. + var isSecondKey = i >> 1; // eslint-disable-line + + // 1.1 Let x = r + jn + var x = isSecondKey ? r.add(n) : r; + var R = curve.pointFromX(isYOdd, x); + + // 1.4 Check that nR is at infinity + var nR = R.multiply(n); + (0, _assert2.default)(curve.isInfinity(nR), 'nR is not a valid curve point'); + + // Compute -e from e + var eNeg = e.negate().mod(n); + + // 1.6.1 Compute Q = r^-1 (sR - eG) + // Q = r^-1 (sR + -eG) + var rInv = r.modInverse(n); + + var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv); + curve.validate(Q); + + return Q; +} + +/** + * Calculate pubkey extraction parameter. + * + * When extracting a pubkey from a signature, we have to + * distinguish four different cases. Rather than putting this + * burden on the verifier, Bitcoin includes a 2-bit value with the + * signature. + * + * This function simply tries all four cases and returns the value + * that resulted in a successful pubkey recovery. + */ +function calcPubKeyRecoveryParam(curve, e, signature, Q) { + for (var i = 0; i < 4; i++) { + var Qprime = recoverPubKey(curve, e, signature, i); + + // 1.6.2 Verify Q + if (Qprime.equals(Q)) { + return i; + } + } + + throw new Error('Unable to find valid recovery factor'); +} + +exports.calcPubKeyRecoveryParam = calcPubKeyRecoveryParam; +exports.deterministicGenerateK = deterministicGenerateK; +exports.recoverPubKey = recoverPubKey; +exports.sign = sign; +exports.verify = verify; +exports.verifyRaw = verifyRaw; +}).call(this,require(35).Buffer) + +},{"15":15,"16":16,"17":17,"27":27,"32":32,"35":35}],15:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _bigi = require(32); + +var _bigi2 = _interopRequireDefault(_bigi); + +var _enforce_types = require(16); + +var _enforce_types2 = _interopRequireDefault(_enforce_types); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// from https://github.com/bitcoinjs/bitcoinjs-lib +function ECSignature(r, s) { + (0, _enforce_types2.default)(_bigi2.default, r); + (0, _enforce_types2.default)(_bigi2.default, s); + + this.r = r; + this.s = s; +} + +// Import operations +/* eslint no-bitwise: "off" */ +ECSignature.parseCompact = function (buffer) { + _assert2.default.equal(buffer.length, 65, 'Invalid signature length'); + var i = buffer.readUInt8(0) - 27; + + // At most 3 bits + _assert2.default.equal(i, i & 7, 'Invalid signature parameter'); + var compressed = !!(i & 4); + + // Recovery param only + i &= 3; + + var r = _bigi2.default.fromBuffer(buffer.slice(1, 33)); + var s = _bigi2.default.fromBuffer(buffer.slice(33)); + + return { + compressed: compressed, + i: i, + signature: new ECSignature(r, s) + }; +}; + +ECSignature.fromDER = function (buffer) { + _assert2.default.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence'); + _assert2.default.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length'); + _assert2.default.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer'); + + var rLen = buffer.readUInt8(3); + (0, _assert2.default)(rLen > 0, 'R length is zero'); + + var offset = 4 + rLen; + _assert2.default.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)'); + + var sLen = buffer.readUInt8(offset + 1); + (0, _assert2.default)(sLen > 0, 'S length is zero'); + + var rB = buffer.slice(4, offset); + var sB = buffer.slice(offset + 2); + offset += 2 + sLen; + + if (rLen > 1 && rB.readUInt8(0) === 0x00) { + (0, _assert2.default)(rB.readUInt8(1) & 0x80, 'R value excessively padded'); + } + + if (sLen > 1 && sB.readUInt8(0) === 0x00) { + (0, _assert2.default)(sB.readUInt8(1) & 0x80, 'S value excessively padded'); + } + + _assert2.default.equal(offset, buffer.length, 'Invalid DER encoding'); + var r = _bigi2.default.fromDERInteger(rB); + var s = _bigi2.default.fromDERInteger(sB); + + (0, _assert2.default)(r.signum() >= 0, 'R value is negative'); + (0, _assert2.default)(s.signum() >= 0, 'S value is negative'); + + return new ECSignature(r, s); +}; + +// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, +// importing Transaction causes a circular dependency +ECSignature.parseScriptSignature = function (buffer) { + var hashType = buffer.readUInt8(buffer.length - 1); + var hashTypeMod = hashType & ~0x80; + + (0, _assert2.default)(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType'); + + return { + signature: ECSignature.fromDER(buffer.slice(0, -1)), + hashType: hashType + }; +}; + +// Export operations +ECSignature.prototype.toCompact = function toCompact(i, compressed) { + if (compressed) { + i += 4; + } + + i += 27; + + var buffer = Buffer.alloc(65); + buffer.writeUInt8(i, 0); + + this.r.toBuffer(32).copy(buffer, 1); + this.s.toBuffer(32).copy(buffer, 33); + + return buffer; +}; + +ECSignature.prototype.toDER = function toDER() { + var rBa = this.r.toDERInteger(); + var sBa = this.s.toDERInteger(); + + var sequence = []; + + // INTEGER + sequence.push(0x02, rBa.length); + sequence = sequence.concat(rBa); + + // INTEGER + sequence.push(0x02, sBa.length); + sequence = sequence.concat(sBa); + + // SEQUENCE + sequence.unshift(0x30, sequence.length); + + return Buffer.from(sequence); +}; + +ECSignature.prototype.toScriptSignature = function toScriptSignature(hashType) { + var hashTypeBuffer = Buffer.alloc(1); + hashTypeBuffer.writeUInt8(hashType, 0); + + return Buffer.concat([this.toDER(), hashTypeBuffer]); +}; + +exports.default = ECSignature; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"16":16,"27":27,"32":32,"35":35}],16:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; +exports.default = enforce; + +function getName(fn) { + // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property + var match = fn.toString().match(/function (.*?)\(/); + return match ? match[1] : null; +} + +function enforce(type, value) { + // Copied from https://github.com/bitcoinjs/bitcoinjs-lib + switch (type) { + case 'Array': + { + if (Array.isArray(value)) { + return; + } + + break; + } + + case 'Boolean': + { + if (typeof value === 'boolean') { + return; + } + + break; + } + + case 'Buffer': + { + if (Buffer.isBuffer(value)) { + return; + } + + break; + } + + case 'Number': + { + if (typeof value === 'number') { + return; + } + + break; + } + + case 'String': + { + if (typeof value === 'string') { + return; + } + + break; + } + + default: + { + if (getName(value.constructor) === getName(type)) { + return; + } + } + } + + throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value); +} +module.exports = exports['default']; +}).call(this,{"isBuffer":require(66)}) + +},{"66":66}],17:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +exports.ripemd160 = exports.HmacSHA256 = exports.sha512 = exports.sha256 = exports.sha1 = undefined; + +var _createHash = require(41); + +var _createHash2 = _interopRequireDefault(_createHash); + +var _createHmac = require(43); + +var _createHmac2 = _interopRequireDefault(_createHmac); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha1(data, encoding) { + return (0, _createHash2.default)('sha1').update(data).digest(encoding); +} + +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha256(data, encoding) { + return (0, _createHash2.default)('sha256').update(data).digest(encoding); +} + +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha512(data, encoding) { + return (0, _createHash2.default)('sha512').update(data).digest(encoding); +} + +function HmacSHA256(buffer, secret) { + return (0, _createHmac2.default)('sha256', secret).update(buffer).digest(); +} + +function ripemd160(data) { + return (0, _createHash2.default)('rmd160').update(data).digest(); +} + +// function hash160(buffer) { +// return ripemd160(sha256(buffer)) +// } +// +// function hash256(buffer) { +// return sha256(sha256(buffer)) +// } + +// +// function HmacSHA512(buffer, secret) { +// return crypto.createHmac('sha512', secret).update(buffer).digest() +// } + +exports.sha1 = sha1; +exports.sha256 = sha256; +exports.sha512 = sha512; +exports.HmacSHA256 = HmacSHA256; +exports.ripemd160 = ripemd160; +},{"41":41,"43":43}],18:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _ecurve = require(59); + +var _assert = require(27); + +var _assert2 = _interopRequireDefault(_assert); + +var _bigi = require(32); + +var _bigi2 = _interopRequireDefault(_bigi); + +var _hash2 = require(17); + +var _ecdsa = require(14); + +var _PublicKey = require(11); + +var _PublicKey2 = _interopRequireDefault(_PublicKey); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* global ByteBuffer */ + + +var secp256k1 = (0, _ecurve.getCurveByName)('secp256k1'); + +var Signature = function () { + function Signature(r1, s1, i1) { + _classCallCheck(this, Signature); + + this.r = r1; + this.s = s1; + this.i = i1; + _assert2.default.equal(this.r != null, true, 'Missing parameter'); + _assert2.default.equal(this.s != null, true, 'Missing parameter'); + _assert2.default.equal(this.i != null, true, 'Missing parameter'); + } + + Signature.fromBuffer = function fromBuffer(buf) { + var i = void 0; + var r = void 0; + var s = void 0; + _assert2.default.equal(buf.length, 65, 'Invalid signature length'); + i = buf.readUInt8(0); + _assert2.default.equal(i - 27, i - 27 & 7, 'Invalid signature parameter'); // eslint-disable-line + r = _bigi2.default.fromBuffer(buf.slice(1, 33)); + s = _bigi2.default.fromBuffer(buf.slice(33)); + return new Signature(r, s, i); + }; + + Signature.prototype.toBuffer = function toBuffer() { + var buf = void 0; + buf = Buffer.alloc(65); + buf.writeUInt8(this.i, 0); + this.r.toBuffer(32).copy(buf, 1); + this.s.toBuffer(32).copy(buf, 33); + return buf; + }; + + Signature.prototype.recoverPublicKeyFromBuffer = function recoverPublicKeyFromBuffer(buffer) { + return this.recoverPublicKey((0, _hash2.sha256)(buffer)); + }; + + /** + @return {PublicKey} + */ + + + Signature.prototype.recoverPublicKey = function recoverPublicKey(sha256_buffer) { + var Q = void 0; + var e = void 0; + var i = void 0; + e = _bigi2.default.fromBuffer(sha256_buffer); + i = this.i; + i -= 27; + i &= 3; // eslint-disable-line + Q = (0, _ecdsa.recoverPubKey)(secp256k1, e, this, i); + return _PublicKey2.default.fromPoint(Q); + }; + + /** + @param {Buffer} buf + @param {PrivateKey} private_key + @return {Signature} + */ + + + Signature.signBuffer = function signBuffer(buf, private_key) { + var _hash = (0, _hash2.sha256)(buf); + return Signature.signBufferSha256(_hash, private_key); + }; + + /** Sign a buffer of exactally 32 bytes in size (sha256(text)) + @param {Buffer} buf - 32 bytes binary + @param {PrivateKey} private_key + @return {Signature} + */ + + + Signature.signBufferSha256 = function signBufferSha256(buf_sha256, private_key) { + if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) { + throw new Error('buf_sha256: 32 byte buffer requred'); + } + + var der = void 0; + var e = void 0; + var ecsignature = void 0; + var i = void 0; + var lenR = void 0; + var lenS = void 0; + var nonce = void 0; + i = null; + nonce = 0; + e = _bigi2.default.fromBuffer(buf_sha256); + + var loop = true; + + while (loop) { + ecsignature = (0, _ecdsa.sign)(secp256k1, buf_sha256, private_key.d, nonce++); + der = ecsignature.toDER(); + lenR = der[3]; + lenS = der[5 + lenR]; + + if (lenR === 32 && lenS === 32) { + i = (0, _ecdsa.calcPubKeyRecoveryParam)(secp256k1, e, ecsignature, private_key.toPublicKey().Q); + i += 4; // compressed + i += 27; // compact // 24 or 27 :( forcing odd-y 2nd key candidate) + loop = false; + break; + } + + if (nonce % 10 === 0) { + console.log('WARN: ' + nonce + ' attempts to find canonical signature'); + } + } + + return new Signature(ecsignature.r, ecsignature.s, i); + }; + + Signature.sign = function sign(string, private_key) { + return Signature.signBuffer(Buffer.from(string), private_key); + }; + + /** + @param {Buffer} un-hashed + @param {./PublicKey} + @return {boolean} + */ + + + Signature.prototype.verifyBuffer = function verifyBuffer(buf, public_key) { + var _hash = (0, _hash2.sha256)(buf); + return this.verifyHash(_hash, public_key); + }; + + Signature.prototype.verifyHash = function verifyHash(hash, public_key) { + _assert2.default.equal(hash.length, 32, 'A SHA 256 should be 32 bytes long, instead got ' + hash.length); + return (0, _ecdsa.verify)(secp256k1, hash, { + r: this.r, + s: this.s + }, public_key.Q); + }; + + /* */ + + Signature.prototype.toByteBuffer = function toByteBuffer() { + var b = void 0; + b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + }; + + Signature.fromHex = function fromHex(hex) { + return Signature.fromBuffer(Buffer.from(hex, 'hex')); + }; + + Signature.prototype.toHex = function toHex() { + return this.toBuffer().toString('hex'); + }; + + Signature.signHex = function signHex(hex, private_key) { + var buf = void 0; + buf = Buffer.from(hex, 'hex'); + return Signature.signBuffer(buf, private_key); + }; + + Signature.prototype.verifyHex = function verifyHex(hex, public_key) { + var buf = void 0; + buf = Buffer.from(hex, 'hex'); + return this.verifyBuffer(buf, public_key); + }; + + return Signature; +}(); + +exports.default = Signature; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"11":11,"14":14,"17":17,"27":27,"32":32,"35":35,"59":59}],19:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +exports.SerializerValidation = exports.template = exports.ops = exports.types = exports.fp = exports.Serializer = undefined; + +var _serializer = require(24); + +var _serializer2 = _interopRequireDefault(_serializer); + +var _FastParser = require(20); + +var _FastParser2 = _interopRequireDefault(_FastParser); + +var _types = require(26); + +var _types2 = _interopRequireDefault(_types); + +var _operations = require(23); + +var ops = _interopRequireWildcard(_operations); + +var _template = require(25); + +var _template2 = _interopRequireDefault(_template); + +var _SerializerValidation = require(21); + +var _SerializerValidation2 = _interopRequireDefault(_SerializerValidation); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.Serializer = _serializer2.default; +exports.fp = _FastParser2.default; +exports.types = _types2.default; +exports.ops = ops; +exports.template = _template2.default; +exports.SerializerValidation = _SerializerValidation2.default; +},{"20":20,"21":21,"23":23,"24":24,"25":25,"26":26}],20:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +exports.__esModule = true; + +var _PublicKey = require(11); + +var _PublicKey2 = _interopRequireDefault(_PublicKey); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var FastParser = function () { + function FastParser() { + _classCallCheck(this, FastParser); + } + + FastParser.fixed_data = function fixed_data(b, len, buffer) { + if (!b) { + return; + } + if (buffer) { + var data = buffer.slice(0, len).toString('binary'); + b.append(data, 'binary'); + while (len-- > data.length) { + b.writeUint8(0); + } + } else { + var b_copy = b.copy(b.offset, b.offset + len); + b.skip(len); + return Buffer.from(b_copy.toBinary(), 'binary'); + } + }; + + FastParser.public_key = function public_key(b, _public_key) { + var buffer = void 0; + if (!b) { + return; + } + if (_public_key) { + buffer = _public_key.toBuffer(); + b.append(buffer.toString('binary'), 'binary'); + } else { + buffer = FastParser.fixed_data(b, 33); + return _PublicKey2.default.fromBuffer(buffer); + } + }; + + FastParser.ripemd160 = function ripemd160(b, _ripemd) { + if (!b) { + return; + } + if (_ripemd) { + FastParser.fixed_data(b, 20, _ripemd); + } else { + return FastParser.fixed_data(b, 20); + } + }; + + FastParser.sha256 = function sha256(b, _sha) { + if (!b) { + return; + } + if (_sha) { + FastParser.fixed_data(b, 32, _sha); + } else { + return FastParser.fixed_data(b, 32); + } + }; + + FastParser.time_point_sec = function time_point_sec(b, epoch) { + if (epoch) { + epoch = Math.ceil(epoch / 1000); + b.writeInt32(epoch); + } else { + epoch = b.readInt32(); // fc::time_point_sec + return new Date(epoch * 1000); + } + }; + + return FastParser; +}(); + +exports.default = FastParser; +module.exports = exports['default']; +}).call(this,require(35).Buffer) + +},{"11":11,"35":35}],21:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _bytebuffer = require(38); + +var _ChainTypes = require(3); + +var _ChainTypes2 = _interopRequireDefault(_ChainTypes); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var MAX_SAFE_INT = 9007199254740991; +var MIN_SAFE_INT = -9007199254740991; + +/** + Most validations are skipped and the value returned unchanged when an empty string, + null, or undefined is encountered (except "required"). + Validations support a string format for dealing with large numbers. +*/ +var _my = { + is_empty: function is_empty(value) { + return value === null || value === undefined; + }, + required: function required(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + throw new Error('value required ' + field_name + ' | ' + value); + } + + return value; + }, + require_long: function require_long(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (!_bytebuffer.Long.isLong(value)) { + throw new Error('Long value required ' + field_name + ' | ' + value); + } + + return value; + }, + string: function string(value) { + if (this.is_empty(value)) { + return value; + } + + if (typeof value !== 'string') { + throw new Error('string required: ' + value); + } + + return value; + }, + number: function number(value) { + if (this.is_empty(value)) { + return value; + } + + if (typeof value !== 'number') { + throw new Error('number required: ' + value); + } + + return value; + }, + whole_number: function whole_number(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + return value; + } + + if (/\./.test(value)) { + throw new Error('whole number required ' + field_name + ' ' + value); + } + + return value; + }, + unsigned: function unsigned(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + return value; + } + + if (/-/.test(value)) { + throw new Error('unsigned required ' + field_name + ' ' + value); + } + + return value; + }, + is_digits: function is_digits(value) { + if (typeof value === 'number') { + return true; + } + + return (/^[0-9]+$/.test(value) + ); + }, + to_number: function to_number(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + return value; + } + + this.no_overflow53(value, field_name); + var int_value = function () { + if (typeof value === 'number') { + return value; + } + + return parseInt(value, 10); + }(); + return int_value; + }, + to_long: function to_long(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + return value; + } + + if (_bytebuffer.Long.isLong(value)) { + return value; + } + + this.no_overflow64(value, field_name); + + if (typeof value === 'number') { + value = '' + value; + } + + return _bytebuffer.Long.fromString(value); + }, + to_ulong: function to_ulong(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + return value; + } + + if (_bytebuffer.Long.isLong(value)) { + return value; + } + + this.no_overflow64(value, field_name, true); + + if (typeof value === 'number') { + value = '' + value; + } + + return _bytebuffer.Long.fromString(value, true); + }, + to_string: function to_string(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (this.is_empty(value)) { + return value; + } + + if (typeof value === 'string') { + return value; + } + + if (typeof value === 'number') { + this.no_overflow53(value, field_name); + return '' + value; + } + + if (_bytebuffer.Long.isLong(value)) { + return value.toString(); + } + + throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value); + }, + require_test: function require_test(regex, value) { + var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; + + if (this.is_empty(value)) { + return value; + } + + if (!regex.test(value)) { + throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); + } + + return value; + }, + require_match: function require_match(regex, value) { + var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; + + if (this.is_empty(value)) { + return value; + } + + var match = value.match(regex); + + if (match === null) { + throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); + } + + return match; + }, + require_object_id: function require_object_id(value, field_name) { + return this.require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, value, field_name); + }, + + + // Does not support over 53 bits + require_range: function require_range(min, max, value) { + var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ''; + + if (this.is_empty(value)) { + return value; + } + + var num = this.to_number(value); + + if (num < min || num > max) { + throw new Error('out of range ' + value + ' ' + field_name + ' ' + value); + } + + return value; + }, + require_object_type: function require_object_type() { + var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var type = arguments[1]; + var value = arguments[2]; + var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ''; + + if (this.is_empty(value)) { + return value; + } + + var object_type = _ChainTypes2.default.object_type[type]; + + if (!object_type) { + throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value); + } + + var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$'); + + if (!re.test(value)) { + throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value)); + } + + return value; + }, + get_instance: function get_instance(reserve_spaces, type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + + this.require_object_type(reserve_spaces, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + require_relative_type: function require_relative_type(type, value, field_name) { + this.require_object_type(0, type, value, field_name); + return value; + }, + get_relative_instance: function get_relative_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + + this.require_object_type(0, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + require_protocol_type: function require_protocol_type(type, value, field_name) { + this.require_object_type(1, type, value, field_name); + return value; + }, + get_protocol_instance: function get_protocol_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + + this.require_object_type(1, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + get_protocol_type: function get_protocol_type(value, field_name) { + if (this.is_empty(value)) { + return value; + } + + this.require_object_id(value, field_name); + var values = value.split('.'); + return this.to_number(values[1]); + }, + get_protocol_type_name: function get_protocol_type_name(value, field_name) { + if (this.is_empty(value)) { + return value; + } + + var type_id = this.get_protocol_type(value, field_name); + return Object.keys(_ChainTypes2.default.object_type)[type_id]; + }, + require_implementation_type: function require_implementation_type(type, value, field_name) { + this.require_object_type(2, type, value, field_name); + return value; + }, + get_implementation_instance: function get_implementation_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + + this.require_object_type(2, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + + + // signed / unsigned decimal + no_overflow53: function no_overflow53(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + if (typeof value === 'number') { + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + + return; + } + + if (typeof value === 'string') { + var int = parseInt(value, 10); + + if (int > MAX_SAFE_INT || int < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + int); + } + + return; + } + + if (_bytebuffer.Long.isLong(value)) { + // typeof value.toInt() is 'number' + this.no_overflow53(value.toInt(), field_name); + return; + } + + throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value); + }, + + + // signed / unsigned whole numbers only + no_overflow64: function no_overflow64(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + // https://github.com/dcodeIO/Long.js/issues/20 + if (_bytebuffer.Long.isLong(value)) { + return; + } + + // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20 + if (value.t !== undefined && value.s !== undefined) { + this.no_overflow64(value.toString(), field_name, unsigned); + + return; + } + + if (typeof value === 'string') { + // remove leading zeros, will cause a false positive + value = value.replace(/^0+/, ''); + + // remove trailing zeros + while (/0$/.test(value)) { + value = value.substring(0, value.length - 1); + } + + if (/\.$/.test(value)) { + // remove trailing dot + value = value.substring(0, value.length - 1); + } + + if (value === '') { + value = '0'; + } + + var long_string = _bytebuffer.Long.fromString(value, unsigned).toString(); + + if (long_string !== value.trim()) { + throw new Error('overflow ' + field_name + ' ' + value); + } + + return; + } + + if (typeof value === 'number') { + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + + return; + } + + throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value); + } +}; + +exports.default = _my; +module.exports = exports['default']; +},{"3":3,"38":38}],22:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** Exception nesting. */ +var ErrorWithCause = function () { + function ErrorWithCause(message, cause) { + _classCallCheck(this, ErrorWithCause); + + this.message = message; + + if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) { + this.message = 'cause\t' + cause.message + '\t' + this.message; + } + + var stack = ''; // (new Error).stack + + if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) { + stack = 'caused by\n\t' + cause.stack + '\t' + stack; + } + + this.stack = this.message + '\n' + stack; + } + + ErrorWithCause.throw = function _throw(message, cause) { + var msg = message; + + if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) { + msg += '\t cause: ' + cause.message + ' '; + } + + if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) { + msg += '\n stack: ' + cause.stack + ' '; + } + + throw new Error(msg); + }; + + return ErrorWithCause; +}(); + +exports.default = ErrorWithCause; +module.exports = exports['default']; +},{}],23:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +exports.stealth_memo_data = exports.global_betting_statistics = exports.betting_market_position = exports.bet = exports.betting_market = exports.betting_market_group = exports.betting_market_rules = exports.event = exports.event_group = exports.sport = exports.signed_transaction = exports.transaction = exports.bet_adjusted = exports.betting_market_update = exports.betting_market_group_update = exports.tournament_leave = exports.tournament_payout = exports.payout_type = exports.bet_canceled = exports.bet_cancel = exports.bet_matched = exports.betting_market_group_cancel_unmatched_bets = exports.betting_market_group_resolved = exports.betting_market_group_resolve = exports.betting_market_resolution_type = exports.bet_place = exports.bet_type = exports.betting_market_create = exports.betting_market_group_create = exports.betting_market_rules_update = exports.betting_market_rules_create = exports.event_update = exports.event_create = exports.event_group_update = exports.event_group_create = exports.sport_update = exports.sport_create = exports.asset_dividend_distribution = exports.asset_update_dividend = exports.dividend_asset_options = exports.game_move = exports.rock_paper_scissors_throw_reveal = exports.rock_paper_scissors_throw_commit = exports.rock_paper_scissors_gesture = exports.tournament_join = exports.tournament_create = exports.tournament_options = exports.rock_paper_scissors_game_options = exports.fba_distribute = exports.asset_claim_fees = exports.asset_settle_cancel = exports.transfer_from_blind = exports.blind_transfer = exports.blind_input = exports.transfer_to_blind = exports.blind_output = exports.stealth_confirmation = exports.override_transfer = exports.balance_claim = exports.assert = exports.block_id_predicate = exports.asset_symbol_eq_lit_predicate = exports.account_name_eq_lit_predicate = exports.custom = exports.worker_create = exports.burn_worker_initializer = exports.vesting_balance_worker_initializer = exports.refund_worker_initializer = exports.vesting_balance_withdraw = exports.vesting_balance_create = exports.cdd_vesting_policy_initializer = exports.linear_vesting_policy_initializer = exports.committee_member_update_global_parameters = exports.chain_parameters = exports.committee_member_update = exports.committee_member_create = exports.withdraw_permission_delete = exports.withdraw_permission_claim = exports.withdraw_permission_update = exports.withdraw_permission_create = exports.proposal_delete = exports.proposal_update = exports.proposal_create = exports.op_wrapper = exports.witness_update = exports.witness_create = exports.asset_publish_feed = exports.price_feed = exports.asset_global_settle = exports.asset_settle = exports.asset_fund_fee_pool = exports.asset_reserve = exports.asset_issue = undefined; +exports.asset_update_feed_producers = exports.asset_update_bitasset = exports.asset_update = exports.asset_create = exports.bitasset_options = exports.asset_options = exports.price = exports.account_transfer = exports.account_upgrade = exports.account_whitelist = exports.account_update = exports.account_create = exports.account_options = exports.authority = exports.fill_order = exports.call_order_update = exports.limit_order_cancel = exports.limit_order_create = exports.transfer = exports.memo_data = exports.signed_block_header = exports.block_header = exports.signed_block = exports.processed_transaction = exports.asset = exports.void_result = exports.fee_schedule = exports.bet_adjusted_operation_fee_parameters = exports.betting_market_update_operation_fee_parameters = exports.betting_market_group_update_operation_fee_parameters = exports.tournament_leave_operation_fee_parameters = exports.tournament_payout_operation_fee_parameters = exports.game_move_operation_fee_parameters = exports.tournament_join_operation_fee_parameters = exports.tournament_create_operation_fee_parameters = exports.bet_canceled_operation_fee_parameters = exports.bet_cancel_operation_fee_parameters = exports.bet_matched_operation_fee_parameters = exports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = exports.betting_market_group_resolved_operation_fee_parameters = exports.betting_market_group_resolve_operation_fee_parameters = exports.bet_place_operation_fee_parameters = exports.betting_market_create_operation_fee_parameters = exports.betting_market_group_create_operation_fee_parameters = exports.betting_market_rules_update_operation_fee_parameters = exports.betting_market_rules_create_operation_fee_parameters = exports.event_update_operation_fee_parameters = exports.event_create_operation_fee_parameters = exports.event_group_update_operation_fee_parameters = exports.event_group_create_operation_fee_parameters = exports.sport_update_operation_fee_parameters = exports.sport_create_operation_fee_parameters = exports.asset_dividend_distribution_operation_fee_parameters = exports.asset_update_dividend_operation_fee_parameters = exports.fba_distribute_operation_fee_parameters = exports.asset_claim_fees_operation_fee_parameters = exports.asset_settle_cancel_operation_fee_parameters = exports.transfer_from_blind_operation_fee_parameters = exports.blind_transfer_operation_fee_parameters = exports.transfer_to_blind_operation_fee_parameters = exports.override_transfer_operation_fee_parameters = exports.balance_claim_operation_fee_parameters = exports.assert_operation_fee_parameters = exports.custom_operation_fee_parameters = exports.worker_create_operation_fee_parameters = exports.vesting_balance_withdraw_operation_fee_parameters = exports.vesting_balance_create_operation_fee_parameters = exports.committee_member_update_global_parameters_operation_fee_parameters = exports.committee_member_update_operation_fee_parameters = exports.committee_member_create_operation_fee_parameters = exports.withdraw_permission_delete_operation_fee_parameters = exports.withdraw_permission_claim_operation_fee_parameters = exports.withdraw_permission_update_operation_fee_parameters = exports.withdraw_permission_create_operation_fee_parameters = exports.proposal_delete_operation_fee_parameters = exports.proposal_update_operation_fee_parameters = exports.proposal_create_operation_fee_parameters = exports.witness_update_operation_fee_parameters = exports.witness_create_operation_fee_parameters = exports.asset_publish_feed_operation_fee_parameters = exports.asset_global_settle_operation_fee_parameters = exports.asset_settle_operation_fee_parameters = exports.asset_fund_fee_pool_operation_fee_parameters = exports.asset_reserve_operation_fee_parameters = exports.asset_issue_operation_fee_parameters = exports.asset_update_feed_producers_operation_fee_parameters = exports.asset_update_bitasset_operation_fee_parameters = exports.asset_update_operation_fee_parameters = exports.asset_create_operation_fee_parameters = exports.account_transfer_operation_fee_parameters = exports.account_upgrade_operation_fee_parameters = exports.account_whitelist_operation_fee_parameters = exports.account_update_operation_fee_parameters = exports.account_create_operation_fee_parameters = exports.fill_order_operation_fee_parameters = exports.call_order_update_operation_fee_parameters = exports.limit_order_cancel_operation_fee_parameters = exports.limit_order_create_operation_fee_parameters = exports.transfer_operation_fee_parameters = exports.operation = undefined; + +var _types = require(26); + +var _types2 = _interopRequireDefault(_types); + +var _serializer = require(24); + +var _serializer2 = _interopRequireDefault(_serializer); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var uint8 = _types2.default.uint8, + uint16 = _types2.default.uint16, + uint32 = _types2.default.uint32, + int64 = _types2.default.int64, + uint64 = _types2.default.uint64, + string = _types2.default.string, + bytes = _types2.default.bytes, + bool = _types2.default.bool, + array = _types2.default.array, + protocol_id_type = _types2.default.protocol_id_type, + object_id_type = _types2.default.object_id_type, + vote_id = _types2.default.vote_id, + implementation_id_type = _types2.default.implementation_id_type, + static_variant = _types2.default.static_variant, + map = _types2.default.map, + set = _types2.default.set, + public_key = _types2.default.public_key, + address = _types2.default.address, + time_point_sec = _types2.default.time_point_sec, + optional = _types2.default.optional, + variant_object = _types2.default.variant_object, + enumeration = _types2.default.enumeration, + sha256 = _types2.default.sha256; + + +var future_extensions = _types2.default.void; + +/* +When updating generated code +Replace: operation = static_variant [ +with: operation.st_operations = [ + +Delete: +public_key = new Serializer( + "public_key" + key_data: bytes 33 +); +*/ + +function Serializer(operation_name, serilization_types_object) { + return new _serializer2.default(operation_name, serilization_types_object); +} +// Place-holder, their are dependencies on "operation" .. The final list of +// operations is not avialble until the very end of the generated code. +// See: operation.st_operations = ... +// module.exports["operation"] = operation; + +var operation = static_variant(); + +// Custom-types follow Generated code: + +// ## Generated code follows +// # programs/js_operation_serializer > npm i -g decaffeinate +// ## ------------------------------- +var transfer_operation_fee_parameters = new Serializer('transfer_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var limit_order_create_operation_fee_parameters = new Serializer('limit_order_create_operation_fee_parameters', { + fee: uint64 +}); + +var limit_order_cancel_operation_fee_parameters = new Serializer('limit_order_cancel_operation_fee_parameters', { + fee: uint64 +}); + +var call_order_update_operation_fee_parameters = new Serializer('call_order_update_operation_fee_parameters', { + fee: uint64 +}); + +var fill_order_operation_fee_parameters = new Serializer('fill_order_operation_fee_parameters'); + +var account_create_operation_fee_parameters = new Serializer('account_create_operation_fee_parameters', { + basic_fee: uint64, + premium_fee: uint64, + price_per_kbyte: uint32 +}); + +var account_update_operation_fee_parameters = new Serializer('account_update_operation_fee_parameters', { + fee: int64, + price_per_kbyte: uint32 +}); + +var account_whitelist_operation_fee_parameters = new Serializer('account_whitelist_operation_fee_parameters', { + fee: int64 +}); + +var account_upgrade_operation_fee_parameters = new Serializer('account_upgrade_operation_fee_parameters', { + membership_annual_fee: uint64, + membership_lifetime_fee: uint64 +}); + +var account_transfer_operation_fee_parameters = new Serializer('account_transfer_operation_fee_parameters', { + fee: uint64 +}); + +var asset_create_operation_fee_parameters = new Serializer('asset_create_operation_fee_parameters', { + symbol3: uint64, + symbol4: uint64, + long_symbol: uint64, + price_per_kbyte: uint32 +}); + +var asset_update_operation_fee_parameters = new Serializer('asset_update_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var asset_update_bitasset_operation_fee_parameters = new Serializer('asset_update_bitasset_operation_fee_parameters', { + fee: uint64 +}); + +var asset_update_feed_producers_operation_fee_parameters = new Serializer('asset_update_feed_producers_operation_fee_parameters', { + fee: uint64 +}); + +var asset_issue_operation_fee_parameters = new Serializer('asset_issue_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var asset_reserve_operation_fee_parameters = new Serializer('asset_reserve_operation_fee_parameters', { + fee: uint64 +}); + +var asset_fund_fee_pool_operation_fee_parameters = new Serializer('asset_fund_fee_pool_operation_fee_parameters', { + fee: uint64 +}); + +var asset_settle_operation_fee_parameters = new Serializer('asset_settle_operation_fee_parameters', { + fee: uint64 +}); + +var asset_global_settle_operation_fee_parameters = new Serializer('asset_global_settle_operation_fee_parameters', { + fee: uint64 +}); + +var asset_publish_feed_operation_fee_parameters = new Serializer('asset_publish_feed_operation_fee_parameters', { + fee: uint64 +}); + +var witness_create_operation_fee_parameters = new Serializer('witness_create_operation_fee_parameters', { + fee: uint64 +}); + +var witness_update_operation_fee_parameters = new Serializer('witness_update_operation_fee_parameters', { + fee: int64 +}); + +var proposal_create_operation_fee_parameters = new Serializer('proposal_create_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var proposal_update_operation_fee_parameters = new Serializer('proposal_update_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var proposal_delete_operation_fee_parameters = new Serializer('proposal_delete_operation_fee_parameters', { + fee: uint64 +}); + +var withdraw_permission_create_operation_fee_parameters = new Serializer('withdraw_permission_create_operation_fee_parameters', { + fee: uint64 +}); + +var withdraw_permission_update_operation_fee_parameters = new Serializer('withdraw_permission_update_operation_fee_parameters', { + fee: uint64 +}); + +var withdraw_permission_claim_operation_fee_parameters = new Serializer('withdraw_permission_claim_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var withdraw_permission_delete_operation_fee_parameters = new Serializer('withdraw_permission_delete_operation_fee_parameters', { + fee: uint64 +}); + +var committee_member_create_operation_fee_parameters = new Serializer('committee_member_create_operation_fee_parameters', { + fee: uint64 +}); + +var committee_member_update_operation_fee_parameters = new Serializer('committee_member_update_operation_fee_parameters', { + fee: uint64 +}); + +var committee_member_update_global_parameters_operation_fee_parameters = new Serializer('committee_member_update_global_parameters_operation_fee_parameters', { + fee: uint64 +}); + +var vesting_balance_create_operation_fee_parameters = new Serializer('vesting_balance_create_operation_fee_parameters', { + fee: uint64 +}); + +var vesting_balance_withdraw_operation_fee_parameters = new Serializer('vesting_balance_withdraw_operation_fee_parameters', { + fee: uint64 +}); + +var worker_create_operation_fee_parameters = new Serializer('worker_create_operation_fee_parameters', { + fee: uint64 +}); + +var custom_operation_fee_parameters = new Serializer('custom_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var assert_operation_fee_parameters = new Serializer('assert_operation_fee_parameters', { + fee: uint64 +}); + +var balance_claim_operation_fee_parameters = new Serializer('balance_claim_operation_fee_parameters'); + +var override_transfer_operation_fee_parameters = new Serializer('override_transfer_operation_fee_parameters', { + fee: uint64, + price_per_kbyte: uint32 +}); + +var transfer_to_blind_operation_fee_parameters = new Serializer('transfer_to_blind_operation_fee_parameters', { + fee: uint64, + price_per_output: uint32 +}); + +var blind_transfer_operation_fee_parameters = new Serializer('blind_transfer_operation_fee_parameters', { + fee: uint64, + price_per_output: uint32 +}); + +var transfer_from_blind_operation_fee_parameters = new Serializer('transfer_from_blind_operation_fee_parameters', { + fee: uint64 +}); + +var asset_settle_cancel_operation_fee_parameters = new Serializer('asset_settle_cancel_operation_fee_parameters'); + +var asset_claim_fees_operation_fee_parameters = new Serializer('asset_claim_fees_operation_fee_parameters', { + fee: uint64 +}); + +var fba_distribute_operation_fee_parameters = new Serializer('fba_distribute_operation_fee_parameters', {}); + +var asset_update_dividend_operation_fee_parameters = new Serializer('asset_update_dividend_operation_fee_parameters', { + fee: uint64 +}); + +var asset_dividend_distribution_operation_fee_parameters = new Serializer('asset_dividend_distribution_operation_fee_parameters', { + distribution_base_fee: uint64, + distribution_fee_per_holder: uint32 +}); + +var sport_create_operation_fee_parameters = new Serializer('sport_create_operation_fee_parameters', { + fee: uint64 +}); + +var sport_update_operation_fee_parameters = new Serializer('sport_update_operation_fee_parameters', { + fee: uint64 +}); + +var event_group_create_operation_fee_parameters = new Serializer('event_group_create_operation_fee_parameters', { + fee: uint64 +}); + +var event_group_update_operation_fee_parameters = new Serializer('event_group_update_operation_fee_parameters', { + fee: uint64 +}); + +var event_create_operation_fee_parameters = new Serializer('event_create_operation_fee_parameters', { + fee: uint64 +}); + +var event_update_operation_fee_parameters = new Serializer('event_update_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_rules_create_operation_fee_parameters = new Serializer('betting_market_rules_create_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_rules_update_operation_fee_parameters = new Serializer('betting_market_rules_update_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_group_create_operation_fee_parameters = new Serializer('betting_market_group_create_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_create_operation_fee_parameters = new Serializer('betting_market_create_operation_fee_parameters', { + fee: uint64 +}); + +var bet_place_operation_fee_parameters = new Serializer('bet_place_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_group_resolve_operation_fee_parameters = new Serializer('betting_market_group_resolve_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_group_resolved_operation_fee_parameters = new Serializer('betting_market_group_resolved_operation_fee_parameters'); + +var betting_market_group_cancel_unmatched_bets_operation_fee_parameters = new Serializer('betting_market_group_cancel_unmatched_bets_operation_fee_parameters', { + fee: uint64 +}); + +var bet_matched_operation_fee_parameters = new Serializer('bet_matched_operation_fee_parameters'); + +var bet_cancel_operation_fee_parameters = new Serializer('bet_cancel_operation_fee_parameters', { + fee: uint64 +}); + +var bet_canceled_operation_fee_parameters = new Serializer('bet_canceled_operation_fee_parameters'); + +var tournament_create_operation_fee_parameters = new Serializer('tournament_create_operation_fee_parameters', { + fee: int64 +}); + +var tournament_join_operation_fee_parameters = new Serializer('tournament_join_operation_fee_parameters', { + fee: int64 +}); + +var game_move_operation_fee_parameters = new Serializer('game_move_operation_fee_parameters', { + fee: int64 +}); + +var tournament_payout_operation_fee_parameters = new Serializer('tournament_payout_operation_fee_parameters'); + +var tournament_leave_operation_fee_parameters = new Serializer('tournament_leave_operation_fee_parameters', { + fee: int64 +}); + +var betting_market_group_update_operation_fee_parameters = new Serializer('betting_market_group_update_operation_fee_parameters', { + fee: uint64 +}); + +var betting_market_update_operation_fee_parameters = new Serializer('betting_market_update_operation_fee_parameters', { + fee: uint64 +}); + +var bet_adjusted_operation_fee_parameters = new Serializer('bet_adjusted_operation_fee_parameters'); + +var fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters, game_move_operation_fee_parameters, asset_update_dividend_operation_fee_parameters, asset_dividend_distribution_operation_fee_parameters, tournament_payout_operation_fee_parameters, tournament_leave_operation_fee_parameters, sport_create_operation_fee_parameters, sport_update_operation_fee_parameters, event_group_create_operation_fee_parameters, event_group_update_operation_fee_parameters, event_create_operation_fee_parameters, event_update_operation_fee_parameters, betting_market_rules_create_operation_fee_parameters, betting_market_rules_update_operation_fee_parameters, betting_market_group_create_operation_fee_parameters, betting_market_create_operation_fee_parameters, bet_place_operation_fee_parameters, betting_market_group_resolve_operation_fee_parameters, betting_market_group_resolved_operation_fee_parameters, bet_adjusted_operation_fee_parameters, betting_market_group_cancel_unmatched_bets_operation_fee_parameters, bet_matched_operation_fee_parameters, bet_cancel_operation_fee_parameters, bet_canceled_operation_fee_parameters, betting_market_group_update_operation_fee_parameters, betting_market_update_operation_fee_parameters +// Missing event_update_status +]); + +var fee_schedule = new Serializer('fee_schedule', { + parameters: set(fee_parameters), + scale: uint32 +}); + +var void_result = new Serializer('void_result'); + +var asset = new Serializer('asset', { + amount: int64, + asset_id: protocol_id_type('asset') +}); + +var operation_result = static_variant([void_result, object_id_type, asset]); + +var processed_transaction = new Serializer('processed_transaction', { + ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions), + signatures: array(bytes(65)), + operation_results: array(operation_result) +}); + +var signed_block = new Serializer('signed_block', { + previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type('witness'), + next_secret_hash: bytes(20), + previous_secret: bytes(20), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions), + witness_signature: bytes(65), + transactions: array(processed_transaction) +}); + +var block_header = new Serializer('block_header', { + previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type('witness'), + next_secret_hash: bytes(20), + previous_secret: bytes(20), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions) +}); + +var signed_block_header = new Serializer('signed_block_header', { + previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type('witness'), + next_secret_hash: bytes(20), + previous_secret: bytes(20), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions), + witness_signature: bytes(65) +}); + +var memo_data = new Serializer('memo_data', { + from: public_key, + to: public_key, + nonce: uint64, + message: bytes() +}); + +var transfer = new Serializer('transfer', { + fee: asset, + from: protocol_id_type('account'), + to: protocol_id_type('account'), + amount: asset, + memo: optional(memo_data), + extensions: set(future_extensions) +}); + +var limit_order_create = new Serializer('limit_order_create', { + fee: asset, + seller: protocol_id_type('account'), + amount_to_sell: asset, + min_to_receive: asset, + expiration: time_point_sec, + fill_or_kill: bool, + extensions: set(future_extensions) +}); + +var limit_order_cancel = new Serializer('limit_order_cancel', { + fee: asset, + fee_paying_account: protocol_id_type('account'), + order: protocol_id_type('limit_order'), + extensions: set(future_extensions) +}); + +var call_order_update = new Serializer('call_order_update', { + fee: asset, + funding_account: protocol_id_type('account'), + delta_collateral: asset, + delta_debt: asset, + extensions: set(future_extensions) +}); + +var fill_order = new Serializer('fill_order', { + fee: asset, + order_id: object_id_type, + account_id: protocol_id_type('account'), + pays: asset, + receives: asset +}); + +var authority = new Serializer('authority', { + weight_threshold: uint32, + account_auths: map(protocol_id_type('account'), uint16), + key_auths: map(public_key, uint16), + address_auths: map(address, uint16) +}); + +var account_options = new Serializer('account_options', { + memo_key: public_key, + voting_account: protocol_id_type('account'), + num_witness: uint16, + num_committee: uint16, + votes: set(vote_id), + extensions: set(future_extensions) +}); + +var account_create = new Serializer('account_create', { + fee: asset, + registrar: protocol_id_type('account'), + referrer: protocol_id_type('account'), + referrer_percent: uint16, + name: string, + owner: authority, + active: authority, + options: account_options, + extensions: set(future_extensions) +}); + +var account_update = new Serializer('account_update', { + fee: asset, + account: protocol_id_type('account'), + owner: optional(authority), + active: optional(authority), + new_options: optional(account_options), + extensions: set(future_extensions) +}); + +var account_whitelist = new Serializer('account_whitelist', { + fee: asset, + authorizing_account: protocol_id_type('account'), + account_to_list: protocol_id_type('account'), + new_listing: uint8, + extensions: set(future_extensions) +}); + +var account_upgrade = new Serializer('account_upgrade', { + fee: asset, + account_to_upgrade: protocol_id_type('account'), + upgrade_to_lifetime_member: bool, + extensions: set(future_extensions) +}); + +var account_transfer = new Serializer('account_transfer', { + fee: asset, + account_id: protocol_id_type('account'), + new_owner: protocol_id_type('account'), + extensions: set(future_extensions) +}); + +var price = new Serializer('price', { + base: asset, + quote: asset +}); + +var asset_options = new Serializer('asset_options', { + max_supply: int64, + market_fee_percent: uint16, + max_market_fee: int64, + issuer_permissions: uint16, + flags: uint16, + core_exchange_rate: price, + whitelist_authorities: set(protocol_id_type('account')), + blacklist_authorities: set(protocol_id_type('account')), + whitelist_markets: set(protocol_id_type('asset')), + blacklist_markets: set(protocol_id_type('asset')), + description: string, + extensions: set(future_extensions) +}); + +var bitasset_options = new Serializer('bitasset_options', { + feed_lifetime_sec: uint32, + minimum_feeds: uint8, + force_settlement_delay_sec: uint32, + force_settlement_offset_percent: uint16, + maximum_force_settlement_volume: uint16, + short_backing_asset: protocol_id_type('asset'), + extensions: set(future_extensions) +}); + +var asset_create = new Serializer('asset_create', { + fee: asset, + issuer: protocol_id_type('account'), + symbol: string, + precision: uint8, + common_options: asset_options, + bitasset_opts: optional(bitasset_options), + is_prediction_market: bool, + extensions: set(future_extensions) +}); + +var asset_update = new Serializer('asset_update', { + fee: asset, + issuer: protocol_id_type('account'), + asset_to_update: protocol_id_type('asset'), + new_issuer: optional(protocol_id_type('account')), + new_options: asset_options, + extensions: set(future_extensions) +}); + +var asset_update_bitasset = new Serializer('asset_update_bitasset', { + fee: asset, + issuer: protocol_id_type('account'), + asset_to_update: protocol_id_type('asset'), + new_options: bitasset_options, + extensions: set(future_extensions) +}); + +var asset_update_feed_producers = new Serializer('asset_update_feed_producers', { + fee: asset, + issuer: protocol_id_type('account'), + asset_to_update: protocol_id_type('asset'), + new_feed_producers: set(protocol_id_type('account')), + extensions: set(future_extensions) +}); + +var asset_issue = new Serializer('asset_issue', { + fee: asset, + issuer: protocol_id_type('account'), + asset_to_issue: asset, + issue_to_account: protocol_id_type('account'), + memo: optional(memo_data), + extensions: set(future_extensions) +}); + +var asset_reserve = new Serializer('asset_reserve', { + fee: asset, + payer: protocol_id_type('account'), + amount_to_reserve: asset, + extensions: set(future_extensions) +}); + +var asset_fund_fee_pool = new Serializer('asset_fund_fee_pool', { + fee: asset, + from_account: protocol_id_type('account'), + asset_id: protocol_id_type('asset'), + amount: int64, + extensions: set(future_extensions) +}); + +var asset_settle = new Serializer('asset_settle', { + fee: asset, + account: protocol_id_type('account'), + amount: asset, + extensions: set(future_extensions) +}); + +var asset_global_settle = new Serializer('asset_global_settle', { + fee: asset, + issuer: protocol_id_type('account'), + asset_to_settle: protocol_id_type('asset'), + settle_price: price, + extensions: set(future_extensions) +}); + +var price_feed = new Serializer('price_feed', { + settlement_price: price, + maintenance_collateral_ratio: uint16, + maximum_short_squeeze_ratio: uint16, + core_exchange_rate: price +}); + +var asset_publish_feed = new Serializer('asset_publish_feed', { + fee: asset, + publisher: protocol_id_type('account'), + asset_id: protocol_id_type('asset'), + feed: price_feed, + extensions: set(future_extensions) +}); + +var witness_create = new Serializer('witness_create', { + fee: asset, + witness_account: protocol_id_type('account'), + url: string, + block_signing_key: public_key, + initial_secret: bytes(20) +}); + +var witness_update = new Serializer('witness_update', { + fee: asset, + witness: protocol_id_type('witness'), + witness_account: protocol_id_type('account'), + new_url: optional(string), + new_signing_key: optional(public_key), + new_initial_secret: optional(bytes(20)) +}); + +var op_wrapper = new Serializer('op_wrapper', { + op: operation +}); + +var proposal_create = new Serializer('proposal_create', { + fee: asset, + fee_paying_account: protocol_id_type('account'), + expiration_time: time_point_sec, + proposed_ops: array(op_wrapper), + review_period_seconds: optional(uint32), + extensions: set(future_extensions) +}); + +var proposal_update = new Serializer('proposal_update', { + fee: asset, + fee_paying_account: protocol_id_type('account'), + proposal: protocol_id_type('proposal'), + active_approvals_to_add: set(protocol_id_type('account')), + active_approvals_to_remove: set(protocol_id_type('account')), + owner_approvals_to_add: set(protocol_id_type('account')), + owner_approvals_to_remove: set(protocol_id_type('account')), + key_approvals_to_add: set(public_key), + key_approvals_to_remove: set(public_key), + extensions: set(future_extensions) +}); + +var proposal_delete = new Serializer('proposal_delete', { + fee: asset, + fee_paying_account: protocol_id_type('account'), + using_owner_authority: bool, + proposal: protocol_id_type('proposal'), + extensions: set(future_extensions) +}); + +var withdraw_permission_create = new Serializer('withdraw_permission_create', { + fee: asset, + withdraw_from_account: protocol_id_type('account'), + authorized_account: protocol_id_type('account'), + withdrawal_limit: asset, + withdrawal_period_sec: uint32, + periods_until_expiration: uint32, + period_start_time: time_point_sec +}); + +var withdraw_permission_update = new Serializer('withdraw_permission_update', { + fee: asset, + withdraw_from_account: protocol_id_type('account'), + authorized_account: protocol_id_type('account'), + permission_to_update: protocol_id_type('withdraw_permission'), + withdrawal_limit: asset, + withdrawal_period_sec: uint32, + period_start_time: time_point_sec, + periods_until_expiration: uint32 +}); + +var withdraw_permission_claim = new Serializer('withdraw_permission_claim', { + fee: asset, + withdraw_permission: protocol_id_type('withdraw_permission'), + withdraw_from_account: protocol_id_type('account'), + withdraw_to_account: protocol_id_type('account'), + amount_to_withdraw: asset, + memo: optional(memo_data) +}); + +var withdraw_permission_delete = new Serializer('withdraw_permission_delete', { + fee: asset, + withdraw_from_account: protocol_id_type('account'), + authorized_account: protocol_id_type('account'), + withdrawal_permission: protocol_id_type('withdraw_permission') +}); + +var committee_member_create = new Serializer('committee_member_create', { + fee: asset, + committee_member_account: protocol_id_type('account'), + url: string +}); + +var committee_member_update = new Serializer('committee_member_update', { + fee: asset, + committee_member: protocol_id_type('committee_member'), + committee_member_account: protocol_id_type('account'), + new_url: optional(string) +}); + +var chain_parameters = new Serializer('chain_parameters', { + current_fees: fee_schedule, + block_interval: uint8, + maintenance_interval: uint32, + maintenance_skip_slots: uint8, + committee_proposal_review_period: uint32, + maximum_transaction_size: uint32, + maximum_block_size: uint32, + maximum_time_until_expiration: uint32, + maximum_proposal_lifetime: uint32, + maximum_asset_whitelist_authorities: uint8, + maximum_asset_feed_publishers: uint8, + maximum_witness_count: uint16, + maximum_committee_count: uint16, + maximum_authority_membership: uint16, + reserve_percent_of_fee: uint16, + network_percent_of_fee: uint16, + lifetime_referrer_percent_of_fee: uint16, + cashback_vesting_period_seconds: uint32, + cashback_vesting_threshold: int64, + count_non_member_votes: bool, + allow_non_member_whitelists: bool, + witness_pay_per_block: int64, + worker_budget_per_day: int64, + max_predicate_opcode: uint16, + fee_liquidation_threshold: int64, + accounts_per_fee_scale: uint16, + account_fee_scale_bitshifts: uint8, + max_authority_depth: uint8, + min_bet_multiplier: uint32, + max_bet_multiplier: uint32, + betting_rake_fee_percentage: uint16, + permitted_betting_odds_increments: map(uint32, uint32), + witness_schedule_algorithm: uint8, + live_betting_delay_time: uint16, + min_round_delay: uint32, + max_round_delay: uint32, + min_time_per_commit_move: uint32, + max_time_per_commit_move: uint32, + min_time_per_reveal_move: uint32, + max_time_per_reveal_move: uint32, + rake_fee_percentage: uint16, + maximum_registration_deadline: uint32, + maximum_players_in_tournament: uint16, + maximum_tournament_whitelist_length: uint16, + maximum_tournament_start_time_in_future: uint32, + maximum_tournament_start_delay: uint32, + maximum_tournament_number_of_wins: uint16, + extensions: set(future_extensions) +}); + +var committee_member_update_global_parameters = new Serializer('committee_member_update_global_parameters', { + fee: asset, + new_parameters: chain_parameters +}); + +var linear_vesting_policy_initializer = new Serializer('linear_vesting_policy_initializer', { + begin_timestamp: time_point_sec, + vesting_cliff_seconds: uint32, + vesting_duration_seconds: uint32 +}); + +var cdd_vesting_policy_initializer = new Serializer('cdd_vesting_policy_initializer', { + start_claim: time_point_sec, + vesting_seconds: uint32 +}); + +var vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]); + +var vesting_balance_create = new Serializer('vesting_balance_create', { + fee: asset, + creator: protocol_id_type('account'), + owner: protocol_id_type('account'), + amount: asset, + policy: vesting_policy_initializer +}); + +var vesting_balance_withdraw = new Serializer('vesting_balance_withdraw', { + fee: asset, + vesting_balance: protocol_id_type('vesting_balance'), + owner: protocol_id_type('account'), + amount: asset +}); + +var refund_worker_initializer = new Serializer('refund_worker_initializer'); + +var vesting_balance_worker_initializer = new Serializer('vesting_balance_worker_initializer', { + pay_vesting_period_days: uint16 +}); + +var burn_worker_initializer = new Serializer('burn_worker_initializer'); + +var worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]); + +var worker_create = new Serializer('worker_create', { + fee: asset, + owner: protocol_id_type('account'), + work_begin_date: time_point_sec, + work_end_date: time_point_sec, + daily_pay: int64, + name: string, + url: string, + initializer: worker_initializer +}); + +var custom = new Serializer('custom', { + fee: asset, + payer: protocol_id_type('account'), + required_auths: set(protocol_id_type('account')), + id: uint16, + data: bytes() +}); + +var account_name_eq_lit_predicate = new Serializer('account_name_eq_lit_predicate', { + account_id: protocol_id_type('account'), + name: string +}); + +var asset_symbol_eq_lit_predicate = new Serializer('asset_symbol_eq_lit_predicate', { + asset_id: protocol_id_type('asset'), + symbol: string +}); + +var block_id_predicate = new Serializer('block_id_predicate', { + id: bytes(20) +}); + +var predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]); + +var assert = new Serializer('assert', { + fee: asset, + fee_paying_account: protocol_id_type('account'), + predicates: array(predicate), + required_auths: set(protocol_id_type('account')), + extensions: set(future_extensions) +}); + +var balance_claim = new Serializer('balance_claim', { + fee: asset, + deposit_to_account: protocol_id_type('account'), + balance_to_claim: protocol_id_type('balance'), + balance_owner_key: public_key, + total_claimed: asset +}); + +var override_transfer = new Serializer('override_transfer', { + fee: asset, + issuer: protocol_id_type('account'), + from: protocol_id_type('account'), + to: protocol_id_type('account'), + amount: asset, + memo: optional(memo_data), + extensions: set(future_extensions) +}); + +var stealth_confirmation = new Serializer('stealth_confirmation', { + one_time_key: public_key, + to: optional(public_key), + encrypted_memo: bytes() +}); + +var blind_output = new Serializer('blind_output', { + commitment: bytes(33), + range_proof: bytes(), + owner: authority, + stealth_memo: optional(stealth_confirmation) +}); + +var transfer_to_blind = new Serializer('transfer_to_blind', { + fee: asset, + amount: asset, + from: protocol_id_type('account'), + blinding_factor: bytes(32), + outputs: array(blind_output) +}); + +var blind_input = new Serializer('blind_input', { + commitment: bytes(33), + owner: authority +}); + +var blind_transfer = new Serializer('blind_transfer', { + fee: asset, + inputs: array(blind_input), + outputs: array(blind_output) +}); + +var transfer_from_blind = new Serializer('transfer_from_blind', { + fee: asset, + amount: asset, + to: protocol_id_type('account'), + blinding_factor: bytes(32), + inputs: array(blind_input) +}); + +var asset_settle_cancel = new Serializer('asset_settle_cancel', { + fee: asset, + settlement: protocol_id_type('force_settlement'), + account: protocol_id_type('account'), + amount: asset, + extensions: set(future_extensions) +}); + +var asset_claim_fees = new Serializer('asset_claim_fees', { + fee: asset, + issuer: protocol_id_type('account'), + amount_to_claim: asset, + extensions: set(future_extensions) +}); + +var fba_distribute = new Serializer('fba_distribute', { + fee: asset, + account_id: protocol_id_type('account'), + fba_id: protocol_id_type('fba_accumulator'), + amount: int64 +}); + +var rock_paper_scissors_game_options = new Serializer('rock_paper_scissors_game_options', { + insurance_enabled: bool, + time_per_commit_move: uint32, + time_per_reveal_move: uint32, + number_of_gestures: uint8 +}); + +var game_specific_details = static_variant([rock_paper_scissors_game_options]); + +var tournament_options = new Serializer('tournament_options', { + type_of_game: uint16, + registration_deadline: time_point_sec, + number_of_players: uint32, + buy_in: asset, + whitelist: set(protocol_id_type('account')), + start_time: optional(time_point_sec), + start_delay: optional(uint32), + round_delay: uint32, + number_of_wins: uint32, + meta: variant_object, + game_options: game_specific_details +}); + +var tournament_create = new Serializer('tournament_create', { + fee: asset, + creator: protocol_id_type('account'), + options: tournament_options, + extensions: set(future_extensions) +}); + +var tournament_join = new Serializer('tournament_join', { + fee: asset, + payer_account_id: protocol_id_type('account'), + player_account_id: protocol_id_type('account'), + tournament_id: protocol_id_type('tournament'), + buy_in: asset, + extensions: set(future_extensions) +}); + +var rock_paper_scissors_gesture = enumeration(['rock', 'paper', 'scissors', 'spock', 'lizard']); + +var rock_paper_scissors_throw_commit = new Serializer('rock_paper_scissors_throw_commit', { + nonce1: uint64, + throw_hash: sha256 +}); + +var rock_paper_scissors_throw_reveal = new Serializer('rock_paper_scissors_throw_reveal', { + nonce2: uint64, + gesture: rock_paper_scissors_gesture +}); + +var game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]); + +var game_move = new Serializer('game_move', { + fee: asset, + game_id: protocol_id_type('game'), + player_account_id: protocol_id_type('account'), + move: game_specific_moves, + extensions: set(future_extensions) +}); + +var dividend_asset_options = new Serializer('dividend_asset_options', { + next_payout_time: optional(time_point_sec), + payout_interval: optional(uint32), + minimum_fee_percentage: uint64, + minimum_distribution_interval: optional(uint32), + extensions: set(future_extensions) +}); + +var asset_update_dividend = new Serializer('asset_update_dividend', { + fee: asset, + issuer: protocol_id_type('account'), + asset_to_update: protocol_id_type('asset'), + new_options: dividend_asset_options, + extensions: set(future_extensions) +}); + +var asset_dividend_distribution = new Serializer('asset_dividend_distribution', { + fee: asset, + dividend_asset_id: protocol_id_type('asset'), + account_id: protocol_id_type('account'), + amounts: set(asset), + extensions: set(future_extensions) +}); + +var sport_create = new Serializer('sport_create', { + fee: asset, + name: map(string, string), + extensions: set(future_extensions) +}); + +var sport_update = new Serializer('sport_update', { + fee: asset, + sport_id: protocol_id_type('sport'), + new_name: optional(map(string, string)), + extensions: set(future_extensions) +}); + +var event_group_create = new Serializer('event_group_create', { + fee: asset, + name: map(string, string), + sport_id: object_id_type, + extensions: set(future_extensions) +}); + +var event_group_update = new Serializer('event_group_update', { + fee: asset, + new_sport_id: optional(protocol_id_type('sport')), + new_name: optional(map(string, string)), + event_group_id: protocol_id_type('event_group'), + extensions: set(future_extensions) +}); + +var event_create = new Serializer('event_create', { + fee: asset, + name: map(string, string), + season: map(string, string), + start_time: optional(time_point_sec), + event_group_id: object_id_type, + extensions: set(future_extensions) +}); + +var event_update = new Serializer('event_update', { + fee: asset, + event_id: protocol_id_type('event'), + new_event_group_id: optional(protocol_id_type('event_group')), + new_name: optional(map(string, string)), + new_season: optional(map(string, string)), + new_start_time: optional(time_point_sec), + is_live_market: optional(bool), + extensions: set(future_extensions) +}); + +var betting_market_rules_create = new Serializer('betting_market_rules_create', { + fee: asset, + name: map(string, string), + description: map(string, string), + extensions: set(future_extensions) +}); + +var betting_market_rules_update = new Serializer('betting_market_rules_update', { + fee: asset, + new_name: optional(map(string, string)), + new_description: optional(map(string, string)), + extensions: set(future_extensions), + betting_market_rules_id: protocol_id_type('betting_market_rules') +}); + +var betting_market_group_create = new Serializer('betting_market_group_create', { + fee: asset, + description: map(string, string), + event_id: object_id_type, + rules_id: object_id_type, + asset_id: protocol_id_type('asset'), + extensions: set(future_extensions) +}); + +var betting_market_create = new Serializer('betting_market_create', { + fee: asset, + group_id: object_id_type, + description: map(string, string), + payout_condition: map(string, string), + extensions: set(future_extensions) +}); + +var bet_type = enumeration(['back', 'lay']); + +var bet_place = new Serializer('bet_place', { + fee: asset, + bettor_id: protocol_id_type('account'), + betting_market_id: protocol_id_type('betting_market'), + amount_to_bet: asset, + backer_multiplier: uint32, + back_or_lay: bet_type, + extensions: set(future_extensions) +}); + +var betting_market_resolution_type = enumeration(['win', 'not_win', 'cancel', 'BETTING_MARKET_RESOLUTION_COUNT']); + +var betting_market_group_resolve = new Serializer('betting_market_group_resolve', { + fee: asset, + betting_market_group_id: protocol_id_type('betting_market_group'), + resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type), + extensions: set(future_extensions) +}); + +var betting_market_group_resolved = new Serializer('betting_market_group_resolved', { + bettor_id: protocol_id_type('account'), + betting_market_group_id: protocol_id_type('betting_market_group'), + resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type), + winnings: int64, + fees_paid: int64, + fee: asset +}); + +var betting_market_group_cancel_unmatched_bets = new Serializer('betting_market_group_cancel_unmatched_bets', { + fee: asset, + betting_market_group_id: protocol_id_type('betting_market_group'), + extensions: set(future_extensions) +}); + +var bet_matched = new Serializer('bet_matched', { + bettor_id: protocol_id_type('account'), + bet_id: protocol_id_type('bet'), + betting_market_id: protocol_id_type('betting_market'), + amount_bet: asset, + fees_paid: int64, + backer_multiplier: uint32, + guaranteed_winnings_returned: int64 +}); + +var bet_cancel = new Serializer('bet_cancel', { + fee: asset, + bettor_id: protocol_id_type('account'), + bet_to_cancel: protocol_id_type('bet'), + extensions: set(future_extensions) +}); + +var bet_canceled = new Serializer('bet_canceled', { + bettor_id: protocol_id_type('account'), + bet_id: protocol_id_type('bet'), + stake_returned: asset, + unused_fees_returned: asset +}); + +var payout_type = enumeration(['prize_award', 'buyin_refund', 'rake_fee']); + +var tournament_payout = new Serializer('tournament_payout', { + fee: asset, + payout_account_id: protocol_id_type('account'), + tournament_id: protocol_id_type('tournament'), + payout_amount: asset, + type: payout_type, + extensions: set(future_extensions) +}); + +var tournament_leave = new Serializer('tournament_leave', { + fee: asset, + canceling_account_id: protocol_id_type('account'), + player_account_id: protocol_id_type('account'), + tournament_id: protocol_id_type('tournament'), + extensions: set(future_extensions) +}); + +var betting_market_group_update = new Serializer('betting_market_group_update', { + fee: asset, + betting_market_group_id: protocol_id_type('betting_market_group'), + new_description: optional(map(string, string)), + new_rules_id: optional(protocol_id_type('betting_market_rules')), + freeze: optional(bool), + delay_bets: optional(bool), + extensions: set(future_extensions) +}); + +var betting_market_update = new Serializer('betting_market_update', { + fee: asset, + betting_market_id: protocol_id_type('betting_market'), + new_group_id: optional(protocol_id_type('betting_market_group')), + new_description: optional(map(string, string)), + new_payout_condition: optional(map(string, string)), + extensions: set(future_extensions) +}); + +var bet_adjusted = new Serializer('bet_adjusted', { + bettor_id: protocol_id_type('account'), + bet_id: protocol_id_type('bet'), + stake_returned: asset +}); + +operation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend, asset_dividend_distribution, tournament_payout, tournament_leave, sport_create, sport_update, event_group_create, event_group_update, event_create, event_update, betting_market_rules_create, betting_market_rules_update, betting_market_group_create, betting_market_create, bet_place, betting_market_group_resolve, betting_market_group_resolved, bet_adjusted, betting_market_group_cancel_unmatched_bets, bet_matched, bet_cancel, bet_canceled, betting_market_group_update, betting_market_update]; + +var transaction = new Serializer('transaction', { + ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions) +}); + +var signed_transaction = new Serializer('signed_transaction', { + ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions), + signatures: array(bytes(65)) +}); +// # ------------------------------- +// # Generated code end +// # ------------------------------- + +// Betting Objects + +var sport = new Serializer('sport', { + id: protocol_id_type('sport'), + name: map(string, string) +}); + +var event_group = new Serializer('event_group', { + id: protocol_id_type('event_group'), + name: map(string, string), + sport_id: protocol_id_type('sport') +}); + +var event_status = enumeration(['upcoming', 'in_progress', 'frozen', 'finished', 'completed', 'canceled', 'STATUS_COUNT']); + +var betting_market_status = enumeration(['unresolved', 'frozen', 'graded', 'canceled', 'settled']); + +var betting_market_group_status = enumeration(['upcoming', 'in_play', 'closed', 'graded', 're-grading', 'settled', 'frozen', 'canceled']); + +var event = new Serializer('event', { + id: protocol_id_type('event'), + name: map(string, string), + season: map(string, string), + start_time: optional(time_point_sec), + event_group_id: protocol_id_type('event_group'), + is_live_market: bool, + status: event_status, + scores: array(string) +}); + +var betting_market_rules = new Serializer('betting_market_rules', { + id: protocol_id_type('betting_market_rules'), + name: map(string, string), + description: map(string, string) +}); + +var betting_market_group = new Serializer('betting_market_group', { + id: protocol_id_type('betting_market_group'), + description: map(string, string), + event_id: protocol_id_type('event'), + rules_id: protocol_id_type('betting_market_rules'), + asset_id: protocol_id_type('asset'), + total_matched_bets_amount: uint64, + frozen: bool, + delay_bets: bool, + status: betting_market_group_status +}); + +var betting_market = new Serializer('betting_market', { + id: protocol_id_type('betting_market'), + group_id: protocol_id_type('betting_market_group'), + description: map(string, string), + payout_condition: map(string, string), + status: betting_market_status +}); + +var bet = new Serializer('bet', { + id: protocol_id_type('bet'), + bettor_id: protocol_id_type('account'), + betting_market_id: protocol_id_type('betting_market'), + amount_to_bet: asset, + backer_multiplier: uint32, + back_or_lay: bet_type +}); + +var betting_market_position = new Serializer('betting_market_position', { + id: implementation_id_type('betting_market_position'), + bettor_id: protocol_id_type('account'), + betting_market_id: protocol_id_type('betting_market'), + pay_if_payout_condition: int64, + pay_if_not_payout_condition: int64, + pay_if_canceled: int64, + pay_if_not_canceled: int64, + fees_collected: int64 +}); + +var global_betting_statistics = new Serializer('global_betting_statistics', { + id: implementation_id_type('global_betting_statistics'), + number_of_active_events: uint32, + total_amount_staked: map(protocol_id_type('asset'), int64) +}); + +// eof Betting Objects + +// Custom Types + +var stealth_memo_data = new Serializer('stealth_memo_data', { + from: optional(public_key), + amount: asset, + blinding_factor: bytes(32), + commitment: bytes(33), + check: uint32 +}); +// var stealth_confirmation = new Serializer( +// "stealth_confirmation", { +// one_time_key: public_key, +// to: optional( public_key ), +// encrypted_memo: stealth_memo_data +// }) + +exports.operation = operation; +exports.transfer_operation_fee_parameters = transfer_operation_fee_parameters; +exports.limit_order_create_operation_fee_parameters = limit_order_create_operation_fee_parameters; +exports.limit_order_cancel_operation_fee_parameters = limit_order_cancel_operation_fee_parameters; +exports.call_order_update_operation_fee_parameters = call_order_update_operation_fee_parameters; +exports.fill_order_operation_fee_parameters = fill_order_operation_fee_parameters; +exports.account_create_operation_fee_parameters = account_create_operation_fee_parameters; +exports.account_update_operation_fee_parameters = account_update_operation_fee_parameters; +exports.account_whitelist_operation_fee_parameters = account_whitelist_operation_fee_parameters; +exports.account_upgrade_operation_fee_parameters = account_upgrade_operation_fee_parameters; +exports.account_transfer_operation_fee_parameters = account_transfer_operation_fee_parameters; +exports.asset_create_operation_fee_parameters = asset_create_operation_fee_parameters; +exports.asset_update_operation_fee_parameters = asset_update_operation_fee_parameters; +exports.asset_update_bitasset_operation_fee_parameters = asset_update_bitasset_operation_fee_parameters; +exports.asset_update_feed_producers_operation_fee_parameters = asset_update_feed_producers_operation_fee_parameters; +exports.asset_issue_operation_fee_parameters = asset_issue_operation_fee_parameters; +exports.asset_reserve_operation_fee_parameters = asset_reserve_operation_fee_parameters; +exports.asset_fund_fee_pool_operation_fee_parameters = asset_fund_fee_pool_operation_fee_parameters; +exports.asset_settle_operation_fee_parameters = asset_settle_operation_fee_parameters; +exports.asset_global_settle_operation_fee_parameters = asset_global_settle_operation_fee_parameters; +exports.asset_publish_feed_operation_fee_parameters = asset_publish_feed_operation_fee_parameters; +exports.witness_create_operation_fee_parameters = witness_create_operation_fee_parameters; +exports.witness_update_operation_fee_parameters = witness_update_operation_fee_parameters; +exports.proposal_create_operation_fee_parameters = proposal_create_operation_fee_parameters; +exports.proposal_update_operation_fee_parameters = proposal_update_operation_fee_parameters; +exports.proposal_delete_operation_fee_parameters = proposal_delete_operation_fee_parameters; +exports.withdraw_permission_create_operation_fee_parameters = withdraw_permission_create_operation_fee_parameters; +exports.withdraw_permission_update_operation_fee_parameters = withdraw_permission_update_operation_fee_parameters; +exports.withdraw_permission_claim_operation_fee_parameters = withdraw_permission_claim_operation_fee_parameters; +exports.withdraw_permission_delete_operation_fee_parameters = withdraw_permission_delete_operation_fee_parameters; +exports.committee_member_create_operation_fee_parameters = committee_member_create_operation_fee_parameters; +exports.committee_member_update_operation_fee_parameters = committee_member_update_operation_fee_parameters; +exports.committee_member_update_global_parameters_operation_fee_parameters = committee_member_update_global_parameters_operation_fee_parameters; +exports.vesting_balance_create_operation_fee_parameters = vesting_balance_create_operation_fee_parameters; +exports.vesting_balance_withdraw_operation_fee_parameters = vesting_balance_withdraw_operation_fee_parameters; +exports.worker_create_operation_fee_parameters = worker_create_operation_fee_parameters; +exports.custom_operation_fee_parameters = custom_operation_fee_parameters; +exports.assert_operation_fee_parameters = assert_operation_fee_parameters; +exports.balance_claim_operation_fee_parameters = balance_claim_operation_fee_parameters; +exports.override_transfer_operation_fee_parameters = override_transfer_operation_fee_parameters; +exports.transfer_to_blind_operation_fee_parameters = transfer_to_blind_operation_fee_parameters; +exports.blind_transfer_operation_fee_parameters = blind_transfer_operation_fee_parameters; +exports.transfer_from_blind_operation_fee_parameters = transfer_from_blind_operation_fee_parameters; +exports.asset_settle_cancel_operation_fee_parameters = asset_settle_cancel_operation_fee_parameters; +exports.asset_claim_fees_operation_fee_parameters = asset_claim_fees_operation_fee_parameters; +exports.fba_distribute_operation_fee_parameters = fba_distribute_operation_fee_parameters; +exports.asset_update_dividend_operation_fee_parameters = asset_update_dividend_operation_fee_parameters; +exports.asset_dividend_distribution_operation_fee_parameters = asset_dividend_distribution_operation_fee_parameters; +exports.sport_create_operation_fee_parameters = sport_create_operation_fee_parameters; +exports.sport_update_operation_fee_parameters = sport_update_operation_fee_parameters; +exports.event_group_create_operation_fee_parameters = event_group_create_operation_fee_parameters; +exports.event_group_update_operation_fee_parameters = event_group_update_operation_fee_parameters; +exports.event_create_operation_fee_parameters = event_create_operation_fee_parameters; +exports.event_update_operation_fee_parameters = event_update_operation_fee_parameters; +exports.betting_market_rules_create_operation_fee_parameters = betting_market_rules_create_operation_fee_parameters; +exports.betting_market_rules_update_operation_fee_parameters = betting_market_rules_update_operation_fee_parameters; +exports.betting_market_group_create_operation_fee_parameters = betting_market_group_create_operation_fee_parameters; +exports.betting_market_create_operation_fee_parameters = betting_market_create_operation_fee_parameters; +exports.bet_place_operation_fee_parameters = bet_place_operation_fee_parameters; +exports.betting_market_group_resolve_operation_fee_parameters = betting_market_group_resolve_operation_fee_parameters; +exports.betting_market_group_resolved_operation_fee_parameters = betting_market_group_resolved_operation_fee_parameters; +exports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = betting_market_group_cancel_unmatched_bets_operation_fee_parameters; +exports.bet_matched_operation_fee_parameters = bet_matched_operation_fee_parameters; +exports.bet_cancel_operation_fee_parameters = bet_cancel_operation_fee_parameters; +exports.bet_canceled_operation_fee_parameters = bet_canceled_operation_fee_parameters; +exports.tournament_create_operation_fee_parameters = tournament_create_operation_fee_parameters; +exports.tournament_join_operation_fee_parameters = tournament_join_operation_fee_parameters; +exports.game_move_operation_fee_parameters = game_move_operation_fee_parameters; +exports.tournament_payout_operation_fee_parameters = tournament_payout_operation_fee_parameters; +exports.tournament_leave_operation_fee_parameters = tournament_leave_operation_fee_parameters; +exports.betting_market_group_update_operation_fee_parameters = betting_market_group_update_operation_fee_parameters; +exports.betting_market_update_operation_fee_parameters = betting_market_update_operation_fee_parameters; +exports.bet_adjusted_operation_fee_parameters = bet_adjusted_operation_fee_parameters; +exports.fee_schedule = fee_schedule; +exports.void_result = void_result; +exports.asset = asset; +exports.processed_transaction = processed_transaction; +exports.signed_block = signed_block; +exports.block_header = block_header; +exports.signed_block_header = signed_block_header; +exports.memo_data = memo_data; +exports.transfer = transfer; +exports.limit_order_create = limit_order_create; +exports.limit_order_cancel = limit_order_cancel; +exports.call_order_update = call_order_update; +exports.fill_order = fill_order; +exports.authority = authority; +exports.account_options = account_options; +exports.account_create = account_create; +exports.account_update = account_update; +exports.account_whitelist = account_whitelist; +exports.account_upgrade = account_upgrade; +exports.account_transfer = account_transfer; +exports.price = price; +exports.asset_options = asset_options; +exports.bitasset_options = bitasset_options; +exports.asset_create = asset_create; +exports.asset_update = asset_update; +exports.asset_update_bitasset = asset_update_bitasset; +exports.asset_update_feed_producers = asset_update_feed_producers; +exports.asset_issue = asset_issue; +exports.asset_reserve = asset_reserve; +exports.asset_fund_fee_pool = asset_fund_fee_pool; +exports.asset_settle = asset_settle; +exports.asset_global_settle = asset_global_settle; +exports.price_feed = price_feed; +exports.asset_publish_feed = asset_publish_feed; +exports.witness_create = witness_create; +exports.witness_update = witness_update; +exports.op_wrapper = op_wrapper; +exports.proposal_create = proposal_create; +exports.proposal_update = proposal_update; +exports.proposal_delete = proposal_delete; +exports.withdraw_permission_create = withdraw_permission_create; +exports.withdraw_permission_update = withdraw_permission_update; +exports.withdraw_permission_claim = withdraw_permission_claim; +exports.withdraw_permission_delete = withdraw_permission_delete; +exports.committee_member_create = committee_member_create; +exports.committee_member_update = committee_member_update; +exports.chain_parameters = chain_parameters; +exports.committee_member_update_global_parameters = committee_member_update_global_parameters; +exports.linear_vesting_policy_initializer = linear_vesting_policy_initializer; +exports.cdd_vesting_policy_initializer = cdd_vesting_policy_initializer; +exports.vesting_balance_create = vesting_balance_create; +exports.vesting_balance_withdraw = vesting_balance_withdraw; +exports.refund_worker_initializer = refund_worker_initializer; +exports.vesting_balance_worker_initializer = vesting_balance_worker_initializer; +exports.burn_worker_initializer = burn_worker_initializer; +exports.worker_create = worker_create; +exports.custom = custom; +exports.account_name_eq_lit_predicate = account_name_eq_lit_predicate; +exports.asset_symbol_eq_lit_predicate = asset_symbol_eq_lit_predicate; +exports.block_id_predicate = block_id_predicate; +exports.assert = assert; +exports.balance_claim = balance_claim; +exports.override_transfer = override_transfer; +exports.stealth_confirmation = stealth_confirmation; +exports.blind_output = blind_output; +exports.transfer_to_blind = transfer_to_blind; +exports.blind_input = blind_input; +exports.blind_transfer = blind_transfer; +exports.transfer_from_blind = transfer_from_blind; +exports.asset_settle_cancel = asset_settle_cancel; +exports.asset_claim_fees = asset_claim_fees; +exports.fba_distribute = fba_distribute; +exports.rock_paper_scissors_game_options = rock_paper_scissors_game_options; +exports.tournament_options = tournament_options; +exports.tournament_create = tournament_create; +exports.tournament_join = tournament_join; +exports.rock_paper_scissors_gesture = rock_paper_scissors_gesture; +exports.rock_paper_scissors_throw_commit = rock_paper_scissors_throw_commit; +exports.rock_paper_scissors_throw_reveal = rock_paper_scissors_throw_reveal; +exports.game_move = game_move; +exports.dividend_asset_options = dividend_asset_options; +exports.asset_update_dividend = asset_update_dividend; +exports.asset_dividend_distribution = asset_dividend_distribution; +exports.sport_create = sport_create; +exports.sport_update = sport_update; +exports.event_group_create = event_group_create; +exports.event_group_update = event_group_update; +exports.event_create = event_create; +exports.event_update = event_update; +exports.betting_market_rules_create = betting_market_rules_create; +exports.betting_market_rules_update = betting_market_rules_update; +exports.betting_market_group_create = betting_market_group_create; +exports.betting_market_create = betting_market_create; +exports.bet_type = bet_type; +exports.bet_place = bet_place; +exports.betting_market_resolution_type = betting_market_resolution_type; +exports.betting_market_group_resolve = betting_market_group_resolve; +exports.betting_market_group_resolved = betting_market_group_resolved; +exports.betting_market_group_cancel_unmatched_bets = betting_market_group_cancel_unmatched_bets; +exports.bet_matched = bet_matched; +exports.bet_cancel = bet_cancel; +exports.bet_canceled = bet_canceled; +exports.payout_type = payout_type; +exports.tournament_payout = tournament_payout; +exports.tournament_leave = tournament_leave; +exports.betting_market_group_update = betting_market_group_update; +exports.betting_market_update = betting_market_update; +exports.bet_adjusted = bet_adjusted; +exports.transaction = transaction; +exports.signed_transaction = signed_transaction; +exports.sport = sport; +exports.event_group = event_group; +exports.event = event; +exports.betting_market_rules = betting_market_rules; +exports.betting_market_group = betting_market_group; +exports.betting_market = betting_market; +exports.bet = bet; +exports.betting_market_position = betting_market_position; +exports.global_betting_statistics = global_betting_statistics; +exports.stealth_memo_data = stealth_memo_data; +},{"24":24,"26":26}],24:[function(require,module,exports){ +(function (process,Buffer){ +'use strict'; + +exports.__esModule = true; + +var _bytebuffer = require(38); + +var _bytebuffer2 = _interopRequireDefault(_bytebuffer); + +var _error_with_cause = require(22); + +var _error_with_cause2 = _interopRequireDefault(_error_with_cause); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; + +var Serializer = function () { + function Serializer(operation_name, types) { + _classCallCheck(this, Serializer); + + this.operation_name = operation_name; + this.types = types; + + if (this.types) { + this.keys = Object.keys(this.types); + } + + Serializer.printDebug = true; + } + + Serializer.prototype.fromByteBuffer = function fromByteBuffer(b) { + var object = {}; + var field = null; + + try { + var iterable = this.keys; + + for (var i = 0; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + + try { + if (HEX_DUMP) { + if (type.operation_name) { + console.error(type.operation_name); + } else { + var o1 = b.offset; + type.fromByteBuffer(b); + var o2 = b.offset; + b.offset = o1; + // b.reset() + var _b = b.copy(o1, o2); + console.error(this.operation_name + '.' + field + '\t', _b.toHex()); + } + } + + object[field] = type.fromByteBuffer(b); + } catch (e) { + if (Serializer.printDebug) { + console.error('Error reading ' + this.operation_name + '.' + field + ' in data:'); + b.printDebug(); + } + + throw e; + } + } + } catch (error) { + _error_with_cause2.default.throw(this.operation_name + '.' + field, error); + } + + return object; + }; + + Serializer.prototype.appendByteBuffer = function appendByteBuffer(b, object) { + var field = null; + + try { + var iterable = this.keys; + + for (var i = 0; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + type.appendByteBuffer(b, object[field]); + } + } catch (error) { + try { + _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + JSON.stringify(object[field]), error); + } catch (e) { + // circular ref + _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + object[field], error); + } + } + }; + + Serializer.prototype.fromObject = function fromObject(serialized_object) { + var result = {}; + var field = null; + + try { + var iterable = this.keys; + + for (var i = 0; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + var value = serialized_object[field]; + // DEBUG value = value.resolve if value.resolve + // DEBUG console.log('... value',field,value) + var object = type.fromObject(value); + result[field] = object; + } + } catch (error) { + _error_with_cause2.default.throw(this.operation_name + '.' + field, error); + } + + return result; + }; + + /** + @arg {boolean} [debug.use_default = false] - more template friendly + @arg {boolean} [debug.annotate = false] - add user-friendly information + */ + + + Serializer.prototype.toObject = function toObject() { + var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false }; + + var result = {}; + var field = null; + + try { + if (!this.types) { + return result; + } + + var iterable = this.keys; + + for (var i = 0; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + var object = type.toObject(typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined, debug); + result[field] = object; + + if (HEX_DUMP) { + var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN); + type.appendByteBuffer(b, typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined); + b = b.copy(0, b.offset); + console.error(this.operation_name + '.' + field, b.toHex()); + } + } + } catch (error) { + _error_with_cause2.default.throw(this.operation_name + '.' + field, error); + } + + return result; + }; + + /** Sort by the first element in a operation */ + + + Serializer.prototype.compare = function compare(a, b) { + var first_key = this.keys[0]; + var first_type = this.types[first_key]; + + var valA = a[first_key]; + var valB = b[first_key]; + + if (first_type.compare) { + return first_type.compare(valA, valB); + } + + if (typeof valA === 'number' && typeof valB === 'number') { + return valA - valB; + } + + var encoding = void 0; + + if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) { + // A binary string compare does not work. If localeCompare is well supported that could + // replace HEX. Performanance is very good so comparing HEX works. + encoding = 'hex'; + } + + var strA = valA.toString(encoding); + var strB = valB.toString(encoding); + + var result = 0; + + if (strA > strB) { + result = 1; + } + + if (strA < strB) { + result = -1; + } + + return result; + }; + + // + + Serializer.prototype.fromHex = function fromHex(hex) { + var b = _bytebuffer2.default.fromHex(hex, _bytebuffer2.default.LITTLE_ENDIAN); + return this.fromByteBuffer(b); + }; + + Serializer.prototype.fromBuffer = function fromBuffer(buffer) { + var b = _bytebuffer2.default.fromBinary(buffer.toString('binary'), _bytebuffer2.default.LITTLE_ENDIAN); + return this.fromByteBuffer(b); + }; + + Serializer.prototype.toHex = function toHex(object) { + // return this.toBuffer(object).toString("hex") + var b = this.toByteBuffer(object); + return b.toHex(); + }; + + Serializer.prototype.toByteBuffer = function toByteBuffer(object) { + var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN); + this.appendByteBuffer(b, object); + return b.copy(0, b.offset); + }; + + Serializer.prototype.toBuffer = function toBuffer(object) { + return Buffer.from(this.toByteBuffer(object).toBinary(), 'binary'); + }; + + return Serializer; +}(); + +exports.default = Serializer; +module.exports = exports['default']; +}).call(this,require(77),require(35).Buffer) + +},{"22":22,"35":35,"38":38,"77":77}],25:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; +exports.default = template; +/** Console print any transaction object with zero default values. */ +function template(op) { + var object = op.toObject(undefined, { use_default: true, annotate: true }); + + // visual (with descriptions) + console.error(JSON.stringify(object, null, 4)); + + // usable in a copy-paste + + object = op.toObject(undefined, { use_default: true, annotate: false }); + + // copy-paste one-lineer + console.error(JSON.stringify(object)); +} +module.exports = exports["default"]; +},{}],26:[function(require,module,exports){ +(function (process,Buffer){ +'use strict'; + +exports.__esModule = true; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; // Low-level types that make up operations + +var _peerplaysjsWs = require(70); + +var _SerializerValidation = require(21); + +var _SerializerValidation2 = _interopRequireDefault(_SerializerValidation); + +var _FastParser = require(20); + +var _FastParser2 = _interopRequireDefault(_FastParser); + +var _ChainTypes = require(3); + +var _ChainTypes2 = _interopRequireDefault(_ChainTypes); + +var _ObjectId = require(4); + +var _ObjectId2 = _interopRequireDefault(_ObjectId); + +var _ecc = require(7); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var MIN_SIGNED_32 = -1 * Math.pow(2, 31); +var MAX_SIGNED_32 = Math.pow(2, 31) - 1; + +var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; + +var strCmp = function strCmp(a, b) { + var result = 0; + + if (a > b) { + result = 1; + } + + if (a < b) { + result = -1; + } + + return result; +}; + +var firstEl = function firstEl(el) { + return Array.isArray(el) ? el[0] : el; +}; + +var sortOperation = function sortOperation(array, st_operation) { + if (!st_operation.nosort) { + // If the operation has its own compare function. + if (st_operation.compare) { + return array.sort(function (a, b) { + return st_operation.compare(firstEl(a), firstEl(b)); + }); + } + + return array.sort(function (a, b) { + var aFirst = firstEl(a); + var bFirst = firstEl(b); + + // If both of the first elements are numbers. + if (typeof aFirst === 'number' && typeof bFirst === 'number') { + return aFirst - bFirst; + } + + // If they are both buffers. + if (Buffer.isBuffer(aFirst) && Buffer.isBuffer(bFirst)) { + return strCmp(aFirst.toString('hex'), bFirst.toString('hex')); + } + + // Otherwise + return strCmp(aFirst.toString(), bFirst.toString()); + }); + } + + return array; +}; + +var Types = {}; + +Types.uint8 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint8(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object); + b.writeUint8(object); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + + _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object); + return parseInt(object, 10); + } +}; + +Types.uint16 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint16(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object); + b.writeUint16(object); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + + _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object); + return parseInt(object, 10); + } +}; + +Types.uint32 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object); + b.writeUint32(object); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + + _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object); + return parseInt(object, 10); + } +}; + +Types.varint32 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readVarint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + b.writeVarint32(object); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + + _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + return parseInt(object, 10); + } +}; + +Types.int64 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readInt64(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + b.writeInt64(_SerializerValidation2.default.to_long(object)); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + return _SerializerValidation2.default.to_long(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return '0'; + } + + _SerializerValidation2.default.required(object); + return _SerializerValidation2.default.to_long(object).toString(); + } +}; + +Types.uint64 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint64(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + b.writeUint64(_SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object))); + }, + fromObject: function fromObject(object) { + return _SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object)); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return '0'; + } + + return _SerializerValidation2.default.to_ulong(object).toString(); + } +}; + +Types.string = { + fromByteBuffer: function fromByteBuffer(b) { + var b_copy = void 0; + var len = b.readVarint32(); + b_copy = b.copy(b.offset, b.offset + len); + b.skip(len); + return Buffer.from(b_copy.toBinary(), 'binary'); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + b.writeVarint32(object.length); + b.append(object.toString('binary'), 'binary'); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + return Buffer.from(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return ''; + } + + return object.toString(); + } +}; + +Types.bytes = function (size) { + var bytes = { + fromByteBuffer: function fromByteBuffer(b) { + if (size === undefined) { + var _b_copy = void 0; + var len = b.readVarint32(); + _b_copy = b.copy(b.offset, b.offset + len); + b.skip(len); + return Buffer.from(_b_copy.toBinary(), 'binary'); + } + + var b_copy = b.copy(b.offset, b.offset + size); + b.skip(size); + return Buffer.from(b_copy.toBinary(), 'binary'); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + + if (typeof object === 'string') { + object = Buffer.from(object, 'hex'); + } + + if (size === undefined) { + b.writeVarint32(object.length); + } + + b.append(object.toString('binary'), 'binary'); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + + if (Buffer.isBuffer(object)) { + return object; + } + + return Buffer.from(object, 'hex'); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return new Array(size).join('00'); + } + + _SerializerValidation2.default.required(object); + return object.toString('hex'); + } + }; + + return bytes; +}; + +Types.bool = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint8() === 1; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + // supports boolean or integer + b.writeUint8(JSON.parse(object) ? 1 : 0); + }, + fromObject: function fromObject(object) { + return !!JSON.parse(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return false; + } + + return !!JSON.parse(object); + } +}; + +Types.void = { + fromByteBuffer: function fromByteBuffer() { + throw new Error('(void) undefined type'); + }, + appendByteBuffer: function appendByteBuffer() { + throw new Error('(void) undefined type'); + }, + fromObject: function fromObject() { + throw new Error('(void) undefined type'); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return undefined; + } + + throw new Error('(void) undefined type'); + } +}; + +Types.array = function (st_operation) { + var array = { + fromByteBuffer: function fromByteBuffer(b) { + var size = b.readVarint32(); + + if (HEX_DUMP) { + console.log('varint32 size = ' + size.toString(16)); + } + + var result = []; + + for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) { + result.push(st_operation.fromByteBuffer(b)); + } + + return sortOperation(result, st_operation); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + object = sortOperation(object, st_operation); + b.writeVarint32(object.length); + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + st_operation.appendByteBuffer(b, o); + } + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + object = sortOperation(object, st_operation); + var result = []; + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + result.push(st_operation.fromObject(o)); + } + + return result; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [st_operation.toObject(object, debug)]; + } + + _SerializerValidation2.default.required(object); + object = sortOperation(object, st_operation); + + var result = []; + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + result.push(st_operation.toObject(o, debug)); + } + + return result; + } + }; + + return array; +}; + +Types.time_point_sec = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (typeof object !== 'number') { + object = Types.time_point_sec.fromObject(object); + } + + b.writeUint32(object); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + + if (typeof object === 'number') { + return object; + } + + if (object.getTime) { + return Math.floor(object.getTime() / 1000); + } + + if (typeof object !== 'string') { + throw new Error('Unknown date type: ' + object); + } + + // if(typeof object === "string" && !/Z$/.test(object)) + // object = object + "Z" + + return Math.floor(new Date(object).getTime() / 1000); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return new Date(0).toISOString().split('.')[0]; + } + + _SerializerValidation2.default.required(object); + + if (typeof object === 'string') { + return object; + } + + if (object.getTime) { + return object.toISOString().split('.')[0]; + } + + var int = parseInt(object, 10); + _SerializerValidation2.default.require_range(0, 0xffffffff, int, 'uint32 ' + object); + return new Date(int * 1000).toISOString().split('.')[0]; + } +}; + +Types.set = function (st_operation) { + var set_object = { + validate: function validate(array) { + var dup_map = {}; + + for (var i = 0, len = array.length; i < len; i++) { + var o = array[i]; + var ref = typeof o === 'undefined' ? 'undefined' : _typeof(o); + + if (['string', 'number'].indexOf(ref) >= 0) { + if (dup_map[o] !== undefined) { + throw new Error('duplicate (set)'); + } + + dup_map[o] = true; + } + } + + return sortOperation(array, st_operation); + }, + fromByteBuffer: function fromByteBuffer(b) { + var size = b.readVarint32(); + + if (HEX_DUMP) { + console.log('varint32 size = ' + size.toString(16)); + } + + return this.validate(function () { + var result = []; + + for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) { + result.push(st_operation.fromByteBuffer(b)); + } + + return result; + }()); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (!object) { + object = []; + } + + b.writeVarint32(object.length); + var iterable = this.validate(object); + + for (var i = 0, len = iterable.length; i < len; i++) { + var o = iterable[i]; + st_operation.appendByteBuffer(b, o); + } + }, + fromObject: function fromObject(object) { + if (!object) { + object = []; + } + + return this.validate(function () { + var result = []; + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + result.push(st_operation.fromObject(o)); + } + + return result; + }()); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [st_operation.toObject(object, debug)]; + } + + if (!object) { + object = []; + } + + var result = []; + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + result.push(st_operation.toObject(o, debug)); + } + + return this.validate(result); + } + }; + + return set_object; +}; + +Types.fixed_array = function (count, st_operation) { + var fixed_array = { + fromByteBuffer: function fromByteBuffer(b) { + var results = []; + + for (var i = 0, ref = count; i < ref; i++) { + results.push(st_operation.fromByteBuffer(b)); + } + + return sortOperation(results, st_operation); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (count !== 0) { + _SerializerValidation2.default.required(object); + object = sortOperation(object, st_operation); + } + + for (var i = 0, ref = count; i < ref; i++) { + st_operation.appendByteBuffer(b, object[i]); + } + }, + fromObject: function fromObject(object) { + if (count !== 0) { + _SerializerValidation2.default.required(object); + } + + var results = []; + + for (var i = 0, ref = count; i < ref; i++) { + results.push(st_operation.fromObject(object[i])); + } + + return results; + }, + toObject: function toObject(object, debug) { + if (debug == null) { + debug = {}; + } + + var results = void 0; + + if (debug.use_default && object === undefined) { + results = []; + + for (var i = 0, ref = count; i < ref; i++) { + results.push(st_operation.toObject(undefined, debug)); + } + + return results; + } + + if (count !== 0) { + _SerializerValidation2.default.required(object); + } + + results = []; + + for (var _i = 0, _ref = count; _i < _ref; _i++) { + results.push(st_operation.toObject(object[_i], debug)); + } + + return results; + } + }; + + return fixed_array; +}; + +/* Supports instance numbers (11) or object types (1.2.11). Object type +Validation is enforced when an object type is used. */ +Types.id_type = function (reserved_spaces, object_type) { + _SerializerValidation2.default.required(reserved_spaces, 'reserved_spaces'); + _SerializerValidation2.default.required(object_type, 'object_type'); + + var id_type_object = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readVarint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + + if (object.resolve !== undefined) { + object = object.resolve; + } + + // convert 1.2.n into just n + if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { + object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object); + } + + b.writeVarint32(_SerializerValidation2.default.to_number(object)); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + + if (object.resolve !== undefined) { + object = object.resolve; + } + + if (_SerializerValidation2.default.is_digits(object)) { + return _SerializerValidation2.default.to_number(object); + } + + return _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var object_type_id = _ChainTypes2.default.object_type[object_type]; + + if (debug.use_default && object === undefined) { + return reserved_spaces + '.' + object_type_id + '.0'; + } + + _SerializerValidation2.default.required(object); + + if (object.resolve !== undefined) { + object = object.resolve; + } + + if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { + object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object); + } + + return reserved_spaces + '.' + object_type_id + '.' + object; + } + }; + + return id_type_object; +}; + +Types.protocol_id_type = function (name) { + _SerializerValidation2.default.required(name, 'name'); + return Types.id_type(_ChainTypes2.default.reserved_spaces.protocol_ids, name); +}; + +Types.implementation_id_type = function (name) { + var result = Types.id_type(_ChainTypes2.default.reserved_spaces.implementation_ids, name); + return result; +}; + +Types.object_id_type = { + fromByteBuffer: function fromByteBuffer(b) { + return _ObjectId2.default.fromByteBuffer(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + + if (object.resolve !== undefined) { + object = object.resolve; + } + + object = _ObjectId2.default.fromString(object); + object.appendByteBuffer(b); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + + if (object.resolve !== undefined) { + object = object.resolve; + } + + return _ObjectId2.default.fromString(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return '0.0.0'; + } + + _SerializerValidation2.default.required(object); + + if (object.resolve !== undefined) { + object = object.resolve; + } + + object = _ObjectId2.default.fromString(object); + return object.toString(); + } +}; + +Types.vote_id = { + TYPE: 0x000000ff, + ID: 0xffffff00, + fromByteBuffer: function fromByteBuffer(b) { + var value = b.readUint32(); + return { + type: value & this.TYPE, // eslint-disable-line + id: value & this.ID // eslint-disable-line + }; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + + if (object === 'string') { + object = Types.vote_id.fromObject(object); + } + + var value = object.id << 8 | object.type; // eslint-disable-line + b.writeUint32(value); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object, '(type vote_id)'); + + if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object') { + _SerializerValidation2.default.required(object.type, 'type'); + _SerializerValidation2.default.required(object.id, 'id'); + return object; + } + + _SerializerValidation2.default.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object); + + var _object$split = object.split(':'), + type = _object$split[0], + id = _object$split[1]; + + _SerializerValidation2.default.require_range(0, 0xff, type, 'vote type ' + object); + _SerializerValidation2.default.require_range(0, 0xffffff, id, 'vote id ' + object); + return { type: type, id: id }; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return '0:0'; + } + + _SerializerValidation2.default.required(object); + + if (typeof object === 'string') { + object = Types.vote_id.fromObject(object); + } + + return object.type + ':' + object.id; + }, + compare: function compare(a, b) { + if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== 'object') { + a = Types.vote_id.fromObject(a); + } + + if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== 'object') { + b = Types.vote_id.fromObject(b); + } + + return parseInt(a.id, 10) - parseInt(b.id, 10); + } +}; + +Types.optional = function (st_operation) { + _SerializerValidation2.default.required(st_operation, 'st_operation'); + return { + fromByteBuffer: function fromByteBuffer(b) { + if (!(b.readUint8() === 1)) { + return undefined; + } + + return st_operation.fromByteBuffer(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (object !== null && object !== undefined) { + b.writeUint8(1); + st_operation.appendByteBuffer(b, object); + } else { + b.writeUint8(0); + } + }, + fromObject: function fromObject(object) { + if (object === undefined) { + return undefined; + } + + return st_operation.fromObject(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + // toObject is only null save if use_default is true + var result_object = function () { + if (!debug.use_default && object === undefined) { + return undefined; + } + + return st_operation.toObject(object, debug); + }(); + + if (debug.annotate) { + if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === 'object') { + result_object.__optional = 'parent is optional'; + } else { + result_object = { __optional: result_object }; + } + } + + return result_object; + } + }; +}; + +Types.static_variant = function (_st_operations) { + var static_variant = { + nosort: true, + st_operations: _st_operations, + fromByteBuffer: function fromByteBuffer(b) { + var type_id = b.readVarint32(); + var st_operation = this.st_operations[type_id]; + + if (HEX_DUMP) { + console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')'); + } + + _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.fromByteBuffer(b)]; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); + b.writeVarint32(type_id); + st_operation.appendByteBuffer(b, object[1]); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + + _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.fromObject(object[1])]; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [0, this.st_operations[0].toObject(undefined, debug)]; + } + + _SerializerValidation2.default.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.toObject(object[1], debug)]; + } + }; + + return static_variant; +}; + +Types.map = function (key_st_operation, value_st_operation) { + var map_object = { + validate: function validate(array) { + if (!Array.isArray(array)) { + throw new Error('expecting array'); + } + + var dup_map = {}; + + for (var i = 0, len = array.length; i < len; i++) { + var o = array[i]; + var ref = void 0; + + if (!(o.length === 2)) { + throw new Error('expecting two elements'); + } + + ref = _typeof(o[0]); + + if (ref && ['number', 'string'].indexOf(ref) >= 0) { + if (dup_map[o[0]] !== undefined) { + throw new Error('duplicate (map)'); + } + + dup_map[o[0]] = true; + } + } + + return sortOperation(array, key_st_operation); + }, + fromByteBuffer: function fromByteBuffer(b) { + var result = []; + var end = b.readVarint32(); + + for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) { + result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]); + } + + return this.validate(result); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + this.validate(object); + b.writeVarint32(object.length); + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + key_st_operation.appendByteBuffer(b, o[0]); + value_st_operation.appendByteBuffer(b, o[1]); + } + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + var result = []; + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]); + } + + return this.validate(result); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]]; + } + + _SerializerValidation2.default.required(object); + object = this.validate(object); + var result = []; + + for (var i = 0, len = object.length; i < len; i++) { + var o = object[i]; + result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]); + } + + return result; + } + }; + + return map_object; +}; + +Types.public_key = { + toPublic: function toPublic(object) { + if (object.resolve !== undefined) { + object = object.resolve; + } + + if (object instanceof _ecc.PublicKey) { + return object; + } + + var result = object; + + if (!object) { + return null; + } + + if (!object.Q) { + result = _ecc.PublicKey.fromStringOrThrow(object); + } + + return result; + }, + fromByteBuffer: function fromByteBuffer(b) { + return _FastParser2.default.public_key(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _SerializerValidation2.default.required(object); + _FastParser2.default.public_key(b, Types.public_key.toPublic(object)); + }, + fromObject: function fromObject(object) { + _SerializerValidation2.default.required(object); + + if (object.Q) { + return object; + } + + return Types.public_key.toPublic(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return _peerplaysjsWs.ChainConfig.address_prefix + '859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM'; + } + + _SerializerValidation2.default.required(object); + return object.toString(); + }, + compare: function compare(a, b) { + return strCmp(a.toAddressString(), b.toAddressString()); + } +}; + +Types.address = { + _to_address: function _to_address(object) { + _SerializerValidation2.default.required(object); + + if (object.addy) { + return object; + } + + return _ecc.Address.fromString(object); + }, + fromByteBuffer: function fromByteBuffer(b) { + return new _ecc.Address(_FastParser2.default.ripemd160(b)); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + _FastParser2.default.ripemd160(b, Types.address._to_address(object).toBuffer()); + }, + fromObject: function fromObject(object) { + return Types.address._to_address(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return _peerplaysjsWs.ChainConfig.address_prefix + '664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S'; + } + + return Types.address._to_address(object).toString(); + }, + compare: function compare(a, b) { + return strCmp(a.toString(), b.toString()); + } +}; + +Types.variant = { + fromByteBuffer: function fromByteBuffer(b) { + var type = b.readUint8(); + + switch (type) { + case 0: + return null; + case 1: + return Types.int64.fromByteBuffer(b); + case 2: + return Types.uint64.fromByteBuffer(b); + case 3: + return b.readDouble(); + case 4: + return Types.bool.fromByteBuffer(b); + case 5: + return Types.string.fromByteBuffer(b); + case 6: + return Types.array(Types.variant).fromByteBuffer(b); + case 7: + default: + return Types.variant_object.fromByteBuffer(b); + } + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (typeof object === 'number') { + if (Number.isInteger(object)) { + if (object >= 0) { + b.writeUint8(2); + Types.uint64.appendByteBuffer(b, object); + } else { + b.writeUint8(1); + Types.int64.appendByteBuffer(b, object); + } + } else { + b.writeUint8(3); + b.writeDouble(Number.parseFloat(object)); + } + } else if (typeof object === 'boolean') { + b.writeUint8(4); + Types.bool.appendByteBuffer(b, object); + } else if (typeof object === 'string') { + b.writeUint8(5); + Types.string.appendByteBuffer(b, object); + } else if (Array.isArray(object)) { + b.writeUint8(6); + Types.array(Types.variant).appendByteBuffer(b, object); + } else { + b.writeUint8(7); + Types.variant_object.appendByteBuffer(b, object); + } + }, + fromObject: function fromObject(object) { + return JSON.parse(object); + }, + toObject: function toObject(object) { + return JSON.parse(object); + } +}; + +Types.variant_object = { + fromByteBuffer: function fromByteBuffer(b) { + var count = b.readVarint32(); + var result = {}; + + for (var i = 0; i < count; ++i) { + var key = Types.string.fromByteBuffer(b); + result[key] = Types.variant.fromByteBuffer(b); + } + + return result; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + var keys = Object.keys(object); + + b.writeVarint32(keys.length); // number of key/value pairs + + for (var i = 0, len = keys.length; i < len; i++) { + var key = keys[i]; + Types.string.appendByteBuffer(b, key); + Types.variant.appendByteBuffer(b, object[key]); + } + }, + fromObject: function fromObject(object) { + var newObject = {}; + + var keys = Object.keys(object); + + for (var i = 0, len = keys.length; i < len; i++) { + var key = keys[i]; + newObject[key] = object[key]; + } + + return newObject; + }, + toObject: function toObject(object) { + var newObject = {}; + + var keys = Object.keys(object); + + for (var i = 0, len = keys.length; i < len; i++) { + var key = keys[i]; + newObject[key] = object[key]; + } + + return newObject; + } +}; + +Types.enumeration = function (values) { + var enumeration = { + fromByteBuffer: function fromByteBuffer(b) { + return values[b.readVarint32ZigZag()]; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + b.writeVarint32ZigZag(values.indexOf(object)); + }, + fromObject: function fromObject(object) { + return object; + }, + toObject: function toObject(object) { + return object; + } + }; + + return enumeration; +}; + +Types.sha256 = Types.bytes(32); + +exports.default = Types; +module.exports = exports['default']; +}).call(this,require(77),require(35).Buffer) + +},{"20":20,"21":21,"3":3,"35":35,"4":4,"7":7,"70":70,"77":77}],27:[function(require,module,exports){ +(function (global){ +'use strict'; + +// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js +// original notice: + +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +function compare(a, b) { + 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; +} +function isBuffer(b) { + if (global.Buffer && typeof global.Buffer.isBuffer === 'function') { + return global.Buffer.isBuffer(b); + } + return !!(b != null && b._isBuffer); +} + +// based on node assert, original notice: + +// http://wiki.commonjs.org/wiki/Unit_Testing/1.0 +// +// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! +// +// Originally from narwhal.js (http://narwhaljs.org) +// Copyright (c) 2009 Thomas Robinson <280north.com> +// +// 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 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. + +var util = require(108); +var hasOwn = Object.prototype.hasOwnProperty; +var pSlice = Array.prototype.slice; +var functionsHaveNames = (function () { + return function foo() {}.name === 'foo'; +}()); +function pToString (obj) { + return Object.prototype.toString.call(obj); +} +function isView(arrbuf) { + if (isBuffer(arrbuf)) { + return false; + } + if (typeof global.ArrayBuffer !== 'function') { + return false; + } + if (typeof ArrayBuffer.isView === 'function') { + return ArrayBuffer.isView(arrbuf); + } + if (!arrbuf) { + return false; + } + if (arrbuf instanceof DataView) { + return true; + } + if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) { + return true; + } + return false; +} +// 1. The assert module provides functions that throw +// AssertionError's when particular conditions are not met. The +// assert module must conform to the following interface. + +var assert = module.exports = ok; + +// 2. The AssertionError is defined in assert. +// new assert.AssertionError({ message: message, +// actual: actual, +// expected: expected }) + +var regex = /\s*function\s+([^\(\s]*)\s*/; +// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js +function getName(func) { + if (!util.isFunction(func)) { + return; + } + if (functionsHaveNames) { + return func.name; + } + var str = func.toString(); + var match = str.match(regex); + return match && match[1]; +} +assert.AssertionError = function AssertionError(options) { + this.name = 'AssertionError'; + this.actual = options.actual; + this.expected = options.expected; + this.operator = options.operator; + if (options.message) { + this.message = options.message; + this.generatedMessage = false; + } else { + this.message = getMessage(this); + this.generatedMessage = true; + } + var stackStartFunction = options.stackStartFunction || fail; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, stackStartFunction); + } else { + // non v8 browsers so we can have a stacktrace + var err = new Error(); + if (err.stack) { + var out = err.stack; + + // try to strip useless frames + var fn_name = getName(stackStartFunction); + var idx = out.indexOf('\n' + fn_name); + if (idx >= 0) { + // once we have located the function frame + // we need to strip out everything before it (and its line) + var next_line = out.indexOf('\n', idx + 1); + out = out.substring(next_line + 1); + } + + this.stack = out; + } + } +}; + +// assert.AssertionError instanceof Error +util.inherits(assert.AssertionError, Error); + +function truncate(s, n) { + if (typeof s === 'string') { + return s.length < n ? s : s.slice(0, n); + } else { + return s; + } +} +function inspect(something) { + if (functionsHaveNames || !util.isFunction(something)) { + return util.inspect(something); + } + var rawname = getName(something); + var name = rawname ? ': ' + rawname : ''; + return '[Function' + name + ']'; +} +function getMessage(self) { + return truncate(inspect(self.actual), 128) + ' ' + + self.operator + ' ' + + truncate(inspect(self.expected), 128); +} + +// At present only the three keys mentioned above are used and +// understood by the spec. Implementations or sub modules can pass +// other keys to the AssertionError's constructor - they will be +// ignored. + +// 3. All of the following functions must throw an AssertionError +// when a corresponding condition is not met, with a message that +// may be undefined if not provided. All assertion methods provide +// both the actual and expected values to the assertion error for +// display purposes. + +function fail(actual, expected, message, operator, stackStartFunction) { + throw new assert.AssertionError({ + message: message, + actual: actual, + expected: expected, + operator: operator, + stackStartFunction: stackStartFunction + }); +} + +// EXTENSION! allows for well behaved errors defined elsewhere. +assert.fail = fail; + +// 4. Pure assertion tests whether a value is truthy, as determined +// by !!guard. +// assert.ok(guard, message_opt); +// This statement is equivalent to assert.equal(true, !!guard, +// message_opt);. To test strictly for the value true, use +// assert.strictEqual(true, guard, message_opt);. + +function ok(value, message) { + if (!value) fail(value, true, message, '==', assert.ok); +} +assert.ok = ok; + +// 5. The equality assertion tests shallow, coercive equality with +// ==. +// assert.equal(actual, expected, message_opt); + +assert.equal = function equal(actual, expected, message) { + if (actual != expected) fail(actual, expected, message, '==', assert.equal); +}; + +// 6. The non-equality assertion tests for whether two objects are not equal +// with != assert.notEqual(actual, expected, message_opt); + +assert.notEqual = function notEqual(actual, expected, message) { + if (actual == expected) { + fail(actual, expected, message, '!=', assert.notEqual); + } +}; + +// 7. The equivalence assertion tests a deep equality relation. +// assert.deepEqual(actual, expected, message_opt); + +assert.deepEqual = function deepEqual(actual, expected, message) { + if (!_deepEqual(actual, expected, false)) { + fail(actual, expected, message, 'deepEqual', assert.deepEqual); + } +}; + +assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) { + if (!_deepEqual(actual, expected, true)) { + fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual); + } +}; + +function _deepEqual(actual, expected, strict, memos) { + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + } else if (isBuffer(actual) && isBuffer(expected)) { + return compare(actual, expected) === 0; + + // 7.2. If the expected value is a Date object, the actual value is + // equivalent if it is also a Date object that refers to the same time. + } else if (util.isDate(actual) && util.isDate(expected)) { + return actual.getTime() === expected.getTime(); + + // 7.3 If the expected value is a RegExp object, the actual value is + // equivalent if it is also a RegExp object with the same source and + // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). + } else if (util.isRegExp(actual) && util.isRegExp(expected)) { + return actual.source === expected.source && + actual.global === expected.global && + actual.multiline === expected.multiline && + actual.lastIndex === expected.lastIndex && + actual.ignoreCase === expected.ignoreCase; + + // 7.4. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if ((actual === null || typeof actual !== 'object') && + (expected === null || typeof expected !== 'object')) { + return strict ? actual === expected : actual == expected; + + // If both values are instances of typed arrays, wrap their underlying + // ArrayBuffers in a Buffer each to increase performance + // This optimization requires the arrays to have the same type as checked by + // Object.prototype.toString (aka pToString). Never perform binary + // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their + // bit patterns are not identical. + } else if (isView(actual) && isView(expected) && + pToString(actual) === pToString(expected) && + !(actual instanceof Float32Array || + actual instanceof Float64Array)) { + return compare(new Uint8Array(actual.buffer), + new Uint8Array(expected.buffer)) === 0; + + // 7.5 For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else if (isBuffer(actual) !== isBuffer(expected)) { + return false; + } else { + memos = memos || {actual: [], expected: []}; + + var actualIndex = memos.actual.indexOf(actual); + if (actualIndex !== -1) { + if (actualIndex === memos.expected.indexOf(expected)) { + return true; + } + } + + memos.actual.push(actual); + memos.expected.push(expected); + + return objEquiv(actual, expected, strict, memos); + } +} + +function isArguments(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +} + +function objEquiv(a, b, strict, actualVisitedObjects) { + if (a === null || a === undefined || b === null || b === undefined) + return false; + // if one is a primitive, the other must be same + if (util.isPrimitive(a) || util.isPrimitive(b)) + return a === b; + if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) + return false; + var aIsArgs = isArguments(a); + var bIsArgs = isArguments(b); + if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) + return false; + if (aIsArgs) { + a = pSlice.call(a); + b = pSlice.call(b); + return _deepEqual(a, b, strict); + } + var ka = objectKeys(a); + var kb = objectKeys(b); + var key, i; + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length !== kb.length) + return false; + //the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + //~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] !== kb[i]) + return false; + } + //equivalent values for every corresponding key, and + //~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects)) + return false; + } + return true; +} + +// 8. The non-equivalence assertion tests for any deep inequality. +// assert.notDeepEqual(actual, expected, message_opt); + +assert.notDeepEqual = function notDeepEqual(actual, expected, message) { + if (_deepEqual(actual, expected, false)) { + fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); + } +}; + +assert.notDeepStrictEqual = notDeepStrictEqual; +function notDeepStrictEqual(actual, expected, message) { + if (_deepEqual(actual, expected, true)) { + fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual); + } +} + + +// 9. The strict equality assertion tests strict equality, as determined by ===. +// assert.strictEqual(actual, expected, message_opt); + +assert.strictEqual = function strictEqual(actual, expected, message) { + if (actual !== expected) { + fail(actual, expected, message, '===', assert.strictEqual); + } +}; + +// 10. The strict non-equality assertion tests for strict inequality, as +// determined by !==. assert.notStrictEqual(actual, expected, message_opt); + +assert.notStrictEqual = function notStrictEqual(actual, expected, message) { + if (actual === expected) { + fail(actual, expected, message, '!==', assert.notStrictEqual); + } +}; + +function expectedException(actual, expected) { + if (!actual || !expected) { + return false; + } + + if (Object.prototype.toString.call(expected) == '[object RegExp]') { + return expected.test(actual); + } + + try { + if (actual instanceof expected) { + return true; + } + } catch (e) { + // Ignore. The instanceof check doesn't work for arrow functions. + } + + if (Error.isPrototypeOf(expected)) { + return false; + } + + return expected.call({}, actual) === true; +} + +function _tryBlock(block) { + var error; + try { + block(); + } catch (e) { + error = e; + } + return error; +} + +function _throws(shouldThrow, block, expected, message) { + var actual; + + if (typeof block !== 'function') { + throw new TypeError('"block" argument must be a function'); + } + + if (typeof expected === 'string') { + message = expected; + expected = null; + } + + actual = _tryBlock(block); + + message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + + (message ? ' ' + message : '.'); + + if (shouldThrow && !actual) { + fail(actual, expected, 'Missing expected exception' + message); + } + + var userProvidedMessage = typeof message === 'string'; + var isUnwantedException = !shouldThrow && util.isError(actual); + var isUnexpectedException = !shouldThrow && actual && !expected; + + if ((isUnwantedException && + userProvidedMessage && + expectedException(actual, expected)) || + isUnexpectedException) { + fail(actual, expected, 'Got unwanted exception' + message); + } + + if ((shouldThrow && actual && expected && + !expectedException(actual, expected)) || (!shouldThrow && actual)) { + throw actual; + } +} + +// 11. Expected to throw an error: +// assert.throws(block, Error_opt, message_opt); + +assert.throws = function(block, /*optional*/error, /*optional*/message) { + _throws(true, block, error, message); +}; + +// EXTENSION! This is annoying to write outside this module. +assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) { + _throws(false, block, error, message); +}; + +assert.ifError = function(err) { if (err) throw err; }; + +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + if (hasOwn.call(obj, key)) keys.push(key); + } + return keys; +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"108":108}],28:[function(require,module,exports){ +// base-x encoding +// Forked from https://github.com/cryptocoinjs/bs58 +// Originally written by Mike Hearn for BitcoinJ +// Copyright (c) 2011 Google Inc +// Ported to JavaScript by Stefan Thomas +// Merged Buffer refactorings from base58-native by Stephen Pair +// Copyright (c) 2013 BitPay Inc + +module.exports = function base (ALPHABET) { + var ALPHABET_MAP = {} + var BASE = ALPHABET.length + var LEADER = ALPHABET.charAt(0) + + // pre-compute lookup table + for (var i = 0; i < ALPHABET.length; i++) { + ALPHABET_MAP[ALPHABET.charAt(i)] = i + } + + function encode (source) { + if (source.length === 0) return '' + + var digits = [0] + for (var i = 0; i < source.length; ++i) { + for (var j = 0, carry = source[i]; j < digits.length; ++j) { + carry += digits[j] << 8 + digits[j] = carry % BASE + carry = (carry / BASE) | 0 + } + + while (carry > 0) { + digits.push(carry % BASE) + carry = (carry / BASE) | 0 + } + } + + var string = '' + + // deal with leading zeros + for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) string += ALPHABET[0] + // convert digits to a string + for (var q = digits.length - 1; q >= 0; --q) string += ALPHABET[digits[q]] + + return string + } + + function decodeUnsafe (string) { + if (string.length === 0) return [] + + var bytes = [0] + for (var i = 0; i < string.length; i++) { + var value = ALPHABET_MAP[string[i]] + if (value === undefined) return + + for (var j = 0, carry = value; j < bytes.length; ++j) { + carry += bytes[j] * BASE + bytes[j] = carry & 0xff + carry >>= 8 + } + + while (carry > 0) { + bytes.push(carry & 0xff) + carry >>= 8 + } + } + + // deal with leading zeros + for (var k = 0; string[k] === LEADER && k < string.length - 1; ++k) { + bytes.push(0) + } + + return bytes.reverse() + } + + function decode (string) { + var array = decodeUnsafe(string) + if (array) return array + + throw new Error('Non-base' + BASE + ' character') + } + + return { + encode: encode, + decodeUnsafe: decodeUnsafe, + decode: decode + } +} + +},{}],29:[function(require,module,exports){ +'use strict' + +exports.byteLength = byteLength +exports.toByteArray = toByteArray +exports.fromByteArray = fromByteArray + +var lookup = [] +var revLookup = [] +var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i +} + +// Support decoding URL-safe base64 strings, as Node.js does. +// See: https://en.wikipedia.org/wiki/Base64#URL_applications +revLookup['-'.charCodeAt(0)] = 62 +revLookup['_'.charCodeAt(0)] = 63 + +function getLens (b64) { + var len = b64.length + + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // Trim off extra bytes after placeholder bytes are found + // See: https://github.com/beatgammit/base64-js/issues/42 + var validLen = b64.indexOf('=') + if (validLen === -1) validLen = len + + var placeHoldersLen = validLen === len + ? 0 + : 4 - (validLen % 4) + + return [validLen, placeHoldersLen] +} + +// base64 is 4/3 + up to two characters of the original data +function byteLength (b64) { + var lens = getLens(b64) + var validLen = lens[0] + var placeHoldersLen = lens[1] + return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen +} + +function _byteLength (b64, validLen, placeHoldersLen) { + return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen +} + +function toByteArray (b64) { + var tmp + var lens = getLens(b64) + var validLen = lens[0] + var placeHoldersLen = lens[1] + + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) + + var curByte = 0 + + // if there are placeholders, only get up to the last complete 4 chars + var len = placeHoldersLen > 0 + ? validLen - 4 + : validLen + + for (var 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('') +} + +},{}],30:[function(require,module,exports){ +// (public) Constructor +function BigInteger(a, b, c) { + if (!(this instanceof BigInteger)) + return new BigInteger(a, b, c) + + if (a != null) { + if ("number" == typeof a) this.fromNumber(a, b, c) + else if (b == null && "string" != typeof a) this.fromString(a, 256) + else this.fromString(a, b) + } +} + +var proto = BigInteger.prototype + +// duck-typed isBigInteger +proto.__bigi = require(33).version +BigInteger.isBigInteger = function (obj, check_ver) { + return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi) +} + +// Bits per digit +var dbits + +// am: Compute w_j += (x*this_i), propagate carries, +// c is initial carry, returns final carry. +// c < 3*dvalue, x < 2*dvalue, this_i < dvalue +// We need to select the fastest one that works in this environment. + +// am1: use a single mult and divide to get the high bits, +// max digit bits should be 26 because +// max internal value = 2*dvalue^2-2*dvalue (< 2^53) +function am1(i, x, w, j, c, n) { + while (--n >= 0) { + var v = x * this[i++] + w[j] + c + c = Math.floor(v / 0x4000000) + w[j++] = v & 0x3ffffff + } + return c +} +// am2 avoids a big mult-and-extract completely. +// Max digit bits should be <= 30 because we do bitwise ops +// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31) +function am2(i, x, w, j, c, n) { + var xl = x & 0x7fff, + xh = x >> 15 + while (--n >= 0) { + var l = this[i] & 0x7fff + var h = this[i++] >> 15 + var m = xh * l + h * xl + l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff) + c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30) + w[j++] = l & 0x3fffffff + } + return c +} +// Alternately, set max digit bits to 28 since some +// browsers slow down when dealing with 32-bit numbers. +function am3(i, x, w, j, c, n) { + var xl = x & 0x3fff, + xh = x >> 14 + while (--n >= 0) { + var l = this[i] & 0x3fff + var h = this[i++] >> 14 + var m = xh * l + h * xl + l = xl * l + ((m & 0x3fff) << 14) + w[j] + c + c = (l >> 28) + (m >> 14) + xh * h + w[j++] = l & 0xfffffff + } + return c +} + +// wtf? +BigInteger.prototype.am = am1 +dbits = 26 + +BigInteger.prototype.DB = dbits +BigInteger.prototype.DM = ((1 << dbits) - 1) +var DV = BigInteger.prototype.DV = (1 << dbits) + +var BI_FP = 52 +BigInteger.prototype.FV = Math.pow(2, BI_FP) +BigInteger.prototype.F1 = BI_FP - dbits +BigInteger.prototype.F2 = 2 * dbits - BI_FP + +// Digit conversions +var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz" +var BI_RC = new Array() +var rr, vv +rr = "0".charCodeAt(0) +for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv +rr = "a".charCodeAt(0) +for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv +rr = "A".charCodeAt(0) +for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv + +function int2char(n) { + return BI_RM.charAt(n) +} + +function intAt(s, i) { + var c = BI_RC[s.charCodeAt(i)] + return (c == null) ? -1 : c +} + +// (protected) copy this to r +function bnpCopyTo(r) { + for (var i = this.t - 1; i >= 0; --i) r[i] = this[i] + r.t = this.t + r.s = this.s +} + +// (protected) set from integer value x, -DV <= x < DV +function bnpFromInt(x) { + this.t = 1 + this.s = (x < 0) ? -1 : 0 + if (x > 0) this[0] = x + else if (x < -1) this[0] = x + DV + else this.t = 0 +} + +// return bigint initialized to value +function nbv(i) { + var r = new BigInteger() + r.fromInt(i) + return r +} + +// (protected) set from string and radix +function bnpFromString(s, b) { + var self = this + + var k + if (b == 16) k = 4 + else if (b == 8) k = 3 + else if (b == 256) k = 8; // byte array + else if (b == 2) k = 1 + else if (b == 32) k = 5 + else if (b == 4) k = 2 + else { + self.fromRadix(s, b) + return + } + self.t = 0 + self.s = 0 + var i = s.length, + mi = false, + sh = 0 + while (--i >= 0) { + var x = (k == 8) ? s[i] & 0xff : intAt(s, i) + if (x < 0) { + if (s.charAt(i) == "-") mi = true + continue + } + mi = false + if (sh == 0) + self[self.t++] = x + else if (sh + k > self.DB) { + self[self.t - 1] |= (x & ((1 << (self.DB - sh)) - 1)) << sh + self[self.t++] = (x >> (self.DB - sh)) + } else + self[self.t - 1] |= x << sh + sh += k + if (sh >= self.DB) sh -= self.DB + } + if (k == 8 && (s[0] & 0x80) != 0) { + self.s = -1 + if (sh > 0) self[self.t - 1] |= ((1 << (self.DB - sh)) - 1) << sh + } + self.clamp() + if (mi) BigInteger.ZERO.subTo(self, self) +} + +// (protected) clamp off excess high words +function bnpClamp() { + var c = this.s & this.DM + while (this.t > 0 && this[this.t - 1] == c)--this.t +} + +// (public) return string representation in given radix +function bnToString(b) { + var self = this + if (self.s < 0) return "-" + self.negate() + .toString(b) + var k + if (b == 16) k = 4 + else if (b == 8) k = 3 + else if (b == 2) k = 1 + else if (b == 32) k = 5 + else if (b == 4) k = 2 + else return self.toRadix(b) + var km = (1 << k) - 1, + d, m = false, + r = "", + i = self.t + var p = self.DB - (i * self.DB) % k + if (i-- > 0) { + if (p < self.DB && (d = self[i] >> p) > 0) { + m = true + r = int2char(d) + } + while (i >= 0) { + if (p < k) { + d = (self[i] & ((1 << p) - 1)) << (k - p) + d |= self[--i] >> (p += self.DB - k) + } else { + d = (self[i] >> (p -= k)) & km + if (p <= 0) { + p += self.DB + --i + } + } + if (d > 0) m = true + if (m) r += int2char(d) + } + } + return m ? r : "0" +} + +// (public) -this +function bnNegate() { + var r = new BigInteger() + BigInteger.ZERO.subTo(this, r) + return r +} + +// (public) |this| +function bnAbs() { + return (this.s < 0) ? this.negate() : this +} + +// (public) return + if this > a, - if this < a, 0 if equal +function bnCompareTo(a) { + var r = this.s - a.s + if (r != 0) return r + var i = this.t + r = i - a.t + if (r != 0) return (this.s < 0) ? -r : r + while (--i >= 0) + if ((r = this[i] - a[i]) != 0) return r + return 0 +} + +// returns bit length of the integer x +function nbits(x) { + var r = 1, + t + if ((t = x >>> 16) != 0) { + x = t + r += 16 + } + if ((t = x >> 8) != 0) { + x = t + r += 8 + } + if ((t = x >> 4) != 0) { + x = t + r += 4 + } + if ((t = x >> 2) != 0) { + x = t + r += 2 + } + if ((t = x >> 1) != 0) { + x = t + r += 1 + } + return r +} + +// (public) return the number of bits in "this" +function bnBitLength() { + if (this.t <= 0) return 0 + return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM)) +} + +// (public) return the number of bytes in "this" +function bnByteLength() { + return this.bitLength() >> 3 +} + +// (protected) r = this << n*DB +function bnpDLShiftTo(n, r) { + var i + for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i] + for (i = n - 1; i >= 0; --i) r[i] = 0 + r.t = this.t + n + r.s = this.s +} + +// (protected) r = this >> n*DB +function bnpDRShiftTo(n, r) { + for (var i = n; i < this.t; ++i) r[i - n] = this[i] + r.t = Math.max(this.t - n, 0) + r.s = this.s +} + +// (protected) r = this << n +function bnpLShiftTo(n, r) { + var self = this + var bs = n % self.DB + var cbs = self.DB - bs + var bm = (1 << cbs) - 1 + var ds = Math.floor(n / self.DB), + c = (self.s << bs) & self.DM, + i + for (i = self.t - 1; i >= 0; --i) { + r[i + ds + 1] = (self[i] >> cbs) | c + c = (self[i] & bm) << bs + } + for (i = ds - 1; i >= 0; --i) r[i] = 0 + r[ds] = c + r.t = self.t + ds + 1 + r.s = self.s + r.clamp() +} + +// (protected) r = this >> n +function bnpRShiftTo(n, r) { + var self = this + r.s = self.s + var ds = Math.floor(n / self.DB) + if (ds >= self.t) { + r.t = 0 + return + } + var bs = n % self.DB + var cbs = self.DB - bs + var bm = (1 << bs) - 1 + r[0] = self[ds] >> bs + for (var i = ds + 1; i < self.t; ++i) { + r[i - ds - 1] |= (self[i] & bm) << cbs + r[i - ds] = self[i] >> bs + } + if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs + r.t = self.t - ds + r.clamp() +} + +// (protected) r = this - a +function bnpSubTo(a, r) { + var self = this + var i = 0, + c = 0, + m = Math.min(a.t, self.t) + while (i < m) { + c += self[i] - a[i] + r[i++] = c & self.DM + c >>= self.DB + } + if (a.t < self.t) { + c -= a.s + while (i < self.t) { + c += self[i] + r[i++] = c & self.DM + c >>= self.DB + } + c += self.s + } else { + c += self.s + while (i < a.t) { + c -= a[i] + r[i++] = c & self.DM + c >>= self.DB + } + c -= a.s + } + r.s = (c < 0) ? -1 : 0 + if (c < -1) r[i++] = self.DV + c + else if (c > 0) r[i++] = c + r.t = i + r.clamp() +} + +// (protected) r = this * a, r != this,a (HAC 14.12) +// "this" should be the larger one if appropriate. +function bnpMultiplyTo(a, r) { + var x = this.abs(), + y = a.abs() + var i = x.t + r.t = i + y.t + while (--i >= 0) r[i] = 0 + for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t) + r.s = 0 + r.clamp() + if (this.s != a.s) BigInteger.ZERO.subTo(r, r) +} + +// (protected) r = this^2, r != this (HAC 14.16) +function bnpSquareTo(r) { + var x = this.abs() + var i = r.t = 2 * x.t + while (--i >= 0) r[i] = 0 + for (i = 0; i < x.t - 1; ++i) { + var c = x.am(i, x[i], r, 2 * i, 0, 1) + if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) { + r[i + x.t] -= x.DV + r[i + x.t + 1] = 1 + } + } + if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1) + r.s = 0 + r.clamp() +} + +// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20) +// r != q, this != m. q or r may be null. +function bnpDivRemTo(m, q, r) { + var self = this + var pm = m.abs() + if (pm.t <= 0) return + var pt = self.abs() + if (pt.t < pm.t) { + if (q != null) q.fromInt(0) + if (r != null) self.copyTo(r) + return + } + if (r == null) r = new BigInteger() + var y = new BigInteger(), + ts = self.s, + ms = m.s + var nsh = self.DB - nbits(pm[pm.t - 1]); // normalize modulus + if (nsh > 0) { + pm.lShiftTo(nsh, y) + pt.lShiftTo(nsh, r) + } else { + pm.copyTo(y) + pt.copyTo(r) + } + var ys = y.t + var y0 = y[ys - 1] + if (y0 == 0) return + var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0) + var d1 = self.FV / yt, + d2 = (1 << self.F1) / yt, + e = 1 << self.F2 + var i = r.t, + j = i - ys, + t = (q == null) ? new BigInteger() : q + y.dlShiftTo(j, t) + if (r.compareTo(t) >= 0) { + r[r.t++] = 1 + r.subTo(t, r) + } + BigInteger.ONE.dlShiftTo(ys, t) + t.subTo(y, y); // "negative" y so we can replace sub with am later + while (y.t < ys) y[y.t++] = 0 + while (--j >= 0) { + // Estimate quotient digit + var qd = (r[--i] == y0) ? self.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2) + if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out + y.dlShiftTo(j, t) + r.subTo(t, r) + while (r[i] < --qd) r.subTo(t, r) + } + } + if (q != null) { + r.drShiftTo(ys, q) + if (ts != ms) BigInteger.ZERO.subTo(q, q) + } + r.t = ys + r.clamp() + if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder + if (ts < 0) BigInteger.ZERO.subTo(r, r) +} + +// (public) this mod a +function bnMod(a) { + var r = new BigInteger() + this.abs() + .divRemTo(a, null, r) + if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r) + return r +} + +// Modular reduction using "classic" algorithm +function Classic(m) { + this.m = m +} + +function cConvert(x) { + if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m) + else return x +} + +function cRevert(x) { + return x +} + +function cReduce(x) { + x.divRemTo(this.m, null, x) +} + +function cMulTo(x, y, r) { + x.multiplyTo(y, r) + this.reduce(r) +} + +function cSqrTo(x, r) { + x.squareTo(r) + this.reduce(r) +} + +Classic.prototype.convert = cConvert +Classic.prototype.revert = cRevert +Classic.prototype.reduce = cReduce +Classic.prototype.mulTo = cMulTo +Classic.prototype.sqrTo = cSqrTo + +// (protected) return "-1/this % 2^DB"; useful for Mont. reduction +// justification: +// xy == 1 (mod m) +// xy = 1+km +// xy(2-xy) = (1+km)(1-km) +// x[y(2-xy)] = 1-k^2m^2 +// x[y(2-xy)] == 1 (mod m^2) +// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2 +// should reduce x and y(2-xy) by m^2 at each step to keep size bounded. +// JS multiply "overflows" differently from C/C++, so care is needed here. +function bnpInvDigit() { + if (this.t < 1) return 0 + var x = this[0] + if ((x & 1) == 0) return 0 + var y = x & 3; // y == 1/x mod 2^2 + y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4 + y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8 + y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16 + // last step - calculate inverse mod DV directly + // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints + y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits + // we really want the negative inverse, and -DV < y < DV + return (y > 0) ? this.DV - y : -y +} + +// Montgomery reduction +function Montgomery(m) { + this.m = m + this.mp = m.invDigit() + this.mpl = this.mp & 0x7fff + this.mph = this.mp >> 15 + this.um = (1 << (m.DB - 15)) - 1 + this.mt2 = 2 * m.t +} + +// xR mod m +function montConvert(x) { + var r = new BigInteger() + x.abs() + .dlShiftTo(this.m.t, r) + r.divRemTo(this.m, null, r) + if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r) + return r +} + +// x/R mod m +function montRevert(x) { + var r = new BigInteger() + x.copyTo(r) + this.reduce(r) + return r +} + +// x = x/R mod m (HAC 14.32) +function montReduce(x) { + while (x.t <= this.mt2) // pad x so am has enough room later + x[x.t++] = 0 + for (var i = 0; i < this.m.t; ++i) { + // faster way of calculating u0 = x[i]*mp mod DV + var j = x[i] & 0x7fff + var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM + // use am to combine the multiply-shift-add into one call + j = i + this.m.t + x[j] += this.m.am(0, u0, x, i, 0, this.m.t) + // propagate carry + while (x[j] >= x.DV) { + x[j] -= x.DV + x[++j]++ + } + } + x.clamp() + x.drShiftTo(this.m.t, x) + if (x.compareTo(this.m) >= 0) x.subTo(this.m, x) +} + +// r = "x^2/R mod m"; x != r +function montSqrTo(x, r) { + x.squareTo(r) + this.reduce(r) +} + +// r = "xy/R mod m"; x,y != r +function montMulTo(x, y, r) { + x.multiplyTo(y, r) + this.reduce(r) +} + +Montgomery.prototype.convert = montConvert +Montgomery.prototype.revert = montRevert +Montgomery.prototype.reduce = montReduce +Montgomery.prototype.mulTo = montMulTo +Montgomery.prototype.sqrTo = montSqrTo + +// (protected) true iff this is even +function bnpIsEven() { + return ((this.t > 0) ? (this[0] & 1) : this.s) == 0 +} + +// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79) +function bnpExp(e, z) { + if (e > 0xffffffff || e < 1) return BigInteger.ONE + var r = new BigInteger(), + r2 = new BigInteger(), + g = z.convert(this), + i = nbits(e) - 1 + g.copyTo(r) + while (--i >= 0) { + z.sqrTo(r, r2) + if ((e & (1 << i)) > 0) z.mulTo(r2, g, r) + else { + var t = r + r = r2 + r2 = t + } + } + return z.revert(r) +} + +// (public) this^e % m, 0 <= e < 2^32 +function bnModPowInt(e, m) { + var z + if (e < 256 || m.isEven()) z = new Classic(m) + else z = new Montgomery(m) + return this.exp(e, z) +} + +// protected +proto.copyTo = bnpCopyTo +proto.fromInt = bnpFromInt +proto.fromString = bnpFromString +proto.clamp = bnpClamp +proto.dlShiftTo = bnpDLShiftTo +proto.drShiftTo = bnpDRShiftTo +proto.lShiftTo = bnpLShiftTo +proto.rShiftTo = bnpRShiftTo +proto.subTo = bnpSubTo +proto.multiplyTo = bnpMultiplyTo +proto.squareTo = bnpSquareTo +proto.divRemTo = bnpDivRemTo +proto.invDigit = bnpInvDigit +proto.isEven = bnpIsEven +proto.exp = bnpExp + +// public +proto.toString = bnToString +proto.negate = bnNegate +proto.abs = bnAbs +proto.compareTo = bnCompareTo +proto.bitLength = bnBitLength +proto.byteLength = bnByteLength +proto.mod = bnMod +proto.modPowInt = bnModPowInt + +// (public) +function bnClone() { + var r = new BigInteger() + this.copyTo(r) + return r +} + +// (public) return value as integer +function bnIntValue() { + if (this.s < 0) { + if (this.t == 1) return this[0] - this.DV + else if (this.t == 0) return -1 + } else if (this.t == 1) return this[0] + else if (this.t == 0) return 0 + // assumes 16 < DB < 32 + return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0] +} + +// (public) return value as byte +function bnByteValue() { + return (this.t == 0) ? this.s : (this[0] << 24) >> 24 +} + +// (public) return value as short (assumes DB>=16) +function bnShortValue() { + return (this.t == 0) ? this.s : (this[0] << 16) >> 16 +} + +// (protected) return x s.t. r^x < DV +function bnpChunkSize(r) { + return Math.floor(Math.LN2 * this.DB / Math.log(r)) +} + +// (public) 0 if this == 0, 1 if this > 0 +function bnSigNum() { + if (this.s < 0) return -1 + else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0 + else return 1 +} + +// (protected) convert to radix string +function bnpToRadix(b) { + if (b == null) b = 10 + if (this.signum() == 0 || b < 2 || b > 36) return "0" + var cs = this.chunkSize(b) + var a = Math.pow(b, cs) + var d = nbv(a), + y = new BigInteger(), + z = new BigInteger(), + r = "" + this.divRemTo(d, y, z) + while (y.signum() > 0) { + r = (a + z.intValue()) + .toString(b) + .substr(1) + r + y.divRemTo(d, y, z) + } + return z.intValue() + .toString(b) + r +} + +// (protected) convert from radix string +function bnpFromRadix(s, b) { + var self = this + self.fromInt(0) + if (b == null) b = 10 + var cs = self.chunkSize(b) + var d = Math.pow(b, cs), + mi = false, + j = 0, + w = 0 + for (var i = 0; i < s.length; ++i) { + var x = intAt(s, i) + if (x < 0) { + if (s.charAt(i) == "-" && self.signum() == 0) mi = true + continue + } + w = b * w + x + if (++j >= cs) { + self.dMultiply(d) + self.dAddOffset(w, 0) + j = 0 + w = 0 + } + } + if (j > 0) { + self.dMultiply(Math.pow(b, j)) + self.dAddOffset(w, 0) + } + if (mi) BigInteger.ZERO.subTo(self, self) +} + +// (protected) alternate constructor +function bnpFromNumber(a, b, c) { + var self = this + if ("number" == typeof b) { + // new BigInteger(int,int,RNG) + if (a < 2) self.fromInt(1) + else { + self.fromNumber(a, c) + if (!self.testBit(a - 1)) // force MSB set + self.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, self) + if (self.isEven()) self.dAddOffset(1, 0); // force odd + while (!self.isProbablePrime(b)) { + self.dAddOffset(2, 0) + if (self.bitLength() > a) self.subTo(BigInteger.ONE.shiftLeft(a - 1), self) + } + } + } else { + // new BigInteger(int,RNG) + var x = new Array(), + t = a & 7 + x.length = (a >> 3) + 1 + b.nextBytes(x) + if (t > 0) x[0] &= ((1 << t) - 1) + else x[0] = 0 + self.fromString(x, 256) + } +} + +// (public) convert to bigendian byte array +function bnToByteArray() { + var self = this + var i = self.t, + r = new Array() + r[0] = self.s + var p = self.DB - (i * self.DB) % 8, + d, k = 0 + if (i-- > 0) { + if (p < self.DB && (d = self[i] >> p) != (self.s & self.DM) >> p) + r[k++] = d | (self.s << (self.DB - p)) + while (i >= 0) { + if (p < 8) { + d = (self[i] & ((1 << p) - 1)) << (8 - p) + d |= self[--i] >> (p += self.DB - 8) + } else { + d = (self[i] >> (p -= 8)) & 0xff + if (p <= 0) { + p += self.DB + --i + } + } + if ((d & 0x80) != 0) d |= -256 + if (k === 0 && (self.s & 0x80) != (d & 0x80))++k + if (k > 0 || d != self.s) r[k++] = d + } + } + return r +} + +function bnEquals(a) { + return (this.compareTo(a) == 0) +} + +function bnMin(a) { + return (this.compareTo(a) < 0) ? this : a +} + +function bnMax(a) { + return (this.compareTo(a) > 0) ? this : a +} + +// (protected) r = this op a (bitwise) +function bnpBitwiseTo(a, op, r) { + var self = this + var i, f, m = Math.min(a.t, self.t) + for (i = 0; i < m; ++i) r[i] = op(self[i], a[i]) + if (a.t < self.t) { + f = a.s & self.DM + for (i = m; i < self.t; ++i) r[i] = op(self[i], f) + r.t = self.t + } else { + f = self.s & self.DM + for (i = m; i < a.t; ++i) r[i] = op(f, a[i]) + r.t = a.t + } + r.s = op(self.s, a.s) + r.clamp() +} + +// (public) this & a +function op_and(x, y) { + return x & y +} + +function bnAnd(a) { + var r = new BigInteger() + this.bitwiseTo(a, op_and, r) + return r +} + +// (public) this | a +function op_or(x, y) { + return x | y +} + +function bnOr(a) { + var r = new BigInteger() + this.bitwiseTo(a, op_or, r) + return r +} + +// (public) this ^ a +function op_xor(x, y) { + return x ^ y +} + +function bnXor(a) { + var r = new BigInteger() + this.bitwiseTo(a, op_xor, r) + return r +} + +// (public) this & ~a +function op_andnot(x, y) { + return x & ~y +} + +function bnAndNot(a) { + var r = new BigInteger() + this.bitwiseTo(a, op_andnot, r) + return r +} + +// (public) ~this +function bnNot() { + var r = new BigInteger() + for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i] + r.t = this.t + r.s = ~this.s + return r +} + +// (public) this << n +function bnShiftLeft(n) { + var r = new BigInteger() + if (n < 0) this.rShiftTo(-n, r) + else this.lShiftTo(n, r) + return r +} + +// (public) this >> n +function bnShiftRight(n) { + var r = new BigInteger() + if (n < 0) this.lShiftTo(-n, r) + else this.rShiftTo(n, r) + return r +} + +// return index of lowest 1-bit in x, x < 2^31 +function lbit(x) { + if (x == 0) return -1 + var r = 0 + if ((x & 0xffff) == 0) { + x >>= 16 + r += 16 + } + if ((x & 0xff) == 0) { + x >>= 8 + r += 8 + } + if ((x & 0xf) == 0) { + x >>= 4 + r += 4 + } + if ((x & 3) == 0) { + x >>= 2 + r += 2 + } + if ((x & 1) == 0)++r + return r +} + +// (public) returns index of lowest 1-bit (or -1 if none) +function bnGetLowestSetBit() { + for (var i = 0; i < this.t; ++i) + if (this[i] != 0) return i * this.DB + lbit(this[i]) + if (this.s < 0) return this.t * this.DB + return -1 +} + +// return number of 1 bits in x +function cbit(x) { + var r = 0 + while (x != 0) { + x &= x - 1 + ++r + } + return r +} + +// (public) return number of set bits +function bnBitCount() { + var r = 0, + x = this.s & this.DM + for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x) + return r +} + +// (public) true iff nth bit is set +function bnTestBit(n) { + var j = Math.floor(n / this.DB) + if (j >= this.t) return (this.s != 0) + return ((this[j] & (1 << (n % this.DB))) != 0) +} + +// (protected) this op (1<>= self.DB + } + if (a.t < self.t) { + c += a.s + while (i < self.t) { + c += self[i] + r[i++] = c & self.DM + c >>= self.DB + } + c += self.s + } else { + c += self.s + while (i < a.t) { + c += a[i] + r[i++] = c & self.DM + c >>= self.DB + } + c += a.s + } + r.s = (c < 0) ? -1 : 0 + if (c > 0) r[i++] = c + else if (c < -1) r[i++] = self.DV + c + r.t = i + r.clamp() +} + +// (public) this + a +function bnAdd(a) { + var r = new BigInteger() + this.addTo(a, r) + return r +} + +// (public) this - a +function bnSubtract(a) { + var r = new BigInteger() + this.subTo(a, r) + return r +} + +// (public) this * a +function bnMultiply(a) { + var r = new BigInteger() + this.multiplyTo(a, r) + return r +} + +// (public) this^2 +function bnSquare() { + var r = new BigInteger() + this.squareTo(r) + return r +} + +// (public) this / a +function bnDivide(a) { + var r = new BigInteger() + this.divRemTo(a, r, null) + return r +} + +// (public) this % a +function bnRemainder(a) { + var r = new BigInteger() + this.divRemTo(a, null, r) + return r +} + +// (public) [this/a,this%a] +function bnDivideAndRemainder(a) { + var q = new BigInteger(), + r = new BigInteger() + this.divRemTo(a, q, r) + return new Array(q, r) +} + +// (protected) this *= n, this >= 0, 1 < n < DV +function bnpDMultiply(n) { + this[this.t] = this.am(0, n - 1, this, 0, 0, this.t) + ++this.t + this.clamp() +} + +// (protected) this += n << w words, this >= 0 +function bnpDAddOffset(n, w) { + if (n == 0) return + while (this.t <= w) this[this.t++] = 0 + this[w] += n + while (this[w] >= this.DV) { + this[w] -= this.DV + if (++w >= this.t) this[this.t++] = 0 + ++this[w] + } +} + +// A "null" reducer +function NullExp() {} + +function nNop(x) { + return x +} + +function nMulTo(x, y, r) { + x.multiplyTo(y, r) +} + +function nSqrTo(x, r) { + x.squareTo(r) +} + +NullExp.prototype.convert = nNop +NullExp.prototype.revert = nNop +NullExp.prototype.mulTo = nMulTo +NullExp.prototype.sqrTo = nSqrTo + +// (public) this^e +function bnPow(e) { + return this.exp(e, new NullExp()) +} + +// (protected) r = lower n words of "this * a", a.t <= n +// "this" should be the larger one if appropriate. +function bnpMultiplyLowerTo(a, n, r) { + var i = Math.min(this.t + a.t, n) + r.s = 0; // assumes a,this >= 0 + r.t = i + while (i > 0) r[--i] = 0 + var j + for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t) + for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i) + r.clamp() +} + +// (protected) r = "this * a" without lower n words, n > 0 +// "this" should be the larger one if appropriate. +function bnpMultiplyUpperTo(a, n, r) { + --n + var i = r.t = this.t + a.t - n + r.s = 0; // assumes a,this >= 0 + while (--i >= 0) r[i] = 0 + for (i = Math.max(n - this.t, 0); i < a.t; ++i) + r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n) + r.clamp() + r.drShiftTo(1, r) +} + +// Barrett modular reduction +function Barrett(m) { + // setup Barrett + this.r2 = new BigInteger() + this.q3 = new BigInteger() + BigInteger.ONE.dlShiftTo(2 * m.t, this.r2) + this.mu = this.r2.divide(m) + this.m = m +} + +function barrettConvert(x) { + if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m) + else if (x.compareTo(this.m) < 0) return x + else { + var r = new BigInteger() + x.copyTo(r) + this.reduce(r) + return r + } +} + +function barrettRevert(x) { + return x +} + +// x = x mod m (HAC 14.42) +function barrettReduce(x) { + var self = this + x.drShiftTo(self.m.t - 1, self.r2) + if (x.t > self.m.t + 1) { + x.t = self.m.t + 1 + x.clamp() + } + self.mu.multiplyUpperTo(self.r2, self.m.t + 1, self.q3) + self.m.multiplyLowerTo(self.q3, self.m.t + 1, self.r2) + while (x.compareTo(self.r2) < 0) x.dAddOffset(1, self.m.t + 1) + x.subTo(self.r2, x) + while (x.compareTo(self.m) >= 0) x.subTo(self.m, x) +} + +// r = x^2 mod m; x != r +function barrettSqrTo(x, r) { + x.squareTo(r) + this.reduce(r) +} + +// r = x*y mod m; x,y != r +function barrettMulTo(x, y, r) { + x.multiplyTo(y, r) + this.reduce(r) +} + +Barrett.prototype.convert = barrettConvert +Barrett.prototype.revert = barrettRevert +Barrett.prototype.reduce = barrettReduce +Barrett.prototype.mulTo = barrettMulTo +Barrett.prototype.sqrTo = barrettSqrTo + +// (public) this^e % m (HAC 14.85) +function bnModPow(e, m) { + var i = e.bitLength(), + k, r = nbv(1), + z + if (i <= 0) return r + else if (i < 18) k = 1 + else if (i < 48) k = 3 + else if (i < 144) k = 4 + else if (i < 768) k = 5 + else k = 6 + if (i < 8) + z = new Classic(m) + else if (m.isEven()) + z = new Barrett(m) + else + z = new Montgomery(m) + + // precomputation + var g = new Array(), + n = 3, + k1 = k - 1, + km = (1 << k) - 1 + g[1] = z.convert(this) + if (k > 1) { + var g2 = new BigInteger() + z.sqrTo(g[1], g2) + while (n <= km) { + g[n] = new BigInteger() + z.mulTo(g2, g[n - 2], g[n]) + n += 2 + } + } + + var j = e.t - 1, + w, is1 = true, + r2 = new BigInteger(), + t + i = nbits(e[j]) - 1 + while (j >= 0) { + if (i >= k1) w = (e[j] >> (i - k1)) & km + else { + w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i) + if (j > 0) w |= e[j - 1] >> (this.DB + i - k1) + } + + n = k + while ((w & 1) == 0) { + w >>= 1 + --n + } + if ((i -= n) < 0) { + i += this.DB + --j + } + if (is1) { // ret == 1, don't bother squaring or multiplying it + g[w].copyTo(r) + is1 = false + } else { + while (n > 1) { + z.sqrTo(r, r2) + z.sqrTo(r2, r) + n -= 2 + } + if (n > 0) z.sqrTo(r, r2) + else { + t = r + r = r2 + r2 = t + } + z.mulTo(r2, g[w], r) + } + + while (j >= 0 && (e[j] & (1 << i)) == 0) { + z.sqrTo(r, r2) + t = r + r = r2 + r2 = t + if (--i < 0) { + i = this.DB - 1 + --j + } + } + } + return z.revert(r) +} + +// (public) gcd(this,a) (HAC 14.54) +function bnGCD(a) { + var x = (this.s < 0) ? this.negate() : this.clone() + var y = (a.s < 0) ? a.negate() : a.clone() + if (x.compareTo(y) < 0) { + var t = x + x = y + y = t + } + var i = x.getLowestSetBit(), + g = y.getLowestSetBit() + if (g < 0) return x + if (i < g) g = i + if (g > 0) { + x.rShiftTo(g, x) + y.rShiftTo(g, y) + } + while (x.signum() > 0) { + if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x) + if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y) + if (x.compareTo(y) >= 0) { + x.subTo(y, x) + x.rShiftTo(1, x) + } else { + y.subTo(x, y) + y.rShiftTo(1, y) + } + } + if (g > 0) y.lShiftTo(g, y) + return y +} + +// (protected) this % n, n < 2^26 +function bnpModInt(n) { + if (n <= 0) return 0 + var d = this.DV % n, + r = (this.s < 0) ? n - 1 : 0 + if (this.t > 0) + if (d == 0) r = this[0] % n + else + for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n + return r +} + +// (public) 1/this % m (HAC 14.61) +function bnModInverse(m) { + var ac = m.isEven() + if (this.signum() === 0) throw new Error('division by zero') + if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO + var u = m.clone(), + v = this.clone() + var a = nbv(1), + b = nbv(0), + c = nbv(0), + d = nbv(1) + while (u.signum() != 0) { + while (u.isEven()) { + u.rShiftTo(1, u) + if (ac) { + if (!a.isEven() || !b.isEven()) { + a.addTo(this, a) + b.subTo(m, b) + } + a.rShiftTo(1, a) + } else if (!b.isEven()) b.subTo(m, b) + b.rShiftTo(1, b) + } + while (v.isEven()) { + v.rShiftTo(1, v) + if (ac) { + if (!c.isEven() || !d.isEven()) { + c.addTo(this, c) + d.subTo(m, d) + } + c.rShiftTo(1, c) + } else if (!d.isEven()) d.subTo(m, d) + d.rShiftTo(1, d) + } + if (u.compareTo(v) >= 0) { + u.subTo(v, u) + if (ac) a.subTo(c, a) + b.subTo(d, b) + } else { + v.subTo(u, v) + if (ac) c.subTo(a, c) + d.subTo(b, d) + } + } + if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO + while (d.compareTo(m) >= 0) d.subTo(m, d) + while (d.signum() < 0) d.addTo(m, d) + return d +} + +var lowprimes = [ + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, + 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, + 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, + 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, + 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, + 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, + 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, + 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, + 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, + 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, + 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 +] + +var lplim = (1 << 26) / lowprimes[lowprimes.length - 1] + +// (public) test primality with certainty >= 1-.5^t +function bnIsProbablePrime(t) { + var i, x = this.abs() + if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) { + for (i = 0; i < lowprimes.length; ++i) + if (x[0] == lowprimes[i]) return true + return false + } + if (x.isEven()) return false + i = 1 + while (i < lowprimes.length) { + var m = lowprimes[i], + j = i + 1 + while (j < lowprimes.length && m < lplim) m *= lowprimes[j++] + m = x.modInt(m) + while (i < j) if (m % lowprimes[i++] == 0) return false + } + return x.millerRabin(t) +} + +// (protected) true if probably prime (HAC 4.24, Miller-Rabin) +function bnpMillerRabin(t) { + var n1 = this.subtract(BigInteger.ONE) + var k = n1.getLowestSetBit() + if (k <= 0) return false + var r = n1.shiftRight(k) + t = (t + 1) >> 1 + if (t > lowprimes.length) t = lowprimes.length + var a = new BigInteger(null) + var j, bases = [] + for (var i = 0; i < t; ++i) { + for (;;) { + j = lowprimes[Math.floor(Math.random() * lowprimes.length)] + if (bases.indexOf(j) == -1) break + } + bases.push(j) + a.fromInt(j) + var y = a.modPow(r, this) + if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) { + var j = 1 + while (j++ < k && y.compareTo(n1) != 0) { + y = y.modPowInt(2, this) + if (y.compareTo(BigInteger.ONE) == 0) return false + } + if (y.compareTo(n1) != 0) return false + } + } + return true +} + +// protected +proto.chunkSize = bnpChunkSize +proto.toRadix = bnpToRadix +proto.fromRadix = bnpFromRadix +proto.fromNumber = bnpFromNumber +proto.bitwiseTo = bnpBitwiseTo +proto.changeBit = bnpChangeBit +proto.addTo = bnpAddTo +proto.dMultiply = bnpDMultiply +proto.dAddOffset = bnpDAddOffset +proto.multiplyLowerTo = bnpMultiplyLowerTo +proto.multiplyUpperTo = bnpMultiplyUpperTo +proto.modInt = bnpModInt +proto.millerRabin = bnpMillerRabin + +// public +proto.clone = bnClone +proto.intValue = bnIntValue +proto.byteValue = bnByteValue +proto.shortValue = bnShortValue +proto.signum = bnSigNum +proto.toByteArray = bnToByteArray +proto.equals = bnEquals +proto.min = bnMin +proto.max = bnMax +proto.and = bnAnd +proto.or = bnOr +proto.xor = bnXor +proto.andNot = bnAndNot +proto.not = bnNot +proto.shiftLeft = bnShiftLeft +proto.shiftRight = bnShiftRight +proto.getLowestSetBit = bnGetLowestSetBit +proto.bitCount = bnBitCount +proto.testBit = bnTestBit +proto.setBit = bnSetBit +proto.clearBit = bnClearBit +proto.flipBit = bnFlipBit +proto.add = bnAdd +proto.subtract = bnSubtract +proto.multiply = bnMultiply +proto.divide = bnDivide +proto.remainder = bnRemainder +proto.divideAndRemainder = bnDivideAndRemainder +proto.modPow = bnModPow +proto.modInverse = bnModInverse +proto.pow = bnPow +proto.gcd = bnGCD +proto.isProbablePrime = bnIsProbablePrime + +// JSBN-specific extension +proto.square = bnSquare + +// constants +BigInteger.ZERO = nbv(0) +BigInteger.ONE = nbv(1) +BigInteger.valueOf = nbv + +module.exports = BigInteger + +},{"33":33}],31:[function(require,module,exports){ +(function (Buffer){ +// FIXME: Kind of a weird way to throw exceptions, consider removing +var assert = require(27) +var BigInteger = require(30) + +/** + * Turns a byte array into a big integer. + * + * This function will interpret a byte array as a big integer in big + * endian notation. + */ +BigInteger.fromByteArrayUnsigned = function(byteArray) { + // BigInteger expects a DER integer conformant byte array + if (byteArray[0] & 0x80) { + return new BigInteger([0].concat(byteArray)) + } + + return new BigInteger(byteArray) +} + +/** + * Returns a byte array representation of the big integer. + * + * This returns the absolute of the contained value in big endian + * form. A value of zero results in an empty array. + */ +BigInteger.prototype.toByteArrayUnsigned = function() { + var byteArray = this.toByteArray() + return byteArray[0] === 0 ? byteArray.slice(1) : byteArray +} + +BigInteger.fromDERInteger = function(byteArray) { + return new BigInteger(byteArray) +} + +/* + * Converts BigInteger to a DER integer representation. + * + * The format for this value uses the most significant bit as a sign + * bit. If the most significant bit is already set and the integer is + * positive, a 0x00 is prepended. + * + * Examples: + * + * 0 => 0x00 + * 1 => 0x01 + * -1 => 0xff + * 127 => 0x7f + * -127 => 0x81 + * 128 => 0x0080 + * -128 => 0x80 + * 255 => 0x00ff + * -255 => 0xff01 + * 16300 => 0x3fac + * -16300 => 0xc054 + * 62300 => 0x00f35c + * -62300 => 0xff0ca4 +*/ +BigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray + +BigInteger.fromBuffer = function(buffer) { + // BigInteger expects a DER integer conformant byte array + if (buffer[0] & 0x80) { + var byteArray = Array.prototype.slice.call(buffer) + + return new BigInteger([0].concat(byteArray)) + } + + return new BigInteger(buffer) +} + +BigInteger.fromHex = function(hex) { + if (hex === '') return BigInteger.ZERO + + assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string') + assert.equal(hex.length % 2, 0, 'Incomplete hex') + return new BigInteger(hex, 16) +} + +BigInteger.prototype.toBuffer = function(size) { + var byteArray = this.toByteArrayUnsigned() + var zeros = [] + + var padding = size - byteArray.length + while (zeros.length < padding) zeros.push(0) + + return new Buffer(zeros.concat(byteArray)) +} + +BigInteger.prototype.toHex = function(size) { + return this.toBuffer(size).toString('hex') +} + +}).call(this,require(35).Buffer) + +},{"27":27,"30":30,"35":35}],32:[function(require,module,exports){ +var BigInteger = require(30) + +//addons +require(31) + +module.exports = BigInteger +},{"30":30,"31":31}],33:[function(require,module,exports){ +module.exports={ + "bugs": { + "url": "https://github.com/cryptocoinjs/bigi/issues" + }, + "bundleDependencies": false, + "dependencies": {}, + "deprecated": false, + "description": "Big integers.", + "devDependencies": { + "coveralls": "^2.11.2", + "istanbul": "^0.3.5", + "jshint": "^2.5.1", + "mocha": "^2.1.0", + "mochify": "^2.1.0" + }, + "homepage": "https://github.com/cryptocoinjs/bigi#readme", + "keywords": [ + "cryptography", + "math", + "bitcoin", + "arbitrary", + "precision", + "arithmetic", + "big", + "integer", + "int", + "number", + "biginteger", + "bigint", + "bignumber", + "decimal", + "float" + ], + "main": "./lib/index.js", + "name": "bigi", + "repository": { + "url": "git+https://github.com/cryptocoinjs/bigi.git", + "type": "git" + }, + "scripts": { + "browser-test": "mochify --wd -R spec", + "coverage": "istanbul cover ./node_modules/.bin/_mocha -- --reporter list test/*.js", + "coveralls": "npm run-script coverage && node ./node_modules/.bin/coveralls < coverage/lcov.info", + "jshint": "jshint --config jshint.json lib/*.js ; true", + "test": "_mocha -- test/*.js", + "unit": "mocha" + }, + "testling": { + "files": "test/*.js", + "harness": "mocha", + "browsers": [ + "ie/9..latest", + "firefox/latest", + "chrome/latest", + "safari/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2..latest" + ] + }, + "version": "1.4.2" +} +},{}],34:[function(require,module,exports){ + +},{}],35:[function(require,module,exports){ +(function (global){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + +'use strict' + +var base64 = require(29) +var ieee754 = require(64) +var isArray = require(67) + +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 +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"29":29,"64":64,"67":67}],36:[function(require,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. + +var Buffer = require(35).Buffer; + +var isBufferEncoding = Buffer.isEncoding + || function(encoding) { + switch (encoding && encoding.toLowerCase()) { + case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; + default: return false; + } + } + + +function assertEncoding(encoding) { + if (encoding && !isBufferEncoding(encoding)) { + throw new Error('Unknown encoding: ' + encoding); + } +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. CESU-8 is handled as part of the UTF-8 encoding. +// +// @TODO Handling all encodings inside a single object makes it very difficult +// to reason about this code, so it should be split up in the future. +// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code +// points as used by CESU-8. +var StringDecoder = exports.StringDecoder = function(encoding) { + this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); + assertEncoding(encoding); + switch (this.encoding) { + case 'utf8': + // CESU-8 represents each of Surrogate Pair by 3-bytes + this.surrogateSize = 3; + break; + case 'ucs2': + case 'utf16le': + // UTF-16 represents each of Surrogate Pair by 2-bytes + this.surrogateSize = 2; + this.detectIncompleteChar = utf16DetectIncompleteChar; + break; + case 'base64': + // Base-64 stores 3 bytes in 4 chars, and pads the remainder. + this.surrogateSize = 3; + this.detectIncompleteChar = base64DetectIncompleteChar; + break; + default: + this.write = passThroughWrite; + return; + } + + // Enough space to store all bytes of a single character. UTF-8 needs 4 + // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). + this.charBuffer = new Buffer(6); + // Number of bytes received for the current incomplete multi-byte character. + this.charReceived = 0; + // Number of bytes expected for the current incomplete multi-byte character. + this.charLength = 0; +}; + + +// write decodes the given buffer and returns it as JS string that is +// guaranteed to not contain any partial multi-byte characters. Any partial +// character found at the end of the buffer is buffered up, and will be +// returned when calling write again with the remaining bytes. +// +// Note: Converting a Buffer containing an orphan surrogate to a String +// currently works, but converting a String to a Buffer (via `new Buffer`, or +// Buffer#write) will replace incomplete surrogates with the unicode +// replacement character. See https://codereview.chromium.org/121173009/ . +StringDecoder.prototype.write = function(buffer) { + var charStr = ''; + // if our last write ended with an incomplete multibyte character + while (this.charLength) { + // determine how many remaining bytes this buffer has to offer for this char + var available = (buffer.length >= this.charLength - this.charReceived) ? + this.charLength - this.charReceived : + buffer.length; + + // add the new bytes to the char buffer + buffer.copy(this.charBuffer, this.charReceived, 0, available); + this.charReceived += available; + + if (this.charReceived < this.charLength) { + // still not enough chars in this buffer? wait for more ... + return ''; + } + + // remove bytes belonging to the current character from the buffer + buffer = buffer.slice(available, buffer.length); + + // get the character that was split + charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); + + // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character + var charCode = charStr.charCodeAt(charStr.length - 1); + if (charCode >= 0xD800 && charCode <= 0xDBFF) { + this.charLength += this.surrogateSize; + charStr = ''; + continue; + } + this.charReceived = this.charLength = 0; + + // if there are no more bytes in this buffer, just emit our char + if (buffer.length === 0) { + return charStr; + } + break; + } + + // determine and set charLength / charReceived + this.detectIncompleteChar(buffer); + + var end = buffer.length; + if (this.charLength) { + // buffer the incomplete character bytes we got + buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); + end -= this.charReceived; + } + + charStr += buffer.toString(this.encoding, 0, end); + + var end = charStr.length - 1; + var charCode = charStr.charCodeAt(end); + // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character + if (charCode >= 0xD800 && charCode <= 0xDBFF) { + var size = this.surrogateSize; + this.charLength += size; + this.charReceived += size; + this.charBuffer.copy(this.charBuffer, size, 0, size); + buffer.copy(this.charBuffer, 0, 0, size); + return charStr.substring(0, end); + } + + // or just emit the charStr + return charStr; +}; + +// detectIncompleteChar determines if there is an incomplete UTF-8 character at +// the end of the given buffer. If so, it sets this.charLength to the byte +// length that character, and sets this.charReceived to the number of bytes +// that are available for this character. +StringDecoder.prototype.detectIncompleteChar = function(buffer) { + // determine how many bytes we have to check at the end of this buffer + var i = (buffer.length >= 3) ? 3 : buffer.length; + + // Figure out if one of the last i bytes of our buffer announces an + // incomplete char. + for (; i > 0; i--) { + var c = buffer[buffer.length - i]; + + // See http://en.wikipedia.org/wiki/UTF-8#Description + + // 110XXXXX + if (i == 1 && c >> 5 == 0x06) { + this.charLength = 2; + break; + } + + // 1110XXXX + if (i <= 2 && c >> 4 == 0x0E) { + this.charLength = 3; + break; + } + + // 11110XXX + if (i <= 3 && c >> 3 == 0x1E) { + this.charLength = 4; + break; + } + } + this.charReceived = i; +}; + +StringDecoder.prototype.end = function(buffer) { + var res = ''; + if (buffer && buffer.length) + res = this.write(buffer); + + if (this.charReceived) { + var cr = this.charReceived; + var buf = this.charBuffer; + var enc = this.encoding; + res += buf.slice(0, cr).toString(enc); + } + + return res; +}; + +function passThroughWrite(buffer) { + return buffer.toString(this.encoding); +} + +function utf16DetectIncompleteChar(buffer) { + this.charReceived = buffer.length % 2; + this.charLength = this.charReceived ? 2 : 0; +} + +function base64DetectIncompleteChar(buffer) { + this.charReceived = buffer.length % 3; + this.charLength = this.charReceived ? 3 : 0; +} + +},{"35":35}],37:[function(require,module,exports){ +var basex = require(28) +var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' + +module.exports = basex(ALPHABET) + +},{"28":28}],38:[function(require,module,exports){ +/* + Copyright 2013-2014 Daniel Wirtz + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + +/** + * @license bytebuffer.js (c) 2015 Daniel Wirtz + * Backing buffer: ArrayBuffer, Accessor: Uint8Array + * Released under the Apache License, Version 2.0 + * see: https://github.com/dcodeIO/bytebuffer.js for details + */ +(function(global, factory) { + + /* AMD */ if (typeof define === 'function' && define["amd"]) + define(["long"], factory); + /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"]) + module['exports'] = (function() { + var Long; try { Long = require(68); } catch (e) {} + return factory(Long); + })(); + /* Global */ else + (global["dcodeIO"] = global["dcodeIO"] || {})["ByteBuffer"] = factory(global["dcodeIO"]["Long"]); + +})(this, function(Long) { + "use strict"; + + /** + * Constructs a new ByteBuffer. + * @class The swiss army knife for binary data in JavaScript. + * @exports ByteBuffer + * @constructor + * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}. + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @expose + */ + var ByteBuffer = function(capacity, littleEndian, noAssert) { + if (typeof capacity === 'undefined') + capacity = ByteBuffer.DEFAULT_CAPACITY; + if (typeof littleEndian === 'undefined') + littleEndian = ByteBuffer.DEFAULT_ENDIAN; + if (typeof noAssert === 'undefined') + noAssert = ByteBuffer.DEFAULT_NOASSERT; + if (!noAssert) { + capacity = capacity | 0; + if (capacity < 0) + throw RangeError("Illegal capacity"); + littleEndian = !!littleEndian; + noAssert = !!noAssert; + } + + /** + * Backing ArrayBuffer. + * @type {!ArrayBuffer} + * @expose + */ + this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity); + + /** + * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`. + * @type {?Uint8Array} + * @expose + */ + this.view = capacity === 0 ? null : new Uint8Array(this.buffer); + + /** + * Absolute read/write offset. + * @type {number} + * @expose + * @see ByteBuffer#flip + * @see ByteBuffer#clear + */ + this.offset = 0; + + /** + * Marked offset. + * @type {number} + * @expose + * @see ByteBuffer#mark + * @see ByteBuffer#reset + */ + this.markedOffset = -1; + + /** + * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation. + * @type {number} + * @expose + * @see ByteBuffer#flip + * @see ByteBuffer#clear + */ + this.limit = capacity; + + /** + * Whether to use little endian byte order, defaults to `false` for big endian. + * @type {boolean} + * @expose + */ + this.littleEndian = littleEndian; + + /** + * Whether to skip assertions of offsets and values, defaults to `false`. + * @type {boolean} + * @expose + */ + this.noAssert = noAssert; + }; + + /** + * ByteBuffer version. + * @type {string} + * @const + * @expose + */ + ByteBuffer.VERSION = "5.0.1"; + + /** + * Little endian constant that can be used instead of its boolean value. Evaluates to `true`. + * @type {boolean} + * @const + * @expose + */ + ByteBuffer.LITTLE_ENDIAN = true; + + /** + * Big endian constant that can be used instead of its boolean value. Evaluates to `false`. + * @type {boolean} + * @const + * @expose + */ + ByteBuffer.BIG_ENDIAN = false; + + /** + * Default initial capacity of `16`. + * @type {number} + * @expose + */ + ByteBuffer.DEFAULT_CAPACITY = 16; + + /** + * Default endianess of `false` for big endian. + * @type {boolean} + * @expose + */ + ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN; + + /** + * Default no assertions flag of `false`. + * @type {boolean} + * @expose + */ + ByteBuffer.DEFAULT_NOASSERT = false; + + /** + * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded + * and int64 support is not available. + * @type {?Long} + * @const + * @see https://github.com/dcodeIO/long.js + * @expose + */ + ByteBuffer.Long = Long || null; + + /** + * @alias ByteBuffer.prototype + * @inner + */ + var ByteBufferPrototype = ByteBuffer.prototype; + + /** + * An indicator used to reliably determine if an object is a ByteBuffer or not. + * @type {boolean} + * @const + * @expose + * @private + */ + ByteBufferPrototype.__isByteBuffer__; + + Object.defineProperty(ByteBufferPrototype, "__isByteBuffer__", { + value: true, + enumerable: false, + configurable: false + }); + + // helpers + + /** + * @type {!ArrayBuffer} + * @inner + */ + var EMPTY_BUFFER = new ArrayBuffer(0); + + /** + * String.fromCharCode reference for compile-time renaming. + * @type {function(...number):string} + * @inner + */ + var stringFromCharCode = String.fromCharCode; + + /** + * Creates a source function for a string. + * @param {string} s String to read from + * @returns {function():number|null} Source function returning the next char code respectively `null` if there are + * no more characters left. + * @throws {TypeError} If the argument is invalid + * @inner + */ + function stringSource(s) { + var i=0; return function() { + return i < s.length ? s.charCodeAt(i++) : null; + }; + } + + /** + * Creates a destination function for a string. + * @returns {function(number=):undefined|string} Destination function successively called with the next char code. + * Returns the final string when called without arguments. + * @inner + */ + function stringDestination() { + var cs = [], ps = []; return function() { + if (arguments.length === 0) + return ps.join('')+stringFromCharCode.apply(String, cs); + if (cs.length + arguments.length > 1024) + ps.push(stringFromCharCode.apply(String, cs)), + cs.length = 0; + Array.prototype.push.apply(cs, arguments); + }; + } + + /** + * Gets the accessor type. + * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes) + * @expose + */ + ByteBuffer.accessor = function() { + return Uint8Array; + }; + /** + * Allocates a new ByteBuffer backed by a buffer of the specified capacity. + * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}. + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @returns {!ByteBuffer} + * @expose + */ + ByteBuffer.allocate = function(capacity, littleEndian, noAssert) { + return new ByteBuffer(capacity, littleEndian, noAssert); + }; + + /** + * Concatenates multiple ByteBuffers into one. + * @param {!Array.} buffers Buffers to concatenate + * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string ("base64", "hex", "binary", + * defaults to "utf8") + * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults + * to {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @returns {!ByteBuffer} Concatenated ByteBuffer + * @expose + */ + ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) { + if (typeof encoding === 'boolean' || typeof encoding !== 'string') { + noAssert = littleEndian; + littleEndian = encoding; + encoding = undefined; + } + var capacity = 0; + for (var i=0, k=buffers.length, length; i 0) capacity += length; + } + if (capacity === 0) + return new ByteBuffer(0, littleEndian, noAssert); + var bb = new ByteBuffer(capacity, littleEndian, noAssert), + bi; + i=0; while (i} buffer Anything that can be wrapped + * @param {(string|boolean)=} encoding String encoding if `buffer` is a string ("base64", "hex", "binary", defaults to + * "utf8") + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer` + * @expose + */ + ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) { + if (typeof encoding !== 'string') { + noAssert = littleEndian; + littleEndian = encoding; + encoding = undefined; + } + if (typeof buffer === 'string') { + if (typeof encoding === 'undefined') + encoding = "utf8"; + switch (encoding) { + case "base64": + return ByteBuffer.fromBase64(buffer, littleEndian); + case "hex": + return ByteBuffer.fromHex(buffer, littleEndian); + case "binary": + return ByteBuffer.fromBinary(buffer, littleEndian); + case "utf8": + return ByteBuffer.fromUTF8(buffer, littleEndian); + case "debug": + return ByteBuffer.fromDebug(buffer, littleEndian); + default: + throw Error("Unsupported encoding: "+encoding); + } + } + if (buffer === null || typeof buffer !== 'object') + throw TypeError("Illegal buffer"); + var bb; + if (ByteBuffer.isByteBuffer(buffer)) { + bb = ByteBufferPrototype.clone.call(buffer); + bb.markedOffset = -1; + return bb; + } + if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array + bb = new ByteBuffer(0, littleEndian, noAssert); + if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER + bb.buffer = buffer.buffer; + bb.offset = buffer.byteOffset; + bb.limit = buffer.byteOffset + buffer.byteLength; + bb.view = new Uint8Array(buffer.buffer); + } + } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer + bb = new ByteBuffer(0, littleEndian, noAssert); + if (buffer.byteLength > 0) { + bb.buffer = buffer; + bb.offset = 0; + bb.limit = buffer.byteLength; + bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null; + } + } else if (Object.prototype.toString.call(buffer) === "[object Array]") { // Create from octets + bb = new ByteBuffer(buffer.length, littleEndian, noAssert); + bb.limit = buffer.length; + for (var i=0; i} value Array of booleans to write + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted. + * @returns {!ByteBuffer} + * @expose + */ + ByteBufferPrototype.writeBitSet = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (!(value instanceof Array)) + throw TypeError("Illegal BitSet: Not an array"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + + var start = offset, + bits = value.length, + bytes = (bits >> 3), + bit = 0, + k; + + offset += this.writeVarint32(bits,offset); + + while(bytes--) { + k = (!!value[bit++] & 1) | + ((!!value[bit++] & 1) << 1) | + ((!!value[bit++] & 1) << 2) | + ((!!value[bit++] & 1) << 3) | + ((!!value[bit++] & 1) << 4) | + ((!!value[bit++] & 1) << 5) | + ((!!value[bit++] & 1) << 6) | + ((!!value[bit++] & 1) << 7); + this.writeByte(k,offset++); + } + + if(bit < bits) { + var m = 0; k = 0; + while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++)); + this.writeByte(k,offset++); + } + + if (relative) { + this.offset = offset; + return this; + } + return offset - start; + } + + /** + * Reads a BitSet as an array of booleans. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted. + * @returns {Array + * @expose + */ + ByteBufferPrototype.readBitSet = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + + var ret = this.readVarint32(offset), + bits = ret.value, + bytes = (bits >> 3), + bit = 0, + value = [], + k; + + offset += ret.length; + + while(bytes--) { + k = this.readByte(offset++); + value[bit++] = !!(k & 0x01); + value[bit++] = !!(k & 0x02); + value[bit++] = !!(k & 0x04); + value[bit++] = !!(k & 0x08); + value[bit++] = !!(k & 0x10); + value[bit++] = !!(k & 0x20); + value[bit++] = !!(k & 0x40); + value[bit++] = !!(k & 0x80); + } + + if(bit < bits) { + var m = 0; + k = this.readByte(offset++); + while(bit < bits) value[bit++] = !!((k >> (m++)) & 1); + } + + if (relative) { + this.offset = offset; + } + return value; + } + /** + * Reads the specified number of bytes. + * @param {number} length Number of bytes to read + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted. + * @returns {!ByteBuffer} + * @expose + */ + ByteBufferPrototype.readBytes = function(length, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + length > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+length+") <= "+this.buffer.byteLength); + } + var slice = this.slice(offset, offset + length); + if (relative) this.offset += length; + return slice; + }; + + /** + * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}. + * @function + * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets + * will be modified according to the performed read operation. + * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8") + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeBytes = ByteBufferPrototype.append; + + // types/ints/int8 + + /** + * Writes an 8bit signed integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeInt8 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value |= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 1; + var capacity0 = this.buffer.byteLength; + if (offset > capacity0) + this.resize((capacity0 *= 2) > offset ? capacity0 : offset); + offset -= 1; + this.view[offset] = value; + if (relative) this.offset += 1; + return this; + }; + + /** + * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8; + + /** + * Reads an 8bit signed integer. + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readInt8 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 1 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength); + } + var value = this.view[offset]; + if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed + if (relative) this.offset += 1; + return value; + }; + + /** + * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}. + * @function + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8; + + /** + * Writes an 8bit unsigned integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeUint8 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value >>>= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 1; + var capacity1 = this.buffer.byteLength; + if (offset > capacity1) + this.resize((capacity1 *= 2) > offset ? capacity1 : offset); + offset -= 1; + this.view[offset] = value; + if (relative) this.offset += 1; + return this; + }; + + /** + * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8; + + /** + * Reads an 8bit unsigned integer. + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readUint8 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 1 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength); + } + var value = this.view[offset]; + if (relative) this.offset += 1; + return value; + }; + + /** + * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}. + * @function + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8; + + // types/ints/int16 + + /** + * Writes a 16bit signed integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @throws {TypeError} If `offset` or `value` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.writeInt16 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value |= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 2; + var capacity2 = this.buffer.byteLength; + if (offset > capacity2) + this.resize((capacity2 *= 2) > offset ? capacity2 : offset); + offset -= 2; + if (this.littleEndian) { + this.view[offset+1] = (value & 0xFF00) >>> 8; + this.view[offset ] = value & 0x00FF; + } else { + this.view[offset] = (value & 0xFF00) >>> 8; + this.view[offset+1] = value & 0x00FF; + } + if (relative) this.offset += 2; + return this; + }; + + /** + * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @throws {TypeError} If `offset` or `value` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16; + + /** + * Reads a 16bit signed integer. + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @returns {number} Value read + * @throws {TypeError} If `offset` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.readInt16 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 2 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+2+") <= "+this.buffer.byteLength); + } + var value = 0; + if (this.littleEndian) { + value = this.view[offset ]; + value |= this.view[offset+1] << 8; + } else { + value = this.view[offset ] << 8; + value |= this.view[offset+1]; + } + if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed + if (relative) this.offset += 2; + return value; + }; + + /** + * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}. + * @function + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @returns {number} Value read + * @throws {TypeError} If `offset` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16; + + /** + * Writes a 16bit unsigned integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @throws {TypeError} If `offset` or `value` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.writeUint16 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value >>>= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 2; + var capacity3 = this.buffer.byteLength; + if (offset > capacity3) + this.resize((capacity3 *= 2) > offset ? capacity3 : offset); + offset -= 2; + if (this.littleEndian) { + this.view[offset+1] = (value & 0xFF00) >>> 8; + this.view[offset ] = value & 0x00FF; + } else { + this.view[offset] = (value & 0xFF00) >>> 8; + this.view[offset+1] = value & 0x00FF; + } + if (relative) this.offset += 2; + return this; + }; + + /** + * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @throws {TypeError} If `offset` or `value` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16; + + /** + * Reads a 16bit unsigned integer. + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @returns {number} Value read + * @throws {TypeError} If `offset` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.readUint16 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 2 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+2+") <= "+this.buffer.byteLength); + } + var value = 0; + if (this.littleEndian) { + value = this.view[offset ]; + value |= this.view[offset+1] << 8; + } else { + value = this.view[offset ] << 8; + value |= this.view[offset+1]; + } + if (relative) this.offset += 2; + return value; + }; + + /** + * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}. + * @function + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted. + * @returns {number} Value read + * @throws {TypeError} If `offset` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @expose + */ + ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16; + + // types/ints/int32 + + /** + * Writes a 32bit signed integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @expose + */ + ByteBufferPrototype.writeInt32 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value |= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 4; + var capacity4 = this.buffer.byteLength; + if (offset > capacity4) + this.resize((capacity4 *= 2) > offset ? capacity4 : offset); + offset -= 4; + if (this.littleEndian) { + this.view[offset+3] = (value >>> 24) & 0xFF; + this.view[offset+2] = (value >>> 16) & 0xFF; + this.view[offset+1] = (value >>> 8) & 0xFF; + this.view[offset ] = value & 0xFF; + } else { + this.view[offset ] = (value >>> 24) & 0xFF; + this.view[offset+1] = (value >>> 16) & 0xFF; + this.view[offset+2] = (value >>> 8) & 0xFF; + this.view[offset+3] = value & 0xFF; + } + if (relative) this.offset += 4; + return this; + }; + + /** + * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @expose + */ + ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32; + + /** + * Reads a 32bit signed integer. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readInt32 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 4 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength); + } + var value = 0; + if (this.littleEndian) { + value = this.view[offset+2] << 16; + value |= this.view[offset+1] << 8; + value |= this.view[offset ]; + value += this.view[offset+3] << 24 >>> 0; + } else { + value = this.view[offset+1] << 16; + value |= this.view[offset+2] << 8; + value |= this.view[offset+3]; + value += this.view[offset ] << 24 >>> 0; + } + value |= 0; // Cast to signed + if (relative) this.offset += 4; + return value; + }; + + /** + * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}. + * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32; + + /** + * Writes a 32bit unsigned integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @expose + */ + ByteBufferPrototype.writeUint32 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value >>>= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 4; + var capacity5 = this.buffer.byteLength; + if (offset > capacity5) + this.resize((capacity5 *= 2) > offset ? capacity5 : offset); + offset -= 4; + if (this.littleEndian) { + this.view[offset+3] = (value >>> 24) & 0xFF; + this.view[offset+2] = (value >>> 16) & 0xFF; + this.view[offset+1] = (value >>> 8) & 0xFF; + this.view[offset ] = value & 0xFF; + } else { + this.view[offset ] = (value >>> 24) & 0xFF; + this.view[offset+1] = (value >>> 16) & 0xFF; + this.view[offset+2] = (value >>> 8) & 0xFF; + this.view[offset+3] = value & 0xFF; + } + if (relative) this.offset += 4; + return this; + }; + + /** + * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @expose + */ + ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32; + + /** + * Reads a 32bit unsigned integer. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readUint32 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 4 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength); + } + var value = 0; + if (this.littleEndian) { + value = this.view[offset+2] << 16; + value |= this.view[offset+1] << 8; + value |= this.view[offset ]; + value += this.view[offset+3] << 24 >>> 0; + } else { + value = this.view[offset+1] << 16; + value |= this.view[offset+2] << 8; + value |= this.view[offset+3]; + value += this.view[offset ] << 24 >>> 0; + } + if (relative) this.offset += 4; + return value; + }; + + /** + * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}. + * @function + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {number} Value read + * @expose + */ + ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32; + + // types/ints/int64 + + if (Long) { + + /** + * Writes a 64bit signed integer. + * @param {number|!Long} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeInt64 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value === 'number') + value = Long.fromNumber(value); + else if (typeof value === 'string') + value = Long.fromString(value); + else if (!(value && value instanceof Long)) + throw TypeError("Illegal value: "+value+" (not an integer or Long)"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + if (typeof value === 'number') + value = Long.fromNumber(value); + else if (typeof value === 'string') + value = Long.fromString(value); + offset += 8; + var capacity6 = this.buffer.byteLength; + if (offset > capacity6) + this.resize((capacity6 *= 2) > offset ? capacity6 : offset); + offset -= 8; + var lo = value.low, + hi = value.high; + if (this.littleEndian) { + this.view[offset+3] = (lo >>> 24) & 0xFF; + this.view[offset+2] = (lo >>> 16) & 0xFF; + this.view[offset+1] = (lo >>> 8) & 0xFF; + this.view[offset ] = lo & 0xFF; + offset += 4; + this.view[offset+3] = (hi >>> 24) & 0xFF; + this.view[offset+2] = (hi >>> 16) & 0xFF; + this.view[offset+1] = (hi >>> 8) & 0xFF; + this.view[offset ] = hi & 0xFF; + } else { + this.view[offset ] = (hi >>> 24) & 0xFF; + this.view[offset+1] = (hi >>> 16) & 0xFF; + this.view[offset+2] = (hi >>> 8) & 0xFF; + this.view[offset+3] = hi & 0xFF; + offset += 4; + this.view[offset ] = (lo >>> 24) & 0xFF; + this.view[offset+1] = (lo >>> 16) & 0xFF; + this.view[offset+2] = (lo >>> 8) & 0xFF; + this.view[offset+3] = lo & 0xFF; + } + if (relative) this.offset += 8; + return this; + }; + + /** + * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}. + * @param {number|!Long} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64; + + /** + * Reads a 64bit signed integer. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!Long} + * @expose + */ + ByteBufferPrototype.readInt64 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 8 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.byteLength); + } + var lo = 0, + hi = 0; + if (this.littleEndian) { + lo = this.view[offset+2] << 16; + lo |= this.view[offset+1] << 8; + lo |= this.view[offset ]; + lo += this.view[offset+3] << 24 >>> 0; + offset += 4; + hi = this.view[offset+2] << 16; + hi |= this.view[offset+1] << 8; + hi |= this.view[offset ]; + hi += this.view[offset+3] << 24 >>> 0; + } else { + hi = this.view[offset+1] << 16; + hi |= this.view[offset+2] << 8; + hi |= this.view[offset+3]; + hi += this.view[offset ] << 24 >>> 0; + offset += 4; + lo = this.view[offset+1] << 16; + lo |= this.view[offset+2] << 8; + lo |= this.view[offset+3]; + lo += this.view[offset ] << 24 >>> 0; + } + var value = new Long(lo, hi, false); + if (relative) this.offset += 8; + return value; + }; + + /** + * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!Long} + * @expose + */ + ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64; + + /** + * Writes a 64bit unsigned integer. + * @param {number|!Long} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeUint64 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value === 'number') + value = Long.fromNumber(value); + else if (typeof value === 'string') + value = Long.fromString(value); + else if (!(value && value instanceof Long)) + throw TypeError("Illegal value: "+value+" (not an integer or Long)"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + if (typeof value === 'number') + value = Long.fromNumber(value); + else if (typeof value === 'string') + value = Long.fromString(value); + offset += 8; + var capacity7 = this.buffer.byteLength; + if (offset > capacity7) + this.resize((capacity7 *= 2) > offset ? capacity7 : offset); + offset -= 8; + var lo = value.low, + hi = value.high; + if (this.littleEndian) { + this.view[offset+3] = (lo >>> 24) & 0xFF; + this.view[offset+2] = (lo >>> 16) & 0xFF; + this.view[offset+1] = (lo >>> 8) & 0xFF; + this.view[offset ] = lo & 0xFF; + offset += 4; + this.view[offset+3] = (hi >>> 24) & 0xFF; + this.view[offset+2] = (hi >>> 16) & 0xFF; + this.view[offset+1] = (hi >>> 8) & 0xFF; + this.view[offset ] = hi & 0xFF; + } else { + this.view[offset ] = (hi >>> 24) & 0xFF; + this.view[offset+1] = (hi >>> 16) & 0xFF; + this.view[offset+2] = (hi >>> 8) & 0xFF; + this.view[offset+3] = hi & 0xFF; + offset += 4; + this.view[offset ] = (lo >>> 24) & 0xFF; + this.view[offset+1] = (lo >>> 16) & 0xFF; + this.view[offset+2] = (lo >>> 8) & 0xFF; + this.view[offset+3] = lo & 0xFF; + } + if (relative) this.offset += 8; + return this; + }; + + /** + * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}. + * @function + * @param {number|!Long} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64; + + /** + * Reads a 64bit unsigned integer. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!Long} + * @expose + */ + ByteBufferPrototype.readUint64 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 8 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.byteLength); + } + var lo = 0, + hi = 0; + if (this.littleEndian) { + lo = this.view[offset+2] << 16; + lo |= this.view[offset+1] << 8; + lo |= this.view[offset ]; + lo += this.view[offset+3] << 24 >>> 0; + offset += 4; + hi = this.view[offset+2] << 16; + hi |= this.view[offset+1] << 8; + hi |= this.view[offset ]; + hi += this.view[offset+3] << 24 >>> 0; + } else { + hi = this.view[offset+1] << 16; + hi |= this.view[offset+2] << 8; + hi |= this.view[offset+3]; + hi += this.view[offset ] << 24 >>> 0; + offset += 4; + lo = this.view[offset+1] << 16; + lo |= this.view[offset+2] << 8; + lo |= this.view[offset+3]; + lo += this.view[offset ] << 24 >>> 0; + } + var value = new Long(lo, hi, true); + if (relative) this.offset += 8; + return value; + }; + + /** + * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}. + * @function + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!Long} + * @expose + */ + ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64; + + } // Long + + + // types/floats/float32 + + /* + ieee754 - https://github.com/feross/ieee754 + + The MIT License (MIT) + + Copyright (c) Feross Aboukhadijeh + + 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. + */ + + /** + * Reads an IEEE754 float from a byte array. + * @param {!Array} buffer + * @param {number} offset + * @param {boolean} isLE + * @param {number} mLen + * @param {number} nBytes + * @returns {number} + * @inner + */ + function ieee754_read(buffer, offset, isLE, mLen, nBytes) { + var e, m, + eLen = nBytes * 8 - mLen - 1, + eMax = (1 << eLen) - 1, + eBias = eMax >> 1, + nBits = -7, + i = isLE ? (nBytes - 1) : 0, + d = isLE ? -1 : 1, + 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); + } + + /** + * Writes an IEEE754 float to a byte array. + * @param {!Array} buffer + * @param {number} value + * @param {number} offset + * @param {boolean} isLE + * @param {number} mLen + * @param {number} nBytes + * @inner + */ + function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c, + eLen = nBytes * 8 - mLen - 1, + eMax = (1 << eLen) - 1, + eBias = eMax >> 1, + rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0), + i = isLE ? 0 : (nBytes - 1), + d = isLE ? 1 : -1, + 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; + } + + /** + * Writes a 32bit float. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeFloat32 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number') + throw TypeError("Illegal value: "+value+" (not a number)"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 4; + var capacity8 = this.buffer.byteLength; + if (offset > capacity8) + this.resize((capacity8 *= 2) > offset ? capacity8 : offset); + offset -= 4; + ieee754_write(this.view, value, offset, this.littleEndian, 23, 4); + if (relative) this.offset += 4; + return this; + }; + + /** + * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32; + + /** + * Reads a 32bit float. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {number} + * @expose + */ + ByteBufferPrototype.readFloat32 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 4 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength); + } + var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4); + if (relative) this.offset += 4; + return value; + }; + + /** + * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}. + * @function + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted. + * @returns {number} + * @expose + */ + ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32; + + // types/floats/float64 + + /** + * Writes a 64bit float. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeFloat64 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number') + throw TypeError("Illegal value: "+value+" (not a number)"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + offset += 8; + var capacity9 = this.buffer.byteLength; + if (offset > capacity9) + this.resize((capacity9 *= 2) > offset ? capacity9 : offset); + offset -= 8; + ieee754_write(this.view, value, offset, this.littleEndian, 52, 8); + if (relative) this.offset += 8; + return this; + }; + + /** + * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}. + * @function + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64; + + /** + * Reads a 64bit float. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {number} + * @expose + */ + ByteBufferPrototype.readFloat64 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 8 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.byteLength); + } + var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8); + if (relative) this.offset += 8; + return value; + }; + + /** + * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}. + * @function + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted. + * @returns {number} + * @expose + */ + ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64; + + + // types/varints/varint32 + + /** + * Maximum number of bytes required to store a 32bit base 128 variable-length integer. + * @type {number} + * @const + * @expose + */ + ByteBuffer.MAX_VARINT32_BYTES = 5; + + /** + * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer. + * @param {number} value Value to encode + * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES} + * @expose + */ + ByteBuffer.calculateVarint32 = function(value) { + // ref: src/google/protobuf/io/coded_stream.cc + value = value >>> 0; + if (value < 1 << 7 ) return 1; + else if (value < 1 << 14) return 2; + else if (value < 1 << 21) return 3; + else if (value < 1 << 28) return 4; + else return 5; + }; + + /** + * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding. + * @param {number} n Signed 32bit integer + * @returns {number} Unsigned zigzag encoded 32bit integer + * @expose + */ + ByteBuffer.zigZagEncode32 = function(n) { + return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h + }; + + /** + * Decodes a zigzag encoded signed 32bit integer. + * @param {number} n Unsigned zigzag encoded 32bit integer + * @returns {number} Signed 32bit integer + * @expose + */ + ByteBuffer.zigZagDecode32 = function(n) { + return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h + }; + + /** + * Writes a 32bit base 128 variable-length integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written + * @expose + */ + ByteBufferPrototype.writeVarint32 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value |= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + var size = ByteBuffer.calculateVarint32(value), + b; + offset += size; + var capacity10 = this.buffer.byteLength; + if (offset > capacity10) + this.resize((capacity10 *= 2) > offset ? capacity10 : offset); + offset -= size; + value >>>= 0; + while (value >= 0x80) { + b = (value & 0x7f) | 0x80; + this.view[offset++] = b; + value >>>= 7; + } + this.view[offset++] = value; + if (relative) { + this.offset = offset; + return this; + } + return size; + }; + + /** + * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer. + * @param {number} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written + * @expose + */ + ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) { + return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset); + }; + + /** + * Reads a 32bit base 128 variable-length integer. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read + * and the actual number of bytes read. + * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available + * to fully decode the varint. + * @expose + */ + ByteBufferPrototype.readVarint32 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 1 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength); + } + var c = 0, + value = 0 >>> 0, + b; + do { + if (!this.noAssert && offset > this.limit) { + var err = Error("Truncated"); + err['truncated'] = true; + throw err; + } + b = this.view[offset++]; + if (c < 5) + value |= (b & 0x7f) << (7*c); + ++c; + } while ((b & 0x80) !== 0); + value |= 0; + if (relative) { + this.offset = offset; + return value; + } + return { + "value": value, + "length": c + }; + }; + + /** + * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read + * and the actual number of bytes read. + * @throws {Error} If it's not a valid varint + * @expose + */ + ByteBufferPrototype.readVarint32ZigZag = function(offset) { + var val = this.readVarint32(offset); + if (typeof val === 'object') + val["value"] = ByteBuffer.zigZagDecode32(val["value"]); + else + val = ByteBuffer.zigZagDecode32(val); + return val; + }; + + // types/varints/varint64 + + if (Long) { + + /** + * Maximum number of bytes required to store a 64bit base 128 variable-length integer. + * @type {number} + * @const + * @expose + */ + ByteBuffer.MAX_VARINT64_BYTES = 10; + + /** + * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer. + * @param {number|!Long} value Value to encode + * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES} + * @expose + */ + ByteBuffer.calculateVarint64 = function(value) { + if (typeof value === 'number') + value = Long.fromNumber(value); + else if (typeof value === 'string') + value = Long.fromString(value); + // ref: src/google/protobuf/io/coded_stream.cc + var part0 = value.toInt() >>> 0, + part1 = value.shiftRightUnsigned(28).toInt() >>> 0, + part2 = value.shiftRightUnsigned(56).toInt() >>> 0; + if (part2 == 0) { + if (part1 == 0) { + if (part0 < 1 << 14) + return part0 < 1 << 7 ? 1 : 2; + else + return part0 < 1 << 21 ? 3 : 4; + } else { + if (part1 < 1 << 14) + return part1 < 1 << 7 ? 5 : 6; + else + return part1 < 1 << 21 ? 7 : 8; + } + } else + return part2 < 1 << 7 ? 9 : 10; + }; + + /** + * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding. + * @param {number|!Long} value Signed long + * @returns {!Long} Unsigned zigzag encoded long + * @expose + */ + ByteBuffer.zigZagEncode64 = function(value) { + if (typeof value === 'number') + value = Long.fromNumber(value, false); + else if (typeof value === 'string') + value = Long.fromString(value, false); + else if (value.unsigned !== false) value = value.toSigned(); + // ref: src/google/protobuf/wire_format_lite.h + return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned(); + }; + + /** + * Decodes a zigzag encoded signed 64bit integer. + * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number + * @returns {!Long} Signed long + * @expose + */ + ByteBuffer.zigZagDecode64 = function(value) { + if (typeof value === 'number') + value = Long.fromNumber(value, false); + else if (typeof value === 'string') + value = Long.fromString(value, false); + else if (value.unsigned !== false) value = value.toSigned(); + // ref: src/google/protobuf/wire_format_lite.h + return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned(); + }; + + /** + * Writes a 64bit base 128 variable-length integer. + * @param {number|Long} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written. + * @expose + */ + ByteBufferPrototype.writeVarint64 = function(value, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof value === 'number') + value = Long.fromNumber(value); + else if (typeof value === 'string') + value = Long.fromString(value); + else if (!(value && value instanceof Long)) + throw TypeError("Illegal value: "+value+" (not an integer or Long)"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + if (typeof value === 'number') + value = Long.fromNumber(value, false); + else if (typeof value === 'string') + value = Long.fromString(value, false); + else if (value.unsigned !== false) value = value.toSigned(); + var size = ByteBuffer.calculateVarint64(value), + part0 = value.toInt() >>> 0, + part1 = value.shiftRightUnsigned(28).toInt() >>> 0, + part2 = value.shiftRightUnsigned(56).toInt() >>> 0; + offset += size; + var capacity11 = this.buffer.byteLength; + if (offset > capacity11) + this.resize((capacity11 *= 2) > offset ? capacity11 : offset); + offset -= size; + switch (size) { + case 10: this.view[offset+9] = (part2 >>> 7) & 0x01; + case 9 : this.view[offset+8] = size !== 9 ? (part2 ) | 0x80 : (part2 ) & 0x7F; + case 8 : this.view[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F; + case 7 : this.view[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F; + case 6 : this.view[offset+5] = size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7F; + case 5 : this.view[offset+4] = size !== 5 ? (part1 ) | 0x80 : (part1 ) & 0x7F; + case 4 : this.view[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F; + case 3 : this.view[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F; + case 2 : this.view[offset+1] = size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7F; + case 1 : this.view[offset ] = size !== 1 ? (part0 ) | 0x80 : (part0 ) & 0x7F; + } + if (relative) { + this.offset += size; + return this; + } else { + return size; + } + }; + + /** + * Writes a zig-zag encoded 64bit base 128 variable-length integer. + * @param {number|Long} value Value to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written. + * @expose + */ + ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) { + return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset); + }; + + /** + * Reads a 64bit base 128 variable-length integer. Requires Long.js. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and + * the actual number of bytes read. + * @throws {Error} If it's not a valid varint + * @expose + */ + ByteBufferPrototype.readVarint64 = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 1 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength); + } + // ref: src/google/protobuf/io/coded_stream.cc + var start = offset, + part0 = 0, + part1 = 0, + part2 = 0, + b = 0; + b = this.view[offset++]; part0 = (b & 0x7F) ; if ( b & 0x80 ) { + b = this.view[offset++]; part0 |= (b & 0x7F) << 7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part1 = (b & 0x7F) ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part1 |= (b & 0x7F) << 7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part2 = (b & 0x7F) ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + b = this.view[offset++]; part2 |= (b & 0x7F) << 7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) { + throw Error("Buffer overrun"); }}}}}}}}}} + var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false); + if (relative) { + this.offset = offset; + return value; + } else { + return { + 'value': value, + 'length': offset-start + }; + } + }; + + /** + * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and + * the actual number of bytes read. + * @throws {Error} If it's not a valid varint + * @expose + */ + ByteBufferPrototype.readVarint64ZigZag = function(offset) { + var val = this.readVarint64(offset); + if (val && val['value'] instanceof Long) + val["value"] = ByteBuffer.zigZagDecode64(val["value"]); + else + val = ByteBuffer.zigZagDecode64(val); + return val; + }; + + } // Long + + + // types/strings/cstring + + /** + * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL + * characters itself. + * @param {string} str String to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * contained in `str` + 1 if omitted. + * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written + * @expose + */ + ByteBufferPrototype.writeCString = function(str, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + var i, + k = str.length; + if (!this.noAssert) { + if (typeof str !== 'string') + throw TypeError("Illegal str: Not a string"); + for (i=0; i>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + // UTF8 strings do not contain zero bytes in between except for the zero character, so: + k = utfx.calculateUTF16asUTF8(stringSource(str))[1]; + offset += k+1; + var capacity12 = this.buffer.byteLength; + if (offset > capacity12) + this.resize((capacity12 *= 2) > offset ? capacity12 : offset); + offset -= k+1; + utfx.encodeUTF16toUTF8(stringSource(str), function(b) { + this.view[offset++] = b; + }.bind(this)); + this.view[offset++] = 0; + if (relative) { + this.offset = offset; + return this; + } + return k; + }; + + /** + * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters + * itself. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string + * read and the actual number of bytes read. + * @expose + */ + ByteBufferPrototype.readCString = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 1 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength); + } + var start = offset, + temp; + // UTF8 strings do not contain zero bytes in between except for the zero character itself, so: + var sd, b = -1; + utfx.decodeUTF8toUTF16(function() { + if (b === 0) return null; + if (offset >= this.limit) + throw RangeError("Illegal range: Truncated data, "+offset+" < "+this.limit); + b = this.view[offset++]; + return b === 0 ? null : b; + }.bind(this), sd = stringDestination(), true); + if (relative) { + this.offset = offset; + return sd(); + } else { + return { + "string": sd(), + "length": offset - start + }; + } + }; + + // types/strings/istring + + /** + * Writes a length as uint32 prefixed UTF8 encoded string. + * @param {string} str String to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written + * @expose + * @see ByteBuffer#writeVarint32 + */ + ByteBufferPrototype.writeIString = function(str, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof str !== 'string') + throw TypeError("Illegal str: Not a string"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + var start = offset, + k; + k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1]; + offset += 4+k; + var capacity13 = this.buffer.byteLength; + if (offset > capacity13) + this.resize((capacity13 *= 2) > offset ? capacity13 : offset); + offset -= 4+k; + if (this.littleEndian) { + this.view[offset+3] = (k >>> 24) & 0xFF; + this.view[offset+2] = (k >>> 16) & 0xFF; + this.view[offset+1] = (k >>> 8) & 0xFF; + this.view[offset ] = k & 0xFF; + } else { + this.view[offset ] = (k >>> 24) & 0xFF; + this.view[offset+1] = (k >>> 16) & 0xFF; + this.view[offset+2] = (k >>> 8) & 0xFF; + this.view[offset+3] = k & 0xFF; + } + offset += 4; + utfx.encodeUTF16toUTF8(stringSource(str), function(b) { + this.view[offset++] = b; + }.bind(this)); + if (offset !== start + 4 + k) + throw RangeError("Illegal range: Truncated data, "+offset+" == "+(offset+4+k)); + if (relative) { + this.offset = offset; + return this; + } + return offset - start; + }; + + /** + * Reads a length as uint32 prefixed UTF8 encoded string. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string + * read and the actual number of bytes read. + * @expose + * @see ByteBuffer#readVarint32 + */ + ByteBufferPrototype.readIString = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 4 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength); + } + var start = offset; + var len = this.readUint32(offset); + var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4); + offset += str['length']; + if (relative) { + this.offset = offset; + return str['string']; + } else { + return { + 'string': str['string'], + 'length': offset - start + }; + } + }; + + // types/strings/utf8string + + /** + * Metrics representing number of UTF8 characters. Evaluates to `c`. + * @type {string} + * @const + * @expose + */ + ByteBuffer.METRICS_CHARS = 'c'; + + /** + * Metrics representing number of bytes. Evaluates to `b`. + * @type {string} + * @const + * @expose + */ + ByteBuffer.METRICS_BYTES = 'b'; + + /** + * Writes an UTF8 encoded string. + * @param {string} str String to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted. + * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written. + * @expose + */ + ByteBufferPrototype.writeUTF8String = function(str, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + var k; + var start = offset; + k = utfx.calculateUTF16asUTF8(stringSource(str))[1]; + offset += k; + var capacity14 = this.buffer.byteLength; + if (offset > capacity14) + this.resize((capacity14 *= 2) > offset ? capacity14 : offset); + offset -= k; + utfx.encodeUTF16toUTF8(stringSource(str), function(b) { + this.view[offset++] = b; + }.bind(this)); + if (relative) { + this.offset = offset; + return this; + } + return offset - start; + }; + + /** + * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}. + * @function + * @param {string} str String to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted. + * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written. + * @expose + */ + ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String; + + /** + * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's + * `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF. + * @param {string} str String to calculate + * @returns {number} Number of UTF8 characters + * @expose + */ + ByteBuffer.calculateUTF8Chars = function(str) { + return utfx.calculateUTF16asUTF8(stringSource(str))[0]; + }; + + /** + * Calculates the number of UTF8 bytes of a string. + * @param {string} str String to calculate + * @returns {number} Number of UTF8 bytes + * @expose + */ + ByteBuffer.calculateUTF8Bytes = function(str) { + return utfx.calculateUTF16asUTF8(stringSource(str))[1]; + }; + + /** + * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}. + * @function + * @param {string} str String to calculate + * @returns {number} Number of UTF8 bytes + * @expose + */ + ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes; + + /** + * Reads an UTF8 encoded string. + * @param {number} length Number of characters or bytes to read. + * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to + * {@link ByteBuffer.METRICS_CHARS}. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string + * read and the actual number of bytes read. + * @expose + */ + ByteBufferPrototype.readUTF8String = function(length, metrics, offset) { + if (typeof metrics === 'number') { + offset = metrics; + metrics = undefined; + } + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS; + if (!this.noAssert) { + if (typeof length !== 'number' || length % 1 !== 0) + throw TypeError("Illegal length: "+length+" (not an integer)"); + length |= 0; + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + var i = 0, + start = offset, + sd; + if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser + sd = stringDestination(); + utfx.decodeUTF8(function() { + return i < length && offset < this.limit ? this.view[offset++] : null; + }.bind(this), function(cp) { + ++i; utfx.UTF8toUTF16(cp, sd); + }); + if (i !== length) + throw RangeError("Illegal range: Truncated data, "+i+" == "+length); + if (relative) { + this.offset = offset; + return sd(); + } else { + return { + "string": sd(), + "length": offset - start + }; + } + } else if (metrics === ByteBuffer.METRICS_BYTES) { + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + length > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+length+") <= "+this.buffer.byteLength); + } + var k = offset + length; + utfx.decodeUTF8toUTF16(function() { + return offset < k ? this.view[offset++] : null; + }.bind(this), sd = stringDestination(), this.noAssert); + if (offset !== k) + throw RangeError("Illegal range: Truncated data, "+offset+" == "+k); + if (relative) { + this.offset = offset; + return sd(); + } else { + return { + 'string': sd(), + 'length': offset - start + }; + } + } else + throw TypeError("Unsupported metrics: "+metrics); + }; + + /** + * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}. + * @function + * @param {number} length Number of characters or bytes to read + * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to + * {@link ByteBuffer.METRICS_CHARS}. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string + * read and the actual number of bytes read. + * @expose + */ + ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String; + + // types/strings/vstring + + /** + * Writes a length as varint32 prefixed UTF8 encoded string. + * @param {string} str String to write + * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written + * @expose + * @see ByteBuffer#writeVarint32 + */ + ByteBufferPrototype.writeVString = function(str, offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof str !== 'string') + throw TypeError("Illegal str: Not a string"); + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + var start = offset, + k, l; + k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1]; + l = ByteBuffer.calculateVarint32(k); + offset += l+k; + var capacity15 = this.buffer.byteLength; + if (offset > capacity15) + this.resize((capacity15 *= 2) > offset ? capacity15 : offset); + offset -= l+k; + offset += this.writeVarint32(k, offset); + utfx.encodeUTF16toUTF8(stringSource(str), function(b) { + this.view[offset++] = b; + }.bind(this)); + if (offset !== start+k+l) + throw RangeError("Illegal range: Truncated data, "+offset+" == "+(offset+k+l)); + if (relative) { + this.offset = offset; + return this; + } + return offset - start; + }; + + /** + * Reads a length as varint32 prefixed UTF8 encoded string. + * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string + * read and the actual number of bytes read. + * @expose + * @see ByteBuffer#readVarint32 + */ + ByteBufferPrototype.readVString = function(offset) { + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 1 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength); + } + var start = offset; + var len = this.readVarint32(offset); + var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']); + offset += str['length']; + if (relative) { + this.offset = offset; + return str['string']; + } else { + return { + 'string': str['string'], + 'length': offset - start + }; + } + }; + + + /** + * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended + * data's length. + * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets + * will be modified according to the performed read operation. + * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8") + * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. + * @returns {!ByteBuffer} this + * @expose + * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|` + * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|` + */ + ByteBufferPrototype.append = function(source, encoding, offset) { + if (typeof encoding === 'number' || typeof encoding !== 'string') { + offset = encoding; + encoding = undefined; + } + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + if (!(source instanceof ByteBuffer)) + source = ByteBuffer.wrap(source, encoding); + var length = source.limit - source.offset; + if (length <= 0) return this; // Nothing to append + offset += length; + var capacity16 = this.buffer.byteLength; + if (offset > capacity16) + this.resize((capacity16 *= 2) > offset ? capacity16 : offset); + offset -= length; + this.view.set(source.view.subarray(source.offset, source.limit), offset); + source.offset += length; + if (relative) this.offset += length; + return this; + }; + + /** + * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the + specified offset up to the length of this ByteBuffer's data. + * @param {!ByteBuffer} target Target ByteBuffer + * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * read if omitted. + * @returns {!ByteBuffer} this + * @expose + * @see ByteBuffer#append + */ + ByteBufferPrototype.appendTo = function(target, offset) { + target.append(this, offset); + return this; + }; + + /** + * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to + * disable them if your code already makes sure that everything is valid. + * @param {boolean} assert `true` to enable assertions, otherwise `false` + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.assert = function(assert) { + this.noAssert = !assert; + return this; + }; + + /** + * Gets the capacity of this ByteBuffer's backing buffer. + * @returns {number} Capacity of the backing buffer + * @expose + */ + ByteBufferPrototype.capacity = function() { + return this.buffer.byteLength; + }; + /** + * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the + * backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.clear = function() { + this.offset = 0; + this.limit = this.buffer.byteLength; + this.markedOffset = -1; + return this; + }; + + /** + * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset}, + * {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}. + * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false` + * @returns {!ByteBuffer} Cloned instance + * @expose + */ + ByteBufferPrototype.clone = function(copy) { + var bb = new ByteBuffer(0, this.littleEndian, this.noAssert); + if (copy) { + bb.buffer = new ArrayBuffer(this.buffer.byteLength); + bb.view = new Uint8Array(bb.buffer); + } else { + bb.buffer = this.buffer; + bb.view = this.view; + } + bb.offset = this.offset; + bb.markedOffset = this.markedOffset; + bb.limit = this.limit; + return bb; + }; + + /** + * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes + * between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and + * adapt {@link ByteBuffer#markedOffset} to the same relative position if set. + * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset} + * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit} + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.compact = function(begin, end) { + if (typeof begin === 'undefined') begin = this.offset; + if (typeof end === 'undefined') end = this.limit; + if (!this.noAssert) { + if (typeof begin !== 'number' || begin % 1 !== 0) + throw TypeError("Illegal begin: Not an integer"); + begin >>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + if (begin === 0 && end === this.buffer.byteLength) + return this; // Already compacted + var len = end - begin; + if (len === 0) { + this.buffer = EMPTY_BUFFER; + this.view = null; + if (this.markedOffset >= 0) this.markedOffset -= begin; + this.offset = 0; + this.limit = 0; + return this; + } + var buffer = new ArrayBuffer(len); + var view = new Uint8Array(buffer); + view.set(this.view.subarray(begin, end)); + this.buffer = buffer; + this.view = view; + if (this.markedOffset >= 0) this.markedOffset -= begin; + this.offset = 0; + this.limit = len; + return this; + }; + + /** + * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and + * {@link ByteBuffer#limit}. + * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}. + * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}. + * @returns {!ByteBuffer} Copy + * @expose + */ + ByteBufferPrototype.copy = function(begin, end) { + if (typeof begin === 'undefined') begin = this.offset; + if (typeof end === 'undefined') end = this.limit; + if (!this.noAssert) { + if (typeof begin !== 'number' || begin % 1 !== 0) + throw TypeError("Illegal begin: Not an integer"); + begin >>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + if (begin === end) + return new ByteBuffer(0, this.littleEndian, this.noAssert); + var capacity = end - begin, + bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert); + bb.offset = 0; + bb.limit = capacity; + if (bb.markedOffset >= 0) bb.markedOffset -= begin; + this.copyTo(bb, 0, begin, end); + return bb; + }; + + /** + * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and + * {@link ByteBuffer#limit}. + * @param {!ByteBuffer} target Target ByteBuffer + * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset} + * by the number of bytes copied if omitted. + * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the + * number of bytes copied if omitted. + * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit} + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) { + var relative, + targetRelative; + if (!this.noAssert) { + if (!ByteBuffer.isByteBuffer(target)) + throw TypeError("Illegal target: Not a ByteBuffer"); + } + targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0; + sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0; + sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0; + + if (targetOffset < 0 || targetOffset > target.buffer.byteLength) + throw RangeError("Illegal target range: 0 <= "+targetOffset+" <= "+target.buffer.byteLength); + if (sourceOffset < 0 || sourceLimit > this.buffer.byteLength) + throw RangeError("Illegal source range: 0 <= "+sourceOffset+" <= "+this.buffer.byteLength); + + var len = sourceLimit - sourceOffset; + if (len === 0) + return target; // Nothing to copy + + target.ensureCapacity(targetOffset + len); + + target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset); + + if (relative) this.offset += len; + if (targetRelative) target.offset += len; + + return this; + }; + + /** + * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the + * current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity, + * the required capacity will be used instead. + * @param {number} capacity Required capacity + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.ensureCapacity = function(capacity) { + var current = this.buffer.byteLength; + if (current < capacity) + return this.resize((current *= 2) > capacity ? current : capacity); + return this; + }; + + /** + * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between + * {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. + * @param {number|string} value Byte value to fill with. If given as a string, the first character is used. + * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes + * written if omitted. defaults to {@link ByteBuffer#offset}. + * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}. + * @returns {!ByteBuffer} this + * @expose + * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes + */ + ByteBufferPrototype.fill = function(value, begin, end) { + var relative = typeof begin === 'undefined'; + if (relative) begin = this.offset; + if (typeof value === 'string' && value.length > 0) + value = value.charCodeAt(0); + if (typeof begin === 'undefined') begin = this.offset; + if (typeof end === 'undefined') end = this.limit; + if (!this.noAssert) { + if (typeof value !== 'number' || value % 1 !== 0) + throw TypeError("Illegal value: "+value+" (not an integer)"); + value |= 0; + if (typeof begin !== 'number' || begin % 1 !== 0) + throw TypeError("Illegal begin: Not an integer"); + begin >>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + if (begin >= end) + return this; // Nothing to fill + while (begin < end) this.view[begin++] = value; + if (relative) this.offset = begin; + return this; + }; + + /** + * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and + * `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.flip = function() { + this.limit = this.offset; + this.offset = 0; + return this; + }; + /** + * Marks an offset on this ByteBuffer to be used later. + * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}. + * @returns {!ByteBuffer} this + * @throws {TypeError} If `offset` is not a valid number + * @throws {RangeError} If `offset` is out of bounds + * @see ByteBuffer#reset + * @expose + */ + ByteBufferPrototype.mark = function(offset) { + offset = typeof offset === 'undefined' ? this.offset : offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + this.markedOffset = offset; + return this; + }; + /** + * Sets the byte order. + * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.order = function(littleEndian) { + if (!this.noAssert) { + if (typeof littleEndian !== 'boolean') + throw TypeError("Illegal littleEndian: Not a boolean"); + } + this.littleEndian = !!littleEndian; + return this; + }; + + /** + * Switches (to) little endian byte order. + * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.LE = function(littleEndian) { + this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true; + return this; + }; + + /** + * Switches (to) big endian byte order. + * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.BE = function(bigEndian) { + this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false; + return this; + }; + /** + * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the + * prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer + * will be resized and its contents moved accordingly. + * @param {!ByteBuffer|string|!ArrayBuffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be + * modified according to the performed read operation. + * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8") + * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes + * prepended if omitted. + * @returns {!ByteBuffer} this + * @expose + * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|` + * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|` + */ + ByteBufferPrototype.prepend = function(source, encoding, offset) { + if (typeof encoding === 'number' || typeof encoding !== 'string') { + offset = encoding; + encoding = undefined; + } + var relative = typeof offset === 'undefined'; + if (relative) offset = this.offset; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: "+offset+" (not an integer)"); + offset >>>= 0; + if (offset < 0 || offset + 0 > this.buffer.byteLength) + throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength); + } + if (!(source instanceof ByteBuffer)) + source = ByteBuffer.wrap(source, encoding); + var len = source.limit - source.offset; + if (len <= 0) return this; // Nothing to prepend + var diff = len - offset; + if (diff > 0) { // Not enough space before offset, so resize + move + var buffer = new ArrayBuffer(this.buffer.byteLength + diff); + var view = new Uint8Array(buffer); + view.set(this.view.subarray(offset, this.buffer.byteLength), len); + this.buffer = buffer; + this.view = view; + this.offset += diff; + if (this.markedOffset >= 0) this.markedOffset += diff; + this.limit += diff; + offset += diff; + } else { + var arrayView = new Uint8Array(this.buffer); + } + this.view.set(source.view.subarray(source.offset, source.limit), offset - len); + + source.offset = source.limit; + if (relative) + this.offset -= len; + return this; + }; + + /** + * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the + * prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer + * will be resized and its contents moved accordingly. + * @param {!ByteBuffer} target Target ByteBuffer + * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes + * prepended if omitted. + * @returns {!ByteBuffer} this + * @expose + * @see ByteBuffer#prepend + */ + ByteBufferPrototype.prependTo = function(target, offset) { + target.prepend(this, offset); + return this; + }; + /** + * Prints debug information about this ByteBuffer's contents. + * @param {function(string)=} out Output function to call, defaults to console.log + * @expose + */ + ByteBufferPrototype.printDebug = function(out) { + if (typeof out !== 'function') out = console.log.bind(console); + out( + this.toString()+"\n"+ + "-------------------------------------------------------------------\n"+ + this.toDebug(/* columns */ true) + ); + }; + + /** + * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and + * {@link ByteBuffer#limit}, so this returns `limit - offset`. + * @returns {number} Remaining readable bytes. May be negative if `offset > limit`. + * @expose + */ + ByteBufferPrototype.remaining = function() { + return this.limit - this.offset; + }; + /** + * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark} + * before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been + * marked, sets `offset = 0`. + * @returns {!ByteBuffer} this + * @see ByteBuffer#mark + * @expose + */ + ByteBufferPrototype.reset = function() { + if (this.markedOffset >= 0) { + this.offset = this.markedOffset; + this.markedOffset = -1; + } else { + this.offset = 0; + } + return this; + }; + /** + * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that + * large or larger. + * @param {number} capacity Capacity required + * @returns {!ByteBuffer} this + * @throws {TypeError} If `capacity` is not a number + * @throws {RangeError} If `capacity < 0` + * @expose + */ + ByteBufferPrototype.resize = function(capacity) { + if (!this.noAssert) { + if (typeof capacity !== 'number' || capacity % 1 !== 0) + throw TypeError("Illegal capacity: "+capacity+" (not an integer)"); + capacity |= 0; + if (capacity < 0) + throw RangeError("Illegal capacity: 0 <= "+capacity); + } + if (this.buffer.byteLength < capacity) { + var buffer = new ArrayBuffer(capacity); + var view = new Uint8Array(buffer); + view.set(this.view); + this.buffer = buffer; + this.view = view; + } + return this; + }; + /** + * Reverses this ByteBuffer's contents. + * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset} + * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit} + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.reverse = function(begin, end) { + if (typeof begin === 'undefined') begin = this.offset; + if (typeof end === 'undefined') end = this.limit; + if (!this.noAssert) { + if (typeof begin !== 'number' || begin % 1 !== 0) + throw TypeError("Illegal begin: Not an integer"); + begin >>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + if (begin === end) + return this; // Nothing to reverse + Array.prototype.reverse.call(this.view.subarray(begin, end)); + return this; + }; + /** + * Skips the next `length` bytes. This will just advance + * @param {number} length Number of bytes to skip. May also be negative to move the offset back. + * @returns {!ByteBuffer} this + * @expose + */ + ByteBufferPrototype.skip = function(length) { + if (!this.noAssert) { + if (typeof length !== 'number' || length % 1 !== 0) + throw TypeError("Illegal length: "+length+" (not an integer)"); + length |= 0; + } + var offset = this.offset + length; + if (!this.noAssert) { + if (offset < 0 || offset > this.buffer.byteLength) + throw RangeError("Illegal length: 0 <= "+this.offset+" + "+length+" <= "+this.buffer.byteLength); + } + this.offset = offset; + return this; + }; + + /** + * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`. + * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}. + * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}. + * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer} + * @expose + */ + ByteBufferPrototype.slice = function(begin, end) { + if (typeof begin === 'undefined') begin = this.offset; + if (typeof end === 'undefined') end = this.limit; + if (!this.noAssert) { + if (typeof begin !== 'number' || begin % 1 !== 0) + throw TypeError("Illegal begin: Not an integer"); + begin >>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + var bb = this.clone(); + bb.offset = begin; + bb.limit = end; + return bb; + }; + /** + * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between + * {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. + * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if + * possible. Defaults to `false` + * @returns {!ArrayBuffer} Contents as an ArrayBuffer + * @expose + */ + ByteBufferPrototype.toBuffer = function(forceCopy) { + var offset = this.offset, + limit = this.limit; + if (!this.noAssert) { + if (typeof offset !== 'number' || offset % 1 !== 0) + throw TypeError("Illegal offset: Not an integer"); + offset >>>= 0; + if (typeof limit !== 'number' || limit % 1 !== 0) + throw TypeError("Illegal limit: Not an integer"); + limit >>>= 0; + if (offset < 0 || offset > limit || limit > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+offset+" <= "+limit+" <= "+this.buffer.byteLength); + } + // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is + // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So: + if (!forceCopy && offset === 0 && limit === this.buffer.byteLength) + return this.buffer; + if (offset === limit) + return EMPTY_BUFFER; + var buffer = new ArrayBuffer(limit - offset); + new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0); + return buffer; + }; + + /** + * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between + * {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}. + * @function + * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory. + * Defaults to `false` + * @returns {!ArrayBuffer} Contents as an ArrayBuffer + * @expose + */ + ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer; + + /** + * Converts the ByteBuffer's contents to a string. + * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows + * direct conversion to "utf8", "hex", "base64" and "binary" encoding. "debug" returns a hex representation with + * highlighted offsets. + * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset} + * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit} + * @returns {string} String representation + * @throws {Error} If `encoding` is invalid + * @expose + */ + ByteBufferPrototype.toString = function(encoding, begin, end) { + if (typeof encoding === 'undefined') + return "ByteBufferAB(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")"; + if (typeof encoding === 'number') + encoding = "utf8", + begin = encoding, + end = begin; + switch (encoding) { + case "utf8": + return this.toUTF8(begin, end); + case "base64": + return this.toBase64(begin, end); + case "hex": + return this.toHex(begin, end); + case "binary": + return this.toBinary(begin, end); + case "debug": + return this.toDebug(); + case "columns": + return this.toColumns(); + default: + throw Error("Unsupported encoding: "+encoding); + } + }; + + // lxiv-embeddable + + /** + * lxiv-embeddable (c) 2014 Daniel Wirtz + * Released under the Apache License, Version 2.0 + * see: https://github.com/dcodeIO/lxiv for details + */ + var lxiv = function() { + "use strict"; + + /** + * lxiv namespace. + * @type {!Object.} + * @exports lxiv + */ + var lxiv = {}; + + /** + * Character codes for output. + * @type {!Array.} + * @inner + */ + var aout = [ + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47 + ]; + + /** + * Character codes for input. + * @type {!Array.} + * @inner + */ + var ain = []; + for (var i=0, k=aout.length; i>2)&0x3f]); + t = (b&0x3)<<4; + if ((b = src()) !== null) { + t |= (b>>4)&0xf; + dst(aout[(t|((b>>4)&0xf))&0x3f]); + t = (b&0xf)<<2; + if ((b = src()) !== null) + dst(aout[(t|((b>>6)&0x3))&0x3f]), + dst(aout[b&0x3f]); + else + dst(aout[t&0x3f]), + dst(61); + } else + dst(aout[t&0x3f]), + dst(61), + dst(61); + } + }; + + /** + * Decodes base64 char codes to bytes. + * @param {!function():number|null} src Characters source as a function returning the next char code respectively + * `null` if there are no more characters left. + * @param {!function(number)} dst Bytes destination as a function successively called with the next byte. + * @throws {Error} If a character code is invalid + */ + lxiv.decode = function(src, dst) { + var c, t1, t2; + function fail(c) { + throw Error("Illegal character code: "+c); + } + while ((c = src()) !== null) { + t1 = ain[c]; + if (typeof t1 === 'undefined') fail(c); + if ((c = src()) !== null) { + t2 = ain[c]; + if (typeof t2 === 'undefined') fail(c); + dst((t1<<2)>>>0|(t2&0x30)>>4); + if ((c = src()) !== null) { + t1 = ain[c]; + if (typeof t1 === 'undefined') + if (c === 61) break; else fail(c); + dst(((t2&0xf)<<4)>>>0|(t1&0x3c)>>2); + if ((c = src()) !== null) { + t2 = ain[c]; + if (typeof t2 === 'undefined') + if (c === 61) break; else fail(c); + dst(((t1&0x3)<<6)>>>0|t2); + } + } + } + } + }; + + /** + * Tests if a string is valid base64. + * @param {string} str String to test + * @returns {boolean} `true` if valid, otherwise `false` + */ + lxiv.test = function(str) { + return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(str); + }; + + return lxiv; + }(); + + // encodings/base64 + + /** + * Encodes this ByteBuffer's contents to a base64 encoded string. + * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}. + * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}. + * @returns {string} Base64 encoded string + * @throws {RangeError} If `begin` or `end` is out of bounds + * @expose + */ + ByteBufferPrototype.toBase64 = function(begin, end) { + if (typeof begin === 'undefined') + begin = this.offset; + if (typeof end === 'undefined') + end = this.limit; + begin = begin | 0; end = end | 0; + if (begin < 0 || end > this.capacity || begin > end) + throw RangeError("begin, end"); + var sd; lxiv.encode(function() { + return begin < end ? this.view[begin++] : null; + }.bind(this), sd = stringDestination()); + return sd(); + }; + + /** + * Decodes a base64 encoded string to a ByteBuffer. + * @param {string} str String to decode + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @returns {!ByteBuffer} ByteBuffer + * @expose + */ + ByteBuffer.fromBase64 = function(str, littleEndian) { + if (typeof str !== 'string') + throw TypeError("str"); + var bb = new ByteBuffer(str.length/4*3, littleEndian), + i = 0; + lxiv.decode(stringSource(str), function(b) { + bb.view[i++] = b; + }); + bb.limit = i; + return bb; + }; + + /** + * Encodes a binary string to base64 like `window.btoa` does. + * @param {string} str Binary string + * @returns {string} Base64 encoded string + * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa + * @expose + */ + ByteBuffer.btoa = function(str) { + return ByteBuffer.fromBinary(str).toBase64(); + }; + + /** + * Decodes a base64 encoded string to binary like `window.atob` does. + * @param {string} b64 Base64 encoded string + * @returns {string} Binary string + * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob + * @expose + */ + ByteBuffer.atob = function(b64) { + return ByteBuffer.fromBase64(b64).toBinary(); + }; + + // encodings/binary + + /** + * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes. + * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}. + * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}. + * @returns {string} Binary encoded string + * @throws {RangeError} If `offset > limit` + * @expose + */ + ByteBufferPrototype.toBinary = function(begin, end) { + if (typeof begin === 'undefined') + begin = this.offset; + if (typeof end === 'undefined') + end = this.limit; + begin |= 0; end |= 0; + if (begin < 0 || end > this.capacity() || begin > end) + throw RangeError("begin, end"); + if (begin === end) + return ""; + var chars = [], + parts = []; + while (begin < end) { + chars.push(this.view[begin++]); + if (chars.length >= 1024) + parts.push(String.fromCharCode.apply(String, chars)), + chars = []; + } + return parts.join('') + String.fromCharCode.apply(String, chars); + }; + + /** + * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer. + * @param {string} str String to decode + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @returns {!ByteBuffer} ByteBuffer + * @expose + */ + ByteBuffer.fromBinary = function(str, littleEndian) { + if (typeof str !== 'string') + throw TypeError("str"); + var i = 0, + k = str.length, + charCode, + bb = new ByteBuffer(k, littleEndian); + while (i 0xff) + throw RangeError("illegal char code: "+charCode); + bb.view[i++] = charCode; + } + bb.limit = k; + return bb; + }; + + // encodings/debug + + /** + * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are: + * * `<` : offset, + * * `'` : markedOffset, + * * `>` : limit, + * * `|` : offset and limit, + * * `[` : offset and markedOffset, + * * `]` : markedOffset and limit, + * * `!` : offset, markedOffset and limit + * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false` + * @returns {string|!Array.} Debug string or array of lines if `asArray = true` + * @expose + * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3` + * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4` + * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1` + * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1` + */ + ByteBufferPrototype.toDebug = function(columns) { + var i = -1, + k = this.buffer.byteLength, + b, + hex = "", + asc = "", + out = ""; + while (i 32 && b < 127 ? String.fromCharCode(b) : '.'; + } + ++i; + if (columns) { + if (i > 0 && i % 16 === 0 && i !== k) { + while (hex.length < 3*16+3) hex += " "; + out += hex+asc+"\n"; + hex = asc = ""; + } + } + if (i === this.offset && i === this.limit) + hex += i === this.markedOffset ? "!" : "|"; + else if (i === this.offset) + hex += i === this.markedOffset ? "[" : "<"; + else if (i === this.limit) + hex += i === this.markedOffset ? "]" : ">"; + else + hex += i === this.markedOffset ? "'" : (columns || (i !== 0 && i !== k) ? " " : ""); + } + if (columns && hex !== " ") { + while (hex.length < 3*16+3) + hex += " "; + out += hex + asc + "\n"; + } + return columns ? out : hex; + }; + + /** + * Decodes a hex encoded string with marked offsets to a ByteBuffer. + * @param {string} str Debug string to decode (not be generated with `columns = true`) + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @returns {!ByteBuffer} ByteBuffer + * @expose + * @see ByteBuffer#toDebug + */ + ByteBuffer.fromDebug = function(str, littleEndian, noAssert) { + var k = str.length, + bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert); + var i = 0, j = 0, ch, b, + rs = false, // Require symbol next + ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)? + fail = false; + while (i': + if (!noAssert) { + if (hl) { + fail = true; + break; + } + hl = true; + } + bb.limit = j; + rs = false; + break; + case "'": + if (!noAssert) { + if (hm) { + fail = true; + break; + } + hm = true; + } + bb.markedOffset = j; + rs = false; + break; + case ' ': + rs = false; + break; + default: + if (!noAssert) { + if (rs) { + fail = true; + break; + } + } + b = parseInt(ch+str.charAt(i++), 16); + if (!noAssert) { + if (isNaN(b) || b < 0 || b > 255) + throw TypeError("Illegal str: Not a debug encoded string"); + } + bb.view[j++] = b; + rs = true; + } + if (fail) + throw TypeError("Illegal str: Invalid symbol at "+i); + } + if (!noAssert) { + if (!ho || !hl) + throw TypeError("Illegal str: Missing offset or limit"); + if (j>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + var out = new Array(end - begin), + b; + while (begin < end) { + b = this.view[begin++]; + if (b < 0x10) + out.push("0", b.toString(16)); + else out.push(b.toString(16)); + } + return out.join(''); + }; + + /** + * Decodes a hex encoded string to a ByteBuffer. + * @param {string} str String to decode + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @returns {!ByteBuffer} ByteBuffer + * @expose + */ + ByteBuffer.fromHex = function(str, littleEndian, noAssert) { + if (!noAssert) { + if (typeof str !== 'string') + throw TypeError("Illegal str: Not a string"); + if (str.length % 2 !== 0) + throw TypeError("Illegal str: Length not a multiple of 2"); + } + var k = str.length, + bb = new ByteBuffer((k / 2) | 0, littleEndian), + b; + for (var i=0, j=0; i 255) + throw TypeError("Illegal str: Contains non-hex characters"); + bb.view[j++] = b; + } + bb.limit = j; + return bb; + }; + + // utfx-embeddable + + /** + * utfx-embeddable (c) 2014 Daniel Wirtz + * Released under the Apache License, Version 2.0 + * see: https://github.com/dcodeIO/utfx for details + */ + var utfx = function() { + "use strict"; + + /** + * utfx namespace. + * @inner + * @type {!Object.} + */ + var utfx = {}; + + /** + * Maximum valid code point. + * @type {number} + * @const + */ + utfx.MAX_CODEPOINT = 0x10FFFF; + + /** + * Encodes UTF8 code points to UTF8 bytes. + * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point + * respectively `null` if there are no more code points left or a single numeric code point. + * @param {!function(number)} dst Bytes destination as a function successively called with the next byte + */ + utfx.encodeUTF8 = function(src, dst) { + var cp = null; + if (typeof src === 'number') + cp = src, + src = function() { return null; }; + while (cp !== null || (cp = src()) !== null) { + if (cp < 0x80) + dst(cp&0x7F); + else if (cp < 0x800) + dst(((cp>>6)&0x1F)|0xC0), + dst((cp&0x3F)|0x80); + else if (cp < 0x10000) + dst(((cp>>12)&0x0F)|0xE0), + dst(((cp>>6)&0x3F)|0x80), + dst((cp&0x3F)|0x80); + else + dst(((cp>>18)&0x07)|0xF0), + dst(((cp>>12)&0x3F)|0x80), + dst(((cp>>6)&0x3F)|0x80), + dst((cp&0x3F)|0x80); + cp = null; + } + }; + + /** + * Decodes UTF8 bytes to UTF8 code points. + * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there + * are no more bytes left. + * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point. + * @throws {RangeError} If a starting byte is invalid in UTF8 + * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the + * remaining bytes. + */ + utfx.decodeUTF8 = function(src, dst) { + var a, b, c, d, fail = function(b) { + b = b.slice(0, b.indexOf(null)); + var err = Error(b.toString()); + err.name = "TruncatedError"; + err['bytes'] = b; + throw err; + }; + while ((a = src()) !== null) { + if ((a&0x80) === 0) + dst(a); + else if ((a&0xE0) === 0xC0) + ((b = src()) === null) && fail([a, b]), + dst(((a&0x1F)<<6) | (b&0x3F)); + else if ((a&0xF0) === 0xE0) + ((b=src()) === null || (c=src()) === null) && fail([a, b, c]), + dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F)); + else if ((a&0xF8) === 0xF0) + ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]), + dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F)); + else throw RangeError("Illegal starting byte: "+a); + } + }; + + /** + * Converts UTF16 characters to UTF8 code points. + * @param {!function():number|null} src Characters source as a function returning the next char code respectively + * `null` if there are no more characters left. + * @param {!function(number)} dst Code points destination as a function successively called with each converted code + * point. + */ + utfx.UTF16toUTF8 = function(src, dst) { + var c1, c2 = null; + while (true) { + if ((c1 = c2 !== null ? c2 : src()) === null) + break; + if (c1 >= 0xD800 && c1 <= 0xDFFF) { + if ((c2 = src()) !== null) { + if (c2 >= 0xDC00 && c2 <= 0xDFFF) { + dst((c1-0xD800)*0x400+c2-0xDC00+0x10000); + c2 = null; continue; + } + } + } + dst(c1); + } + if (c2 !== null) dst(c2); + }; + + /** + * Converts UTF8 code points to UTF16 characters. + * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point + * respectively `null` if there are no more code points left or a single numeric code point. + * @param {!function(number)} dst Characters destination as a function successively called with each converted char code. + * @throws {RangeError} If a code point is out of range + */ + utfx.UTF8toUTF16 = function(src, dst) { + var cp = null; + if (typeof src === 'number') + cp = src, src = function() { return null; }; + while (cp !== null || (cp = src()) !== null) { + if (cp <= 0xFFFF) + dst(cp); + else + cp -= 0x10000, + dst((cp>>10)+0xD800), + dst((cp%0x400)+0xDC00); + cp = null; + } + }; + + /** + * Converts and encodes UTF16 characters to UTF8 bytes. + * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null` + * if there are no more characters left. + * @param {!function(number)} dst Bytes destination as a function successively called with the next byte. + */ + utfx.encodeUTF16toUTF8 = function(src, dst) { + utfx.UTF16toUTF8(src, function(cp) { + utfx.encodeUTF8(cp, dst); + }); + }; + + /** + * Decodes and converts UTF8 bytes to UTF16 characters. + * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there + * are no more bytes left. + * @param {!function(number)} dst Characters destination as a function successively called with each converted char code. + * @throws {RangeError} If a starting byte is invalid in UTF8 + * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes. + */ + utfx.decodeUTF8toUTF16 = function(src, dst) { + utfx.decodeUTF8(src, function(cp) { + utfx.UTF8toUTF16(cp, dst); + }); + }; + + /** + * Calculates the byte length of an UTF8 code point. + * @param {number} cp UTF8 code point + * @returns {number} Byte length + */ + utfx.calculateCodePoint = function(cp) { + return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4; + }; + + /** + * Calculates the number of UTF8 bytes required to store UTF8 code points. + * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively + * `null` if there are no more code points left. + * @returns {number} The number of UTF8 bytes required + */ + utfx.calculateUTF8 = function(src) { + var cp, l=0; + while ((cp = src()) !== null) + l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4; + return l; + }; + + /** + * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes. + * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively + * `null` if there are no more characters left. + * @returns {!Array.} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1. + */ + utfx.calculateUTF16asUTF8 = function(src) { + var n=0, l=0; + utfx.UTF16toUTF8(src, function(cp) { + ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4; + }); + return [n,l]; + }; + + return utfx; + }(); + + // encodings/utf8 + + /** + * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded + * string. + * @returns {string} Hex encoded string + * @throws {RangeError} If `offset > limit` + * @expose + */ + ByteBufferPrototype.toUTF8 = function(begin, end) { + if (typeof begin === 'undefined') begin = this.offset; + if (typeof end === 'undefined') end = this.limit; + if (!this.noAssert) { + if (typeof begin !== 'number' || begin % 1 !== 0) + throw TypeError("Illegal begin: Not an integer"); + begin >>>= 0; + if (typeof end !== 'number' || end % 1 !== 0) + throw TypeError("Illegal end: Not an integer"); + end >>>= 0; + if (begin < 0 || begin > end || end > this.buffer.byteLength) + throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength); + } + var sd; try { + utfx.decodeUTF8toUTF16(function() { + return begin < end ? this.view[begin++] : null; + }.bind(this), sd = stringDestination()); + } catch (e) { + if (begin !== end) + throw RangeError("Illegal range: Truncated data, "+begin+" != "+end); + } + return sd(); + }; + + /** + * Decodes an UTF8 encoded string to a ByteBuffer. + * @param {string} str String to decode + * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to + * {@link ByteBuffer.DEFAULT_ENDIAN}. + * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to + * {@link ByteBuffer.DEFAULT_NOASSERT}. + * @returns {!ByteBuffer} ByteBuffer + * @expose + */ + ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) { + if (!noAssert) + if (typeof str !== 'string') + throw TypeError("Illegal str: Not a string"); + var bb = new ByteBuffer(utfx.calculateUTF16asUTF8(stringSource(str), true)[1], littleEndian, noAssert), + i = 0; + utfx.encodeUTF16toUTF8(stringSource(str), function(b) { + bb.view[i++] = b; + }); + bb.limit = i; + return bb; + }; + + return ByteBuffer; +}); + +},{"68":68}],39:[function(require,module,exports){ +var Buffer = require(93).Buffer +var Transform = require(103).Transform +var StringDecoder = require(36).StringDecoder +var inherits = require(65) + +function CipherBase (hashMode) { + Transform.call(this) + this.hashMode = typeof hashMode === 'string' + if (this.hashMode) { + this[hashMode] = this._finalOrDigest + } else { + this.final = this._finalOrDigest + } + if (this._final) { + this.__final = this._final + this._final = null + } + this._decoder = null + this._encoding = null +} +inherits(CipherBase, Transform) + +CipherBase.prototype.update = function (data, inputEnc, outputEnc) { + if (typeof data === 'string') { + data = Buffer.from(data, inputEnc) + } + + var outData = this._update(data) + if (this.hashMode) return this + + if (outputEnc) { + outData = this._toString(outData, outputEnc) + } + + return outData +} + +CipherBase.prototype.setAutoPadding = function () {} +CipherBase.prototype.getAuthTag = function () { + throw new Error('trying to get auth tag in unsupported state') +} + +CipherBase.prototype.setAuthTag = function () { + throw new Error('trying to set auth tag in unsupported state') +} + +CipherBase.prototype.setAAD = function () { + throw new Error('trying to set aad in unsupported state') +} + +CipherBase.prototype._transform = function (data, _, next) { + var err + try { + if (this.hashMode) { + this._update(data) + } else { + this.push(this._update(data)) + } + } catch (e) { + err = e + } finally { + next(err) + } +} +CipherBase.prototype._flush = function (done) { + var err + try { + this.push(this.__final()) + } catch (e) { + err = e + } + + done(err) +} +CipherBase.prototype._finalOrDigest = function (outputEnc) { + var outData = this.__final() || Buffer.alloc(0) + if (outputEnc) { + outData = this._toString(outData, outputEnc, true) + } + return outData +} + +CipherBase.prototype._toString = function (value, enc, fin) { + if (!this._decoder) { + this._decoder = new StringDecoder(enc) + this._encoding = enc + } + + if (this._encoding !== enc) throw new Error('can\'t switch encodings') + + var out = this._decoder.write(value) + if (fin) { + out += this._decoder.end() + } + + return out +} + +module.exports = CipherBase + +},{"103":103,"36":36,"65":65,"93":93}],40:[function(require,module,exports){ +(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); +} + +}).call(this,{"isBuffer":require(66)}) + +},{"66":66}],41:[function(require,module,exports){ +'use strict' +var inherits = require(65) +var MD5 = require(69) +var RIPEMD160 = require(92) +var sha = require(96) +var Base = require(39) + +function Hash (hash) { + Base.call(this, 'digest') + + this._hash = hash +} + +inherits(Hash, Base) + +Hash.prototype._update = function (data) { + this._hash.update(data) +} + +Hash.prototype._final = function () { + return this._hash.digest() +} + +module.exports = function createHash (alg) { + alg = alg.toLowerCase() + if (alg === 'md5') return new MD5() + if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160() + + return new Hash(sha(alg)) +} + +},{"39":39,"65":65,"69":69,"92":92,"96":96}],42:[function(require,module,exports){ +var MD5 = require(69) + +module.exports = function (buffer) { + return new MD5().update(buffer).digest() +} + +},{"69":69}],43:[function(require,module,exports){ +'use strict' +var inherits = require(65) +var Legacy = require(44) +var Base = require(39) +var Buffer = require(93).Buffer +var md5 = require(42) +var RIPEMD160 = require(92) + +var sha = require(96) + +var ZEROS = Buffer.alloc(128) + +function Hmac (alg, key) { + Base.call(this, 'digest') + if (typeof key === 'string') { + key = Buffer.from(key) + } + + var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64 + + this._alg = alg + this._key = key + if (key.length > blocksize) { + var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg) + key = hash.update(key).digest() + } else if (key.length < blocksize) { + key = Buffer.concat([key, ZEROS], blocksize) + } + + var ipad = this._ipad = Buffer.allocUnsafe(blocksize) + var opad = this._opad = Buffer.allocUnsafe(blocksize) + + for (var i = 0; i < blocksize; i++) { + ipad[i] = key[i] ^ 0x36 + opad[i] = key[i] ^ 0x5C + } + this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg) + this._hash.update(ipad) +} + +inherits(Hmac, Base) + +Hmac.prototype._update = function (data) { + this._hash.update(data) +} + +Hmac.prototype._final = function () { + var h = this._hash.digest() + var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg) + return hash.update(this._opad).update(h).digest() +} + +module.exports = function createHmac (alg, key) { + alg = alg.toLowerCase() + if (alg === 'rmd160' || alg === 'ripemd160') { + return new Hmac('rmd160', key) + } + if (alg === 'md5') { + return new Legacy(md5, key) + } + return new Hmac(alg, key) +} + +},{"39":39,"42":42,"44":44,"65":65,"92":92,"93":93,"96":96}],44:[function(require,module,exports){ +'use strict' +var inherits = require(65) +var Buffer = require(93).Buffer + +var Base = require(39) + +var ZEROS = Buffer.alloc(128) +var blocksize = 64 + +function Hmac (alg, key) { + Base.call(this, 'digest') + if (typeof key === 'string') { + key = Buffer.from(key) + } + + this._alg = alg + this._key = key + + if (key.length > blocksize) { + key = alg(key) + } else if (key.length < blocksize) { + key = Buffer.concat([key, ZEROS], blocksize) + } + + var ipad = this._ipad = Buffer.allocUnsafe(blocksize) + var opad = this._opad = Buffer.allocUnsafe(blocksize) + + for (var i = 0; i < blocksize; i++) { + ipad[i] = key[i] ^ 0x36 + opad[i] = key[i] ^ 0x5C + } + + this._hash = [ipad] +} + +inherits(Hmac, Base) + +Hmac.prototype._update = function (data) { + this._hash.push(data) +} + +Hmac.prototype._final = function () { + var h = this._alg(Buffer.concat(this._hash)) + return this._alg(Buffer.concat([this._opad, h])) +} +module.exports = Hmac + +},{"39":39,"65":65,"93":93}],45:[function(require,module,exports){ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47), require(48), require(52), require(50), require(46)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + + // Lookup tables + var SBOX = []; + var INV_SBOX = []; + var SUB_MIX_0 = []; + var SUB_MIX_1 = []; + var SUB_MIX_2 = []; + var SUB_MIX_3 = []; + var INV_SUB_MIX_0 = []; + var INV_SUB_MIX_1 = []; + var INV_SUB_MIX_2 = []; + var INV_SUB_MIX_3 = []; + + // Compute lookup tables + (function () { + // Compute double table + var d = []; + for (var i = 0; i < 256; i++) { + if (i < 128) { + d[i] = i << 1; + } else { + d[i] = (i << 1) ^ 0x11b; + } + } + + // Walk GF(2^8) + var x = 0; + var xi = 0; + for (var i = 0; i < 256; i++) { + // Compute sbox + var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4); + sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63; + SBOX[x] = sx; + INV_SBOX[sx] = x; + + // Compute multiplication + var x2 = d[x]; + var x4 = d[x2]; + var x8 = d[x4]; + + // Compute sub bytes, mix columns tables + var t = (d[sx] * 0x101) ^ (sx * 0x1010100); + SUB_MIX_0[x] = (t << 24) | (t >>> 8); + SUB_MIX_1[x] = (t << 16) | (t >>> 16); + SUB_MIX_2[x] = (t << 8) | (t >>> 24); + SUB_MIX_3[x] = t; + + // Compute inv sub bytes, inv mix columns tables + var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100); + INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8); + INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16); + INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24); + INV_SUB_MIX_3[sx] = t; + + // Compute next counter + if (!x) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + }()); + + // Precomputed Rcon lookup + var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; + + /** + * AES block cipher algorithm. + */ + var AES = C_algo.AES = BlockCipher.extend({ + _doReset: function () { + // Skip reset of nRounds has been set before and key did not change + if (this._nRounds && this._keyPriorReset === this._key) { + return; + } + + // Shortcuts + var key = this._keyPriorReset = this._key; + var keyWords = key.words; + var keySize = key.sigBytes / 4; + + // Compute number of rounds + var nRounds = this._nRounds = keySize + 6; + + // Compute number of key schedule rows + var ksRows = (nRounds + 1) * 4; + + // Compute key schedule + var keySchedule = this._keySchedule = []; + for (var ksRow = 0; ksRow < ksRows; ksRow++) { + if (ksRow < keySize) { + keySchedule[ksRow] = keyWords[ksRow]; + } else { + var t = keySchedule[ksRow - 1]; + + if (!(ksRow % keySize)) { + // Rot word + t = (t << 8) | (t >>> 24); + + // Sub word + t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; + + // Mix Rcon + t ^= RCON[(ksRow / keySize) | 0] << 24; + } else if (keySize > 6 && ksRow % keySize == 4) { + // Sub word + t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; + } + + keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t; + } + } + + // Compute inv key schedule + var invKeySchedule = this._invKeySchedule = []; + for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) { + var ksRow = ksRows - invKsRow; + + if (invKsRow % 4) { + var t = keySchedule[ksRow]; + } else { + var t = keySchedule[ksRow - 4]; + } + + if (invKsRow < 4 || ksRow <= 4) { + invKeySchedule[invKsRow] = t; + } else { + invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^ + INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]]; + } + } + }, + + encryptBlock: function (M, offset) { + this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX); + }, + + decryptBlock: function (M, offset) { + // Swap 2nd and 4th rows + var t = M[offset + 1]; + M[offset + 1] = M[offset + 3]; + M[offset + 3] = t; + + this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX); + + // Inv swap 2nd and 4th rows + var t = M[offset + 1]; + M[offset + 1] = M[offset + 3]; + M[offset + 3] = t; + }, + + _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) { + // Shortcut + var nRounds = this._nRounds; + + // Get input, add round key + var s0 = M[offset] ^ keySchedule[0]; + var s1 = M[offset + 1] ^ keySchedule[1]; + var s2 = M[offset + 2] ^ keySchedule[2]; + var s3 = M[offset + 3] ^ keySchedule[3]; + + // Key schedule row counter + var ksRow = 4; + + // Rounds + for (var round = 1; round < nRounds; round++) { + // Shift rows, sub bytes, mix columns, add round key + var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++]; + var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++]; + var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++]; + var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++]; + + // Update state + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + + // Shift rows, sub bytes, add round key + var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]; + var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]; + var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]; + var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]; + + // Set output + M[offset] = t0; + M[offset + 1] = t1; + M[offset + 2] = t2; + M[offset + 3] = t3; + }, + + keySize: 256/32 + }); + + /** + * Shortcut functions to the cipher's object interface. + * + * @example + * + * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg); + * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg); + */ + C.AES = BlockCipher._createHelper(AES); + }()); + + + return CryptoJS.AES; + +})); +},{"46":46,"47":47,"48":48,"50":50,"52":52}],46:[function(require,module,exports){ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47), require(50)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./evpkdf"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + /** + * Cipher core components. + */ + CryptoJS.lib.Cipher || (function (undefined) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var Base64 = C_enc.Base64; + var C_algo = C.algo; + var EvpKDF = C_algo.EvpKDF; + + /** + * Abstract base cipher template. + * + * @property {number} keySize This cipher's key size. Default: 4 (128 bits) + * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits) + * @property {number} _ENC_XFORM_MODE A constant representing encryption mode. + * @property {number} _DEC_XFORM_MODE A constant representing decryption mode. + */ + var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({ + /** + * Configuration options. + * + * @property {WordArray} iv The IV to use for this operation. + */ + cfg: Base.extend(), + + /** + * Creates this cipher in encryption mode. + * + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {Cipher} A cipher instance. + * + * @static + * + * @example + * + * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray }); + */ + createEncryptor: function (key, cfg) { + return this.create(this._ENC_XFORM_MODE, key, cfg); + }, + + /** + * Creates this cipher in decryption mode. + * + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {Cipher} A cipher instance. + * + * @static + * + * @example + * + * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray }); + */ + createDecryptor: function (key, cfg) { + return this.create(this._DEC_XFORM_MODE, key, cfg); + }, + + /** + * Initializes a newly created cipher. + * + * @param {number} xformMode Either the encryption or decryption transormation mode constant. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @example + * + * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray }); + */ + init: function (xformMode, key, cfg) { + // Apply config defaults + this.cfg = this.cfg.extend(cfg); + + // Store transform mode and key + this._xformMode = xformMode; + this._key = key; + + // Set initial values + this.reset(); + }, + + /** + * Resets this cipher to its initial state. + * + * @example + * + * cipher.reset(); + */ + reset: function () { + // Reset data buffer + BufferedBlockAlgorithm.reset.call(this); + + // Perform concrete-cipher logic + this._doReset(); + }, + + /** + * Adds data to be encrypted or decrypted. + * + * @param {WordArray|string} dataUpdate The data to encrypt or decrypt. + * + * @return {WordArray} The data after processing. + * + * @example + * + * var encrypted = cipher.process('data'); + * var encrypted = cipher.process(wordArray); + */ + process: function (dataUpdate) { + // Append + this._append(dataUpdate); + + // Process available blocks + return this._process(); + }, + + /** + * Finalizes the encryption or decryption process. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt. + * + * @return {WordArray} The data after final processing. + * + * @example + * + * var encrypted = cipher.finalize(); + * var encrypted = cipher.finalize('data'); + * var encrypted = cipher.finalize(wordArray); + */ + finalize: function (dataUpdate) { + // Final data update + if (dataUpdate) { + this._append(dataUpdate); + } + + // Perform concrete-cipher logic + var finalProcessedData = this._doFinalize(); + + return finalProcessedData; + }, + + keySize: 128/32, + + ivSize: 128/32, + + _ENC_XFORM_MODE: 1, + + _DEC_XFORM_MODE: 2, + + /** + * Creates shortcut functions to a cipher's object interface. + * + * @param {Cipher} cipher The cipher to create a helper for. + * + * @return {Object} An object with encrypt and decrypt shortcut functions. + * + * @static + * + * @example + * + * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES); + */ + _createHelper: (function () { + function selectCipherStrategy(key) { + if (typeof key == 'string') { + return PasswordBasedCipher; + } else { + return SerializableCipher; + } + } + + return function (cipher) { + return { + encrypt: function (message, key, cfg) { + return selectCipherStrategy(key).encrypt(cipher, message, key, cfg); + }, + + decrypt: function (ciphertext, key, cfg) { + return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg); + } + }; + }; + }()) + }); + + /** + * Abstract base stream cipher template. + * + * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits) + */ + var StreamCipher = C_lib.StreamCipher = Cipher.extend({ + _doFinalize: function () { + // Process partial blocks + var finalProcessedBlocks = this._process(!!'flush'); + + return finalProcessedBlocks; + }, + + blockSize: 1 + }); + + /** + * Mode namespace. + */ + var C_mode = C.mode = {}; + + /** + * Abstract base block cipher mode template. + */ + var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({ + /** + * Creates this mode for encryption. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @static + * + * @example + * + * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words); + */ + createEncryptor: function (cipher, iv) { + return this.Encryptor.create(cipher, iv); + }, + + /** + * Creates this mode for decryption. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @static + * + * @example + * + * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words); + */ + createDecryptor: function (cipher, iv) { + return this.Decryptor.create(cipher, iv); + }, + + /** + * Initializes a newly created mode. + * + * @param {Cipher} cipher A block cipher instance. + * @param {Array} iv The IV words. + * + * @example + * + * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words); + */ + init: function (cipher, iv) { + this._cipher = cipher; + this._iv = iv; + } + }); + + /** + * Cipher Block Chaining mode. + */ + var CBC = C_mode.CBC = (function () { + /** + * Abstract base CBC mode. + */ + var CBC = BlockCipherMode.extend(); + + /** + * CBC encryptor. + */ + CBC.Encryptor = CBC.extend({ + /** + * Processes the data block at offset. + * + * @param {Array} words The data words to operate on. + * @param {number} offset The offset where the block starts. + * + * @example + * + * mode.processBlock(data.words, offset); + */ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // XOR and encrypt + xorBlock.call(this, words, offset, blockSize); + cipher.encryptBlock(words, offset); + + // Remember this block to use with next block + this._prevBlock = words.slice(offset, offset + blockSize); + } + }); + + /** + * CBC decryptor. + */ + CBC.Decryptor = CBC.extend({ + /** + * Processes the data block at offset. + * + * @param {Array} words The data words to operate on. + * @param {number} offset The offset where the block starts. + * + * @example + * + * mode.processBlock(data.words, offset); + */ + processBlock: function (words, offset) { + // Shortcuts + var cipher = this._cipher; + var blockSize = cipher.blockSize; + + // Remember this block to use with next block + var thisBlock = words.slice(offset, offset + blockSize); + + // Decrypt and XOR + cipher.decryptBlock(words, offset); + xorBlock.call(this, words, offset, blockSize); + + // This block becomes the previous block + this._prevBlock = thisBlock; + } + }); + + function xorBlock(words, offset, blockSize) { + // Shortcut + var iv = this._iv; + + // Choose mixing block + if (iv) { + var block = iv; + + // Remove IV for subsequent blocks + this._iv = undefined; + } else { + var block = this._prevBlock; + } + + // XOR blocks + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= block[i]; + } + } + + return CBC; + }()); + + /** + * Padding namespace. + */ + var C_pad = C.pad = {}; + + /** + * PKCS #5/7 padding strategy. + */ + var Pkcs7 = C_pad.Pkcs7 = { + /** + * Pads data using the algorithm defined in PKCS #5/7. + * + * @param {WordArray} data The data to pad. + * @param {number} blockSize The multiple that the data should be padded to. + * + * @static + * + * @example + * + * CryptoJS.pad.Pkcs7.pad(wordArray, 4); + */ + pad: function (data, blockSize) { + // Shortcut + var blockSizeBytes = blockSize * 4; + + // Count padding bytes + var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; + + // Create padding word + var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes; + + // Create padding + var paddingWords = []; + for (var i = 0; i < nPaddingBytes; i += 4) { + paddingWords.push(paddingWord); + } + var padding = WordArray.create(paddingWords, nPaddingBytes); + + // Add padding + data.concat(padding); + }, + + /** + * Unpads data that had been padded using the algorithm defined in PKCS #5/7. + * + * @param {WordArray} data The data to unpad. + * + * @static + * + * @example + * + * CryptoJS.pad.Pkcs7.unpad(wordArray); + */ + unpad: function (data) { + // Get number of padding bytes from last byte + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + + // Remove padding + data.sigBytes -= nPaddingBytes; + } + }; + + /** + * Abstract base block cipher template. + * + * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits) + */ + var BlockCipher = C_lib.BlockCipher = Cipher.extend({ + /** + * Configuration options. + * + * @property {Mode} mode The block mode to use. Default: CBC + * @property {Padding} padding The padding strategy to use. Default: Pkcs7 + */ + cfg: Cipher.cfg.extend({ + mode: CBC, + padding: Pkcs7 + }), + + reset: function () { + // Reset cipher + Cipher.reset.call(this); + + // Shortcuts + var cfg = this.cfg; + var iv = cfg.iv; + var mode = cfg.mode; + + // Reset block mode + if (this._xformMode == this._ENC_XFORM_MODE) { + var modeCreator = mode.createEncryptor; + } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { + var modeCreator = mode.createDecryptor; + // Keep at least one block in the buffer for unpadding + this._minBufferSize = 1; + } + + if (this._mode && this._mode.__creator == modeCreator) { + this._mode.init(this, iv && iv.words); + } else { + this._mode = modeCreator.call(mode, this, iv && iv.words); + this._mode.__creator = modeCreator; + } + }, + + _doProcessBlock: function (words, offset) { + this._mode.processBlock(words, offset); + }, + + _doFinalize: function () { + // Shortcut + var padding = this.cfg.padding; + + // Finalize + if (this._xformMode == this._ENC_XFORM_MODE) { + // Pad data + padding.pad(this._data, this.blockSize); + + // Process final blocks + var finalProcessedBlocks = this._process(!!'flush'); + } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { + // Process final blocks + var finalProcessedBlocks = this._process(!!'flush'); + + // Unpad data + padding.unpad(finalProcessedBlocks); + } + + return finalProcessedBlocks; + }, + + blockSize: 128/32 + }); + + /** + * A collection of cipher parameters. + * + * @property {WordArray} ciphertext The raw ciphertext. + * @property {WordArray} key The key to this ciphertext. + * @property {WordArray} iv The IV used in the ciphering operation. + * @property {WordArray} salt The salt used with a key derivation function. + * @property {Cipher} algorithm The cipher algorithm. + * @property {Mode} mode The block mode used in the ciphering operation. + * @property {Padding} padding The padding scheme used in the ciphering operation. + * @property {number} blockSize The block size of the cipher. + * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string. + */ + var CipherParams = C_lib.CipherParams = Base.extend({ + /** + * Initializes a newly created cipher params object. + * + * @param {Object} cipherParams An object with any of the possible cipher parameters. + * + * @example + * + * var cipherParams = CryptoJS.lib.CipherParams.create({ + * ciphertext: ciphertextWordArray, + * key: keyWordArray, + * iv: ivWordArray, + * salt: saltWordArray, + * algorithm: CryptoJS.algo.AES, + * mode: CryptoJS.mode.CBC, + * padding: CryptoJS.pad.PKCS7, + * blockSize: 4, + * formatter: CryptoJS.format.OpenSSL + * }); + */ + init: function (cipherParams) { + this.mixIn(cipherParams); + }, + + /** + * Converts this cipher params object to a string. + * + * @param {Format} formatter (Optional) The formatting strategy to use. + * + * @return {string} The stringified cipher params. + * + * @throws Error If neither the formatter nor the default formatter is set. + * + * @example + * + * var string = cipherParams + ''; + * var string = cipherParams.toString(); + * var string = cipherParams.toString(CryptoJS.format.OpenSSL); + */ + toString: function (formatter) { + return (formatter || this.formatter).stringify(this); + } + }); + + /** + * Format namespace. + */ + var C_format = C.format = {}; + + /** + * OpenSSL formatting strategy. + */ + var OpenSSLFormatter = C_format.OpenSSL = { + /** + * Converts a cipher params object to an OpenSSL-compatible string. + * + * @param {CipherParams} cipherParams The cipher params object. + * + * @return {string} The OpenSSL-compatible string. + * + * @static + * + * @example + * + * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams); + */ + stringify: function (cipherParams) { + // Shortcuts + var ciphertext = cipherParams.ciphertext; + var salt = cipherParams.salt; + + // Format + if (salt) { + var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext); + } else { + var wordArray = ciphertext; + } + + return wordArray.toString(Base64); + }, + + /** + * Converts an OpenSSL-compatible string to a cipher params object. + * + * @param {string} openSSLStr The OpenSSL-compatible string. + * + * @return {CipherParams} The cipher params object. + * + * @static + * + * @example + * + * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString); + */ + parse: function (openSSLStr) { + // Parse base64 + var ciphertext = Base64.parse(openSSLStr); + + // Shortcut + var ciphertextWords = ciphertext.words; + + // Test for salt + if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) { + // Extract salt + var salt = WordArray.create(ciphertextWords.slice(2, 4)); + + // Remove salt from ciphertext + ciphertextWords.splice(0, 4); + ciphertext.sigBytes -= 16; + } + + return CipherParams.create({ ciphertext: ciphertext, salt: salt }); + } + }; + + /** + * A cipher wrapper that returns ciphertext as a serializable cipher params object. + */ + var SerializableCipher = C_lib.SerializableCipher = Base.extend({ + /** + * Configuration options. + * + * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL + */ + cfg: Base.extend({ + format: OpenSSLFormatter + }), + + /** + * Encrypts a message. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {WordArray|string} message The message to encrypt. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {CipherParams} A cipher params object. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key); + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv }); + * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + */ + encrypt: function (cipher, message, key, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Encrypt + var encryptor = cipher.createEncryptor(key, cfg); + var ciphertext = encryptor.finalize(message); + + // Shortcut + var cipherCfg = encryptor.cfg; + + // Create and return serializable cipher params + return CipherParams.create({ + ciphertext: ciphertext, + key: key, + iv: cipherCfg.iv, + algorithm: cipher, + mode: cipherCfg.mode, + padding: cipherCfg.padding, + blockSize: cipher.blockSize, + formatter: cfg.format + }); + }, + + /** + * Decrypts serialized ciphertext. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {CipherParams|string} ciphertext The ciphertext to decrypt. + * @param {WordArray} key The key. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {WordArray} The plaintext. + * + * @static + * + * @example + * + * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL }); + */ + decrypt: function (cipher, ciphertext, key, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Convert string to CipherParams + ciphertext = this._parse(ciphertext, cfg.format); + + // Decrypt + var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext); + + return plaintext; + }, + + /** + * Converts serialized ciphertext to CipherParams, + * else assumed CipherParams already and returns ciphertext unchanged. + * + * @param {CipherParams|string} ciphertext The ciphertext. + * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext. + * + * @return {CipherParams} The unserialized ciphertext. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format); + */ + _parse: function (ciphertext, format) { + if (typeof ciphertext == 'string') { + return format.parse(ciphertext, this); + } else { + return ciphertext; + } + } + }); + + /** + * Key derivation function namespace. + */ + var C_kdf = C.kdf = {}; + + /** + * OpenSSL key derivation function. + */ + var OpenSSLKdf = C_kdf.OpenSSL = { + /** + * Derives a key and IV from a password. + * + * @param {string} password The password to derive from. + * @param {number} keySize The size in words of the key to generate. + * @param {number} ivSize The size in words of the IV to generate. + * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly. + * + * @return {CipherParams} A cipher params object with the key, IV, and salt. + * + * @static + * + * @example + * + * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32); + * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt'); + */ + execute: function (password, keySize, ivSize, salt) { + // Generate random salt + if (!salt) { + salt = WordArray.random(64/8); + } + + // Derive key and IV + var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt); + + // Separate key and IV + var iv = WordArray.create(key.words.slice(keySize), ivSize * 4); + key.sigBytes = keySize * 4; + + // Return params + return CipherParams.create({ key: key, iv: iv, salt: salt }); + } + }; + + /** + * A serializable cipher wrapper that derives the key from a password, + * and returns ciphertext as a serializable cipher params object. + */ + var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({ + /** + * Configuration options. + * + * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL + */ + cfg: SerializableCipher.cfg.extend({ + kdf: OpenSSLKdf + }), + + /** + * Encrypts a message using a password. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {WordArray|string} message The message to encrypt. + * @param {string} password The password. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {CipherParams} A cipher params object. + * + * @static + * + * @example + * + * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password'); + * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL }); + */ + encrypt: function (cipher, message, password, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Derive key and other params + var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize); + + // Add IV to config + cfg.iv = derivedParams.iv; + + // Encrypt + var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg); + + // Mix in derived params + ciphertext.mixIn(derivedParams); + + return ciphertext; + }, + + /** + * Decrypts serialized ciphertext using a password. + * + * @param {Cipher} cipher The cipher algorithm to use. + * @param {CipherParams|string} ciphertext The ciphertext to decrypt. + * @param {string} password The password. + * @param {Object} cfg (Optional) The configuration options to use for this operation. + * + * @return {WordArray} The plaintext. + * + * @static + * + * @example + * + * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL }); + * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL }); + */ + decrypt: function (cipher, ciphertext, password, cfg) { + // Apply config defaults + cfg = this.cfg.extend(cfg); + + // Convert string to CipherParams + ciphertext = this._parse(ciphertext, cfg.format); + + // Derive key and other params + var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt); + + // Add IV to config + cfg.iv = derivedParams.iv; + + // Decrypt + var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg); + + return plaintext; + } + }); + }()); + + +})); +},{"47":47,"50":50}],47:[function(require,module,exports){ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(); + } + else if (typeof define === "function" && define.amd) { + // AMD + define([], factory); + } + else { + // Global (browser) + root.CryptoJS = factory(); + } +}(this, function () { + + /** + * CryptoJS core components. + */ + var CryptoJS = CryptoJS || (function (Math, undefined) { + /* + * Local polyfil of Object.create + */ + var create = Object.create || (function () { + function F() {}; + + return function (obj) { + var subtype; + + F.prototype = obj; + + subtype = new F(); + + F.prototype = null; + + return subtype; + }; + }()) + + /** + * CryptoJS namespace. + */ + var C = {}; + + /** + * Library namespace. + */ + var C_lib = C.lib = {}; + + /** + * Base object for prototypal inheritance. + */ + var Base = C_lib.Base = (function () { + + + return { + /** + * Creates a new object that inherits from this object. + * + * @param {Object} overrides Properties to copy into the new object. + * + * @return {Object} The new object. + * + * @static + * + * @example + * + * var MyType = CryptoJS.lib.Base.extend({ + * field: 'value', + * + * method: function () { + * } + * }); + */ + extend: function (overrides) { + // Spawn + var subtype = create(this); + + // Augment + if (overrides) { + subtype.mixIn(overrides); + } + + // Create default initializer + if (!subtype.hasOwnProperty('init') || this.init === subtype.init) { + subtype.init = function () { + subtype.$super.init.apply(this, arguments); + }; + } + + // Initializer's prototype is the subtype object + subtype.init.prototype = subtype; + + // Reference supertype + subtype.$super = this; + + return subtype; + }, + + /** + * Extends this object and runs the init method. + * Arguments to create() will be passed to init(). + * + * @return {Object} The new object. + * + * @static + * + * @example + * + * var instance = MyType.create(); + */ + create: function () { + var instance = this.extend(); + instance.init.apply(instance, arguments); + + return instance; + }, + + /** + * Initializes a newly created object. + * Override this method to add some logic when your objects are created. + * + * @example + * + * var MyType = CryptoJS.lib.Base.extend({ + * init: function () { + * // ... + * } + * }); + */ + init: function () { + }, + + /** + * Copies properties into this object. + * + * @param {Object} properties The properties to mix in. + * + * @example + * + * MyType.mixIn({ + * field: 'value' + * }); + */ + mixIn: function (properties) { + for (var propertyName in properties) { + if (properties.hasOwnProperty(propertyName)) { + this[propertyName] = properties[propertyName]; + } + } + + // IE won't copy toString using the loop above + if (properties.hasOwnProperty('toString')) { + this.toString = properties.toString; + } + }, + + /** + * Creates a copy of this object. + * + * @return {Object} The clone. + * + * @example + * + * var clone = instance.clone(); + */ + clone: function () { + return this.init.prototype.extend(this); + } + }; + }()); + + /** + * An array of 32-bit words. + * + * @property {Array} words The array of 32-bit words. + * @property {number} sigBytes The number of significant bytes in this word array. + */ + var WordArray = C_lib.WordArray = Base.extend({ + /** + * Initializes a newly created word array. + * + * @param {Array} words (Optional) An array of 32-bit words. + * @param {number} sigBytes (Optional) The number of significant bytes in the words. + * + * @example + * + * var wordArray = CryptoJS.lib.WordArray.create(); + * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]); + * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6); + */ + init: function (words, sigBytes) { + words = this.words = words || []; + + if (sigBytes != undefined) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 4; + } + }, + + /** + * Converts this word array to a string. + * + * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex + * + * @return {string} The stringified word array. + * + * @example + * + * var string = wordArray + ''; + * var string = wordArray.toString(); + * var string = wordArray.toString(CryptoJS.enc.Utf8); + */ + toString: function (encoder) { + return (encoder || Hex).stringify(this); + }, + + /** + * Concatenates a word array to this word array. + * + * @param {WordArray} wordArray The word array to append. + * + * @return {WordArray} This word array. + * + * @example + * + * wordArray1.concat(wordArray2); + */ + concat: function (wordArray) { + // Shortcuts + var thisWords = this.words; + var thatWords = wordArray.words; + var thisSigBytes = this.sigBytes; + var thatSigBytes = wordArray.sigBytes; + + // Clamp excess bits + this.clamp(); + + // Concat + if (thisSigBytes % 4) { + // Copy one byte at a time + for (var i = 0; i < thatSigBytes; i++) { + var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8); + } + } else { + // Copy one word at a time + for (var i = 0; i < thatSigBytes; i += 4) { + thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2]; + } + } + this.sigBytes += thatSigBytes; + + // Chainable + return this; + }, + + /** + * Removes insignificant bits. + * + * @example + * + * wordArray.clamp(); + */ + clamp: function () { + // Shortcuts + var words = this.words; + var sigBytes = this.sigBytes; + + // Clamp + words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); + words.length = Math.ceil(sigBytes / 4); + }, + + /** + * Creates a copy of this word array. + * + * @return {WordArray} The clone. + * + * @example + * + * var clone = wordArray.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + clone.words = this.words.slice(0); + + return clone; + }, + + /** + * Creates a word array filled with random bytes. + * + * @param {number} nBytes The number of random bytes to generate. + * + * @return {WordArray} The random word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.lib.WordArray.random(16); + */ + random: function (nBytes) { + var words = []; + + var r = (function (m_w) { + var m_w = m_w; + var m_z = 0x3ade68b1; + var mask = 0xffffffff; + + return function () { + m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask; + m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask; + var result = ((m_z << 0x10) + m_w) & mask; + result /= 0x100000000; + result += 0.5; + return result * (Math.random() > .5 ? 1 : -1); + } + }); + + for (var i = 0, rcache; i < nBytes; i += 4) { + var _r = r((rcache || Math.random()) * 0x100000000); + + rcache = _r() * 0x3ade67b7; + words.push((_r() * 0x100000000) | 0); + } + + return new WordArray.init(words, nBytes); + } + }); + + /** + * Encoder namespace. + */ + var C_enc = C.enc = {}; + + /** + * Hex encoding strategy. + */ + var Hex = C_enc.Hex = { + /** + * Converts a word array to a hex string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The hex string. + * + * @static + * + * @example + * + * var hexString = CryptoJS.enc.Hex.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var hexChars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + hexChars.push((bite >>> 4).toString(16)); + hexChars.push((bite & 0x0f).toString(16)); + } + + return hexChars.join(''); + }, + + /** + * Converts a hex string to a word array. + * + * @param {string} hexStr The hex string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Hex.parse(hexString); + */ + parse: function (hexStr) { + // Shortcut + var hexStrLength = hexStr.length; + + // Convert + var words = []; + for (var i = 0; i < hexStrLength; i += 2) { + words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4); + } + + return new WordArray.init(words, hexStrLength / 2); + } + }; + + /** + * Latin1 encoding strategy. + */ + var Latin1 = C_enc.Latin1 = { + /** + * Converts a word array to a Latin1 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The Latin1 string. + * + * @static + * + * @example + * + * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + + // Convert + var latin1Chars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + latin1Chars.push(String.fromCharCode(bite)); + } + + return latin1Chars.join(''); + }, + + /** + * Converts a Latin1 string to a word array. + * + * @param {string} latin1Str The Latin1 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Latin1.parse(latin1String); + */ + parse: function (latin1Str) { + // Shortcut + var latin1StrLength = latin1Str.length; + + // Convert + var words = []; + for (var i = 0; i < latin1StrLength; i++) { + words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8); + } + + return new WordArray.init(words, latin1StrLength); + } + }; + + /** + * UTF-8 encoding strategy. + */ + var Utf8 = C_enc.Utf8 = { + /** + * Converts a word array to a UTF-8 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The UTF-8 string. + * + * @static + * + * @example + * + * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray); + */ + stringify: function (wordArray) { + try { + return decodeURIComponent(escape(Latin1.stringify(wordArray))); + } catch (e) { + throw new Error('Malformed UTF-8 data'); + } + }, + + /** + * Converts a UTF-8 string to a word array. + * + * @param {string} utf8Str The UTF-8 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Utf8.parse(utf8String); + */ + parse: function (utf8Str) { + return Latin1.parse(unescape(encodeURIComponent(utf8Str))); + } + }; + + /** + * Abstract buffered block algorithm template. + * + * The property blockSize must be implemented in a concrete subtype. + * + * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0 + */ + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({ + /** + * Resets this block algorithm's data buffer to its initial state. + * + * @example + * + * bufferedBlockAlgorithm.reset(); + */ + reset: function () { + // Initial values + this._data = new WordArray.init(); + this._nDataBytes = 0; + }, + + /** + * Adds new data to this block algorithm's buffer. + * + * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8. + * + * @example + * + * bufferedBlockAlgorithm._append('data'); + * bufferedBlockAlgorithm._append(wordArray); + */ + _append: function (data) { + // Convert string to WordArray, else assume WordArray already + if (typeof data == 'string') { + data = Utf8.parse(data); + } + + // Append + this._data.concat(data); + this._nDataBytes += data.sigBytes; + }, + + /** + * Processes available data blocks. + * + * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype. + * + * @param {boolean} doFlush Whether all blocks and partial blocks should be processed. + * + * @return {WordArray} The processed data. + * + * @example + * + * var processedData = bufferedBlockAlgorithm._process(); + * var processedData = bufferedBlockAlgorithm._process(!!'flush'); + */ + _process: function (doFlush) { + // Shortcuts + var data = this._data; + var dataWords = data.words; + var dataSigBytes = data.sigBytes; + var blockSize = this.blockSize; + var blockSizeBytes = blockSize * 4; + + // Count blocks ready + var nBlocksReady = dataSigBytes / blockSizeBytes; + if (doFlush) { + // Round up to include partial blocks + nBlocksReady = Math.ceil(nBlocksReady); + } else { + // Round down to include only full blocks, + // less the number of blocks that must remain in the buffer + nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0); + } + + // Count words ready + var nWordsReady = nBlocksReady * blockSize; + + // Count bytes ready + var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); + + // Process blocks + if (nWordsReady) { + for (var offset = 0; offset < nWordsReady; offset += blockSize) { + // Perform concrete-algorithm logic + this._doProcessBlock(dataWords, offset); + } + + // Remove processed words + var processedWords = dataWords.splice(0, nWordsReady); + data.sigBytes -= nBytesReady; + } + + // Return processed words + return new WordArray.init(processedWords, nBytesReady); + }, + + /** + * Creates a copy of this object. + * + * @return {Object} The clone. + * + * @example + * + * var clone = bufferedBlockAlgorithm.clone(); + */ + clone: function () { + var clone = Base.clone.call(this); + clone._data = this._data.clone(); + + return clone; + }, + + _minBufferSize: 0 + }); + + /** + * Abstract hasher template. + * + * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits) + */ + var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({ + /** + * Configuration options. + */ + cfg: Base.extend(), + + /** + * Initializes a newly created hasher. + * + * @param {Object} cfg (Optional) The configuration options to use for this hash computation. + * + * @example + * + * var hasher = CryptoJS.algo.SHA256.create(); + */ + init: function (cfg) { + // Apply config defaults + this.cfg = this.cfg.extend(cfg); + + // Set initial values + this.reset(); + }, + + /** + * Resets this hasher to its initial state. + * + * @example + * + * hasher.reset(); + */ + reset: function () { + // Reset data buffer + BufferedBlockAlgorithm.reset.call(this); + + // Perform concrete-hasher logic + this._doReset(); + }, + + /** + * Updates this hasher with a message. + * + * @param {WordArray|string} messageUpdate The message to append. + * + * @return {Hasher} This hasher. + * + * @example + * + * hasher.update('message'); + * hasher.update(wordArray); + */ + update: function (messageUpdate) { + // Append + this._append(messageUpdate); + + // Update the hash + this._process(); + + // Chainable + return this; + }, + + /** + * Finalizes the hash computation. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} messageUpdate (Optional) A final message update. + * + * @return {WordArray} The hash. + * + * @example + * + * var hash = hasher.finalize(); + * var hash = hasher.finalize('message'); + * var hash = hasher.finalize(wordArray); + */ + finalize: function (messageUpdate) { + // Final message update + if (messageUpdate) { + this._append(messageUpdate); + } + + // Perform concrete-hasher logic + var hash = this._doFinalize(); + + return hash; + }, + + blockSize: 512/32, + + /** + * Creates a shortcut function to a hasher's object interface. + * + * @param {Hasher} hasher The hasher to create a helper for. + * + * @return {Function} The shortcut function. + * + * @static + * + * @example + * + * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256); + */ + _createHelper: function (hasher) { + return function (message, cfg) { + return new hasher.init(cfg).finalize(message); + }; + }, + + /** + * Creates a shortcut function to the HMAC's object interface. + * + * @param {Hasher} hasher The hasher to use in this HMAC helper. + * + * @return {Function} The shortcut function. + * + * @static + * + * @example + * + * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256); + */ + _createHmacHelper: function (hasher) { + return function (message, key) { + return new C_algo.HMAC.init(hasher, key).finalize(message); + }; + } + }); + + /** + * Algorithm namespace. + */ + var C_algo = C.algo = {}; + + return C; + }(Math)); + + + return CryptoJS; + +})); +},{}],48:[function(require,module,exports){ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + + /** + * Base64 encoding strategy. + */ + var Base64 = C_enc.Base64 = { + /** + * Converts a word array to a Base64 string. + * + * @param {WordArray} wordArray The word array. + * + * @return {string} The Base64 string. + * + * @static + * + * @example + * + * var base64String = CryptoJS.enc.Base64.stringify(wordArray); + */ + stringify: function (wordArray) { + // Shortcuts + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var map = this._map; + + // Clamp excess bits + wordArray.clamp(); + + // Convert + var base64Chars = []; + for (var i = 0; i < sigBytes; i += 3) { + var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; + var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; + + var triplet = (byte1 << 16) | (byte2 << 8) | byte3; + + for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { + base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); + } + } + + // Add padding + var paddingChar = map.charAt(64); + if (paddingChar) { + while (base64Chars.length % 4) { + base64Chars.push(paddingChar); + } + } + + return base64Chars.join(''); + }, + + /** + * Converts a Base64 string to a word array. + * + * @param {string} base64Str The Base64 string. + * + * @return {WordArray} The word array. + * + * @static + * + * @example + * + * var wordArray = CryptoJS.enc.Base64.parse(base64String); + */ + parse: function (base64Str) { + // Shortcuts + var base64StrLength = base64Str.length; + var map = this._map; + var reverseMap = this._reverseMap; + + if (!reverseMap) { + reverseMap = this._reverseMap = []; + for (var j = 0; j < map.length; j++) { + reverseMap[map.charCodeAt(j)] = j; + } + } + + // Ignore padding + var paddingChar = map.charAt(64); + if (paddingChar) { + var paddingIndex = base64Str.indexOf(paddingChar); + if (paddingIndex !== -1) { + base64StrLength = paddingIndex; + } + } + + // Convert + return parseLoop(base64Str, base64StrLength, reverseMap); + + }, + + _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' + }; + + function parseLoop(base64Str, base64StrLength, reverseMap) { + var words = []; + var nBytes = 0; + for (var i = 0; i < base64StrLength; i++) { + if (i % 4) { + var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); + var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); + words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8); + nBytes++; + } + } + return WordArray.create(words, nBytes); + } + }()); + + + return CryptoJS.enc.Base64; + +})); +},{"47":47}],49:[function(require,module,exports){ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + return CryptoJS.enc.Hex; + +})); +},{"47":47}],50:[function(require,module,exports){ +;(function (root, factory, undef) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47), require(53), require(51)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core", "./sha1", "./hmac"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var C_algo = C.algo; + var MD5 = C_algo.MD5; + + /** + * This key derivation function is meant to conform with EVP_BytesToKey. + * www.openssl.org/docs/crypto/EVP_BytesToKey.html + */ + var EvpKDF = C_algo.EvpKDF = Base.extend({ + /** + * Configuration options. + * + * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) + * @property {Hasher} hasher The hash algorithm to use. Default: MD5 + * @property {number} iterations The number of iterations to perform. Default: 1 + */ + cfg: Base.extend({ + keySize: 128/32, + hasher: MD5, + iterations: 1 + }), + + /** + * Initializes a newly created key derivation function. + * + * @param {Object} cfg (Optional) The configuration options to use for the derivation. + * + * @example + * + * var kdf = CryptoJS.algo.EvpKDF.create(); + * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 }); + * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 }); + */ + init: function (cfg) { + this.cfg = this.cfg.extend(cfg); + }, + + /** + * Derives a key from a password. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * + * @return {WordArray} The derived key. + * + * @example + * + * var key = kdf.compute(password, salt); + */ + compute: function (password, salt) { + // Shortcut + var cfg = this.cfg; + + // Init hasher + var hasher = cfg.hasher.create(); + + // Initial values + var derivedKey = WordArray.create(); + + // Shortcuts + var derivedKeyWords = derivedKey.words; + var keySize = cfg.keySize; + var iterations = cfg.iterations; + + // Generate key + while (derivedKeyWords.length < keySize) { + if (block) { + hasher.update(block); + } + var block = hasher.update(password).finalize(salt); + hasher.reset(); + + // Iterations + for (var i = 1; i < iterations; i++) { + block = hasher.finalize(block); + hasher.reset(); + } + + derivedKey.concat(block); + } + derivedKey.sigBytes = keySize * 4; + + return derivedKey; + } + }); + + /** + * Derives a key from a password. + * + * @param {WordArray|string} password The password. + * @param {WordArray|string} salt A salt. + * @param {Object} cfg (Optional) The configuration options to use for this computation. + * + * @return {WordArray} The derived key. + * + * @static + * + * @example + * + * var key = CryptoJS.EvpKDF(password, salt); + * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 }); + * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 }); + */ + C.EvpKDF = function (password, salt, cfg) { + return EvpKDF.create(cfg).compute(password, salt); + }; + }()); + + + return CryptoJS.EvpKDF; + +})); +},{"47":47,"51":51,"53":53}],51:[function(require,module,exports){ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var C_algo = C.algo; + + /** + * HMAC algorithm. + */ + var HMAC = C_algo.HMAC = Base.extend({ + /** + * Initializes a newly created HMAC. + * + * @param {Hasher} hasher The hash algorithm to use. + * @param {WordArray|string} key The secret key. + * + * @example + * + * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key); + */ + init: function (hasher, key) { + // Init hasher + hasher = this._hasher = new hasher.init(); + + // Convert string to WordArray, else assume WordArray already + if (typeof key == 'string') { + key = Utf8.parse(key); + } + + // Shortcuts + var hasherBlockSize = hasher.blockSize; + var hasherBlockSizeBytes = hasherBlockSize * 4; + + // Allow arbitrary length keys + if (key.sigBytes > hasherBlockSizeBytes) { + key = hasher.finalize(key); + } + + // Clamp excess bits + key.clamp(); + + // Clone key for inner and outer pads + var oKey = this._oKey = key.clone(); + var iKey = this._iKey = key.clone(); + + // Shortcuts + var oKeyWords = oKey.words; + var iKeyWords = iKey.words; + + // XOR keys with pad constants + for (var i = 0; i < hasherBlockSize; i++) { + oKeyWords[i] ^= 0x5c5c5c5c; + iKeyWords[i] ^= 0x36363636; + } + oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes; + + // Set initial values + this.reset(); + }, + + /** + * Resets this HMAC to its initial state. + * + * @example + * + * hmacHasher.reset(); + */ + reset: function () { + // Shortcut + var hasher = this._hasher; + + // Reset + hasher.reset(); + hasher.update(this._iKey); + }, + + /** + * Updates this HMAC with a message. + * + * @param {WordArray|string} messageUpdate The message to append. + * + * @return {HMAC} This HMAC instance. + * + * @example + * + * hmacHasher.update('message'); + * hmacHasher.update(wordArray); + */ + update: function (messageUpdate) { + this._hasher.update(messageUpdate); + + // Chainable + return this; + }, + + /** + * Finalizes the HMAC computation. + * Note that the finalize operation is effectively a destructive, read-once operation. + * + * @param {WordArray|string} messageUpdate (Optional) A final message update. + * + * @return {WordArray} The HMAC. + * + * @example + * + * var hmac = hmacHasher.finalize(); + * var hmac = hmacHasher.finalize('message'); + * var hmac = hmacHasher.finalize(wordArray); + */ + finalize: function (messageUpdate) { + // Shortcut + var hasher = this._hasher; + + // Compute HMAC + var innerHash = hasher.finalize(messageUpdate); + hasher.reset(); + var hmac = hasher.finalize(this._oKey.clone().concat(innerHash)); + + return hmac; + } + }); + }()); + + +})); +},{"47":47}],52:[function(require,module,exports){ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function (Math) { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Constants table + var T = []; + + // Compute constants + (function () { + for (var i = 0; i < 64; i++) { + T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0; + } + }()); + + /** + * MD5 hash algorithm. + */ + var MD5 = C_algo.MD5 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0x67452301, 0xefcdab89, + 0x98badcfe, 0x10325476 + ]); + }, + + _doProcessBlock: function (M, offset) { + // Swap endian + for (var i = 0; i < 16; i++) { + // Shortcuts + var offset_i = offset + i; + var M_offset_i = M[offset_i]; + + M[offset_i] = ( + (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | + (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) + ); + } + + // Shortcuts + var H = this._hash.words; + + var M_offset_0 = M[offset + 0]; + var M_offset_1 = M[offset + 1]; + var M_offset_2 = M[offset + 2]; + var M_offset_3 = M[offset + 3]; + var M_offset_4 = M[offset + 4]; + var M_offset_5 = M[offset + 5]; + var M_offset_6 = M[offset + 6]; + var M_offset_7 = M[offset + 7]; + var M_offset_8 = M[offset + 8]; + var M_offset_9 = M[offset + 9]; + var M_offset_10 = M[offset + 10]; + var M_offset_11 = M[offset + 11]; + var M_offset_12 = M[offset + 12]; + var M_offset_13 = M[offset + 13]; + var M_offset_14 = M[offset + 14]; + var M_offset_15 = M[offset + 15]; + + // Working varialbes + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + + // Computation + a = FF(a, b, c, d, M_offset_0, 7, T[0]); + d = FF(d, a, b, c, M_offset_1, 12, T[1]); + c = FF(c, d, a, b, M_offset_2, 17, T[2]); + b = FF(b, c, d, a, M_offset_3, 22, T[3]); + a = FF(a, b, c, d, M_offset_4, 7, T[4]); + d = FF(d, a, b, c, M_offset_5, 12, T[5]); + c = FF(c, d, a, b, M_offset_6, 17, T[6]); + b = FF(b, c, d, a, M_offset_7, 22, T[7]); + a = FF(a, b, c, d, M_offset_8, 7, T[8]); + d = FF(d, a, b, c, M_offset_9, 12, T[9]); + c = FF(c, d, a, b, M_offset_10, 17, T[10]); + b = FF(b, c, d, a, M_offset_11, 22, T[11]); + a = FF(a, b, c, d, M_offset_12, 7, T[12]); + d = FF(d, a, b, c, M_offset_13, 12, T[13]); + c = FF(c, d, a, b, M_offset_14, 17, T[14]); + b = FF(b, c, d, a, M_offset_15, 22, T[15]); + + a = GG(a, b, c, d, M_offset_1, 5, T[16]); + d = GG(d, a, b, c, M_offset_6, 9, T[17]); + c = GG(c, d, a, b, M_offset_11, 14, T[18]); + b = GG(b, c, d, a, M_offset_0, 20, T[19]); + a = GG(a, b, c, d, M_offset_5, 5, T[20]); + d = GG(d, a, b, c, M_offset_10, 9, T[21]); + c = GG(c, d, a, b, M_offset_15, 14, T[22]); + b = GG(b, c, d, a, M_offset_4, 20, T[23]); + a = GG(a, b, c, d, M_offset_9, 5, T[24]); + d = GG(d, a, b, c, M_offset_14, 9, T[25]); + c = GG(c, d, a, b, M_offset_3, 14, T[26]); + b = GG(b, c, d, a, M_offset_8, 20, T[27]); + a = GG(a, b, c, d, M_offset_13, 5, T[28]); + d = GG(d, a, b, c, M_offset_2, 9, T[29]); + c = GG(c, d, a, b, M_offset_7, 14, T[30]); + b = GG(b, c, d, a, M_offset_12, 20, T[31]); + + a = HH(a, b, c, d, M_offset_5, 4, T[32]); + d = HH(d, a, b, c, M_offset_8, 11, T[33]); + c = HH(c, d, a, b, M_offset_11, 16, T[34]); + b = HH(b, c, d, a, M_offset_14, 23, T[35]); + a = HH(a, b, c, d, M_offset_1, 4, T[36]); + d = HH(d, a, b, c, M_offset_4, 11, T[37]); + c = HH(c, d, a, b, M_offset_7, 16, T[38]); + b = HH(b, c, d, a, M_offset_10, 23, T[39]); + a = HH(a, b, c, d, M_offset_13, 4, T[40]); + d = HH(d, a, b, c, M_offset_0, 11, T[41]); + c = HH(c, d, a, b, M_offset_3, 16, T[42]); + b = HH(b, c, d, a, M_offset_6, 23, T[43]); + a = HH(a, b, c, d, M_offset_9, 4, T[44]); + d = HH(d, a, b, c, M_offset_12, 11, T[45]); + c = HH(c, d, a, b, M_offset_15, 16, T[46]); + b = HH(b, c, d, a, M_offset_2, 23, T[47]); + + a = II(a, b, c, d, M_offset_0, 6, T[48]); + d = II(d, a, b, c, M_offset_7, 10, T[49]); + c = II(c, d, a, b, M_offset_14, 15, T[50]); + b = II(b, c, d, a, M_offset_5, 21, T[51]); + a = II(a, b, c, d, M_offset_12, 6, T[52]); + d = II(d, a, b, c, M_offset_3, 10, T[53]); + c = II(c, d, a, b, M_offset_10, 15, T[54]); + b = II(b, c, d, a, M_offset_1, 21, T[55]); + a = II(a, b, c, d, M_offset_8, 6, T[56]); + d = II(d, a, b, c, M_offset_15, 10, T[57]); + c = II(c, d, a, b, M_offset_6, 15, T[58]); + b = II(b, c, d, a, M_offset_13, 21, T[59]); + a = II(a, b, c, d, M_offset_4, 6, T[60]); + d = II(d, a, b, c, M_offset_11, 10, T[61]); + c = II(c, d, a, b, M_offset_2, 15, T[62]); + b = II(b, c, d, a, M_offset_9, 21, T[63]); + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + + var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000); + var nBitsTotalL = nBitsTotal; + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = ( + (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) | + (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00) + ); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( + (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) | + (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00) + ); + + data.sigBytes = (dataWords.length + 1) * 4; + + // Hash final blocks + this._process(); + + // Shortcuts + var hash = this._hash; + var H = hash.words; + + // Swap endian + for (var i = 0; i < 4; i++) { + // Shortcut + var H_i = H[i]; + + H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | + (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); + } + + // Return final computed hash + return hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + function FF(a, b, c, d, x, s, t) { + var n = a + ((b & c) | (~b & d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function GG(a, b, c, d, x, s, t) { + var n = a + ((b & d) | (c & ~d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function HH(a, b, c, d, x, s, t) { + var n = a + (b ^ c ^ d) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + function II(a, b, c, d, x, s, t) { + var n = a + (c ^ (b | ~d)) + x + t; + return ((n << s) | (n >>> (32 - s))) + b; + } + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.MD5('message'); + * var hash = CryptoJS.MD5(wordArray); + */ + C.MD5 = Hasher._createHelper(MD5); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacMD5(message, key); + */ + C.HmacMD5 = Hasher._createHmacHelper(MD5); + }(Math)); + + + return CryptoJS.MD5; + +})); +},{"47":47}],53:[function(require,module,exports){ +;(function (root, factory) { + if (typeof exports === "object") { + // CommonJS + module.exports = exports = factory(require(47)); + } + else if (typeof define === "function" && define.amd) { + // AMD + define(["./core"], factory); + } + else { + // Global (browser) + factory(root.CryptoJS); + } +}(this, function (CryptoJS) { + + (function () { + // Shortcuts + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + + // Reusable object + var W = []; + + /** + * SHA-1 hash algorithm. + */ + var SHA1 = C_algo.SHA1 = Hasher.extend({ + _doReset: function () { + this._hash = new WordArray.init([ + 0x67452301, 0xefcdab89, + 0x98badcfe, 0x10325476, + 0xc3d2e1f0 + ]); + }, + + _doProcessBlock: function (M, offset) { + // Shortcut + var H = this._hash.words; + + // Working variables + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + + // Computation + for (var i = 0; i < 80; i++) { + if (i < 16) { + W[i] = M[offset + i] | 0; + } else { + var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; + W[i] = (n << 1) | (n >>> 31); + } + + var t = ((a << 5) | (a >>> 27)) + e + W[i]; + if (i < 20) { + t += ((b & c) | (~b & d)) + 0x5a827999; + } else if (i < 40) { + t += (b ^ c ^ d) + 0x6ed9eba1; + } else if (i < 60) { + t += ((b & c) | (b & d) | (c & d)) - 0x70e44324; + } else /* if (i < 80) */ { + t += (b ^ c ^ d) - 0x359d3e2a; + } + + e = d; + d = c; + c = (b << 30) | (b >>> 2); + b = a; + a = t; + } + + // Intermediate hash value + H[0] = (H[0] + a) | 0; + H[1] = (H[1] + b) | 0; + H[2] = (H[2] + c) | 0; + H[3] = (H[3] + d) | 0; + H[4] = (H[4] + e) | 0; + }, + + _doFinalize: function () { + // Shortcuts + var data = this._data; + var dataWords = data.words; + + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + + // Add padding + dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); + dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + + // Hash final blocks + this._process(); + + // Return final computed hash + return this._hash; + }, + + clone: function () { + var clone = Hasher.clone.call(this); + clone._hash = this._hash.clone(); + + return clone; + } + }); + + /** + * Shortcut function to the hasher's object interface. + * + * @param {WordArray|string} message The message to hash. + * + * @return {WordArray} The hash. + * + * @static + * + * @example + * + * var hash = CryptoJS.SHA1('message'); + * var hash = CryptoJS.SHA1(wordArray); + */ + C.SHA1 = Hasher._createHelper(SHA1); + + /** + * Shortcut function to the HMAC's object interface. + * + * @param {WordArray|string} message The message to hash. + * @param {WordArray|string} key The secret key. + * + * @return {WordArray} The HMAC. + * + * @static + * + * @example + * + * var hmac = CryptoJS.HmacSHA1(message, key); + */ + C.HmacSHA1 = Hasher._createHmacHelper(SHA1); + }()); + + + return CryptoJS.SHA1; + +})); +},{"47":47}],54:[function(require,module,exports){ +var pSlice = Array.prototype.slice; +var objectKeys = require(56); +var isArguments = require(55); + +var deepEqual = module.exports = function (actual, expected, opts) { + if (!opts) opts = {}; + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + + } else if (actual instanceof Date && expected instanceof Date) { + return actual.getTime() === expected.getTime(); + + // 7.3. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') { + return opts.strict ? actual === expected : actual == expected; + + // 7.4. For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else { + return objEquiv(actual, expected, opts); + } +} + +function isUndefinedOrNull(value) { + return value === null || value === undefined; +} + +function isBuffer (x) { + if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false; + if (typeof x.copy !== 'function' || typeof x.slice !== 'function') { + return false; + } + if (x.length > 0 && typeof x[0] !== 'number') return false; + return true; +} + +function objEquiv(a, b, opts) { + var i, key; + if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) + return false; + // an identical 'prototype' property. + if (a.prototype !== b.prototype) return false; + //~~~I've managed to break Object.keys through screwy arguments passing. + // Converting to array solves the problem. + if (isArguments(a)) { + if (!isArguments(b)) { + return false; + } + a = pSlice.call(a); + b = pSlice.call(b); + return deepEqual(a, b, opts); + } + if (isBuffer(a)) { + if (!isBuffer(b)) { + return false; + } + if (a.length !== b.length) return false; + for (i = 0; i < a.length; i++) { + if (a[i] !== b[i]) return false; + } + return true; + } + try { + var ka = objectKeys(a), + kb = objectKeys(b); + } catch (e) {//happens when one is a string literal and the other isn't + return false; + } + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length != kb.length) + return false; + //the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + //~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] != kb[i]) + return false; + } + //equivalent values for every corresponding key, and + //~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!deepEqual(a[key], b[key], opts)) return false; + } + return typeof a === typeof b; +} + +},{"55":55,"56":56}],55:[function(require,module,exports){ +var supportsArgumentsClass = (function(){ + return Object.prototype.toString.call(arguments) +})() == '[object Arguments]'; + +exports = module.exports = supportsArgumentsClass ? supported : unsupported; + +exports.supported = supported; +function supported(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +}; + +exports.unsupported = unsupported; +function unsupported(object){ + return object && + typeof object == 'object' && + typeof object.length == 'number' && + Object.prototype.hasOwnProperty.call(object, 'callee') && + !Object.prototype.propertyIsEnumerable.call(object, 'callee') || + false; +}; + +},{}],56:[function(require,module,exports){ +exports = module.exports = typeof Object.keys === 'function' + ? Object.keys : shim; + +exports.shim = shim; +function shim (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +} + +},{}],57:[function(require,module,exports){ +var assert = require(27) +var BigInteger = require(32) + +var Point = require(61) + +function Curve (p, a, b, Gx, Gy, n, h) { + this.p = p + this.a = a + this.b = b + this.G = Point.fromAffine(this, Gx, Gy) + this.n = n + this.h = h + + this.infinity = new Point(this, null, null, BigInteger.ZERO) + + // result caching + this.pOverFour = p.add(BigInteger.ONE).shiftRight(2) + + // determine size of p in bytes + this.pLength = Math.floor((this.p.bitLength() + 7) / 8) +} + +Curve.prototype.pointFromX = function (isOdd, x) { + var alpha = x.pow(3).add(this.a.multiply(x)).add(this.b).mod(this.p) + var beta = alpha.modPow(this.pOverFour, this.p) // XXX: not compatible with all curves + + var y = beta + if (beta.isEven() ^ !isOdd) { + y = this.p.subtract(y) // -y % p + } + + return Point.fromAffine(this, x, y) +} + +Curve.prototype.isInfinity = function (Q) { + if (Q === this.infinity) return true + + return Q.z.signum() === 0 && Q.y.signum() !== 0 +} + +Curve.prototype.isOnCurve = function (Q) { + if (this.isInfinity(Q)) return true + + var x = Q.affineX + var y = Q.affineY + var a = this.a + var b = this.b + var p = this.p + + // Check that xQ and yQ are integers in the interval [0, p - 1] + if (x.signum() < 0 || x.compareTo(p) >= 0) return false + if (y.signum() < 0 || y.compareTo(p) >= 0) return false + + // and check that y^2 = x^3 + ax + b (mod p) + var lhs = y.square().mod(p) + var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p) + return lhs.equals(rhs) +} + +/** + * Validate an elliptic curve point. + * + * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive + */ +Curve.prototype.validate = function (Q) { + // Check Q != O + assert(!this.isInfinity(Q), 'Point is at infinity') + assert(this.isOnCurve(Q), 'Point is not on the curve') + + // Check nQ = O (where Q is a scalar multiple of G) + var nQ = Q.multiply(this.n) + assert(this.isInfinity(nQ), 'Point is not a scalar multiple of G') + + return true +} + +module.exports = Curve + +},{"27":27,"32":32,"61":61}],58:[function(require,module,exports){ +module.exports={ + "secp128r1": { + "p": "fffffffdffffffffffffffffffffffff", + "a": "fffffffdfffffffffffffffffffffffc", + "b": "e87579c11079f43dd824993c2cee5ed3", + "n": "fffffffe0000000075a30d1b9038a115", + "h": "01", + "Gx": "161ff7528b899b2d0c28607ca52c5b86", + "Gy": "cf5ac8395bafeb13c02da292dded7a83" + }, + "secp160k1": { + "p": "fffffffffffffffffffffffffffffffeffffac73", + "a": "00", + "b": "07", + "n": "0100000000000000000001b8fa16dfab9aca16b6b3", + "h": "01", + "Gx": "3b4c382ce37aa192a4019e763036f4f5dd4d7ebb", + "Gy": "938cf935318fdced6bc28286531733c3f03c4fee" + }, + "secp160r1": { + "p": "ffffffffffffffffffffffffffffffff7fffffff", + "a": "ffffffffffffffffffffffffffffffff7ffffffc", + "b": "1c97befc54bd7a8b65acf89f81d4d4adc565fa45", + "n": "0100000000000000000001f4c8f927aed3ca752257", + "h": "01", + "Gx": "4a96b5688ef573284664698968c38bb913cbfc82", + "Gy": "23a628553168947d59dcc912042351377ac5fb32" + }, + "secp192k1": { + "p": "fffffffffffffffffffffffffffffffffffffffeffffee37", + "a": "00", + "b": "03", + "n": "fffffffffffffffffffffffe26f2fc170f69466a74defd8d", + "h": "01", + "Gx": "db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d", + "Gy": "9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d" + }, + "secp192r1": { + "p": "fffffffffffffffffffffffffffffffeffffffffffffffff", + "a": "fffffffffffffffffffffffffffffffefffffffffffffffc", + "b": "64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", + "n": "ffffffffffffffffffffffff99def836146bc9b1b4d22831", + "h": "01", + "Gx": "188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012", + "Gy": "07192b95ffc8da78631011ed6b24cdd573f977a11e794811" + }, + "secp256k1": { + "p": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f", + "a": "00", + "b": "07", + "n": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", + "h": "01", + "Gx": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", + "Gy": "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8" + }, + "secp256r1": { + "p": "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff", + "a": "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc", + "b": "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b", + "n": "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551", + "h": "01", + "Gx": "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296", + "Gy": "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5" + } +} + +},{}],59:[function(require,module,exports){ +var Point = require(61) +var Curve = require(57) + +var getCurveByName = require(60) + +module.exports = { + Curve: Curve, + Point: Point, + getCurveByName: getCurveByName +} + +},{"57":57,"60":60,"61":61}],60:[function(require,module,exports){ +var BigInteger = require(32) + +var curves = require(58) +var Curve = require(57) + +function getCurveByName (name) { + var curve = curves[name] + if (!curve) return null + + var p = new BigInteger(curve.p, 16) + var a = new BigInteger(curve.a, 16) + var b = new BigInteger(curve.b, 16) + var n = new BigInteger(curve.n, 16) + var h = new BigInteger(curve.h, 16) + var Gx = new BigInteger(curve.Gx, 16) + var Gy = new BigInteger(curve.Gy, 16) + + return new Curve(p, a, b, Gx, Gy, n, h) +} + +module.exports = getCurveByName + +},{"32":32,"57":57,"58":58}],61:[function(require,module,exports){ +var assert = require(27) +var Buffer = require(93).Buffer +var BigInteger = require(32) + +var THREE = BigInteger.valueOf(3) + +function Point (curve, x, y, z) { + assert.notStrictEqual(z, undefined, 'Missing Z coordinate') + + this.curve = curve + this.x = x + this.y = y + this.z = z + this._zInv = null + + this.compressed = true +} + +Object.defineProperty(Point.prototype, 'zInv', { + get: function () { + if (this._zInv === null) { + this._zInv = this.z.modInverse(this.curve.p) + } + + return this._zInv + } +}) + +Object.defineProperty(Point.prototype, 'affineX', { + get: function () { + return this.x.multiply(this.zInv).mod(this.curve.p) + } +}) + +Object.defineProperty(Point.prototype, 'affineY', { + get: function () { + return this.y.multiply(this.zInv).mod(this.curve.p) + } +}) + +Point.fromAffine = function (curve, x, y) { + return new Point(curve, x, y, BigInteger.ONE) +} + +Point.prototype.equals = function (other) { + if (other === this) return true + if (this.curve.isInfinity(this)) return this.curve.isInfinity(other) + if (this.curve.isInfinity(other)) return this.curve.isInfinity(this) + + // u = Y2 * Z1 - Y1 * Z2 + var u = other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p) + + if (u.signum() !== 0) return false + + // v = X2 * Z1 - X1 * Z2 + var v = other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p) + + return v.signum() === 0 +} + +Point.prototype.negate = function () { + var y = this.curve.p.subtract(this.y) + + return new Point(this.curve, this.x, y, this.z) +} + +Point.prototype.add = function (b) { + if (this.curve.isInfinity(this)) return b + if (this.curve.isInfinity(b)) return this + + var x1 = this.x + var y1 = this.y + var x2 = b.x + var y2 = b.y + + // u = Y2 * Z1 - Y1 * Z2 + var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p) + // v = X2 * Z1 - X1 * Z2 + var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p) + + if (v.signum() === 0) { + if (u.signum() === 0) { + return this.twice() // this == b, so double + } + + return this.curve.infinity // this = -b, so infinity + } + + var v2 = v.square() + var v3 = v2.multiply(v) + var x1v2 = x1.multiply(v2) + var zu2 = u.square().multiply(this.z) + + // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3) + var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.p) + // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3 + var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.p) + // z3 = v^3 * z1 * z2 + var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.p) + + return new Point(this.curve, x3, y3, z3) +} + +Point.prototype.twice = function () { + if (this.curve.isInfinity(this)) return this + if (this.y.signum() === 0) return this.curve.infinity + + var x1 = this.x + var y1 = this.y + + var y1z1 = y1.multiply(this.z).mod(this.curve.p) + var y1sqz1 = y1z1.multiply(y1).mod(this.curve.p) + var a = this.curve.a + + // w = 3 * x1^2 + a * z1^2 + var w = x1.square().multiply(THREE) + + if (a.signum() !== 0) { + w = w.add(this.z.square().multiply(a)) + } + + w = w.mod(this.curve.p) + // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1) + var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.p) + // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3 + var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.pow(3)).mod(this.curve.p) + // z3 = 8 * (y1 * z1)^3 + var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.p) + + return new Point(this.curve, x3, y3, z3) +} + +// Simple NAF (Non-Adjacent Form) multiplication algorithm +// TODO: modularize the multiplication algorithm +Point.prototype.multiply = function (k) { + if (this.curve.isInfinity(this)) return this + if (k.signum() === 0) return this.curve.infinity + + var e = k + var h = e.multiply(THREE) + + var neg = this.negate() + var R = this + + for (var i = h.bitLength() - 2; i > 0; --i) { + var hBit = h.testBit(i) + var eBit = e.testBit(i) + + R = R.twice() + + if (hBit !== eBit) { + R = R.add(hBit ? this : neg) + } + } + + return R +} + +// Compute this*j + x*k (simultaneous multiplication) +Point.prototype.multiplyTwo = function (j, x, k) { + var i = Math.max(j.bitLength(), k.bitLength()) - 1 + var R = this.curve.infinity + var both = this.add(x) + + while (i >= 0) { + var jBit = j.testBit(i) + var kBit = k.testBit(i) + + R = R.twice() + + if (jBit) { + if (kBit) { + R = R.add(both) + } else { + R = R.add(this) + } + } else if (kBit) { + R = R.add(x) + } + --i + } + + return R +} + +Point.prototype.getEncoded = function (compressed) { + if (compressed == null) compressed = this.compressed + if (this.curve.isInfinity(this)) return Buffer.alloc(1, 0) // Infinity point encoded is simply '00' + + var x = this.affineX + var y = this.affineY + var byteLength = this.curve.pLength + var buffer + + // 0x02/0x03 | X + if (compressed) { + buffer = Buffer.allocUnsafe(1 + byteLength) + buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0) + + // 0x04 | X | Y + } else { + buffer = Buffer.allocUnsafe(1 + byteLength + byteLength) + buffer.writeUInt8(0x04, 0) + + y.toBuffer(byteLength).copy(buffer, 1 + byteLength) + } + + x.toBuffer(byteLength).copy(buffer, 1) + + return buffer +} + +Point.decodeFrom = function (curve, buffer) { + var type = buffer.readUInt8(0) + var compressed = (type !== 4) + + var byteLength = Math.floor((curve.p.bitLength() + 7) / 8) + var x = BigInteger.fromBuffer(buffer.slice(1, 1 + byteLength)) + + var Q + if (compressed) { + assert.equal(buffer.length, byteLength + 1, 'Invalid sequence length') + assert(type === 0x02 || type === 0x03, 'Invalid sequence tag') + + var isOdd = (type === 0x03) + Q = curve.pointFromX(isOdd, x) + } else { + assert.equal(buffer.length, 1 + byteLength + byteLength, 'Invalid sequence length') + + var y = BigInteger.fromBuffer(buffer.slice(1 + byteLength)) + Q = Point.fromAffine(curve, x, y) + } + + Q.compressed = compressed + return Q +} + +Point.prototype.toString = function () { + if (this.curve.isInfinity(this)) return '(INFINITY)' + + return '(' + this.affineX.toString() + ',' + this.affineY.toString() + ')' +} + +module.exports = Point + +},{"27":27,"32":32,"93":93}],62:[function(require,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; +} + +},{}],63:[function(require,module,exports){ +'use strict' +var Buffer = require(93).Buffer +var Transform = require(103).Transform +var inherits = require(65) + +function throwIfNotStringOrBuffer (val, prefix) { + if (!Buffer.isBuffer(val) && typeof val !== 'string') { + throw new TypeError(prefix + ' must be a string or a buffer') + } +} + +function HashBase (blockSize) { + Transform.call(this) + + this._block = Buffer.allocUnsafe(blockSize) + this._blockSize = blockSize + this._blockOffset = 0 + this._length = [0, 0, 0, 0] + + this._finalized = false +} + +inherits(HashBase, Transform) + +HashBase.prototype._transform = function (chunk, encoding, callback) { + var error = null + try { + this.update(chunk, encoding) + } catch (err) { + error = err + } + + callback(error) +} + +HashBase.prototype._flush = function (callback) { + var error = null + try { + this.push(this.digest()) + } catch (err) { + error = err + } + + callback(error) +} + +HashBase.prototype.update = function (data, encoding) { + throwIfNotStringOrBuffer(data, 'Data') + if (this._finalized) throw new Error('Digest already called') + if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding) + + // consume data + var block = this._block + var offset = 0 + while (this._blockOffset + data.length - offset >= this._blockSize) { + for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++] + this._update() + this._blockOffset = 0 + } + while (offset < data.length) block[this._blockOffset++] = data[offset++] + + // update length + for (var j = 0, carry = data.length * 8; carry > 0; ++j) { + this._length[j] += carry + carry = (this._length[j] / 0x0100000000) | 0 + if (carry > 0) this._length[j] -= 0x0100000000 * carry + } + + return this +} + +HashBase.prototype._update = function () { + throw new Error('_update is not implemented') +} + +HashBase.prototype.digest = function (encoding) { + if (this._finalized) throw new Error('Digest already called') + this._finalized = true + + var digest = this._digest() + if (encoding !== undefined) digest = digest.toString(encoding) + + // reset state + this._block.fill(0) + this._blockOffset = 0 + for (var i = 0; i < 4; ++i) this._length[i] = 0 + + return digest +} + +HashBase.prototype._digest = function () { + throw new Error('_digest is not implemented') +} + +module.exports = HashBase + +},{"103":103,"65":65,"93":93}],64:[function(require,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 +} + +},{}],65:[function(require,module,exports){ +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, 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) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } +} + +},{}],66:[function(require,module,exports){ +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ + +// The _isBuffer check is for Safari 5-7 support, because it's missing +// Object.prototype.constructor. Remove this eventually +module.exports = function (obj) { + return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) +} + +function isBuffer (obj) { + return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) +} + +// For Node v0.10 support. Remove this eventually. +function isSlowBuffer (obj) { + return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) +} + +},{}],67:[function(require,module,exports){ +var toString = {}.toString; + +module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; +}; + +},{}],68:[function(require,module,exports){ +/* + Copyright 2013 Daniel Wirtz + Copyright 2009 The Closure Library Authors. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS-IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + +/** + * @license long.js (c) 2013 Daniel Wirtz + * Released under the Apache License, Version 2.0 + * see: https://github.com/dcodeIO/long.js for details + */ +(function(global, factory) { + + /* AMD */ if (typeof define === 'function' && define["amd"]) + define([], factory); + /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"]) + module["exports"] = factory(); + /* Global */ else + (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory(); + +})(this, function() { + "use strict"; + + /** + * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers. + * See the from* functions below for more convenient ways of constructing Longs. + * @exports Long + * @class A Long class for representing a 64 bit two's-complement integer value. + * @param {number} low The low (signed) 32 bits of the long + * @param {number} high The high (signed) 32 bits of the long + * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed + * @constructor + */ + function Long(low, high, unsigned) { + + /** + * The low 32 bits as a signed value. + * @type {number} + */ + this.low = low | 0; + + /** + * The high 32 bits as a signed value. + * @type {number} + */ + this.high = high | 0; + + /** + * Whether unsigned or not. + * @type {boolean} + */ + this.unsigned = !!unsigned; + } + + // The internal representation of a long is the two given signed, 32-bit values. + // We use 32-bit pieces because these are the size of integers on which + // Javascript performs bit-operations. For operations like addition and + // multiplication, we split each number into 16 bit pieces, which can easily be + // multiplied within Javascript's floating-point representation without overflow + // or change in sign. + // + // In the algorithms below, we frequently reduce the negative case to the + // positive case by negating the input(s) and then post-processing the result. + // Note that we must ALWAYS check specially whether those values are MIN_VALUE + // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as + // a positive number, it overflows back into a negative). Not handling this + // case would often result in infinite recursion. + // + // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from* + // methods on which they depend. + + /** + * An indicator used to reliably determine if an object is a Long or not. + * @type {boolean} + * @const + * @private + */ + Long.prototype.__isLong__; + + Object.defineProperty(Long.prototype, "__isLong__", { + value: true, + enumerable: false, + configurable: false + }); + + /** + * @function + * @param {*} obj Object + * @returns {boolean} + * @inner + */ + function isLong(obj) { + return (obj && obj["__isLong__"]) === true; + } + + /** + * Tests if the specified object is a Long. + * @function + * @param {*} obj Object + * @returns {boolean} + */ + Long.isLong = isLong; + + /** + * A cache of the Long representations of small integer values. + * @type {!Object} + * @inner + */ + var INT_CACHE = {}; + + /** + * A cache of the Long representations of small unsigned integer values. + * @type {!Object} + * @inner + */ + var UINT_CACHE = {}; + + /** + * @param {number} value + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ + function fromInt(value, unsigned) { + var obj, cachedObj, cache; + if (unsigned) { + value >>>= 0; + if (cache = (0 <= value && value < 256)) { + cachedObj = UINT_CACHE[value]; + if (cachedObj) + return cachedObj; + } + obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true); + if (cache) + UINT_CACHE[value] = obj; + return obj; + } else { + value |= 0; + if (cache = (-128 <= value && value < 128)) { + cachedObj = INT_CACHE[value]; + if (cachedObj) + return cachedObj; + } + obj = fromBits(value, value < 0 ? -1 : 0, false); + if (cache) + INT_CACHE[value] = obj; + return obj; + } + } + + /** + * Returns a Long representing the given 32 bit integer value. + * @function + * @param {number} value The 32 bit integer in question + * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed + * @returns {!Long} The corresponding Long value + */ + Long.fromInt = fromInt; + + /** + * @param {number} value + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ + function fromNumber(value, unsigned) { + if (isNaN(value) || !isFinite(value)) + return unsigned ? UZERO : ZERO; + if (unsigned) { + if (value < 0) + return UZERO; + if (value >= TWO_PWR_64_DBL) + return MAX_UNSIGNED_VALUE; + } else { + if (value <= -TWO_PWR_63_DBL) + return MIN_VALUE; + if (value + 1 >= TWO_PWR_63_DBL) + return MAX_VALUE; + } + if (value < 0) + return fromNumber(-value, unsigned).neg(); + return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned); + } + + /** + * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned. + * @function + * @param {number} value The number in question + * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed + * @returns {!Long} The corresponding Long value + */ + Long.fromNumber = fromNumber; + + /** + * @param {number} lowBits + * @param {number} highBits + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ + function fromBits(lowBits, highBits, unsigned) { + return new Long(lowBits, highBits, unsigned); + } + + /** + * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is + * assumed to use 32 bits. + * @function + * @param {number} lowBits The low 32 bits + * @param {number} highBits The high 32 bits + * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed + * @returns {!Long} The corresponding Long value + */ + Long.fromBits = fromBits; + + /** + * @function + * @param {number} base + * @param {number} exponent + * @returns {number} + * @inner + */ + var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4) + + /** + * @param {string} str + * @param {(boolean|number)=} unsigned + * @param {number=} radix + * @returns {!Long} + * @inner + */ + function fromString(str, unsigned, radix) { + if (str.length === 0) + throw Error('empty string'); + if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") + return ZERO; + if (typeof unsigned === 'number') { + // For goog.math.long compatibility + radix = unsigned, + unsigned = false; + } else { + unsigned = !! unsigned; + } + radix = radix || 10; + if (radix < 2 || 36 < radix) + throw RangeError('radix'); + + var p; + if ((p = str.indexOf('-')) > 0) + throw Error('interior hyphen'); + else if (p === 0) { + return fromString(str.substring(1), unsigned, radix).neg(); + } + + // Do several (8) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + var radixToPower = fromNumber(pow_dbl(radix, 8)); + + var result = ZERO; + for (var i = 0; i < str.length; i += 8) { + var size = Math.min(8, str.length - i), + value = parseInt(str.substring(i, i + size), radix); + if (size < 8) { + var power = fromNumber(pow_dbl(radix, size)); + result = result.mul(power).add(fromNumber(value)); + } else { + result = result.mul(radixToPower); + result = result.add(fromNumber(value)); + } + } + result.unsigned = unsigned; + return result; + } + + /** + * Returns a Long representation of the given string, written using the specified radix. + * @function + * @param {string} str The textual representation of the Long + * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed + * @param {number=} radix The radix in which the text is written (2-36), defaults to 10 + * @returns {!Long} The corresponding Long value + */ + Long.fromString = fromString; + + /** + * @function + * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val + * @returns {!Long} + * @inner + */ + function fromValue(val) { + if (val /* is compatible */ instanceof Long) + return val; + if (typeof val === 'number') + return fromNumber(val); + if (typeof val === 'string') + return fromString(val); + // Throws for non-objects, converts non-instanceof Long: + return fromBits(val.low, val.high, val.unsigned); + } + + /** + * Converts the specified value to a Long. + * @function + * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value + * @returns {!Long} + */ + Long.fromValue = fromValue; + + // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be + // no runtime penalty for these. + + /** + * @type {number} + * @const + * @inner + */ + var TWO_PWR_16_DBL = 1 << 16; + + /** + * @type {number} + * @const + * @inner + */ + var TWO_PWR_24_DBL = 1 << 24; + + /** + * @type {number} + * @const + * @inner + */ + var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; + + /** + * @type {number} + * @const + * @inner + */ + var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; + + /** + * @type {number} + * @const + * @inner + */ + var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; + + /** + * @type {!Long} + * @const + * @inner + */ + var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL); + + /** + * @type {!Long} + * @inner + */ + var ZERO = fromInt(0); + + /** + * Signed zero. + * @type {!Long} + */ + Long.ZERO = ZERO; + + /** + * @type {!Long} + * @inner + */ + var UZERO = fromInt(0, true); + + /** + * Unsigned zero. + * @type {!Long} + */ + Long.UZERO = UZERO; + + /** + * @type {!Long} + * @inner + */ + var ONE = fromInt(1); + + /** + * Signed one. + * @type {!Long} + */ + Long.ONE = ONE; + + /** + * @type {!Long} + * @inner + */ + var UONE = fromInt(1, true); + + /** + * Unsigned one. + * @type {!Long} + */ + Long.UONE = UONE; + + /** + * @type {!Long} + * @inner + */ + var NEG_ONE = fromInt(-1); + + /** + * Signed negative one. + * @type {!Long} + */ + Long.NEG_ONE = NEG_ONE; + + /** + * @type {!Long} + * @inner + */ + var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false); + + /** + * Maximum signed value. + * @type {!Long} + */ + Long.MAX_VALUE = MAX_VALUE; + + /** + * @type {!Long} + * @inner + */ + var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true); + + /** + * Maximum unsigned value. + * @type {!Long} + */ + Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE; + + /** + * @type {!Long} + * @inner + */ + var MIN_VALUE = fromBits(0, 0x80000000|0, false); + + /** + * Minimum signed value. + * @type {!Long} + */ + Long.MIN_VALUE = MIN_VALUE; + + /** + * @alias Long.prototype + * @inner + */ + var LongPrototype = Long.prototype; + + /** + * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. + * @returns {number} + */ + LongPrototype.toInt = function toInt() { + return this.unsigned ? this.low >>> 0 : this.low; + }; + + /** + * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). + * @returns {number} + */ + LongPrototype.toNumber = function toNumber() { + if (this.unsigned) + return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0); + return this.high * TWO_PWR_32_DBL + (this.low >>> 0); + }; + + /** + * Converts the Long to a string written in the specified radix. + * @param {number=} radix Radix (2-36), defaults to 10 + * @returns {string} + * @override + * @throws {RangeError} If `radix` is out of range + */ + LongPrototype.toString = function toString(radix) { + radix = radix || 10; + if (radix < 2 || 36 < radix) + throw RangeError('radix'); + if (this.isZero()) + return '0'; + if (this.isNegative()) { // Unsigned Longs are never negative + if (this.eq(MIN_VALUE)) { + // We need to change the Long value before it can be negated, so we remove + // the bottom-most digit in this base and then recurse to do the rest. + var radixLong = fromNumber(radix), + div = this.div(radixLong), + rem1 = div.mul(radixLong).sub(this); + return div.toString(radix) + rem1.toInt().toString(radix); + } else + return '-' + this.neg().toString(radix); + } + + // Do several (6) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), + rem = this; + var result = ''; + while (true) { + var remDiv = rem.div(radixToPower), + intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, + digits = intval.toString(radix); + rem = remDiv; + if (rem.isZero()) + return digits + result; + else { + while (digits.length < 6) + digits = '0' + digits; + result = '' + digits + result; + } + } + }; + + /** + * Gets the high 32 bits as a signed integer. + * @returns {number} Signed high bits + */ + LongPrototype.getHighBits = function getHighBits() { + return this.high; + }; + + /** + * Gets the high 32 bits as an unsigned integer. + * @returns {number} Unsigned high bits + */ + LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() { + return this.high >>> 0; + }; + + /** + * Gets the low 32 bits as a signed integer. + * @returns {number} Signed low bits + */ + LongPrototype.getLowBits = function getLowBits() { + return this.low; + }; + + /** + * Gets the low 32 bits as an unsigned integer. + * @returns {number} Unsigned low bits + */ + LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() { + return this.low >>> 0; + }; + + /** + * Gets the number of bits needed to represent the absolute value of this Long. + * @returns {number} + */ + LongPrototype.getNumBitsAbs = function getNumBitsAbs() { + if (this.isNegative()) // Unsigned Longs are never negative + return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); + var val = this.high != 0 ? this.high : this.low; + for (var bit = 31; bit > 0; bit--) + if ((val & (1 << bit)) != 0) + break; + return this.high != 0 ? bit + 33 : bit + 1; + }; + + /** + * Tests if this Long's value equals zero. + * @returns {boolean} + */ + LongPrototype.isZero = function isZero() { + return this.high === 0 && this.low === 0; + }; + + /** + * Tests if this Long's value is negative. + * @returns {boolean} + */ + LongPrototype.isNegative = function isNegative() { + return !this.unsigned && this.high < 0; + }; + + /** + * Tests if this Long's value is positive. + * @returns {boolean} + */ + LongPrototype.isPositive = function isPositive() { + return this.unsigned || this.high >= 0; + }; + + /** + * Tests if this Long's value is odd. + * @returns {boolean} + */ + LongPrototype.isOdd = function isOdd() { + return (this.low & 1) === 1; + }; + + /** + * Tests if this Long's value is even. + * @returns {boolean} + */ + LongPrototype.isEven = function isEven() { + return (this.low & 1) === 0; + }; + + /** + * Tests if this Long's value equals the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.equals = function equals(other) { + if (!isLong(other)) + other = fromValue(other); + if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1) + return false; + return this.high === other.high && this.low === other.low; + }; + + /** + * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.eq = LongPrototype.equals; + + /** + * Tests if this Long's value differs from the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.notEquals = function notEquals(other) { + return !this.eq(/* validates */ other); + }; + + /** + * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.neq = LongPrototype.notEquals; + + /** + * Tests if this Long's value is less than the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.lessThan = function lessThan(other) { + return this.comp(/* validates */ other) < 0; + }; + + /** + * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.lt = LongPrototype.lessThan; + + /** + * Tests if this Long's value is less than or equal the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) { + return this.comp(/* validates */ other) <= 0; + }; + + /** + * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.lte = LongPrototype.lessThanOrEqual; + + /** + * Tests if this Long's value is greater than the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.greaterThan = function greaterThan(other) { + return this.comp(/* validates */ other) > 0; + }; + + /** + * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.gt = LongPrototype.greaterThan; + + /** + * Tests if this Long's value is greater than or equal the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) { + return this.comp(/* validates */ other) >= 0; + }; + + /** + * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ + LongPrototype.gte = LongPrototype.greaterThanOrEqual; + + /** + * Compares this Long's value with the specified's. + * @param {!Long|number|string} other Other value + * @returns {number} 0 if they are the same, 1 if the this is greater and -1 + * if the given one is greater + */ + LongPrototype.compare = function compare(other) { + if (!isLong(other)) + other = fromValue(other); + if (this.eq(other)) + return 0; + var thisNeg = this.isNegative(), + otherNeg = other.isNegative(); + if (thisNeg && !otherNeg) + return -1; + if (!thisNeg && otherNeg) + return 1; + // At this point the sign bits are the same + if (!this.unsigned) + return this.sub(other).isNegative() ? -1 : 1; + // Both are positive if at least one is unsigned + return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1; + }; + + /** + * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}. + * @function + * @param {!Long|number|string} other Other value + * @returns {number} 0 if they are the same, 1 if the this is greater and -1 + * if the given one is greater + */ + LongPrototype.comp = LongPrototype.compare; + + /** + * Negates this Long's value. + * @returns {!Long} Negated Long + */ + LongPrototype.negate = function negate() { + if (!this.unsigned && this.eq(MIN_VALUE)) + return MIN_VALUE; + return this.not().add(ONE); + }; + + /** + * Negates this Long's value. This is an alias of {@link Long#negate}. + * @function + * @returns {!Long} Negated Long + */ + LongPrototype.neg = LongPrototype.negate; + + /** + * Returns the sum of this and the specified Long. + * @param {!Long|number|string} addend Addend + * @returns {!Long} Sum + */ + LongPrototype.add = function add(addend) { + if (!isLong(addend)) + addend = fromValue(addend); + + // Divide each number into 4 chunks of 16 bits, and then sum the chunks. + + var a48 = this.high >>> 16; + var a32 = this.high & 0xFFFF; + var a16 = this.low >>> 16; + var a00 = this.low & 0xFFFF; + + var b48 = addend.high >>> 16; + var b32 = addend.high & 0xFFFF; + var b16 = addend.low >>> 16; + var b00 = addend.low & 0xFFFF; + + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 0xFFFF; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c48 += a48 + b48; + c48 &= 0xFFFF; + return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); + }; + + /** + * Returns the difference of this and the specified Long. + * @param {!Long|number|string} subtrahend Subtrahend + * @returns {!Long} Difference + */ + LongPrototype.subtract = function subtract(subtrahend) { + if (!isLong(subtrahend)) + subtrahend = fromValue(subtrahend); + return this.add(subtrahend.neg()); + }; + + /** + * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}. + * @function + * @param {!Long|number|string} subtrahend Subtrahend + * @returns {!Long} Difference + */ + LongPrototype.sub = LongPrototype.subtract; + + /** + * Returns the product of this and the specified Long. + * @param {!Long|number|string} multiplier Multiplier + * @returns {!Long} Product + */ + LongPrototype.multiply = function multiply(multiplier) { + if (this.isZero()) + return ZERO; + if (!isLong(multiplier)) + multiplier = fromValue(multiplier); + if (multiplier.isZero()) + return ZERO; + if (this.eq(MIN_VALUE)) + return multiplier.isOdd() ? MIN_VALUE : ZERO; + if (multiplier.eq(MIN_VALUE)) + return this.isOdd() ? MIN_VALUE : ZERO; + + if (this.isNegative()) { + if (multiplier.isNegative()) + return this.neg().mul(multiplier.neg()); + else + return this.neg().mul(multiplier).neg(); + } else if (multiplier.isNegative()) + return this.mul(multiplier.neg()).neg(); + + // If both longs are small, use float multiplication + if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24)) + return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); + + // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. + // We can skip products that would overflow. + + var a48 = this.high >>> 16; + var a32 = this.high & 0xFFFF; + var a16 = this.low >>> 16; + var a00 = this.low & 0xFFFF; + + var b48 = multiplier.high >>> 16; + var b32 = multiplier.high & 0xFFFF; + var b16 = multiplier.low >>> 16; + var b00 = multiplier.low & 0xFFFF; + + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 0xFFFF; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 0xFFFF; + return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); + }; + + /** + * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}. + * @function + * @param {!Long|number|string} multiplier Multiplier + * @returns {!Long} Product + */ + LongPrototype.mul = LongPrototype.multiply; + + /** + * Returns this Long divided by the specified. The result is signed if this Long is signed or + * unsigned if this Long is unsigned. + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Quotient + */ + LongPrototype.divide = function divide(divisor) { + if (!isLong(divisor)) + divisor = fromValue(divisor); + if (divisor.isZero()) + throw Error('division by zero'); + if (this.isZero()) + return this.unsigned ? UZERO : ZERO; + var approx, rem, res; + if (!this.unsigned) { + // This section is only relevant for signed longs and is derived from the + // closure library as a whole. + if (this.eq(MIN_VALUE)) { + if (divisor.eq(ONE) || divisor.eq(NEG_ONE)) + return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE + else if (divisor.eq(MIN_VALUE)) + return ONE; + else { + // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. + var halfThis = this.shr(1); + approx = halfThis.div(divisor).shl(1); + if (approx.eq(ZERO)) { + return divisor.isNegative() ? ONE : NEG_ONE; + } else { + rem = this.sub(divisor.mul(approx)); + res = approx.add(rem.div(divisor)); + return res; + } + } + } else if (divisor.eq(MIN_VALUE)) + return this.unsigned ? UZERO : ZERO; + if (this.isNegative()) { + if (divisor.isNegative()) + return this.neg().div(divisor.neg()); + return this.neg().div(divisor).neg(); + } else if (divisor.isNegative()) + return this.div(divisor.neg()).neg(); + res = ZERO; + } else { + // The algorithm below has not been made for unsigned longs. It's therefore + // required to take special care of the MSB prior to running it. + if (!divisor.unsigned) + divisor = divisor.toUnsigned(); + if (divisor.gt(this)) + return UZERO; + if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true + return UONE; + res = UZERO; + } + + // Repeat the following until the remainder is less than other: find a + // floating-point that approximates remainder / other *from below*, add this + // into the result, and subtract it from the remainder. It is critical that + // the approximate value is less than or equal to the real value so that the + // remainder never becomes negative. + rem = this; + while (rem.gte(divisor)) { + // Approximate the result of division. This may be a little greater or + // smaller than the actual value. + approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); + + // We will tweak the approximate result by changing it in the 48-th digit or + // the smallest non-fractional digit, whichever is larger. + var log2 = Math.ceil(Math.log(approx) / Math.LN2), + delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), + + // Decrease the approximation until it is smaller than the remainder. Note + // that if it is too large, the product overflows and is negative. + approxRes = fromNumber(approx), + approxRem = approxRes.mul(divisor); + while (approxRem.isNegative() || approxRem.gt(rem)) { + approx -= delta; + approxRes = fromNumber(approx, this.unsigned); + approxRem = approxRes.mul(divisor); + } + + // We know the answer can't be zero... and actually, zero would cause + // infinite recursion since we would make no progress. + if (approxRes.isZero()) + approxRes = ONE; + + res = res.add(approxRes); + rem = rem.sub(approxRem); + } + return res; + }; + + /** + * Returns this Long divided by the specified. This is an alias of {@link Long#divide}. + * @function + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Quotient + */ + LongPrototype.div = LongPrototype.divide; + + /** + * Returns this Long modulo the specified. + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Remainder + */ + LongPrototype.modulo = function modulo(divisor) { + if (!isLong(divisor)) + divisor = fromValue(divisor); + return this.sub(this.div(divisor).mul(divisor)); + }; + + /** + * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. + * @function + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Remainder + */ + LongPrototype.mod = LongPrototype.modulo; + + /** + * Returns the bitwise NOT of this Long. + * @returns {!Long} + */ + LongPrototype.not = function not() { + return fromBits(~this.low, ~this.high, this.unsigned); + }; + + /** + * Returns the bitwise AND of this Long and the specified. + * @param {!Long|number|string} other Other Long + * @returns {!Long} + */ + LongPrototype.and = function and(other) { + if (!isLong(other)) + other = fromValue(other); + return fromBits(this.low & other.low, this.high & other.high, this.unsigned); + }; + + /** + * Returns the bitwise OR of this Long and the specified. + * @param {!Long|number|string} other Other Long + * @returns {!Long} + */ + LongPrototype.or = function or(other) { + if (!isLong(other)) + other = fromValue(other); + return fromBits(this.low | other.low, this.high | other.high, this.unsigned); + }; + + /** + * Returns the bitwise XOR of this Long and the given one. + * @param {!Long|number|string} other Other Long + * @returns {!Long} + */ + LongPrototype.xor = function xor(other) { + if (!isLong(other)) + other = fromValue(other); + return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); + }; + + /** + * Returns this Long with bits shifted to the left by the given amount. + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ + LongPrototype.shiftLeft = function shiftLeft(numBits) { + if (isLong(numBits)) + numBits = numBits.toInt(); + if ((numBits &= 63) === 0) + return this; + else if (numBits < 32) + return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned); + else + return fromBits(0, this.low << (numBits - 32), this.unsigned); + }; + + /** + * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ + LongPrototype.shl = LongPrototype.shiftLeft; + + /** + * Returns this Long with bits arithmetically shifted to the right by the given amount. + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ + LongPrototype.shiftRight = function shiftRight(numBits) { + if (isLong(numBits)) + numBits = numBits.toInt(); + if ((numBits &= 63) === 0) + return this; + else if (numBits < 32) + return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned); + else + return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned); + }; + + /** + * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ + LongPrototype.shr = LongPrototype.shiftRight; + + /** + * Returns this Long with bits logically shifted to the right by the given amount. + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ + LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { + if (isLong(numBits)) + numBits = numBits.toInt(); + numBits &= 63; + if (numBits === 0) + return this; + else { + var high = this.high; + if (numBits < 32) { + var low = this.low; + return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned); + } else if (numBits === 32) + return fromBits(high, 0, this.unsigned); + else + return fromBits(high >>> (numBits - 32), 0, this.unsigned); + } + }; + + /** + * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ + LongPrototype.shru = LongPrototype.shiftRightUnsigned; + + /** + * Converts this Long to signed. + * @returns {!Long} Signed long + */ + LongPrototype.toSigned = function toSigned() { + if (!this.unsigned) + return this; + return fromBits(this.low, this.high, false); + }; + + /** + * Converts this Long to unsigned. + * @returns {!Long} Unsigned long + */ + LongPrototype.toUnsigned = function toUnsigned() { + if (this.unsigned) + return this; + return fromBits(this.low, this.high, true); + }; + + /** + * Converts this Long to its byte representation. + * @param {boolean=} le Whether little or big endian, defaults to big endian + * @returns {!Array.} Byte representation + */ + LongPrototype.toBytes = function(le) { + return le ? this.toBytesLE() : this.toBytesBE(); + } + + /** + * Converts this Long to its little endian byte representation. + * @returns {!Array.} Little endian byte representation + */ + LongPrototype.toBytesLE = function() { + var hi = this.high, + lo = this.low; + return [ + lo & 0xff, + (lo >>> 8) & 0xff, + (lo >>> 16) & 0xff, + (lo >>> 24) & 0xff, + hi & 0xff, + (hi >>> 8) & 0xff, + (hi >>> 16) & 0xff, + (hi >>> 24) & 0xff + ]; + } + + /** + * Converts this Long to its big endian byte representation. + * @returns {!Array.} Big endian byte representation + */ + LongPrototype.toBytesBE = function() { + var hi = this.high, + lo = this.low; + return [ + (hi >>> 24) & 0xff, + (hi >>> 16) & 0xff, + (hi >>> 8) & 0xff, + hi & 0xff, + (lo >>> 24) & 0xff, + (lo >>> 16) & 0xff, + (lo >>> 8) & 0xff, + lo & 0xff + ]; + } + + return Long; +}); + +},{}],69:[function(require,module,exports){ +(function (Buffer){ +'use strict' +var inherits = require(65) +var HashBase = require(63) + +var ARRAY16 = new Array(16) + +function MD5 () { + HashBase.call(this, 64) + + // state + this._a = 0x67452301 + this._b = 0xefcdab89 + this._c = 0x98badcfe + this._d = 0x10325476 +} + +inherits(MD5, HashBase) + +MD5.prototype._update = function () { + var M = ARRAY16 + for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4) + + var a = this._a + var b = this._b + var c = this._c + var d = this._d + + a = fnF(a, b, c, d, M[0], 0xd76aa478, 7) + d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12) + c = fnF(c, d, a, b, M[2], 0x242070db, 17) + b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22) + a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7) + d = fnF(d, a, b, c, M[5], 0x4787c62a, 12) + c = fnF(c, d, a, b, M[6], 0xa8304613, 17) + b = fnF(b, c, d, a, M[7], 0xfd469501, 22) + a = fnF(a, b, c, d, M[8], 0x698098d8, 7) + d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12) + c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17) + b = fnF(b, c, d, a, M[11], 0x895cd7be, 22) + a = fnF(a, b, c, d, M[12], 0x6b901122, 7) + d = fnF(d, a, b, c, M[13], 0xfd987193, 12) + c = fnF(c, d, a, b, M[14], 0xa679438e, 17) + b = fnF(b, c, d, a, M[15], 0x49b40821, 22) + + a = fnG(a, b, c, d, M[1], 0xf61e2562, 5) + d = fnG(d, a, b, c, M[6], 0xc040b340, 9) + c = fnG(c, d, a, b, M[11], 0x265e5a51, 14) + b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20) + a = fnG(a, b, c, d, M[5], 0xd62f105d, 5) + d = fnG(d, a, b, c, M[10], 0x02441453, 9) + c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14) + b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20) + a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5) + d = fnG(d, a, b, c, M[14], 0xc33707d6, 9) + c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14) + b = fnG(b, c, d, a, M[8], 0x455a14ed, 20) + a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5) + d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9) + c = fnG(c, d, a, b, M[7], 0x676f02d9, 14) + b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20) + + a = fnH(a, b, c, d, M[5], 0xfffa3942, 4) + d = fnH(d, a, b, c, M[8], 0x8771f681, 11) + c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16) + b = fnH(b, c, d, a, M[14], 0xfde5380c, 23) + a = fnH(a, b, c, d, M[1], 0xa4beea44, 4) + d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11) + c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16) + b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23) + a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4) + d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11) + c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16) + b = fnH(b, c, d, a, M[6], 0x04881d05, 23) + a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4) + d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11) + c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16) + b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23) + + a = fnI(a, b, c, d, M[0], 0xf4292244, 6) + d = fnI(d, a, b, c, M[7], 0x432aff97, 10) + c = fnI(c, d, a, b, M[14], 0xab9423a7, 15) + b = fnI(b, c, d, a, M[5], 0xfc93a039, 21) + a = fnI(a, b, c, d, M[12], 0x655b59c3, 6) + d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10) + c = fnI(c, d, a, b, M[10], 0xffeff47d, 15) + b = fnI(b, c, d, a, M[1], 0x85845dd1, 21) + a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6) + d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10) + c = fnI(c, d, a, b, M[6], 0xa3014314, 15) + b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21) + a = fnI(a, b, c, d, M[4], 0xf7537e82, 6) + d = fnI(d, a, b, c, M[11], 0xbd3af235, 10) + c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15) + b = fnI(b, c, d, a, M[9], 0xeb86d391, 21) + + this._a = (this._a + a) | 0 + this._b = (this._b + b) | 0 + this._c = (this._c + c) | 0 + this._d = (this._d + d) | 0 +} + +MD5.prototype._digest = function () { + // create padding and handle blocks + this._block[this._blockOffset++] = 0x80 + if (this._blockOffset > 56) { + this._block.fill(0, this._blockOffset, 64) + this._update() + this._blockOffset = 0 + } + + this._block.fill(0, this._blockOffset, 56) + this._block.writeUInt32LE(this._length[0], 56) + this._block.writeUInt32LE(this._length[1], 60) + this._update() + + // produce result + var buffer = new Buffer(16) + buffer.writeInt32LE(this._a, 0) + buffer.writeInt32LE(this._b, 4) + buffer.writeInt32LE(this._c, 8) + buffer.writeInt32LE(this._d, 12) + return buffer +} + +function rotl (x, n) { + return (x << n) | (x >>> (32 - n)) +} + +function fnF (a, b, c, d, m, k, s) { + return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0 +} + +function fnG (a, b, c, d, m, k, s) { + return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0 +} + +function fnH (a, b, c, d, m, k, s) { + return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0 +} + +function fnI (a, b, c, d, m, k, s) { + return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0 +} + +module.exports = MD5 + +}).call(this,require(35).Buffer) + +},{"35":35,"63":63,"65":65}],70:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; +exports.Manager = exports.ChainConfig = exports.Apis = undefined; + +var _ApiInstances = require(71); + +var _ApiInstances2 = _interopRequireDefault(_ApiInstances); + +var _ConnectionManager = require(74); + +var _ConnectionManager2 = _interopRequireDefault(_ConnectionManager); + +var _ChainConfig = require(72); + +var _ChainConfig2 = _interopRequireDefault(_ChainConfig); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.Apis = _ApiInstances2.default; +exports.ChainConfig = _ChainConfig2.default; +exports.Manager = _ConnectionManager2.default; +},{"71":71,"72":72,"74":74}],71:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +var _ChainWebSocket = require(73); + +var _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket); + +var _GrapheneApi = require(75); + +var _GrapheneApi2 = _interopRequireDefault(_GrapheneApi); + +var _ChainConfig = require(72); + +var _ChainConfig2 = _interopRequireDefault(_ChainConfig); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var inst = void 0; + +var ApisInstance = function () { + function ApisInstance() { + _classCallCheck(this, ApisInstance); + } + + /** @arg {string} connection .. */ + ApisInstance.prototype.connect = function connect(cs, connectTimeout) { + var _this = this; + + var rpc_user = ''; + var rpc_password = ''; + + if (typeof window !== 'undefined' && window.location && window.location.protocol === 'https:' && cs.indexOf('wss://') < 0) { + throw new Error('Secure domains require wss connection'); + } + + this.ws_rpc = new _ChainWebSocket2.default(cs, this.statusCb, connectTimeout); + + this.init_promise = this.ws_rpc.login(rpc_user, rpc_password).then(function () { + console.log('Connected to API node:', cs); + _this._db = new _GrapheneApi2.default(_this.ws_rpc, 'database'); + _this._net = new _GrapheneApi2.default(_this.ws_rpc, 'network_broadcast'); + _this._hist = new _GrapheneApi2.default(_this.ws_rpc, 'history'); + _this._crypto = new _GrapheneApi2.default(_this.ws_rpc, 'crypto'); + _this._bookie = new _GrapheneApi2.default(_this.ws_rpc, 'bookie'); + var db_promise = _this._db.init().then(function () { + return _this._db.exec('get_chain_id', []).then(function (_chain_id) { + _this.chain_id = _chain_id; + return _ChainConfig2.default.setChainId(_chain_id); + }); + }); + + _this.ws_rpc.on_reconnect = function () { + _this.ws_rpc.login('', '').then(function () { + _this._db.init().then(function () { + if (_this.statusCb) { + _this.statusCb(_ChainWebSocket2.default.status.RECONNECTED); + } + }); + _this._net.init(); + _this._hist.init(); + _this._crypto.init(); + _this._bookie.init(); + }); + }; + + return Promise.all([db_promise, _this._net.init(), _this._hist.init(), + // Temporary squash crypto API error until the API is upgraded everywhere + _this._crypto.init().catch(function (e) { + return console.error('ApiInstance\tCrypto API Error', e); + }), _this._bookie.init()]); + }); + }; + + ApisInstance.prototype.close = function close() { + if (this.ws_rpc) { + this.ws_rpc.close(); + } + + this.ws_rpc = null; + }; + + ApisInstance.prototype.db_api = function db_api() { + return this._db; + }; + + ApisInstance.prototype.network_api = function network_api() { + return this._net; + }; + + ApisInstance.prototype.history_api = function history_api() { + return this._hist; + }; + + ApisInstance.prototype.crypto_api = function crypto_api() { + return this._crypto; + }; + + ApisInstance.prototype.bookie_api = function bookie_api() { + return this._bookie; + }; + + ApisInstance.prototype.setRpcConnectionStatusCallback = function setRpcConnectionStatusCallback(callback) { + this.statusCb = callback; + }; + + return ApisInstance; +}(); + +/** + Configure: configure as follows `Apis.instance("ws://localhost:8090").init_promise`. This + returns a promise, once resolved the connection is ready. + + Import: import { Apis } from "@graphene/chain" + + Short-hand: Apis.db("method", "parm1", 2, 3, ...). Returns a promise with results. + + Additional usage: Apis.instance().db_api().exec("method", ["method", "parm1", 2, 3, ...]). + Returns a promise with results. +*/ + +exports.default = { + setRpcConnectionStatusCallback: function setRpcConnectionStatusCallback(callback) { + this.statusCb = callback; + + if (inst) { + inst.setRpcConnectionStatusCallback(callback); + } + }, + + /** + @arg {string} cs is only provided in the first call + @return {Apis} singleton .. Check Apis.instance().init_promise to + know when the connection is established + */ + reset: function reset() { + var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090'; + var connect = arguments[1]; + var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000; + + if (inst) { + inst.close(); + inst = null; + } + + inst = new ApisInstance(); + inst.setRpcConnectionStatusCallback(this.statusCb); + + if (inst && connect) { + inst.connect(cs, connectTimeout); + } + + return inst; + }, + instance: function instance() { + var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090'; + var connect = arguments[1]; + var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000; + + if (!inst) { + inst = new ApisInstance(); + inst.setRpcConnectionStatusCallback(this.statusCb); + } + + if (inst && connect) { + inst.connect(cs, connectTimeout); + } + + return inst; + }, + chainId: function chainId() { + return this.instance().chain_id; + }, + close: function close() { + if (inst) { + inst.close(); + inst = null; + } + } + // db: (method, ...args) => Apis.instance().db_api().exec(method, toStrings(args)), + // network: (method, ...args) => Apis.instance().network_api().exec(method, toStrings(args)), + // history: (method, ...args) => Apis.instance().history_api().exec(method, toStrings(args)), + // crypto: (method, ...args) => Apis.instance().crypto_api().exec(method, toStrings(args)) + +}; +},{"72":72,"73":73,"75":75}],72:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var defaults = { + core_asset: 'PPY', + address_prefix: 'PPY', + expire_in_secs: 15, + expire_in_secs_proposal: 24 * 60 * 60, + review_in_secs_committee: 24 * 60 * 60 +}; + +var networks = { + networks: { + Peerplays: { + core_asset: 'PPY', + address_prefix: 'PPY', + chain_id: '6b6b5f0ce7a36d323768e534f3edb41c6d6332a541a95725b98e28d140850134' + }, + PeerplaysTestnet: { + core_asset: 'PPYTEST', + address_prefix: 'PPYTEST', + chain_id: 'be6b79295e728406cbb7494bcb626e62ad278fa4018699cf8f75739f4c1a81fd' + } + } +}; + +var ChainConfig = function () { + function ChainConfig() { + _classCallCheck(this, ChainConfig); + + this.reset(); + } + + ChainConfig.prototype.reset = function reset() { + Object.assign(this, defaults); + }; + + ChainConfig.prototype.setChainId = function setChainId(chainID) { + var ref = Object.keys(networks); + + for (var i = 0, len = ref.length; i < len; i++) { + var network_name = ref[i]; + var network = networks[network_name]; + + if (network.chain_id === chainID) { + this.network_name = network_name; + + if (network.address_prefix) { + this.address_prefix = network.address_prefix; + } + + return { + network_name: network_name, + network: network + }; + } + } + + if (!this.network_name) { + console.log('Unknown chain id (this may be a testnet)', chainID); + } + }; + + ChainConfig.prototype.setPrefix = function setPrefix() { + var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'PPY'; + + this.address_prefix = prefix; + }; + + return ChainConfig; +}(); + +exports.default = new ChainConfig(); +},{}],73:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var SOCKET_DEBUG = false; +var WebSocketClient = null; + +if (typeof WebSocket !== 'undefined') { + WebSocketClient = WebSocket; +} else { + WebSocketClient = require(34); // eslint-disable-line global-require +} + +var SUBSCRIBE_OPERATIONS = ['set_subscribe_callback', 'subscribe_to_market', 'broadcast_transaction_with_callback', 'set_pending_transaction_callback']; + +var UNSUBSCRIBE_OPERATIONS = ['unsubscribe_from_market', 'unsubscribe_from_accounts']; + +var HEALTH_CHECK_INTERVAL = 10000; + +var ChainWebSocket = function () { + /** + *Creates an instance of ChainWebSocket. + * @param {string} serverAddress The address of the websocket to connect to. + * @param {function} statusCb Called when status events occur. + * @param {number} [connectTimeout=10000] The time for a connection attempt to complete. + * @memberof ChainWebSocket + */ + function ChainWebSocket(serverAddress, statusCb) { + var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10000; + + _classCallCheck(this, ChainWebSocket); + + this.statusCb = statusCb; + this.serverAddress = serverAddress; + this.timeoutInterval = connectTimeout; + + // The currenct connection state of the websocket. + this.connected = false; + this.reconnectTimeout = null; + + // Callback to execute when the websocket is reconnected. + this.on_reconnect = null; + + // An incrementing ID for each request so that we can pair it with the + // response from the websocket. + this.cbId = 0; + + // Objects to store key/value pairs for callbacks, subscription callbacks + // and unsubscribe callbacks. + this.cbs = {}; + this.subs = {}; + this.unsub = {}; + + // Current connection promises' rejection + this.currentResolve = null; + this.currentReject = null; + + // Health check for the connection to the BlockChain. + this.healthCheck = null; + + // Copy the constants to this instance. + this.status = ChainWebSocket.status; + + // Bind the functions to the instance. + this.onConnectionOpen = this.onConnectionOpen.bind(this); + this.onConnectionClose = this.onConnectionClose.bind(this); + this.onConnectionTerminate = this.onConnectionTerminate.bind(this); + this.onConnectionError = this.onConnectionError.bind(this); + this.onConnectionTimeout = this.onConnectionTimeout.bind(this); + this.createConnection = this.createConnection.bind(this); + this.createConnectionPromise = this.createConnectionPromise.bind(this); + this.listener = this.listener.bind(this); + + // Create the initial connection the blockchain. + this.createConnection(); + } + + /** + * Create the connection to the Blockchain. + * + * @returns + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.createConnection = function createConnection() { + this.debug('!!! ChainWebSocket create connection'); + + // Clear any possible reconnect timers. + this.reconnectTimeout = null; + + // Create the promise for this connection + if (!this.connect_promise) { + this.connect_promise = new Promise(this.createConnectionPromise); + } + + // Attempt to create the websocket + try { + this.ws = new WebSocketClient(this.serverAddress); + } catch (error) { + // Set a timeout to try and reconnect here. + return this.resetConnection(); + } + + this.addEventListeners(); + + // Handle timeouts to the websocket's initial connection. + this.connectionTimeout = setTimeout(this.onConnectionTimeout, this.timeoutInterval); + }; + + /** + * Reset the connection to the BlockChain. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.resetConnection = function resetConnection() { + // Close the Websocket if its still 'half-open' + this.close(); + + // Make sure we only ever have one timeout running to reconnect. + if (!this.reconnectTimeout) { + this.debug('!!! ChainWebSocket reset connection', this.timeoutInterval); + this.reconnectTimeout = setTimeout(this.createConnection, this.timeoutInterval); + } + + // Reject the current promise if there is one. + if (this.currentReject) { + this.currentReject(new Error('Connection attempt failed: ' + this.serverAddress)); + } + }; + + /** + * Add event listeners to the WebSocket. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.addEventListeners = function addEventListeners() { + this.debug('!!! ChainWebSocket add event listeners'); + this.ws.addEventListener('open', this.onConnectionOpen); + this.ws.addEventListener('close', this.onConnectionClose); + this.ws.addEventListener('error', this.onConnectionError); + this.ws.addEventListener('message', this.listener); + }; + + /** + * Remove the event listers from the WebSocket. Its important to remove the event listerers + * for garbaage collection. Because we are creating a new WebSocket on each connection attempt + * any listeners that are still attached could prevent the old sockets from + * being garbage collected. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.removeEventListeners = function removeEventListeners() { + this.debug('!!! ChainWebSocket remove event listeners'); + this.ws.removeEventListener('open', this.onConnectionOpen); + this.ws.removeEventListener('close', this.onConnectionClose); + this.ws.removeEventListener('error', this.onConnectionError); + this.ws.removeEventListener('message', this.listener); + }; + + /** + * A function that is passed to a new promise that stores the resolve and reject callbacks + * in the state. + * + * @param {function} resolve A callback to be executed when the promise is resolved. + * @param {function} reject A callback to be executed when the promise is rejected. + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.createConnectionPromise = function createConnectionPromise(resolve, reject) { + this.debug('!!! ChainWebSocket createPromise'); + this.currentResolve = resolve; + this.currentReject = reject; + }; + + /** + * Called when a new Websocket connection is opened. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.onConnectionOpen = function onConnectionOpen() { + this.debug('!!! ChainWebSocket Connected '); + + this.connected = true; + + clearTimeout(this.connectionTimeout); + this.connectionTimeout = null; + + // This will trigger the login process as well as some additional setup in ApiInstances + if (this.on_reconnect) { + this.on_reconnect(); + } + + if (this.currentResolve) { + this.currentResolve(); + } + + if (this.statusCb) { + this.statusCb(ChainWebSocket.status.OPEN); + } + }; + + /** + * called when the connection attempt times out. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.onConnectionTimeout = function onConnectionTimeout() { + this.debug('!!! ChainWebSocket timeout'); + this.onConnectionClose(new Error('Connection timed out.')); + }; + + /** + * Called when the Websocket is not responding to the health checks. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.onConnectionTerminate = function onConnectionTerminate() { + this.debug('!!! ChainWebSocket terminate'); + this.onConnectionClose(new Error('Connection was terminated.')); + }; + + /** + * Called when the connection to the Blockchain is closed. + * + * @param {*} error + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.onConnectionClose = function onConnectionClose(error) { + this.debug('!!! ChainWebSocket Close ', error); + + this.resetConnection(); + + if (this.statusCb) { + this.statusCb(ChainWebSocket.status.CLOSED); + } + }; + + /** + * Called when the Websocket encounters an error. + * + * @param {*} error + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.onConnectionError = function onConnectionError(error) { + this.debug('!!! ChainWebSocket On Connection Error ', error); + + this.resetConnection(); + + if (this.statusCb) { + this.statusCb(ChainWebSocket.status.ERROR); + } + }; + + /** + * Entry point to make RPC calls on the BlockChain. + * + * @param {array} params An array of params to be passed to the rpc call. [method, ...params] + * @returns A new promise for this specific call. + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.call = function call(params) { + var _this = this; + + if (!this.connected) { + this.debug('!!! ChainWebSocket Call not connected. '); + return Promise.reject(new Error('Disconnected from the BlockChain.')); + } + + this.debug('!!! ChainWebSocket Call connected. ', params); + + var request = { + method: params[1], + params: params, + id: this.cbId + 1 + }; + + this.cbId = request.id; + + if (SUBSCRIBE_OPERATIONS.includes(request.method)) { + // Store callback in subs map + this.subs[request.id] = { + callback: request.params[2][0] + }; + + // Replace callback with the callback id + request.params[2][0] = request.id; + } + + if (UNSUBSCRIBE_OPERATIONS.includes(request.method)) { + if (typeof request.params[2][0] !== 'function') { + throw new Error('First parameter of unsub must be the original callback'); + } + + var unSubCb = request.params[2].splice(0, 1)[0]; + + // Find the corresponding subscription + for (var id in this.subs) { + // eslint-disable-line + if (this.subs[id].callback === unSubCb) { + this.unsub[request.id] = id; + break; + } + } + } + + if (!this.healthCheck) { + this.healthCheck = setTimeout(this.onConnectionTerminate.bind(this), HEALTH_CHECK_INTERVAL); + } + + return new Promise(function (resolve, reject) { + _this.cbs[request.id] = { + time: new Date(), + resolve: resolve, + reject: reject + }; + + // Set all requests to be 'call' methods. + request.method = 'call'; + + try { + _this.ws.send(JSON.stringify(request)); + } catch (error) { + _this.debug('Caught a nasty error : ', error); + } + }); + }; + + /** + * Called when messages are received on the Websocket. + * + * @param {*} response The message received. + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.listener = function listener(response) { + var responseJSON = null; + + try { + responseJSON = JSON.parse(response.data); + } catch (error) { + responseJSON.error = 'Error parsing response: ' + error.stack; + this.debug('Error parsing response: ', response); + } + + // Clear the health check timeout, we've just received a healthy response from the server. + if (this.healthCheck) { + clearTimeout(this.healthCheck); + this.healthCheck = null; + } + + var sub = false; + var callback = null; + + if (responseJSON.method === 'notice') { + sub = true; + responseJSON.id = responseJSON.params[0]; + } + + if (!sub) { + callback = this.cbs[responseJSON.id]; + } else { + callback = this.subs[responseJSON.id].callback; + } + + if (callback && !sub) { + if (responseJSON.error) { + this.debug('----> responseJSON : ', responseJSON); + callback.reject(responseJSON.error); + } else { + callback.resolve(responseJSON.result); + } + + delete this.cbs[responseJSON.id]; + + if (this.unsub[responseJSON.id]) { + delete this.subs[this.unsub[responseJSON.id]]; + delete this.unsub[responseJSON.id]; + } + } else if (callback && sub) { + callback(responseJSON.params[1]); + } else { + this.debug('Warning: unknown websocket responseJSON: ', responseJSON); + } + }; + + /** + * Login to the Blockchain. + * + * @param {string} user Username + * @param {string} password Password + * @returns A promise that is fulfilled after login. + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.login = function login(user, password) { + var _this2 = this; + + this.debug('!!! ChainWebSocket login.', user, password); + return this.connect_promise.then(function () { + return _this2.call([1, 'login', [user, password]]); + }); + }; + + /** + * Close the connection to the Blockchain. + * + * @memberof ChainWebSocket + */ + + + ChainWebSocket.prototype.close = function close() { + if (this.ws) { + this.removeEventListeners(); + + // Try and fire close on the connection. + this.ws.close(); + + // Clear our references so that it can be garbage collected. + this.ws = null; + } + + // Clear our timeouts for connection timeout and health check. + clearTimeout(this.connectionTimeout); + this.connectionTimeout = null; + + clearTimeout(this.healthCheck); + this.healthCheck = null; + + clearTimeout(this.reconnectTimeout); + this.reconnectTimeout = null; + + // Toggle the connected flag. + this.connected = false; + }; + + ChainWebSocket.prototype.debug = function debug() { + if (SOCKET_DEBUG) { + for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) { + params[_key] = arguments[_key]; + } + + console.log.apply(null, params); + } + }; + + return ChainWebSocket; +}(); + +// Constants for STATE + + +ChainWebSocket.status = { + RECONNECTED: 'reconnected', + OPEN: 'open', + CLOSED: 'closed', + ERROR: 'error' +}; + +exports.default = ChainWebSocket; +},{"34":34}],74:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +var _ApiInstances = require(71); + +var _ApiInstances2 = _interopRequireDefault(_ApiInstances); + +var _ChainWebSocket = require(73); + +var _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Manager = function () { + function Manager(_ref) { + var url = _ref.url, + urls = _ref.urls; + + _classCallCheck(this, Manager); + + this.url = url; + this.urls = urls.filter(function (a) { + return a !== url; + }); + } + + Manager.prototype.logFailure = function logFailure(url) { + console.error('Unable to connect to', url + ', skipping to next full node API server'); + }; + + Manager.prototype.connect = function connect() { + var _connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url; + + return new Promise(function (resolve, reject) { + _ApiInstances2.default.instance(url, _connect).init_promise.then(resolve).catch(function (error) { + _ApiInstances2.default.instance().close(); + reject(error); + }); + }); + }; + + Manager.prototype.connectWithFallback = function connectWithFallback() { + var connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url; + var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + + var _this = this; + + var resolve = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; + var reject = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null; + + if (reject && index > this.urls.length - 1) { + return reject(new Error('Tried ' + (index + 1) + ' connections, none of which worked: ' + JSON.stringify(this.urls.concat(this.url)))); + } + + var fallback = function fallback(resolve, reject) { + _this.logFailure(url); + return _this.connectWithFallback(connect, _this.urls[index], index + 1, resolve, reject); + }; + + if (resolve && reject) { + return this.connect(connect, url).then(resolve).catch(function () { + fallback(resolve, reject); + }); + } + + return new Promise(function (resolve, reject) { + _this.connect(connect).then(resolve).catch(function () { + fallback(resolve, reject); + }); + }); + }; + + Manager.prototype.checkConnections = function checkConnections() { + var rpc_user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var rpc_password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + var _this2 = this; + + var resolve = arguments[2]; + var reject = arguments[3]; + + var connectionStartTimes = {}; + + var checkFunction = function checkFunction(resolve, reject) { + var fullList = _this2.urls.concat(_this2.url); + var connectionPromises = []; + + fullList.forEach(function (url) { + var conn = new _ChainWebSocket2.default(url, function () {}); + connectionStartTimes[url] = new Date().getTime(); + connectionPromises.push(function () { + return conn.login(rpc_user, rpc_password).then(function () { + var _ref2; + + conn.close(); + return _ref2 = {}, _ref2[url] = new Date().getTime() - connectionStartTimes[url], _ref2; + }).catch(function () { + if (url === _this2.url) { + _this2.url = _this2.urls[0]; + } else { + _this2.urls = _this2.urls.filter(function (a) { + return a !== url; + }); + } + + conn.close(); + return null; + }); + }); + }); + + Promise.all(connectionPromises.map(function (a) { + return a(); + })).then(function (res) { + resolve(res.filter(function (a) { + return !!a; + }).reduce(function (f, a) { + var key = Object.keys(a)[0]; + f[key] = a[key]; + return f; + }, {})); + }).catch(function () { + return _this2.checkConnections(rpc_user, rpc_password, resolve, reject); + }); + }; + + if (resolve && reject) { + checkFunction(resolve, reject); + } else { + return new Promise(checkFunction); + } + }; + + return Manager; +}(); + +exports.default = Manager; +},{"71":71,"73":73}],75:[function(require,module,exports){ +'use strict'; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var GrapheneApi = function () { + function GrapheneApi(ws_rpc, api_name) { + _classCallCheck(this, GrapheneApi); + + this.ws_rpc = ws_rpc; + this.api_name = api_name; + } + + GrapheneApi.prototype.init = function init() { + var _this = this; + + return this.ws_rpc.call([1, this.api_name, []]).then(function (response) { + _this.api_id = response; + return _this; + }); + }; + + GrapheneApi.prototype.exec = function exec(method, params) { + return this.ws_rpc.call([this.api_id, method, params]).catch(function (error) { + console.log('!!! GrapheneApi error: ', method, params, error, JSON.stringify(error)); + throw error; + }); + }; + + return GrapheneApi; +}(); + +exports.default = GrapheneApi; +},{}],76:[function(require,module,exports){ +(function (process){ +'use strict'; + +if (!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); + }); + } +} + + +}).call(this,require(77)) + +},{"77":77}],77:[function(require,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; }; + +},{}],78:[function(require,module,exports){ +module.exports = require(79); + +},{"79":79}],79:[function(require,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. + +// 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 = require(76); +/**/ + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + keys.push(key); + }return keys; +}; +/**/ + +module.exports = Duplex; + +/**/ +var util = require(40); +util.inherits = require(87); +/**/ + +var Readable = require(81); +var Writable = require(83); + +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); +}; +},{"40":40,"76":76,"81":81,"83":83,"87":87}],80:[function(require,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. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + +'use strict'; + +module.exports = PassThrough; + +var Transform = require(82); + +/**/ +var util = require(40); +util.inherits = require(87); +/**/ + +util.inherits(PassThrough, Transform); + +function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + + Transform.call(this, options); +} + +PassThrough.prototype._transform = function (chunk, encoding, cb) { + cb(null, chunk); +}; +},{"40":40,"82":82,"87":87}],81:[function(require,module,exports){ +(function (process,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. + +'use strict'; + +/**/ + +var pna = require(76); +/**/ + +module.exports = Readable; + +/**/ +var isArray = require(67); +/**/ + +/**/ +var Duplex; +/**/ + +Readable.ReadableState = ReadableState; + +/**/ +var EE = require(62).EventEmitter; + +var EElistenerCount = function (emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +/**/ +var Stream = require(86); +/**/ + +/**/ + +var Buffer = require(93).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 = require(40); +util.inherits = require(87); +/**/ + +/**/ +var debugUtil = require(34); +var debug = void 0; +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function () {}; +} +/**/ + +var BufferList = require(84); +var destroyImpl = require(85); +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 || require(79); + + 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 = require(104).StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + Duplex = Duplex || require(79); + + 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 = require(104).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; +} +}).call(this,require(77),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"104":104,"34":34,"40":40,"62":62,"67":67,"76":76,"77":77,"79":79,"84":84,"85":85,"86":86,"87":87,"93":93}],82:[function(require,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. + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + +'use strict'; + +module.exports = Transform; + +var Duplex = require(79); + +/**/ +var util = require(40); +util.inherits = require(87); +/**/ + +util.inherits(Transform, Duplex); + +function afterTransform(er, data) { + var ts = this._transformState; + ts.transforming = false; + + var cb = ts.writecb; + + if (!cb) { + return this.emit('error', new Error('write callback called multiple times')); + } + + ts.writechunk = null; + ts.writecb = null; + + if (data != null) // single equals check for both `null` and `undefined` + this.push(data); + + cb(er); + + var rs = this._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + this._read(rs.highWaterMark); + } +} + +function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + + Duplex.call(this, options); + + this._transformState = { + afterTransform: afterTransform.bind(this), + needTransform: false, + transforming: false, + writecb: null, + writechunk: null, + writeencoding: null + }; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + + if (options) { + if (typeof options.transform === 'function') this._transform = options.transform; + + if (typeof options.flush === 'function') this._flush = options.flush; + } + + // When the writable side finishes, then flush out anything remaining. + this.on('prefinish', prefinish); +} + +function prefinish() { + var _this = this; + + if (typeof this._flush === 'function') { + this._flush(function (er, data) { + done(_this, er, data); + }); + } else { + done(this, null, null); + } +} + +Transform.prototype.push = function (chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function (chunk, encoding, cb) { + throw new Error('_transform() is not implemented'); +}; + +Transform.prototype._write = function (chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function (n) { + var ts = this._transformState; + + if (ts.writechunk !== null && ts.writecb && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; + +Transform.prototype._destroy = function (err, cb) { + var _this2 = this; + + Duplex.prototype._destroy.call(this, err, function (err2) { + cb(err2); + _this2.emit('close'); + }); +}; + +function done(stream, er, data) { + if (er) return stream.emit('error', er); + + if (data != null) // single equals check for both `null` and `undefined` + stream.push(data); + + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0'); + + if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming'); + + return stream.push(null); +} +},{"40":40,"79":79,"87":87}],83:[function(require,module,exports){ +(function (process,global,setImmediate){ +// 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 = require(76); +/**/ + +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 = require(40); +util.inherits = require(87); +/**/ + +/**/ +var internalUtil = { + deprecate: require(106) +}; +/**/ + +/**/ +var Stream = require(86); +/**/ + +/**/ + +var Buffer = require(93).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 = require(85); + +util.inherits(Writable, Stream); + +function nop() {} + +function WritableState(options, stream) { + Duplex = Duplex || require(79); + + 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 || require(79); + + // 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); +}; +}).call(this,require(77),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require(105).setImmediate) + +},{"105":105,"106":106,"40":40,"76":76,"77":77,"79":79,"85":85,"86":86,"87":87,"93":93}],84:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Buffer = require(93).Buffer; +var util = require(34); + +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; + }; +} +},{"34":34,"93":93}],85:[function(require,module,exports){ +'use strict'; + +/**/ + +var pna = require(76); +/**/ + +// 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 +}; +},{"76":76}],86:[function(require,module,exports){ +module.exports = require(62).EventEmitter; + +},{"62":62}],87:[function(require,module,exports){ +arguments[4][65][0].apply(exports,arguments) +},{"65":65}],88:[function(require,module,exports){ +module.exports = require(89).PassThrough + +},{"89":89}],89:[function(require,module,exports){ +exports = module.exports = require(81); +exports.Stream = exports; +exports.Readable = exports; +exports.Writable = require(83); +exports.Duplex = require(79); +exports.Transform = require(82); +exports.PassThrough = require(80); + +},{"79":79,"80":80,"81":81,"82":82,"83":83}],90:[function(require,module,exports){ +module.exports = require(89).Transform + +},{"89":89}],91:[function(require,module,exports){ +module.exports = require(83); + +},{"83":83}],92:[function(require,module,exports){ +'use strict' +var Buffer = require(35).Buffer +var inherits = require(65) +var HashBase = require(63) + +var ARRAY16 = new Array(16) + +var zl = [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, + 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, + 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, + 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 +] + +var zr = [ + 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, + 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, + 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, + 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, + 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 +] + +var sl = [ + 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, + 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, + 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, + 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, + 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 +] + +var sr = [ + 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, + 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, + 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, + 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, + 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 +] + +var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e] +var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000] + +function RIPEMD160 () { + HashBase.call(this, 64) + + // state + this._a = 0x67452301 + this._b = 0xefcdab89 + this._c = 0x98badcfe + this._d = 0x10325476 + this._e = 0xc3d2e1f0 +} + +inherits(RIPEMD160, HashBase) + +RIPEMD160.prototype._update = function () { + var words = ARRAY16 + for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4) + + var al = this._a | 0 + var bl = this._b | 0 + var cl = this._c | 0 + var dl = this._d | 0 + var el = this._e | 0 + + var ar = this._a | 0 + var br = this._b | 0 + var cr = this._c | 0 + var dr = this._d | 0 + var er = this._e | 0 + + // computation + for (var i = 0; i < 80; i += 1) { + var tl + var tr + if (i < 16) { + tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]) + tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]) + } else if (i < 32) { + tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]) + tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]) + } else if (i < 48) { + tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]) + tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]) + } else if (i < 64) { + tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]) + tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]) + } else { // if (i<80) { + tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]) + tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]) + } + + al = el + el = dl + dl = rotl(cl, 10) + cl = bl + bl = tl + + ar = er + er = dr + dr = rotl(cr, 10) + cr = br + br = tr + } + + // update state + var t = (this._b + cl + dr) | 0 + this._b = (this._c + dl + er) | 0 + this._c = (this._d + el + ar) | 0 + this._d = (this._e + al + br) | 0 + this._e = (this._a + bl + cr) | 0 + this._a = t +} + +RIPEMD160.prototype._digest = function () { + // create padding and handle blocks + this._block[this._blockOffset++] = 0x80 + if (this._blockOffset > 56) { + this._block.fill(0, this._blockOffset, 64) + this._update() + this._blockOffset = 0 + } + + this._block.fill(0, this._blockOffset, 56) + this._block.writeUInt32LE(this._length[0], 56) + this._block.writeUInt32LE(this._length[1], 60) + this._update() + + // produce result + var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20) + buffer.writeInt32LE(this._a, 0) + buffer.writeInt32LE(this._b, 4) + buffer.writeInt32LE(this._c, 8) + buffer.writeInt32LE(this._d, 12) + buffer.writeInt32LE(this._e, 16) + return buffer +} + +function rotl (x, n) { + return (x << n) | (x >>> (32 - n)) +} + +function fn1 (a, b, c, d, e, m, k, s) { + return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0 +} + +function fn2 (a, b, c, d, e, m, k, s) { + return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0 +} + +function fn3 (a, b, c, d, e, m, k, s) { + return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0 +} + +function fn4 (a, b, c, d, e, m, k, s) { + return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0 +} + +function fn5 (a, b, c, d, e, m, k, s) { + return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0 +} + +module.exports = RIPEMD160 + +},{"35":35,"63":63,"65":65}],93:[function(require,module,exports){ +/* eslint-disable node/no-deprecated-api */ +var buffer = require(35) +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) +} + +},{"35":35}],94:[function(require,module,exports){ +(function (process,Buffer){ +!function(globals){ +'use strict' + +//*** UMD BEGIN +if (typeof define !== 'undefined' && define.amd) { //require.js / AMD + define([], function() { + return secureRandom + }) +} else if (typeof module !== 'undefined' && module.exports) { //CommonJS + module.exports = secureRandom +} else { //script / browser + globals.secureRandom = secureRandom +} +//*** UMD END + +//options.type is the only valid option +function secureRandom(count, options) { + options = options || {type: 'Array'} + //we check for process.pid to prevent browserify from tricking us + if (typeof process != 'undefined' && typeof process.pid == 'number') { + return nodeRandom(count, options) + } else { + var crypto = window.crypto || window.msCrypto + if (!crypto) throw new Error("Your browser does not support window.crypto.") + return browserRandom(count, options) + } +} + +function nodeRandom(count, options) { + var crypto = require(34) + var buf = crypto.randomBytes(count) + + switch (options.type) { + case 'Array': + return [].slice.call(buf) + case 'Buffer': + return buf + case 'Uint8Array': + var arr = new Uint8Array(count) + for (var i = 0; i < count; ++i) { arr[i] = buf.readUInt8(i) } + return arr + default: + throw new Error(options.type + " is unsupported.") + } +} + +function browserRandom(count, options) { + var nativeArr = new Uint8Array(count) + var crypto = window.crypto || window.msCrypto + crypto.getRandomValues(nativeArr) + + switch (options.type) { + case 'Array': + return [].slice.call(nativeArr) + case 'Buffer': + try { var b = new Buffer(1) } catch(e) { throw new Error('Buffer not supported in this environment. Use Node.js or Browserify for browser support.')} + return new Buffer(nativeArr) + case 'Uint8Array': + return nativeArr + default: + throw new Error(options.type + " is unsupported.") + } +} + +secureRandom.randomArray = function(byteCount) { + return secureRandom(byteCount, {type: 'Array'}) +} + +secureRandom.randomUint8Array = function(byteCount) { + return secureRandom(byteCount, {type: 'Uint8Array'}) +} + +secureRandom.randomBuffer = function(byteCount) { + return secureRandom(byteCount, {type: 'Buffer'}) +} + + +}(this); + +}).call(this,require(77),require(35).Buffer) + +},{"34":34,"35":35,"77":77}],95:[function(require,module,exports){ +var Buffer = require(93).Buffer + +// prototype class for hash functions +function Hash (blockSize, finalSize) { + this._block = Buffer.alloc(blockSize) + this._finalSize = finalSize + this._blockSize = blockSize + this._len = 0 +} + +Hash.prototype.update = function (data, enc) { + if (typeof data === 'string') { + enc = enc || 'utf8' + data = Buffer.from(data, enc) + } + + var block = this._block + var blockSize = this._blockSize + var length = data.length + var accum = this._len + + for (var offset = 0; offset < length;) { + var assigned = accum % blockSize + var remainder = Math.min(length - offset, blockSize - assigned) + + for (var i = 0; i < remainder; i++) { + block[assigned + i] = data[offset + i] + } + + accum += remainder + offset += remainder + + if ((accum % blockSize) === 0) { + this._update(block) + } + } + + this._len += length + return this +} + +Hash.prototype.digest = function (enc) { + var rem = this._len % this._blockSize + + this._block[rem] = 0x80 + + // zero (rem + 1) trailing bits, where (rem + 1) is the smallest + // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize + this._block.fill(0, rem + 1) + + if (rem >= this._finalSize) { + this._update(this._block) + this._block.fill(0) + } + + var bits = this._len * 8 + + // uint32 + if (bits <= 0xffffffff) { + this._block.writeUInt32BE(bits, this._blockSize - 4) + + // uint64 + } else { + var lowBits = (bits & 0xffffffff) >>> 0 + var highBits = (bits - lowBits) / 0x100000000 + + this._block.writeUInt32BE(highBits, this._blockSize - 8) + this._block.writeUInt32BE(lowBits, this._blockSize - 4) + } + + this._update(this._block) + var hash = this._hash() + + return enc ? hash.toString(enc) : hash +} + +Hash.prototype._update = function () { + throw new Error('_update must be implemented by subclass') +} + +module.exports = Hash + +},{"93":93}],96:[function(require,module,exports){ +var exports = module.exports = function SHA (algorithm) { + algorithm = algorithm.toLowerCase() + + var Algorithm = exports[algorithm] + if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)') + + return new Algorithm() +} + +exports.sha = require(97) +exports.sha1 = require(98) +exports.sha224 = require(99) +exports.sha256 = require(100) +exports.sha384 = require(101) +exports.sha512 = require(102) + +},{"100":100,"101":101,"102":102,"97":97,"98":98,"99":99}],97:[function(require,module,exports){ +/* + * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined + * in FIPS PUB 180-1 + * This source code is derived from sha1.js of the same repository. + * The difference between SHA-0 and SHA-1 is just a bitwise rotate left + * operation was added. + */ + +var inherits = require(65) +var Hash = require(95) +var Buffer = require(93).Buffer + +var K = [ + 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 +] + +var W = new Array(80) + +function Sha () { + this.init() + this._w = W + + Hash.call(this, 64, 56) +} + +inherits(Sha, Hash) + +Sha.prototype.init = function () { + this._a = 0x67452301 + this._b = 0xefcdab89 + this._c = 0x98badcfe + this._d = 0x10325476 + this._e = 0xc3d2e1f0 + + return this +} + +function rotl5 (num) { + return (num << 5) | (num >>> 27) +} + +function rotl30 (num) { + return (num << 30) | (num >>> 2) +} + +function ft (s, b, c, d) { + if (s === 0) return (b & c) | ((~b) & d) + if (s === 2) return (b & c) | (b & d) | (c & d) + return b ^ c ^ d +} + +Sha.prototype._update = function (M) { + var W = this._w + + var a = this._a | 0 + var b = this._b | 0 + var c = this._c | 0 + var d = this._d | 0 + var e = this._e | 0 + + for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) + for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16] + + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20) + var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0 + + e = d + d = c + c = rotl30(b) + b = a + a = t + } + + this._a = (a + this._a) | 0 + this._b = (b + this._b) | 0 + this._c = (c + this._c) | 0 + this._d = (d + this._d) | 0 + this._e = (e + this._e) | 0 +} + +Sha.prototype._hash = function () { + var H = Buffer.allocUnsafe(20) + + H.writeInt32BE(this._a | 0, 0) + H.writeInt32BE(this._b | 0, 4) + H.writeInt32BE(this._c | 0, 8) + H.writeInt32BE(this._d | 0, 12) + H.writeInt32BE(this._e | 0, 16) + + return H +} + +module.exports = Sha + +},{"65":65,"93":93,"95":95}],98:[function(require,module,exports){ +/* + * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined + * in FIPS PUB 180-1 + * Version 2.1a Copyright Paul Johnston 2000 - 2002. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for details. + */ + +var inherits = require(65) +var Hash = require(95) +var Buffer = require(93).Buffer + +var K = [ + 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 +] + +var W = new Array(80) + +function Sha1 () { + this.init() + this._w = W + + Hash.call(this, 64, 56) +} + +inherits(Sha1, Hash) + +Sha1.prototype.init = function () { + this._a = 0x67452301 + this._b = 0xefcdab89 + this._c = 0x98badcfe + this._d = 0x10325476 + this._e = 0xc3d2e1f0 + + return this +} + +function rotl1 (num) { + return (num << 1) | (num >>> 31) +} + +function rotl5 (num) { + return (num << 5) | (num >>> 27) +} + +function rotl30 (num) { + return (num << 30) | (num >>> 2) +} + +function ft (s, b, c, d) { + if (s === 0) return (b & c) | ((~b) & d) + if (s === 2) return (b & c) | (b & d) | (c & d) + return b ^ c ^ d +} + +Sha1.prototype._update = function (M) { + var W = this._w + + var a = this._a | 0 + var b = this._b | 0 + var c = this._c | 0 + var d = this._d | 0 + var e = this._e | 0 + + for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) + for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]) + + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20) + var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0 + + e = d + d = c + c = rotl30(b) + b = a + a = t + } + + this._a = (a + this._a) | 0 + this._b = (b + this._b) | 0 + this._c = (c + this._c) | 0 + this._d = (d + this._d) | 0 + this._e = (e + this._e) | 0 +} + +Sha1.prototype._hash = function () { + var H = Buffer.allocUnsafe(20) + + H.writeInt32BE(this._a | 0, 0) + H.writeInt32BE(this._b | 0, 4) + H.writeInt32BE(this._c | 0, 8) + H.writeInt32BE(this._d | 0, 12) + H.writeInt32BE(this._e | 0, 16) + + return H +} + +module.exports = Sha1 + +},{"65":65,"93":93,"95":95}],99:[function(require,module,exports){ +/** + * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined + * in FIPS 180-2 + * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * + */ + +var inherits = require(65) +var Sha256 = require(100) +var Hash = require(95) +var Buffer = require(93).Buffer + +var W = new Array(64) + +function Sha224 () { + this.init() + + this._w = W // new Array(64) + + Hash.call(this, 64, 56) +} + +inherits(Sha224, Sha256) + +Sha224.prototype.init = function () { + this._a = 0xc1059ed8 + this._b = 0x367cd507 + this._c = 0x3070dd17 + this._d = 0xf70e5939 + this._e = 0xffc00b31 + this._f = 0x68581511 + this._g = 0x64f98fa7 + this._h = 0xbefa4fa4 + + return this +} + +Sha224.prototype._hash = function () { + var H = Buffer.allocUnsafe(28) + + H.writeInt32BE(this._a, 0) + H.writeInt32BE(this._b, 4) + H.writeInt32BE(this._c, 8) + H.writeInt32BE(this._d, 12) + H.writeInt32BE(this._e, 16) + H.writeInt32BE(this._f, 20) + H.writeInt32BE(this._g, 24) + + return H +} + +module.exports = Sha224 + +},{"100":100,"65":65,"93":93,"95":95}],100:[function(require,module,exports){ +/** + * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined + * in FIPS 180-2 + * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * + */ + +var inherits = require(65) +var Hash = require(95) +var Buffer = require(93).Buffer + +var K = [ + 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, + 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, + 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, + 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, + 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, + 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, + 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, + 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, + 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, + 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, + 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, + 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, + 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, + 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, + 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, + 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 +] + +var W = new Array(64) + +function Sha256 () { + this.init() + + this._w = W // new Array(64) + + Hash.call(this, 64, 56) +} + +inherits(Sha256, Hash) + +Sha256.prototype.init = function () { + this._a = 0x6a09e667 + this._b = 0xbb67ae85 + this._c = 0x3c6ef372 + this._d = 0xa54ff53a + this._e = 0x510e527f + this._f = 0x9b05688c + this._g = 0x1f83d9ab + this._h = 0x5be0cd19 + + return this +} + +function ch (x, y, z) { + return z ^ (x & (y ^ z)) +} + +function maj (x, y, z) { + return (x & y) | (z & (x | y)) +} + +function sigma0 (x) { + return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10) +} + +function sigma1 (x) { + return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7) +} + +function gamma0 (x) { + return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3) +} + +function gamma1 (x) { + return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10) +} + +Sha256.prototype._update = function (M) { + var W = this._w + + var a = this._a | 0 + var b = this._b | 0 + var c = this._c | 0 + var d = this._d | 0 + var e = this._e | 0 + var f = this._f | 0 + var g = this._g | 0 + var h = this._h | 0 + + for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) + for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0 + + for (var j = 0; j < 64; ++j) { + var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0 + var T2 = (sigma0(a) + maj(a, b, c)) | 0 + + h = g + g = f + f = e + e = (d + T1) | 0 + d = c + c = b + b = a + a = (T1 + T2) | 0 + } + + this._a = (a + this._a) | 0 + this._b = (b + this._b) | 0 + this._c = (c + this._c) | 0 + this._d = (d + this._d) | 0 + this._e = (e + this._e) | 0 + this._f = (f + this._f) | 0 + this._g = (g + this._g) | 0 + this._h = (h + this._h) | 0 +} + +Sha256.prototype._hash = function () { + var H = Buffer.allocUnsafe(32) + + H.writeInt32BE(this._a, 0) + H.writeInt32BE(this._b, 4) + H.writeInt32BE(this._c, 8) + H.writeInt32BE(this._d, 12) + H.writeInt32BE(this._e, 16) + H.writeInt32BE(this._f, 20) + H.writeInt32BE(this._g, 24) + H.writeInt32BE(this._h, 28) + + return H +} + +module.exports = Sha256 + +},{"65":65,"93":93,"95":95}],101:[function(require,module,exports){ +var inherits = require(65) +var SHA512 = require(102) +var Hash = require(95) +var Buffer = require(93).Buffer + +var W = new Array(160) + +function Sha384 () { + this.init() + this._w = W + + Hash.call(this, 128, 112) +} + +inherits(Sha384, SHA512) + +Sha384.prototype.init = function () { + this._ah = 0xcbbb9d5d + this._bh = 0x629a292a + this._ch = 0x9159015a + this._dh = 0x152fecd8 + this._eh = 0x67332667 + this._fh = 0x8eb44a87 + this._gh = 0xdb0c2e0d + this._hh = 0x47b5481d + + this._al = 0xc1059ed8 + this._bl = 0x367cd507 + this._cl = 0x3070dd17 + this._dl = 0xf70e5939 + this._el = 0xffc00b31 + this._fl = 0x68581511 + this._gl = 0x64f98fa7 + this._hl = 0xbefa4fa4 + + return this +} + +Sha384.prototype._hash = function () { + var H = Buffer.allocUnsafe(48) + + function writeInt64BE (h, l, offset) { + H.writeInt32BE(h, offset) + H.writeInt32BE(l, offset + 4) + } + + writeInt64BE(this._ah, this._al, 0) + writeInt64BE(this._bh, this._bl, 8) + writeInt64BE(this._ch, this._cl, 16) + writeInt64BE(this._dh, this._dl, 24) + writeInt64BE(this._eh, this._el, 32) + writeInt64BE(this._fh, this._fl, 40) + + return H +} + +module.exports = Sha384 + +},{"102":102,"65":65,"93":93,"95":95}],102:[function(require,module,exports){ +var inherits = require(65) +var Hash = require(95) +var Buffer = require(93).Buffer + +var K = [ + 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, + 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, + 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, + 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, + 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, + 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, + 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, + 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, + 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, + 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, + 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, + 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, + 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, + 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, + 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, + 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, + 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, + 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, + 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, + 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, + 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, + 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, + 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, + 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, + 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, + 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, + 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, + 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, + 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, + 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, + 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, + 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, + 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, + 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, + 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, + 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, + 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, + 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, + 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, + 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 +] + +var W = new Array(160) + +function Sha512 () { + this.init() + this._w = W + + Hash.call(this, 128, 112) +} + +inherits(Sha512, Hash) + +Sha512.prototype.init = function () { + this._ah = 0x6a09e667 + this._bh = 0xbb67ae85 + this._ch = 0x3c6ef372 + this._dh = 0xa54ff53a + this._eh = 0x510e527f + this._fh = 0x9b05688c + this._gh = 0x1f83d9ab + this._hh = 0x5be0cd19 + + this._al = 0xf3bcc908 + this._bl = 0x84caa73b + this._cl = 0xfe94f82b + this._dl = 0x5f1d36f1 + this._el = 0xade682d1 + this._fl = 0x2b3e6c1f + this._gl = 0xfb41bd6b + this._hl = 0x137e2179 + + return this +} + +function Ch (x, y, z) { + return z ^ (x & (y ^ z)) +} + +function maj (x, y, z) { + return (x & y) | (z & (x | y)) +} + +function sigma0 (x, xl) { + return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25) +} + +function sigma1 (x, xl) { + return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23) +} + +function Gamma0 (x, xl) { + return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7) +} + +function Gamma0l (x, xl) { + return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25) +} + +function Gamma1 (x, xl) { + return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6) +} + +function Gamma1l (x, xl) { + return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26) +} + +function getCarry (a, b) { + return (a >>> 0) < (b >>> 0) ? 1 : 0 +} + +Sha512.prototype._update = function (M) { + var W = this._w + + var ah = this._ah | 0 + var bh = this._bh | 0 + var ch = this._ch | 0 + var dh = this._dh | 0 + var eh = this._eh | 0 + var fh = this._fh | 0 + var gh = this._gh | 0 + var hh = this._hh | 0 + + var al = this._al | 0 + var bl = this._bl | 0 + var cl = this._cl | 0 + var dl = this._dl | 0 + var el = this._el | 0 + var fl = this._fl | 0 + var gl = this._gl | 0 + var hl = this._hl | 0 + + for (var i = 0; i < 32; i += 2) { + W[i] = M.readInt32BE(i * 4) + W[i + 1] = M.readInt32BE(i * 4 + 4) + } + for (; i < 160; i += 2) { + var xh = W[i - 15 * 2] + var xl = W[i - 15 * 2 + 1] + var gamma0 = Gamma0(xh, xl) + var gamma0l = Gamma0l(xl, xh) + + xh = W[i - 2 * 2] + xl = W[i - 2 * 2 + 1] + var gamma1 = Gamma1(xh, xl) + var gamma1l = Gamma1l(xl, xh) + + // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] + var Wi7h = W[i - 7 * 2] + var Wi7l = W[i - 7 * 2 + 1] + + var Wi16h = W[i - 16 * 2] + var Wi16l = W[i - 16 * 2 + 1] + + var Wil = (gamma0l + Wi7l) | 0 + var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0 + Wil = (Wil + gamma1l) | 0 + Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0 + Wil = (Wil + Wi16l) | 0 + Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0 + + W[i] = Wih + W[i + 1] = Wil + } + + for (var j = 0; j < 160; j += 2) { + Wih = W[j] + Wil = W[j + 1] + + var majh = maj(ah, bh, ch) + var majl = maj(al, bl, cl) + + var sigma0h = sigma0(ah, al) + var sigma0l = sigma0(al, ah) + var sigma1h = sigma1(eh, el) + var sigma1l = sigma1(el, eh) + + // t1 = h + sigma1 + ch + K[j] + W[j] + var Kih = K[j] + var Kil = K[j + 1] + + var chh = Ch(eh, fh, gh) + var chl = Ch(el, fl, gl) + + var t1l = (hl + sigma1l) | 0 + var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0 + t1l = (t1l + chl) | 0 + t1h = (t1h + chh + getCarry(t1l, chl)) | 0 + t1l = (t1l + Kil) | 0 + t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0 + t1l = (t1l + Wil) | 0 + t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0 + + // t2 = sigma0 + maj + var t2l = (sigma0l + majl) | 0 + var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0 + + hh = gh + hl = gl + gh = fh + gl = fl + fh = eh + fl = el + el = (dl + t1l) | 0 + eh = (dh + t1h + getCarry(el, dl)) | 0 + dh = ch + dl = cl + ch = bh + cl = bl + bh = ah + bl = al + al = (t1l + t2l) | 0 + ah = (t1h + t2h + getCarry(al, t1l)) | 0 + } + + this._al = (this._al + al) | 0 + this._bl = (this._bl + bl) | 0 + this._cl = (this._cl + cl) | 0 + this._dl = (this._dl + dl) | 0 + this._el = (this._el + el) | 0 + this._fl = (this._fl + fl) | 0 + this._gl = (this._gl + gl) | 0 + this._hl = (this._hl + hl) | 0 + + this._ah = (this._ah + ah + getCarry(this._al, al)) | 0 + this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0 + this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0 + this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0 + this._eh = (this._eh + eh + getCarry(this._el, el)) | 0 + this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0 + this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0 + this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0 +} + +Sha512.prototype._hash = function () { + var H = Buffer.allocUnsafe(64) + + function writeInt64BE (h, l, offset) { + H.writeInt32BE(h, offset) + H.writeInt32BE(l, offset + 4) + } + + writeInt64BE(this._ah, this._al, 0) + writeInt64BE(this._bh, this._bl, 8) + writeInt64BE(this._ch, this._cl, 16) + writeInt64BE(this._dh, this._dl, 24) + writeInt64BE(this._eh, this._el, 32) + writeInt64BE(this._fh, this._fl, 40) + writeInt64BE(this._gh, this._gl, 48) + writeInt64BE(this._hh, this._hl, 56) + + return H +} + +module.exports = Sha512 + +},{"65":65,"93":93,"95":95}],103:[function(require,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. + +module.exports = Stream; + +var EE = require(62).EventEmitter; +var inherits = require(65); + +inherits(Stream, EE); +Stream.Readable = require(89); +Stream.Writable = require(91); +Stream.Duplex = require(78); +Stream.Transform = require(90); +Stream.PassThrough = require(88); + +// 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; +}; + +},{"62":62,"65":65,"78":78,"88":88,"89":89,"90":90,"91":91}],104:[function(require,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. + +'use strict'; + +/**/ + +var Buffer = require(93).Buffer; +/**/ + +var isEncoding = Buffer.isEncoding || function (encoding) { + encoding = '' + encoding; + switch (encoding && encoding.toLowerCase()) { + case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw': + return true; + default: + return false; + } +}; + +function _normalizeEncoding(enc) { + if (!enc) return 'utf8'; + var retried; + while (true) { + switch (enc) { + case 'utf8': + case 'utf-8': + return 'utf8'; + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return 'utf16le'; + case 'latin1': + case 'binary': + return 'latin1'; + case 'base64': + case 'ascii': + case 'hex': + return enc; + default: + if (retried) return; // undefined + enc = ('' + enc).toLowerCase(); + retried = true; + } + } +}; + +// Do not cache `Buffer.isEncoding` when checking encoding names as some +// modules monkey-patch it to support additional encodings +function normalizeEncoding(enc) { + var nenc = _normalizeEncoding(enc); + if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); + return nenc || enc; +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. +exports.StringDecoder = StringDecoder; +function StringDecoder(encoding) { + this.encoding = normalizeEncoding(encoding); + var nb; + switch (this.encoding) { + case 'utf16le': + this.text = utf16Text; + this.end = utf16End; + nb = 4; + break; + case 'utf8': + this.fillLast = utf8FillLast; + nb = 4; + break; + case 'base64': + this.text = base64Text; + this.end = base64End; + nb = 3; + break; + default: + this.write = simpleWrite; + this.end = simpleEnd; + return; + } + this.lastNeed = 0; + this.lastTotal = 0; + this.lastChar = Buffer.allocUnsafe(nb); +} + +StringDecoder.prototype.write = function (buf) { + if (buf.length === 0) return ''; + var r; + var i; + if (this.lastNeed) { + r = this.fillLast(buf); + if (r === undefined) return ''; + i = this.lastNeed; + this.lastNeed = 0; + } else { + i = 0; + } + if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); + return r || ''; +}; + +StringDecoder.prototype.end = utf8End; + +// Returns only complete characters in a Buffer +StringDecoder.prototype.text = utf8Text; + +// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer +StringDecoder.prototype.fillLast = function (buf) { + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); + this.lastNeed -= buf.length; +}; + +// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a +// continuation byte. If an invalid byte is detected, -2 is returned. +function utf8CheckByte(byte) { + if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; + return byte >> 6 === 0x02 ? -1 : -2; +} + +// Checks at most 3 bytes at the end of a Buffer in order to detect an +// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) +// needed to complete the UTF-8 character (if applicable) are returned. +function utf8CheckIncomplete(self, buf, i) { + var j = buf.length - 1; + if (j < i) return 0; + var nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 1; + return nb; + } + if (--j < i || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 2; + return nb; + } + if (--j < i || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) { + if (nb === 2) nb = 0;else self.lastNeed = nb - 3; + } + return nb; + } + return 0; +} + +// Validates as many continuation bytes for a multi-byte UTF-8 character as +// needed or are available. If we see a non-continuation byte where we expect +// one, we "replace" the validated continuation bytes we've seen so far with +// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding +// behavior. The continuation byte check is included three times in the case +// where all of the continuation bytes for a character exist in the same buffer. +// It is also done this way as a slight performance increase instead of using a +// loop. +function utf8CheckExtraBytes(self, buf, p) { + if ((buf[0] & 0xC0) !== 0x80) { + self.lastNeed = 0; + return '\ufffd'; + } + if (self.lastNeed > 1 && buf.length > 1) { + if ((buf[1] & 0xC0) !== 0x80) { + self.lastNeed = 1; + return '\ufffd'; + } + if (self.lastNeed > 2 && buf.length > 2) { + if ((buf[2] & 0xC0) !== 0x80) { + self.lastNeed = 2; + return '\ufffd'; + } + } + } +} + +// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. +function utf8FillLast(buf) { + var p = this.lastTotal - this.lastNeed; + var r = utf8CheckExtraBytes(this, buf, p); + if (r !== undefined) return r; + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, p, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, p, 0, buf.length); + this.lastNeed -= buf.length; +} + +// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a +// partial character, the character's bytes are buffered until the required +// number of bytes are available. +function utf8Text(buf, i) { + var total = utf8CheckIncomplete(this, buf, i); + if (!this.lastNeed) return buf.toString('utf8', i); + this.lastTotal = total; + var end = buf.length - (total - this.lastNeed); + buf.copy(this.lastChar, 0, end); + return buf.toString('utf8', i, end); +} + +// For UTF-8, a replacement character is added when ending on a partial +// character. +function utf8End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + '\ufffd'; + return r; +} + +// UTF-16LE typically needs two bytes per character, but even if we have an even +// number of bytes available, we need to check if we end on a leading/high +// surrogate. In that case, we need to wait for the next two bytes in order to +// decode the last character properly. +function utf16Text(buf, i) { + if ((buf.length - i) % 2 === 0) { + var r = buf.toString('utf16le', i); + if (r) { + var c = r.charCodeAt(r.length - 1); + if (c >= 0xD800 && c <= 0xDBFF) { + this.lastNeed = 2; + this.lastTotal = 4; + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + return r.slice(0, -1); + } + } + return r; + } + this.lastNeed = 1; + this.lastTotal = 2; + this.lastChar[0] = buf[buf.length - 1]; + return buf.toString('utf16le', i, buf.length - 1); +} + +// For UTF-16LE we do not explicitly append special replacement characters if we +// end on a partial character, we simply let v8 handle that. +function utf16End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) { + var end = this.lastTotal - this.lastNeed; + return r + this.lastChar.toString('utf16le', 0, end); + } + return r; +} + +function base64Text(buf, i) { + var n = (buf.length - i) % 3; + if (n === 0) return buf.toString('base64', i); + this.lastNeed = 3 - n; + this.lastTotal = 3; + if (n === 1) { + this.lastChar[0] = buf[buf.length - 1]; + } else { + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + } + return buf.toString('base64', i, buf.length - n); +} + +function base64End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); + return r; +} + +// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) +function simpleWrite(buf) { + return buf.toString(this.encoding); +} + +function simpleEnd(buf) { + return buf && buf.length ? this.write(buf) : ''; +} +},{"93":93}],105:[function(require,module,exports){ +(function (setImmediate,clearImmediate){ +var nextTick = require(77).nextTick; +var apply = Function.prototype.apply; +var slice = Array.prototype.slice; +var immediateIds = {}; +var nextImmediateId = 0; + +// DOM APIs, for completeness + +exports.setTimeout = function() { + return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); +}; +exports.setInterval = function() { + return new Timeout(apply.call(setInterval, window, arguments), clearInterval); +}; +exports.clearTimeout = +exports.clearInterval = function(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(window, 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); + } +}; + +// That's not how node.js implements it but the exposed api is the same. +exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { + var id = nextImmediateId++; + var args = arguments.length < 2 ? false : slice.call(arguments, 1); + + immediateIds[id] = true; + + nextTick(function onNextTick() { + if (immediateIds[id]) { + // fn.call() is faster so we optimize for the common use-case + // @see http://jsperf.com/call-apply-segu + if (args) { + fn.apply(null, args); + } else { + fn.call(null); + } + // Prevent ids from leaking + exports.clearImmediate(id); + } + }); + + return id; +}; + +exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { + delete immediateIds[id]; +}; +}).call(this,require(105).setImmediate,require(105).clearImmediate) + +},{"105":105,"77":77}],106:[function(require,module,exports){ +(function (global){ + +/** + * Module exports. + */ + +module.exports = deprecate; + +/** + * Mark that a method should not be used. + * Returns a modified function which warns once by default. + * + * If `localStorage.noDeprecation = true` is set, then it is a no-op. + * + * If `localStorage.throwDeprecation = true` is set, then deprecated functions + * will throw an Error when invoked. + * + * If `localStorage.traceDeprecation = true` is set, then deprecated functions + * will invoke `console.trace()` instead of `console.error()`. + * + * @param {Function} fn - the function to deprecate + * @param {String} msg - the string to print to the console when `fn` is invoked + * @returns {Function} a new "deprecated" version of `fn` + * @api public + */ + +function deprecate (fn, msg) { + if (config('noDeprecation')) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (config('throwDeprecation')) { + throw new Error(msg); + } else if (config('traceDeprecation')) { + console.trace(msg); + } else { + console.warn(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +} + +/** + * Checks `localStorage` for boolean values for the given `name`. + * + * @param {String} name + * @returns {Boolean} + * @api private + */ + +function config (name) { + // accessing global.localStorage can trigger a DOMException in sandboxed iframes + try { + if (!global.localStorage) return false; + } catch (_) { + return false; + } + var val = global.localStorage[name]; + if (null == val) return false; + return String(val).toLowerCase() === 'true'; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],107:[function(require,module,exports){ +module.exports = function isBuffer(arg) { + return arg && typeof arg === 'object' + && typeof arg.copy === 'function' + && typeof arg.fill === 'function' + && typeof arg.readUInt8 === 'function'; +} +},{}],108:[function(require,module,exports){ +(function (process,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. + +var formatRegExp = /%[sdj%]/g; +exports.format = function(f) { + if (!isString(f)) { + var objects = []; + for (var i = 0; i < arguments.length; i++) { + objects.push(inspect(arguments[i])); + } + return objects.join(' '); + } + + var i = 1; + var args = arguments; + var len = args.length; + var str = String(f).replace(formatRegExp, function(x) { + if (x === '%%') return '%'; + if (i >= len) return x; + switch (x) { + case '%s': return String(args[i++]); + case '%d': return Number(args[i++]); + case '%j': + try { + return JSON.stringify(args[i++]); + } catch (_) { + return '[Circular]'; + } + default: + return x; + } + }); + for (var x = args[i]; i < len; x = args[++i]) { + if (isNull(x) || !isObject(x)) { + str += ' ' + x; + } else { + str += ' ' + inspect(x); + } + } + return str; +}; + + +// Mark that a method should not be used. +// Returns a modified function which warns once by default. +// If --no-deprecation is set, then it is a no-op. +exports.deprecate = function(fn, msg) { + // Allow for deprecating things in the process of starting up. + if (isUndefined(global.process)) { + return function() { + return exports.deprecate(fn, msg).apply(this, arguments); + }; + } + + if (process.noDeprecation === true) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (process.throwDeprecation) { + throw new Error(msg); + } else if (process.traceDeprecation) { + console.trace(msg); + } else { + console.error(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +}; + + +var debugs = {}; +var debugEnviron; +exports.debuglog = function(set) { + if (isUndefined(debugEnviron)) + debugEnviron = process.env.NODE_DEBUG || ''; + set = set.toUpperCase(); + if (!debugs[set]) { + if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { + var pid = process.pid; + debugs[set] = function() { + var msg = exports.format.apply(exports, arguments); + console.error('%s %d: %s', set, pid, msg); + }; + } else { + debugs[set] = function() {}; + } + } + return debugs[set]; +}; + + +/** + * Echos the value of a value. Trys to print the value out + * in the best way possible given the different types. + * + * @param {Object} obj The object to print out. + * @param {Object} opts Optional options object that alters the output. + */ +/* legacy: obj, showHidden, depth, colors*/ +function inspect(obj, opts) { + // default options + var ctx = { + seen: [], + stylize: stylizeNoColor + }; + // legacy... + if (arguments.length >= 3) ctx.depth = arguments[2]; + if (arguments.length >= 4) ctx.colors = arguments[3]; + if (isBoolean(opts)) { + // legacy... + ctx.showHidden = opts; + } else if (opts) { + // got an "options" object + exports._extend(ctx, opts); + } + // set default options + if (isUndefined(ctx.showHidden)) ctx.showHidden = false; + if (isUndefined(ctx.depth)) ctx.depth = 2; + if (isUndefined(ctx.colors)) ctx.colors = false; + if (isUndefined(ctx.customInspect)) ctx.customInspect = true; + if (ctx.colors) ctx.stylize = stylizeWithColor; + return formatValue(ctx, obj, ctx.depth); +} +exports.inspect = inspect; + + +// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics +inspect.colors = { + 'bold' : [1, 22], + 'italic' : [3, 23], + 'underline' : [4, 24], + 'inverse' : [7, 27], + 'white' : [37, 39], + 'grey' : [90, 39], + 'black' : [30, 39], + 'blue' : [34, 39], + 'cyan' : [36, 39], + 'green' : [32, 39], + 'magenta' : [35, 39], + 'red' : [31, 39], + 'yellow' : [33, 39] +}; + +// Don't use 'blue' not visible on cmd.exe +inspect.styles = { + 'special': 'cyan', + 'number': 'yellow', + 'boolean': 'yellow', + 'undefined': 'grey', + 'null': 'bold', + 'string': 'green', + 'date': 'magenta', + // "name": intentionally not styling + 'regexp': 'red' +}; + + +function stylizeWithColor(str, styleType) { + var style = inspect.styles[styleType]; + + if (style) { + return '\u001b[' + inspect.colors[style][0] + 'm' + str + + '\u001b[' + inspect.colors[style][1] + 'm'; + } else { + return str; + } +} + + +function stylizeNoColor(str, styleType) { + return str; +} + + +function arrayToHash(array) { + var hash = {}; + + array.forEach(function(val, idx) { + hash[val] = true; + }); + + return hash; +} + + +function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (ctx.customInspect && + value && + isFunction(value.inspect) && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes, ctx); + if (!isString(ret)) { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } + + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + + // Look up the keys of the object. + var keys = Object.keys(value); + var visibleKeys = arrayToHash(keys); + + if (ctx.showHidden) { + keys = Object.getOwnPropertyNames(value); + } + + // IE doesn't make error fields non-enumerable + // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx + if (isError(value) + && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { + return formatError(value); + } + + // Some type of object without properties can be shortcutted. + if (keys.length === 0) { + if (isFunction(value)) { + var name = value.name ? ': ' + value.name : ''; + return ctx.stylize('[Function' + name + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } + + var base = '', array = false, braces = ['{', '}']; + + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } + + // Make functions say that they are functions + if (isFunction(value)) { + var n = value.name ? ': ' + value.name : ''; + base = ' [Function' + n + ']'; + } + + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } + + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } + + // Make error with message first say the error + if (isError(value)) { + base = ' ' + formatError(value); + } + + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } + + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } + + ctx.seen.push(value); + + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } + + ctx.seen.pop(); + + return reduceToSingleString(output, base, braces); +} + + +function formatPrimitive(ctx, value) { + if (isUndefined(value)) + return ctx.stylize('undefined', 'undefined'); + if (isString(value)) { + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + } + if (isNumber(value)) + return ctx.stylize('' + value, 'number'); + if (isBoolean(value)) + return ctx.stylize('' + value, 'boolean'); + // For some reason typeof null is "object", so special case here. + if (isNull(value)) + return ctx.stylize('null', 'null'); +} + + +function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; +} + + +function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (hasOwnProperty(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; +} + + +function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str, desc; + desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; + if (desc.get) { + if (desc.set) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (desc.set) { + str = ctx.stylize('[Setter]', 'special'); + } + } + if (!hasOwnProperty(visibleKeys, key)) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(desc.value) < 0) { + if (isNull(recurseTimes)) { + str = formatValue(ctx, desc.value, null); + } else { + str = formatValue(ctx, desc.value, recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').substr(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (isUndefined(name)) { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.substr(1, name.length - 2); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } + + return name + ': ' + str; +} + + +function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } + + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; +} + + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. +function isArray(ar) { + return Array.isArray(ar); +} +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 isObject(re) && objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return isObject(d) && objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; + +function isError(e) { + return isObject(e) && + (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 = require(107); + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + + +function pad(n) { + return n < 10 ? '0' + n.toString(10) : n.toString(10); +} + + +var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', + 'Oct', 'Nov', 'Dec']; + +// 26 Feb 16:19:34 +function timestamp() { + var d = new Date(); + var time = [pad(d.getHours()), + pad(d.getMinutes()), + pad(d.getSeconds())].join(':'); + return [d.getDate(), months[d.getMonth()], time].join(' '); +} + + +// log is just a thin wrapper to console.log that prepends a timestamp +exports.log = function() { + console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); +}; + + +/** + * Inherit the prototype methods from one constructor into another. + * + * The Function.prototype.inherits from lang.js rewritten as a standalone + * function (not on Function.prototype). NOTE: If this file is to be loaded + * during bootstrapping this function needs to be rewritten using some native + * functions as prototype setup using normal JavaScript does not work as + * expected during bootstrapping (see mirror.js in r114903). + * + * @param {function} ctor Constructor function which needs to inherit the + * prototype. + * @param {function} superCtor Constructor function to inherit prototype from. + */ +exports.inherits = require(65); + +exports._extend = function(origin, add) { + // Don't do anything if add isn't an object + if (!add || !isObject(add)) return origin; + + var keys = Object.keys(add); + var i = keys.length; + while (i--) { + origin[keys[i]] = add[keys[i]]; + } + return origin; +}; + +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +}).call(this,require(77),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"107":107,"65":65,"77":77}]},{},[1])(1) +}); + +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","dist/browser.js","dist/chain/src/AccountLogin.js","dist/chain/src/ChainTypes.js","dist/chain/src/ObjectId.js","dist/chain/src/TransactionBuilder.js","dist/chain/src/state.js","dist/ecc/index.js","dist/ecc/src/BrainKey.js","dist/ecc/src/KeyUtils.js","dist/ecc/src/PrivateKey.js","dist/ecc/src/PublicKey.js","dist/ecc/src/address.js","dist/ecc/src/aes.js","dist/ecc/src/ecdsa.js","dist/ecc/src/ecsignature.js","dist/ecc/src/enforce_types.js","dist/ecc/src/hash.js","dist/ecc/src/signature.js","dist/serializer/index.js","dist/serializer/src/FastParser.js","dist/serializer/src/SerializerValidation.js","dist/serializer/src/error_with_cause.js","dist/serializer/src/operations.js","dist/serializer/src/serializer.js","dist/serializer/src/template.js","dist/serializer/src/types.js","node_modules/assert/assert.js","node_modules/base-x/index.js","node_modules/base64-js/index.js","node_modules/bigi/lib/bigi.js","node_modules/bigi/lib/convert.js","node_modules/bigi/lib/index.js","node_modules/bigi/package.json","node_modules/browser-resolve/empty.js","node_modules/browserify/node_modules/buffer/index.js","node_modules/browserify/node_modules/string_decoder/index.js","node_modules/bs58/index.js","node_modules/bytebuffer/dist/bytebuffer.js","node_modules/cipher-base/index.js","node_modules/core-util-is/lib/util.js","node_modules/create-hash/browser.js","node_modules/create-hash/md5.js","node_modules/create-hmac/browser.js","node_modules/create-hmac/legacy.js","node_modules/crypto-js/aes.js","node_modules/crypto-js/cipher-core.js","node_modules/crypto-js/core.js","node_modules/crypto-js/enc-base64.js","node_modules/crypto-js/enc-hex.js","node_modules/crypto-js/evpkdf.js","node_modules/crypto-js/hmac.js","node_modules/crypto-js/md5.js","node_modules/crypto-js/sha1.js","node_modules/deep-equal/index.js","node_modules/deep-equal/lib/is_arguments.js","node_modules/deep-equal/lib/keys.js","node_modules/ecurve/lib/curve.js","node_modules/ecurve/lib/curves.json","node_modules/ecurve/lib/index.js","node_modules/ecurve/lib/names.js","node_modules/ecurve/lib/point.js","node_modules/events/events.js","node_modules/hash-base/index.js","node_modules/ieee754/index.js","node_modules/inherits/inherits_browser.js","node_modules/is-buffer/index.js","node_modules/isarray/index.js","node_modules/long/dist/long.js","node_modules/md5.js/index.js","node_modules/peerplaysjs-ws/dist/index.js","node_modules/peerplaysjs-ws/dist/src/ApiInstances.js","node_modules/peerplaysjs-ws/dist/src/ChainConfig.js","node_modules/peerplaysjs-ws/dist/src/ChainWebSocket.js","node_modules/peerplaysjs-ws/dist/src/ConnectionManager.js","node_modules/peerplaysjs-ws/dist/src/GrapheneApi.js","node_modules/process-nextick-args/index.js","node_modules/process/browser.js","node_modules/readable-stream/duplex-browser.js","node_modules/readable-stream/lib/_stream_duplex.js","node_modules/readable-stream/lib/_stream_passthrough.js","node_modules/readable-stream/lib/_stream_readable.js","node_modules/readable-stream/lib/_stream_transform.js","node_modules/readable-stream/lib/_stream_writable.js","node_modules/readable-stream/lib/internal/streams/BufferList.js","node_modules/readable-stream/lib/internal/streams/destroy.js","node_modules/readable-stream/lib/internal/streams/stream-browser.js","node_modules/readable-stream/passthrough.js","node_modules/readable-stream/readable-browser.js","node_modules/readable-stream/transform.js","node_modules/readable-stream/writable-browser.js","node_modules/ripemd160/index.js","node_modules/safe-buffer/index.js","node_modules/secure-random/lib/secure-random.js","node_modules/sha.js/hash.js","node_modules/sha.js/index.js","node_modules/sha.js/sha.js","node_modules/sha.js/sha1.js","node_modules/sha.js/sha224.js","node_modules/sha.js/sha256.js","node_modules/sha.js/sha384.js","node_modules/sha.js/sha512.js","node_modules/stream-browserify/index.js","node_modules/string_decoder/lib/string_decoder.js","node_modules/timers-browserify/main.js","node_modules/util-deprecate/browser.js","node_modules/util/support/isBufferBrowser.js","node_modules/util/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AClqBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACnOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AChOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACx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zPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACjJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACrEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC5gDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACrrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1eA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACr+CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3FA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5DA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7NA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClqHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/2BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3QA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9SA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACleA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxLA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACrNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9qBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;;;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACvSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACn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file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","'use strict';\n\nexports.__esModule = true;\n\nvar _peerplaysjsWs = require(70);\n\nvar _peerplaysjsWs2 = _interopRequireDefault(_peerplaysjsWs);\n\nvar _PrivateKey = require(10);\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _PublicKey = require(11);\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nvar _signature = require(18);\n\nvar _signature2 = _interopRequireDefault(_signature);\n\nvar _KeyUtils = require(9);\n\nvar _KeyUtils2 = _interopRequireDefault(_KeyUtils);\n\nvar _TransactionBuilder = require(5);\n\nvar _TransactionBuilder2 = _interopRequireDefault(_TransactionBuilder);\n\nvar _AccountLogin = require(2);\n\nvar _AccountLogin2 = _interopRequireDefault(_AccountLogin);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  PrivateKey: _PrivateKey2.default,\n  PublicKey: _PublicKey2.default,\n  Signature: _signature2.default,\n  key: _KeyUtils2.default,\n  TransactionBuilder: _TransactionBuilder2.default,\n  Login: _AccountLogin2.default,\n  peerplaysjs_ws: _peerplaysjsWs2.default\n};\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _PrivateKey = require(10);\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _KeyUtils = require(9);\n\nvar _KeyUtils2 = _interopRequireDefault(_KeyUtils);\n\nvar _state = require(6);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _keyCachePriv = {};\nvar _keyCachePub = {};\n\nvar AccountLogin = function () {\n  function AccountLogin() {\n    _classCallCheck(this, AccountLogin);\n\n    var state = { loggedIn: false, roles: ['active', 'owner', 'memo'] };\n    this.get = (0, _state.get)(state);\n    this.set = (0, _state.set)(state);\n\n    this.subs = {};\n  }\n\n  AccountLogin.prototype.addSubscription = function addSubscription(cb) {\n    this.subs[cb] = cb;\n  };\n\n  AccountLogin.prototype.setRoles = function setRoles(roles) {\n    this.set('roles', roles);\n  };\n\n  AccountLogin.prototype.generateKeys = function generateKeys(accountName, password, roles, prefix) {\n    if (!accountName || !password) {\n      throw new Error('Account name or password required');\n    }\n\n    if (password.length < 12) {\n      throw new Error('Password must have at least 12 characters');\n    }\n\n    var privKeys = {};\n    var pubKeys = {};\n\n    (roles || this.get('roles')).forEach(function (role) {\n      var seed = password + accountName + role;\n      var pkey = _keyCachePriv[seed] ? _keyCachePriv[seed] : _PrivateKey2.default.fromSeed(_KeyUtils2.default.normalize_brainKey(seed));\n      _keyCachePriv[seed] = pkey;\n\n      privKeys[role] = pkey;\n      pubKeys[role] = _keyCachePub[seed] ? _keyCachePub[seed] : pkey.toPublicKey().toString(prefix);\n\n      _keyCachePub[seed] = pubKeys[role];\n    });\n\n    return { privKeys: privKeys, pubKeys: pubKeys };\n  };\n\n  AccountLogin.prototype.checkKeys = function checkKeys(_ref) {\n    var _this = this;\n\n    var accountName = _ref.accountName,\n        password = _ref.password,\n        auths = _ref.auths;\n\n    if (!accountName || !password || !auths) {\n      throw new Error('checkKeys: Missing inputs');\n    }\n\n    var hasKey = false;\n    var roles = Object.keys(auths);\n\n    var _loop = function _loop(i, len) {\n      var role = roles[i];\n\n      var _generateKeys = _this.generateKeys(accountName, password, [role]),\n          privKeys = _generateKeys.privKeys,\n          pubKeys = _generateKeys.pubKeys;\n\n      auths[role].forEach(function (roleKey) {\n        if (roleKey[0] === pubKeys[role]) {\n          hasKey = true;\n          _this.set(role, { priv: privKeys[role], pub: pubKeys[role] });\n        }\n      });\n    };\n\n    for (var i = 0, len = roles.length; i < len; i++) {\n      _loop(i, len);\n    }\n\n    if (hasKey) {\n      this.set('name', accountName);\n    }\n\n    this.set('loggedIn', hasKey);\n\n    return hasKey;\n  };\n\n  AccountLogin.prototype.signTransaction = function signTransaction(tr) {\n    var _this2 = this;\n\n    var hasKey = false;\n\n    this.get('roles').forEach(function (role) {\n      var myKey = _this2.get(role);\n\n      if (myKey) {\n        hasKey = true;\n        console.log('adding signer:', myKey.pub);\n        tr.add_signer(myKey.priv, myKey.pub);\n      }\n    });\n\n    if (!hasKey) {\n      throw new Error('You do not have any private keys to sign this transaction');\n    }\n  };\n\n  return AccountLogin;\n}();\n\nexports.default = new AccountLogin();\nmodule.exports = exports['default'];","\"use strict\";\n\nexports.__esModule = true;\nvar reserved_spaces = {\n  relative_protocol_ids: 0,\n  protocol_ids: 1,\n  implementation_ids: 2\n};\n\nvar object_type = {\n  null: 0,\n  base: 1,\n  account: 2,\n  asset: 3,\n  force_settlement: 4,\n  committee_member: 5,\n  witness: 6,\n  limit_order: 7,\n  call_order: 8,\n  custom: 9,\n  proposal: 10,\n  operation_history: 11,\n  withdraw_permission: 12,\n  vesting_balance: 13,\n  worker: 14,\n  balance: 15,\n  tournament: 16,\n  tournament_details: 17,\n  match: 18,\n  game: 19,\n  sport: 20,\n  event_group: 21,\n  event: 22,\n  betting_market_rules: 23,\n  betting_market_group: 24,\n  betting_market: 25,\n  bet: 26\n};\n\nvar impl_object_type = {\n  global_property: 0,\n  dynamic_global_property: 1,\n  reserved0: 2,\n  asset_dynamic_data: 3,\n  asset_bitasset_data: 4,\n  account_balance: 5,\n  account_statistics: 6,\n  transaction: 7,\n  block_summary: 8,\n  account_transaction_history: 9,\n  blinded_balance: 10,\n  chain_property: 11,\n  witness_schedule: 12,\n  budget_record: 13,\n  special_authority: 14,\n  buyback: 15,\n  fba_accumulator: 16,\n  betting_market_position: 17,\n  global_betting_statistics: 18,\n  asset_dividend_data: 19,\n  pending_dividend_payout_balance_for_holder: 20,\n  distributed_dividend_balance_data: 21\n};\n\nvar vote_type = {\n  committee: 0,\n  witness: 1,\n  worker: 2\n};\n\nvar operations = {\n  transfer: 0,\n  limit_order_create: 1,\n  limit_order_cancel: 2,\n  call_order_update: 3,\n  fill_order: 4,\n  account_create: 5,\n  account_update: 6,\n  account_whitelist: 7,\n  account_upgrade: 8,\n  account_transfer: 9,\n  asset_create: 10,\n  asset_update: 11,\n  asset_update_bitasset: 12,\n  asset_update_feed_producers: 13,\n  asset_issue: 14,\n  asset_reserve: 15,\n  asset_fund_fee_pool: 16,\n  asset_settle: 17,\n  asset_global_settle: 18,\n  asset_publish_feed: 19,\n  witness_create: 20,\n  witness_update: 21,\n  proposal_create: 22,\n  proposal_update: 23,\n  proposal_delete: 24,\n  withdraw_permission_create: 25,\n  withdraw_permission_update: 26,\n  withdraw_permission_claim: 27,\n  withdraw_permission_delete: 28,\n  committee_member_create: 29,\n  committee_member_update: 30,\n  committee_member_update_global_parameters: 31,\n  vesting_balance_create: 32,\n  vesting_balance_withdraw: 33,\n  worker_create: 34,\n  custom: 35,\n  assert: 36,\n  balance_claim: 37,\n  override_transfer: 38,\n  transfer_to_blind: 39,\n  blind_transfer: 40,\n  transfer_from_blind: 41,\n  asset_settle_cancel: 42,\n  asset_claim_fees: 43,\n  fba_distribute_operation: 44,\n  tournament_create: 45,\n  tournament_join: 46,\n  game_move: 47,\n  asset_update_dividend: 48,\n  asset_dividend_distribution: 49,\n  tournament_payout: 50,\n  tournament_leave: 51,\n  sport_create: 52,\n  sport_update: 53,\n  event_group_create: 54,\n  event_group_update: 55,\n  event_create: 56,\n  event_update: 57,\n  betting_market_rules_create: 58,\n  betting_market_rules_update: 59,\n  betting_market_group_create: 60,\n  betting_market_create: 61,\n  bet_place: 62,\n  betting_market_group_resolve: 63,\n  betting_market_group_resolved: 64,\n  bet_adjusted: 65,\n  betting_market_group_cancel: 66,\n  bet_matched: 67,\n  bet_cancel: 68,\n  bet_canceled: 69,\n  betting_market_group_update: 70,\n  betting_market_update: 71,\n  event_update_status: 72\n};\n\nvar ChainTypes = {\n  reserved_spaces: reserved_spaces,\n  object_type: object_type,\n  impl_object_type: impl_object_type,\n  vote_type: vote_type,\n  operations: operations\n};\n\nexports.default = ChainTypes;\nmodule.exports = exports[\"default\"];","'use strict';\n\nexports.__esModule = true;\n\nvar _bytebuffer = require(38);\n\nvar _SerializerValidation = require(21);\n\nvar _SerializerValidation2 = _interopRequireDefault(_SerializerValidation);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar DB_MAX_INSTANCE_ID = _bytebuffer.Long.fromNumber(Math.pow(2, 48) - 1);\n\nvar ObjectId = function () {\n  function ObjectId(space, type, instance) {\n    _classCallCheck(this, ObjectId);\n\n    this.space = space;\n    this.type = type;\n    this.instance = instance;\n    var instance_string = this.instance.toString();\n    var id = this.space + '.' + this.type + '.' + instance_string;\n\n    if (!_SerializerValidation2.default.is_digits(instance_string)) {\n      throw new ('Invalid object id ' + id)();\n    }\n  }\n\n  ObjectId.fromString = function fromString(value) {\n    if (value.space !== undefined && value.type !== undefined && value.instance !== undefined) {\n      return value;\n    }\n\n    var params = _SerializerValidation2.default.require_match(/^([0-9]+)\\.([0-9]+)\\.([0-9]+)$/, _SerializerValidation2.default.required(value, 'ObjectId'), 'ObjectId');\n    return new ObjectId(parseInt(params[1], 10), parseInt(params[2], 10), _bytebuffer.Long.fromString(params[3]));\n  };\n\n  ObjectId.fromLong = function fromLong(long) {\n    var space = long.shiftRight(56).toInt();\n    var type = long.shiftRight(48).toInt() & 0x00ff; // eslint-disable-line\n    var instance = long.and(DB_MAX_INSTANCE_ID);\n    return new ObjectId(space, type, instance);\n  };\n\n  ObjectId.fromByteBuffer = function fromByteBuffer(b) {\n    return ObjectId.fromLong(b.readUint64());\n  };\n\n  ObjectId.prototype.toLong = function toLong() {\n    return _bytebuffer.Long.fromNumber(this.space).shiftLeft(56).or(_bytebuffer.Long.fromNumber(this.type).shiftLeft(48).or(this.instance));\n  };\n\n  ObjectId.prototype.appendByteBuffer = function appendByteBuffer(b) {\n    return b.writeUint64(this.toLong());\n  };\n\n  ObjectId.prototype.toString = function toString() {\n    return this.space + '.' + this.type + '.' + this.instance.toString();\n  };\n\n  return ObjectId;\n}();\n\nexports.default = ObjectId;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _ecc = require('../../ecc');\n\nvar _serializer = require('../../serializer');\n\nvar _ChainTypes = require('./ChainTypes');\n\nvar _ChainTypes2 = _interopRequireDefault(_ChainTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar TransactionBuilder = function () {\n  function TransactionBuilder() {\n    _classCallCheck(this, TransactionBuilder);\n\n    this.ref_block_num = 0;\n    this.ref_block_prefix = 0;\n    this.expiration = 0;\n    this.operations = [];\n    this.signatures = [];\n    this.signer_private_keys = [];\n\n    this.head_block_time_string = null;\n    this.committee_min_review = null;\n\n    // semi-private method bindings\n    this._broadcast = this._broadcast.bind(this);\n  }\n\n  /**\n        @arg {string} name - like \"transfer\"\n        @arg {object} operation - JSON matchching the operation's format\n    */\n\n\n  TransactionBuilder.prototype.add_type_operation = function add_type_operation(name, operation) {\n    this.add_operation(this.get_type_operation(name, operation));\n  };\n\n  /**\n        This does it all: set fees, finalize, sign, and broadcast (if wanted).\n         @arg {ConfidentialWallet} cwallet - must be unlocked, used to gather signing keys\n         @arg {array<string>} [signer_pubkeys = null] - Optional [\"GPHAbc9Def0...\", ...].  These are\n        additional signing keys.  Some balance claims require propritary address formats, the\n        witness node can't tell us which ones are needed so they must be passed in.  If the\n        witness node can figure out a signing key (mostly all other transactions), it should\n        not be passed in here.\n         @arg {boolean} [broadcast = false]\n    */\n\n\n  TransactionBuilder.prototype.process_transaction = function process_transaction(cwallet) {\n    var _this = this;\n\n    var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n    var wallet_object = cwallet.wallet.wallet_object;\n\n\n    if (_peerplaysjsWs.Apis.instance().chain_id !== wallet_object.get('chain_id')) {\n      var wallet_chain_id = wallet_object.get('chain_id');\n      var api_chain_id = _peerplaysjsWs.Apis.instance().chain_id;\n\n      var error = new Error('Mismatched chain_id; expecting ' + wallet_chain_id + ', but got ' + api_chain_id);\n\n      return Promise.reject(error);\n    }\n\n    return this.set_required_fees().then(function () {\n      var signer_pubkeys_added = {};\n\n      if (signer_pubkeys) {\n        // Balance claims are by address, only the private\n        // key holder can know about these additional\n        // potential keys.\n        var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys);\n\n        if (!pubkeys.length) {\n          throw new Error('Missing signing key');\n        }\n\n        var keys = Object.keys(pubkeys);\n\n        for (var i = 0, len = keys.length; i < len; i++) {\n          var pubkey_string = pubkeys[i];\n          var private_key = cwallet.getPrivateKey(pubkey_string);\n          _this.add_signer(private_key, pubkey_string);\n          signer_pubkeys_added[pubkey_string] = true;\n        }\n      }\n\n      return _this.get_potential_signatures().then(function (_ref) {\n        var pubkeys = _ref.pubkeys,\n            addys = _ref.addys;\n\n        var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys);\n\n        return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) {\n          var keys = Object.keys(required_pubkeys);\n\n          for (var _i = 0, _len = keys.length; _i < _len; _i++) {\n            var _pubkey_string = keys[_i];\n\n            if (!signer_pubkeys_added[_pubkey_string]) {\n              var _private_key = cwallet.getPrivateKey(_pubkey_string);\n\n              // This should not happen, get_required_signatures will only\n              // returned keys from my_pubkeys\n              if (!_private_key) {\n                throw new Error('Missing signing key for ' + _pubkey_string);\n              }\n\n              _this.add_signer(_private_key, _pubkey_string);\n            }\n          }\n        });\n      }).then(function () {\n        return broadcast ? _this.broadcast() : _this.serialize();\n      });\n    });\n  };\n\n  /** Typically this is called automatically just prior to signing.\n   * Once finalized this transaction can not be changed. */\n\n\n  TransactionBuilder.prototype.finalize = function finalize() {\n    var _this2 = this;\n\n    return new Promise(function (resolve) {\n      if (_this2.tr_buffer) {\n        throw new Error('already finalized');\n      }\n\n      resolve(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.1.0']]).then(function (r) {\n        _this2.head_block_time_string = r[0].time;\n\n        if (_this2.expiration === 0) {\n          _this2.expiration = _this2.base_expiration_sec() + _peerplaysjsWs.ChainConfig.expire_in_secs;\n        }\n\n        _this2.ref_block_num = r[0].head_block_number & 0xffff; // eslint-disable-line\n        _this2.ref_block_prefix = Buffer.from(r[0].head_block_id, 'hex').readUInt32LE(4);\n        // DEBUG console.log(\"ref_block\",@ref_block_num,@ref_block_prefix,r)\n\n        var iterable = _this2.operations;\n\n        for (var i = 0, len = iterable.length; i < len; i++) {\n          var op = iterable[i];\n\n          if (op[1].finalize) {\n            op[1].finalize();\n          }\n\n          var _type = _serializer.ops.operation.st_operations[op[0]];\n          var hexBuffer = _type.toBuffer(op[1]).toString('hex');\n          console.log('Operation %s: %O => %s (%d bytes)', _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2);\n        }\n\n        _this2.tr_buffer = _serializer.ops.transaction.toBuffer(_this2);\n      }));\n    });\n  };\n\n  /** @return {string} hex transaction ID */\n\n\n  TransactionBuilder.prototype.id = function id() {\n    if (!this.tr_buffer) {\n      throw new Error('not finalized');\n    }\n\n    return _ecc.hash.sha256(this.tr_buffer).toString('hex').substring(0, 40);\n  };\n\n  /**\n        Typically one will use {@link this.add_type_operation} instead.\n        @arg {array} operation - [operation_id, operation]\n    */\n\n\n  TransactionBuilder.prototype.add_operation = function add_operation(operation) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    (0, _assert2.default)(operation, 'operation');\n\n    if (!Array.isArray(operation)) {\n      throw new Error('Expecting array [operation_id, operation]');\n    }\n\n    this.operations.push(operation);\n  };\n\n  TransactionBuilder.prototype.get_type_operation = function get_type_operation(name, operation) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    (0, _assert2.default)(name, 'name');\n    (0, _assert2.default)(operation, 'operation');\n    var _type = _serializer.ops[name];\n    (0, _assert2.default)(_type, 'Unknown operation ' + name);\n    var operation_id = _ChainTypes2.default.operations[_type.operation_name];\n\n    if (operation_id === undefined) {\n      throw new Error('unknown operation: ' + _type.operation_name);\n    }\n\n    if (!operation.fee) {\n      operation.fee = { amount: 0, asset_id: 0 };\n    }\n\n    if (name === 'proposal_create') {\n      /*\n            * Proposals involving the committee account require a review\n            * period to be set, look for them here\n            */\n      var requiresReview = false;\n      var extraReview = 0;\n\n      operation.proposed_ops.forEach(function (op) {\n        var COMMITTE_ACCOUNT = 0;\n        var key = void 0;\n\n        switch (op.op[0]) {\n          case 0:\n            // transfer\n            key = 'from';\n            break;\n\n          case 6: // account_update\n          case 17:\n            // asset_settle\n            key = 'account';\n            break;\n\n          case 10: // asset_create\n          case 11: // asset_update\n          case 12: // asset_update_bitasset\n          case 13: // asset_update_feed_producers\n          case 14: // asset_issue\n          case 18: // asset_global_settle\n          case 43:\n            // asset_claim_fees\n            key = 'issuer';\n            break;\n\n          case 15:\n            // asset_reserve\n            key = 'payer';\n            break;\n\n          case 16:\n            // asset_fund_fee_pool\n            key = 'from_account';\n            break;\n\n          case 22: // proposal_create\n          case 23: // proposal_update\n          case 24:\n            // proposal_delete\n            key = 'fee_paying_account';\n            break;\n\n          case 31:\n            // committee_member_update_global_parameters\n            requiresReview = true;\n            extraReview = 60 * 60 * 24 * 13; // Make the review period 2 weeks total\n            break;\n          default:\n            break;\n        }\n\n        if (key in op.op[1] && op.op[1][key] === COMMITTE_ACCOUNT) {\n          requiresReview = true;\n        }\n      });\n\n      if (!operation.expiration_time) {\n        var experationTime = this.base_expiration_sec();\n        operation.expiration_time = experationTime + _peerplaysjsWs.ChainConfig.expire_in_secs_proposal;\n      }\n\n      if (requiresReview) {\n        var one_day = 24 * 60 * 60; // One day in seconds\n        var max = Math.max(this.commitee_min_review, one_day, _peerplaysjsWs.ChainConfig.review_in_secs_committee);\n\n        operation.review_period_seconds = extraReview + max;\n        /*\n                * Expiration time must be at least equal to\n                * now + review_period_seconds, so we add one hour to make sure\n                */\n        operation.expiration_time += 60 * 60 + extraReview;\n      }\n    }\n\n    var operation_instance = _type.fromObject(operation);\n    return [operation_id, operation_instance];\n  };\n\n  /* optional: fetch the current head block */\n\n  TransactionBuilder.prototype.update_head_block = function update_head_block() {\n    var _this3 = this;\n\n    return _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.0.0', '2.1.0']]).then(function (res) {\n      var g = res[0],\n          r = res[1];\n\n      _this3.head_block_time_string = r[0].time;\n      _this3.committee_min_review = g[0].parameters.committee_proposal_review_period;\n    });\n  };\n\n  /** optional: there is a deafult expiration */\n\n\n  TransactionBuilder.prototype.set_expire_seconds = function set_expire_seconds(sec) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    this.expiration = this.base_expiration_sec() + sec;\n\n    return this.expiration;\n  };\n\n  /* Wraps this transaction in a proposal_create transaction */\n\n\n  TransactionBuilder.prototype.propose = function propose(proposal_create_options) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    if (!this.operations.length) {\n      throw new Error('add operation first');\n    }\n\n    (0, _assert2.default)(proposal_create_options, 'proposal_create_options');\n    (0, _assert2.default)(proposal_create_options.fee_paying_account, 'proposal_create_options.fee_paying_account');\n\n    var proposed_ops = this.operations.map(function (op) {\n      return { op: op };\n    });\n\n    this.operations = [];\n    this.signatures = [];\n    this.signer_private_keys = [];\n    proposal_create_options.proposed_ops = proposed_ops;\n    this.add_type_operation('proposal_create', proposal_create_options);\n    return this;\n  };\n\n  TransactionBuilder.prototype.has_proposed_operation = function has_proposed_operation() {\n    var hasProposed = false;\n\n    for (var i = 0; i < this.operations.length; i++) {\n      if ('proposed_ops' in this.operations[i][1]) {\n        hasProposed = true;\n        break;\n      }\n    }\n\n    return hasProposed;\n  };\n\n  /** optional: the fees can be obtained from the witness node */\n\n\n  TransactionBuilder.prototype.set_required_fees = function set_required_fees(asset_id) {\n    var _this4 = this;\n\n    var fee_pool = void 0;\n\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    if (!this.operations.length) {\n      throw new Error('add operations first');\n    }\n\n    var operations = [];\n\n    for (var i = 0, len = this.operations.length; i < len; i++) {\n      var op = this.operations[i];\n      operations.push(_serializer.ops.operation.toObject(op));\n    }\n\n    if (!asset_id) {\n      var op1_fee = operations[0][1].fee;\n\n      if (op1_fee && op1_fee.asset_id !== null) {\n        asset_id = op1_fee.asset_id;\n      } else {\n        asset_id = '1.3.0';\n      }\n    }\n\n    var promises = [_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, asset_id])];\n\n    if (asset_id !== '1.3.0') {\n      // This handles the fallback to paying fees in BTS if the fee pool is empty.\n      promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, '1.3.0']));\n      promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset_id]]));\n    }\n\n    return Promise.all(promises).then(function (results) {\n      var fees = results[0],\n          coreFees = results[1],\n          asset = results[2];\n\n      asset = asset ? asset[0] : null;\n\n      var dynamicPromise = asset_id !== '1.3.0' && asset ? _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve) {\n        resolve();\n      });\n\n      return dynamicPromise.then(function (dynamicObject) {\n        if (asset_id !== '1.3.0') {\n          fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0;\n          var totalFees = 0;\n\n          for (var j = 0, fee; j < coreFees.length; j++) {\n            fee = coreFees[j];\n            totalFees += fee.amount;\n          }\n\n          if (totalFees > parseInt(fee_pool, 10)) {\n            fees = coreFees;\n            asset_id = '1.3.0';\n          }\n        }\n\n        // Proposed transactions need to be flattened\n        var flat_assets = [];\n\n        var flatten = function flatten(obj) {\n          if (Array.isArray(obj)) {\n            for (var k = 0, _len2 = obj.length; k < _len2; k++) {\n              var item = obj[k];\n              flatten(item);\n            }\n          } else {\n            flat_assets.push(obj);\n          }\n        };\n\n        flatten(fees);\n\n        var asset_index = 0;\n\n        var set_fee = function set_fee(operation) {\n          if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === '0' // Long\n          ) {\n              operation.fee = flat_assets[asset_index];\n              // console.log(\"new operation.fee\", operation.fee)\n            } else {\n              // console.log(\"old operation.fee\", operation.fee)\n            }\n\n          asset_index++;\n\n          if (operation.proposed_ops) {\n            var result = [];\n\n            for (var y = 0; y < operation.proposed_ops.length; y++) {\n              result.push(set_fee(operation.proposed_ops[y].op[1]));\n            }\n\n            return result;\n          }\n        };\n\n        for (var _i2 = 0; _i2 < _this4.operations.length; _i2++) {\n          set_fee(_this4.operations[_i2][1]);\n        }\n      });\n      // DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets)\n    });\n  };\n\n  TransactionBuilder.prototype.get_potential_signatures = function get_potential_signatures() {\n    var tr_object = _serializer.ops.signed_transaction.toObject(this);\n    return Promise.all([_peerplaysjsWs.Apis.instance().db_api().exec('get_potential_signatures', [tr_object]), _peerplaysjsWs.Apis.instance().db_api().exec('get_potential_address_signatures', [tr_object])]).then(function (results) {\n      return { pubkeys: results[0], addys: results[1] };\n    });\n  };\n\n  TransactionBuilder.prototype.get_required_signatures = function get_required_signatures(available_keys) {\n    if (!available_keys.length) {\n      return Promise.resolve([]);\n    }\n\n    var tr_object = _serializer.ops.signed_transaction.toObject(this);\n    // DEBUG console.log('... tr_object',tr_object)\n    return _peerplaysjsWs.Apis.instance().db_api().exec('get_required_signatures', [tr_object, available_keys]).then(function (required_public_keys) {\n      return required_public_keys;\n    });\n  };\n\n  TransactionBuilder.prototype.add_signer = function add_signer(private_key) {\n    var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey();\n\n    (0, _assert2.default)(private_key.d, 'required PrivateKey object');\n\n    if (this.signed) {\n      throw new Error('already signed');\n    }\n\n    if (!public_key.Q) {\n      public_key = _ecc.PublicKey.fromPublicKeyString(public_key);\n    }\n\n    // prevent duplicates\n    var spHex = private_key.toHex();\n\n    var keys = Object.keys(this.signer_private_keys);\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var sp = this.signer_private_keys[keys[i]];\n\n      if (sp[0].toHex() === spHex) {\n        return;\n      }\n    }\n\n    this.signer_private_keys.push([private_key, public_key]);\n  };\n\n  TransactionBuilder.prototype.sign = function sign() {\n    var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.Apis.instance().chain_id;\n\n    if (!this.tr_buffer) {\n      throw new Error('not finalized');\n    }\n\n    if (this.signed) {\n      throw new Error('already signed');\n    }\n\n    if (!this.signer_private_keys.length) {\n      throw new Error('Transaction was not signed. Do you have a private key? [no_signers]');\n    }\n\n    var end = this.signer_private_keys.length;\n\n    for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) {\n      var _signer_private_keys$ = this.signer_private_keys[i],\n          private_key = _signer_private_keys$[0],\n          public_key = _signer_private_keys$[1];\n\n      var sig = _ecc.Signature.signBuffer(Buffer.concat([Buffer.from(chain_id, 'hex'), this.tr_buffer]), private_key, public_key);\n      this.signatures.push(sig.toBuffer());\n    }\n\n    this.signer_private_keys = [];\n    this.signed = true;\n  };\n\n  TransactionBuilder.prototype.serialize = function serialize() {\n    return _serializer.ops.signed_transaction.toObject(this);\n  };\n\n  TransactionBuilder.prototype.toObject = function toObject() {\n    return _serializer.ops.signed_transaction.toObject(this);\n  };\n\n  TransactionBuilder.prototype.broadcast = function broadcast(was_broadcast_callback) {\n    var _this5 = this;\n\n    if (this.tr_buffer) {\n      return this._broadcast(was_broadcast_callback);\n    }\n\n    return this.finalize().then(function () {\n      return _this5._broadcast(was_broadcast_callback);\n    });\n  };\n\n  TransactionBuilder.prototype._broadcast = function _broadcast(was_broadcast_callback) {\n    var _this6 = this;\n\n    return new Promise(function (resolve, reject) {\n      if (!_this6.signed) {\n        _this6.sign();\n      }\n\n      if (!_this6.tr_buffer) {\n        throw new Error('not finalized');\n      }\n\n      if (!_this6.signatures.length) {\n        throw new Error('not signed');\n      }\n\n      if (!_this6.operations.length) {\n        throw new Error('no operations');\n      }\n\n      var tr_object = _serializer.ops.signed_transaction.toObject(_this6);\n      // console.log('... broadcast_transaction_with_callback !!!')\n      _peerplaysjsWs.Apis.instance().network_api().exec('broadcast_transaction_with_callback', [function (res) {\n        return resolve(res);\n      }, tr_object]).then(function () {\n        // console.log('... broadcast success, waiting for callback')\n        if (was_broadcast_callback) {\n          was_broadcast_callback();\n        }\n      }).catch(function (error) {\n        // console.log may be redundant for network errors, other errors could occur\n        console.log(error);\n        var message = error.message;\n\n\n        if (!message) {\n          message = '';\n        }\n\n        reject(new Error(message + '\\n' + 'peerplays-crypto ' + (' digest ' + _ecc.hash.sha256(_this6.tr_buffer).toString('hex') + ' transaction ' + _this6.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object))));\n      });\n    });\n  };\n\n  TransactionBuilder.timeStringToDate = function timeStringToDate(time_string) {\n    if (!time_string) {\n      time_string = '1970-01-01T00:00:00.000Z';\n    }\n\n    if (!/Z$/.test(time_string)) {\n      // does not end in Z\n      // https://github.com/cryptonomex/graphene/issues/368\n      time_string += 'Z';\n    }\n\n    return new Date(time_string);\n  };\n\n  TransactionBuilder.prototype.getHeadBlockDate = function getHeadBlockDate() {\n    return TransactionBuilder.timeStringToDate(this.head_block_time_string);\n  };\n\n  TransactionBuilder.prototype.base_expiration_sec = function base_expiration_sec() {\n    var head_block_sec = Math.ceil(this.getHeadBlockDate().getTime() / 1000);\n    var now_sec = Math.ceil(Date.now() / 1000);\n\n    // The head block time should be updated every 3 seconds.  If it isn't\n    // then help the transaction to expire (use head_block_sec)\n    if (now_sec - head_block_sec > 30) {\n      return head_block_sec;\n    }\n\n    // If the user's clock is very far behind, use the head block time.\n    return Math.max(now_sec, head_block_sec);\n  };\n\n  return TransactionBuilder;\n}();\n\nexports.default = TransactionBuilder;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nfunction get(state) {\n  return function (key) {\n    return state[key] || '';\n  };\n}\n\nfunction set(state) {\n  var _this = this;\n\n  return function (key, value) {\n    state[key] = value;\n    return _this;\n  };\n}\n\nexports.get = get;\nexports.set = set;","'use strict';\n\nexports.__esModule = true;\nexports.key = exports.hash = exports.brainKey = exports.Signature = exports.PublicKey = exports.PrivateKey = exports.Aes = exports.Address = undefined;\n\nvar _address = require(12);\n\nvar _address2 = _interopRequireDefault(_address);\n\nvar _aes = require(13);\n\nvar _aes2 = _interopRequireDefault(_aes);\n\nvar _PrivateKey = require(10);\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _PublicKey = require(11);\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nvar _signature = require(18);\n\nvar _signature2 = _interopRequireDefault(_signature);\n\nvar _BrainKey = require(8);\n\nvar _BrainKey2 = _interopRequireDefault(_BrainKey);\n\nvar _hash = require(17);\n\nvar hash = _interopRequireWildcard(_hash);\n\nvar _KeyUtils = require(9);\n\nvar _KeyUtils2 = _interopRequireDefault(_KeyUtils);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Address = _address2.default;\nexports.Aes = _aes2.default;\nexports.PrivateKey = _PrivateKey2.default;\nexports.PublicKey = _PublicKey2.default;\nexports.Signature = _signature2.default;\nexports.brainKey = _BrainKey2.default;\nexports.hash = hash;\nexports.key = _KeyUtils2.default;","'use strict';\n\nexports.__esModule = true;\nexports.default = normalize;\nfunction normalize(brainKey) {\n  if (typeof brainKey !== 'string') {\n    throw new Error('string required for brainKey');\n  }\n\n  brainKey = brainKey.trim();\n  return brainKey.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n}\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _secureRandom = require('secure-random');\n\nvar _secureRandom2 = _interopRequireDefault(_secureRandom);\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _PrivateKey = require('./PrivateKey');\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _PublicKey = require('./PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nvar _address = require('./address');\n\nvar _address2 = _interopRequireDefault(_address);\n\nvar _aes = require('./aes');\n\nvar _aes2 = _interopRequireDefault(_aes);\n\nvar _hash = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// import dictionary from './dictionary_en';\n\n// hash for .25 second\nvar HASH_POWER_MILLS = 250;\n\nvar key = {\n  /** Uses 1 second of hashing power to create a key/password checksum.  An\n    implementation can re-call this method with the same password to re-match\n    the strength of the CPU (either after moving from a desktop to a mobile,\n    mobile to desktop, or N years from now when CPUs are presumably stronger).\n     A salt is used for all the normal reasons...\n     @return object {\n        aes_private: Aes,\n        checksum: \"{hash_iteration_count},{salt},{checksum}\"\n    }\n    */\n  aes_checksum: function aes_checksum(password) {\n    if (!(typeof password === 'string')) {\n      throw new 'password string required'();\n    }\n\n    var salt = _secureRandom2.default.randomBuffer(4).toString('hex');\n    var iterations = 0;\n    var secret = salt + password;\n    // hash for .1 second\n    var start_t = Date.now();\n\n    while (Date.now() - start_t < HASH_POWER_MILLS) {\n      secret = (0, _hash.sha256)(secret);\n      iterations += 1;\n    }\n\n    var checksum = (0, _hash.sha256)(secret);\n    var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(',');\n\n    return {\n      aes_private: _aes2.default.fromSeed(secret),\n      checksum: checksum_string\n    };\n  },\n\n\n  /** Provide a matching password and key_checksum.  A \"wrong password\"\n    error is thrown if the password does not match.  If this method takes\n    much more or less than 1 second to return, one should consider updating\n    all encyrpted fields using a new key.key_checksum.\n    */\n  aes_private: function aes_private(password, key_checksum) {\n    var _key_checksum$split = key_checksum.split(','),\n        iterations = _key_checksum$split[0],\n        salt = _key_checksum$split[1],\n        checksum = _key_checksum$split[2];\n\n    var secret = salt + password;\n\n    for (var i = 0; iterations > 0 ? i < iterations : i > iterations; iterations > 0 ? i++ : i++) {\n      secret = (0, _hash.sha256)(secret);\n    }\n\n    var new_checksum = (0, _hash.sha256)(secret);\n\n    if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) {\n      throw new Error('wrong password');\n    }\n\n    return _aes2.default.fromSeed(secret);\n  },\n\n\n  /**\n        A week random number generator can run out of entropy.\n        This should ensure even the worst random number implementation will be reasonably safe.\n         @param1 string entropy of at least 32 bytes\n    */\n  random32ByteBuffer: function random32ByteBuffer() {\n    var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy();\n\n    if (!(typeof entropy === 'string')) {\n      throw new Error('string required for entropy');\n    }\n\n    if (entropy.length < 32) {\n      throw new Error('expecting at least 32 bytes of entropy');\n    }\n\n    var start_t = Date.now();\n\n    while (Date.now() - start_t < HASH_POWER_MILLS) {\n      entropy = (0, _hash.sha256)(entropy);\n    }\n\n    var hash_array = [];\n    hash_array.push(entropy);\n\n    // Hashing for 1 second may helps the computer is not low on entropy\n    // (this method may be called back-to-back).\n    hash_array.push(_secureRandom2.default.randomBuffer(32));\n\n    return (0, _hash.sha256)(Buffer.concat(hash_array));\n  },\n  suggest_brain_key: function suggest_brain_key() {\n    var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ',';\n    var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy();\n\n    var randomBuffer = this.random32ByteBuffer(entropy);\n\n    var word_count = 16;\n    var dictionary_lines = dictionary.split(',');\n\n    if (!(dictionary_lines.length === 49744)) {\n      throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words');\n    }\n\n    var brainkey = [];\n    var end = word_count * 2;\n\n    for (var i = 0; i < end; i += 2) {\n      // randomBuffer has 256 bits / 16 bits per word == 16 words\n      var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; // eslint-disable-line\n\n      // convert into a number between 0 and 1 (inclusive)\n      var rndMultiplier = num / Math.pow(2, 16);\n      var wordIndex = Math.round(dictionary_lines.length * rndMultiplier);\n\n      brainkey.push(dictionary_lines[wordIndex]);\n    }\n\n    return this.normalize_brainKey(brainkey.join(' '));\n  },\n  get_random_key: function get_random_key(entropy) {\n    return _PrivateKey2.default.fromBuffer(this.random32ByteBuffer(entropy));\n  },\n  get_brainPrivateKey: function get_brainPrivateKey(brainKey) {\n    var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n    if (sequence < 0) {\n      throw new Error('invalid sequence');\n    }\n\n    brainKey = key.normalize_brainKey(brainKey);\n    return _PrivateKey2.default.fromBuffer((0, _hash.sha256)((0, _hash.sha512)(brainKey + ' ' + sequence)));\n  },\n\n\n  // Turn invisible space like characters into a single space\n  normalize_brainKey: function normalize_brainKey(brainKey) {\n    if (!(typeof brainKey === 'string')) {\n      throw new Error('string required for brainKey');\n    }\n\n    brainKey = brainKey.trim();\n    return brainKey.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n  },\n  browserEntropy: function browserEntropy() {\n    var entropyStr = '';\n\n    try {\n      entropyStr = new Date().toString() + ' ' + window.screen.height + ' ' + window.screen.width;\n      entropyStr = entropyStr + ' ' + window.screen.colorDepth + ' ' + window.screen.availHeight;\n      entropyStr = entropyStr + ' ' + window.screen.availWidth + ' ' + window.screen.pixelDepth;\n      entropyStr = entropyStr + ' ' + navigator.language + ' ' + window.location;\n      entropyStr = entropyStr + ' ' + window.history.length;\n\n      for (var i = 0, len = navigator.mimeTypes.length; i < len; i++) {\n        var mimeType = navigator.mimeTypes[i];\n        entropyStr += mimeType.description + ' ' + mimeType.type + ' ' + mimeType.suffixes + ' ';\n      }\n\n      console.log('INFO\\tbrowserEntropy gathered');\n    } catch (error) {\n      // nodejs:ReferenceError: window is not defined\n      entropyStr = (0, _hash.sha256)(new Date().toString());\n    }\n\n    var b = Buffer.from(entropyStr);\n    entropyStr += b.toString('binary') + ' ' + new Date().toString();\n    return entropyStr;\n  },\n\n\n  // @return array of 5 legacy addresses for a pubkey string parameter.\n  addresses: function addresses(pubkey) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var public_key = _PublicKey2.default.fromPublicKeyString(pubkey, address_prefix);\n    // S L O W\n    var address_string = [_address2.default.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed\n    _address2.default.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed\n    _address2.default.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed\n    _address2.default.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed\n    public_key.toAddressString(address_prefix) // bts_short, most recent format\n    ];\n    return address_string;\n  }\n};\n\nexports.default = key;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _ecurve = require('ecurve');\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _bs = require('bs58');\n\nvar _deepEqual = require('deep-equal');\n\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _hash = require('./hash');\n\nvar _PublicKey = require('./PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global ByteBuffer */\n\n\nvar secp256k1 = (0, _ecurve.getCurveByName)('secp256k1');\nvar n = secp256k1.n;\n\n\nfunction toPublic(data) {\n  if (!data || data.Q) {\n    return data;\n  }\n\n  return _PublicKey2.default.fromStringOrThrow(data);\n}\n\nvar PrivateKey = function () {\n  /**\n        @private see static functions\n        @param {BigInteger}\n    */\n  function PrivateKey(d) {\n    _classCallCheck(this, PrivateKey);\n\n    this.d = d;\n  }\n\n  PrivateKey.fromBuffer = function fromBuffer(buf) {\n    if (!Buffer.isBuffer(buf)) {\n      throw new Error('Expecting paramter to be a Buffer type');\n    }\n\n    if (buf.length !== 32) {\n      console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack);\n    }\n\n    if (buf.length === 0) {\n      throw new Error('Empty buffer');\n    }\n\n    return new PrivateKey(_bigi2.default.fromBuffer(buf));\n  };\n\n  /** @arg {string} seed - any length string.  This is private,\n   * the same seed produces the same private key every time.  */\n\n\n  PrivateKey.fromSeed = function fromSeed(seed) {\n    // generate_private_key\n    if (!(typeof seed === 'string')) {\n      throw new Error('seed must be of type string');\n    }\n\n    return PrivateKey.fromBuffer((0, _hash.sha256)(seed));\n  };\n\n  /** @return {string} Wallet Import Format (still a secret, Not encrypted) */\n\n\n  PrivateKey.fromWif = function fromWif(_private_wif) {\n    var private_wif = Buffer.from((0, _bs.decode)(_private_wif));\n    var version = private_wif.readUInt8(0);\n    _assert2.default.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version);\n    // checksum includes the version\n    var private_key = private_wif.slice(0, -4);\n    var checksum = private_wif.slice(-4);\n    var new_checksum = (0, _hash.sha256)(private_key);\n    new_checksum = (0, _hash.sha256)(new_checksum);\n    new_checksum = new_checksum.slice(0, 4);\n    var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum'\n\n    if (!isEqual) {\n      throw new Error('Checksum did not match');\n    }\n\n    private_key = private_key.slice(1);\n    private_key = private_key.slice(0, 32);\n    return PrivateKey.fromBuffer(private_key);\n  };\n\n  PrivateKey.prototype.toWif = function toWif() {\n    var private_key = this.toBuffer();\n    // checksum includes the version\n    private_key = Buffer.concat([Buffer.from([0x80]), private_key]);\n    var checksum = (0, _hash.sha256)(private_key);\n    checksum = (0, _hash.sha256)(checksum);\n    checksum = checksum.slice(0, 4);\n    var private_wif = Buffer.concat([private_key, checksum]);\n    return (0, _bs.encode)(private_wif);\n  };\n\n  /**\n        @return {Point}\n    */\n\n\n  PrivateKey.prototype.toPublicKeyPoint = function toPublicKeyPoint() {\n    var Q = secp256k1.G.multiply(this.d);\n    return Q;\n  };\n\n  PrivateKey.prototype.toPublicKey = function toPublicKey() {\n    if (this.public_key) {\n      return this.public_key;\n    }\n\n    this.public_key = _PublicKey2.default.fromPoint(this.toPublicKeyPoint());\n\n    return this.public_key;\n  };\n\n  PrivateKey.prototype.toBuffer = function toBuffer() {\n    return this.d.toBuffer(32);\n  };\n\n  /** ECIES */\n\n\n  PrivateKey.prototype.get_shared_secret = function get_shared_secret(public_key) {\n    var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n    public_key = toPublic(public_key);\n    var KB = public_key.toUncompressed().toBuffer();\n    var KBP = _ecurve.Point.fromAffine(secp256k1, _bigi2.default.fromBuffer(KB.slice(1, 33)), // x\n    _bigi2.default.fromBuffer(KB.slice(33, 65)) // y\n    );\n    var r = this.toBuffer();\n    var P = KBP.multiply(_bigi2.default.fromBuffer(r));\n    var S = P.affineX.toBuffer({ size: 32 });\n\n    /*\n        the input to sha512 must be exactly 32-bytes, to match the c++ implementation\n        of get_shared_secret.  Right now S will be shorter if the most significant\n        byte(s) is zero.  Pad it back to the full 32-bytes\n        */\n    if (!legacy && S.length < 32) {\n      var pad = Buffer.alloc(32 - S.length, 0);\n      S = Buffer.concat([pad, S]);\n    }\n\n    // SHA512 used in ECIES\n    return (0, _hash.sha512)(S);\n  };\n\n  // /** ECIES (does not always match the Point.fromAffine version above) */\n  // get_shared_secret(public_key){\n  //     public_key = toPublic(public_key)\n  //     var P = public_key.Q.multiply( this.d );\n  //     var S = P.affineX.toBuffer({size: 32});\n  //     // ECIES, adds an extra sha512\n  //     return sha512(S);\n  // }\n\n  /** @throws {Error} - overflow of the key could not be derived */\n\n\n  PrivateKey.prototype.child = function child(offset) {\n    offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);\n    offset = (0, _hash.sha256)(offset);\n    var c = _bigi2.default.fromBuffer(offset);\n\n    if (c.compareTo(n) >= 0) {\n      throw new Error('Child offset went out of bounds, try again');\n    }\n\n    var derived = this.d.add(c); // .mod(n)\n\n    if (derived.signum() === 0) {\n      throw new Error('Child offset derived to an invalid key, try again');\n    }\n\n    return new PrivateKey(derived);\n  };\n\n  /* <helper_functions> */\n\n  PrivateKey.prototype.toByteBuffer = function toByteBuffer() {\n    var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    this.appendByteBuffer(b);\n    return b.copy(0, b.offset);\n  };\n\n  PrivateKey.fromHex = function fromHex(hex) {\n    return PrivateKey.fromBuffer(Buffer.from(hex, 'hex'));\n  };\n\n  PrivateKey.prototype.toHex = function toHex() {\n    return this.toBuffer().toString('hex');\n  };\n\n  /* </helper_functions> */\n\n\n  return PrivateKey;\n}();\n\nexports.default = PrivateKey;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _ecurve = require('ecurve');\n\nvar _bs = require('bs58');\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _deepEqual = require('deep-equal');\n\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\n\nvar _hash = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global ByteBuffer */\n\n\nvar secp256k1 = (0, _ecurve.getCurveByName)('secp256k1');\n\nvar G = secp256k1.G,\n    n = secp256k1.n;\n\nvar PublicKey = function () {\n  /** @param {Point} public key */\n  function PublicKey(Q) {\n    _classCallCheck(this, PublicKey);\n\n    this.Q = Q;\n  }\n\n  PublicKey.fromBinary = function fromBinary(bin) {\n    return PublicKey.fromBuffer(Buffer.from(bin, 'binary'));\n  };\n\n  PublicKey.fromBuffer = function fromBuffer(buffer) {\n    if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') {\n      return new PublicKey(null);\n    }\n\n    return new PublicKey(_ecurve.Point.decodeFrom(secp256k1, buffer));\n  };\n\n  PublicKey.prototype.toBuffer = function toBuffer() {\n    var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null;\n\n    if (this.Q === null) {\n      return Buffer.from('000000000000000000000000000000000000000000000000000000000000000000', 'hex');\n    }\n\n    return this.Q.getEncoded(compressed);\n  };\n\n  PublicKey.fromPoint = function fromPoint(point) {\n    return new PublicKey(point);\n  };\n\n  PublicKey.prototype.toUncompressed = function toUncompressed() {\n    var buf = this.Q.getEncoded(false);\n    var point = _ecurve.Point.decodeFrom(secp256k1, buf);\n    return PublicKey.fromPoint(point);\n  };\n\n  /** bts::blockchain::address (unique but not a full public key) */\n\n\n  PublicKey.prototype.toBlockchainAddress = function toBlockchainAddress() {\n    var pub_buf = this.toBuffer();\n    var pub_sha = (0, _hash.sha512)(pub_buf);\n    return (0, _hash.ripemd160)(pub_sha);\n  };\n\n  /** Alias for {@link toPublicKeyString} */\n\n\n  PublicKey.prototype.toString = function toString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    return this.toPublicKeyString(address_prefix);\n  };\n\n  /**\n        Full public key\n        {return} string\n    */\n\n\n  PublicKey.prototype.toPublicKeyString = function toPublicKeyString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var pub_buf = this.toBuffer();\n    var checksum = (0, _hash.ripemd160)(pub_buf);\n    // Slice from the buffer directly, slicing from the checksum\n    // Uint8array will return the entire array each time.\n    var sliced = new Uint8Array(checksum.buffer.slice(0, 4));\n\n    // concat only accepts buffers so initialize the sliced Uint8array as a Buffer.\n    var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]);\n    return address_prefix + (0, _bs.encode)(addy);\n  };\n\n  /**\n        @arg {string} public_key - like GPHXyz...\n        @arg {string} address_prefix - like GPH\n        @return PublicKey or `null` (if the public_key string is invalid)\n    */\n\n\n  PublicKey.fromPublicKeyString = function fromPublicKeyString(public_key) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    try {\n      return PublicKey.fromStringOrThrow(public_key, address_prefix);\n    } catch (e) {\n      return null;\n    }\n  };\n\n  /**\n        @arg {string} public_key - like GPHXyz...\n        @arg {string} address_prefix - like GPH\n        @throws {Error} if public key is invalid\n        @return PublicKey\n    */\n\n\n  PublicKey.fromStringOrThrow = function fromStringOrThrow(public_key) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var prefix = public_key.slice(0, address_prefix.length);\n    _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n    public_key = public_key.slice(address_prefix.length);\n\n    public_key = Buffer.from((0, _bs.decode)(public_key), 'binary');\n    var checksum = public_key.slice(-4);\n    public_key = public_key.slice(0, -4);\n    var new_checksum = (0, _hash.ripemd160)(public_key);\n    new_checksum = new_checksum.slice(0, 4);\n    var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum'\n\n    if (!isEqual) {\n      throw new Error('Checksum did not match');\n    }\n\n    return PublicKey.fromBuffer(public_key);\n  };\n\n  PublicKey.prototype.toAddressString = function toAddressString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var pub_buf = this.toBuffer();\n    var pub_sha = (0, _hash.sha512)(pub_buf);\n    var addy = (0, _hash.ripemd160)(pub_sha);\n    var checksum = (0, _hash.ripemd160)(addy);\n    addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n    return address_prefix + (0, _bs.encode)(addy);\n  };\n\n  PublicKey.prototype.toPtsAddy = function toPtsAddy() {\n    var pub_buf = this.toBuffer();\n    var pub_sha = (0, _hash.sha256)(pub_buf);\n    var addy = (0, _hash.ripemd160)(pub_sha);\n    addy = Buffer.concat([Buffer.from([0x38]), addy]); // version 56(decimal)\n\n    var checksum = (0, _hash.sha256)(addy);\n    checksum = (0, _hash.sha256)(checksum);\n\n    addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n    return (0, _bs.encode)(addy);\n  };\n\n  PublicKey.prototype.child = function child(offset) {\n    (0, _assert2.default)(Buffer.isBuffer(offset), 'Buffer required: offset');\n    _assert2.default.equal(offset.length, 32, 'offset length');\n\n    offset = Buffer.concat([this.toBuffer(), offset]);\n    offset = (0, _hash.sha256)(offset);\n\n    var c = _bigi2.default.fromBuffer(offset);\n\n    if (c.compareTo(n) >= 0) {\n      throw new Error('Child offset went out of bounds, try again');\n    }\n\n    var cG = G.multiply(c);\n    var Qprime = this.Q.add(cG);\n\n    if (secp256k1.isInfinity(Qprime)) {\n      throw new Error('Child offset derived to an invalid key, try again');\n    }\n\n    return PublicKey.fromPoint(Qprime);\n  };\n\n  /* <HEX> */\n\n  PublicKey.prototype.toByteBuffer = function toByteBuffer() {\n    var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    this.appendByteBuffer(b);\n    return b.copy(0, b.offset);\n  };\n\n  PublicKey.fromHex = function fromHex(hex) {\n    return PublicKey.fromBuffer(Buffer.from(hex, 'hex'));\n  };\n\n  PublicKey.prototype.toHex = function toHex() {\n    return this.toBuffer().toString('hex');\n  };\n\n  PublicKey.fromPublicKeyStringHex = function fromPublicKeyStringHex(hex) {\n    return PublicKey.fromPublicKeyString(Buffer.from(hex, 'hex'));\n  };\n\n  /* </HEX> */\n\n\n  return PublicKey;\n}();\n\nexports.default = PublicKey;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _bs = require('bs58');\n\nvar _deepEqual = require('deep-equal');\n\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\n\nvar _hash2 = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** Addresses are shortened non-reversable hashes of a public key.  The full PublicKey is preferred.\n    @deprecated\n*/\nvar Address = function () {\n  function Address(addy) {\n    _classCallCheck(this, Address);\n\n    this.addy = addy;\n  }\n\n  Address.fromBuffer = function fromBuffer(buffer) {\n    var _hash = (0, _hash2.sha512)(buffer);\n    var addy = (0, _hash2.ripemd160)(_hash);\n    return new Address(addy);\n  };\n\n  Address.fromString = function fromString(string) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var prefix = string.slice(0, address_prefix.length);\n    _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n    var addy = string.slice(address_prefix.length);\n    addy = Buffer.from((0, _bs.decode)(addy), 'binary');\n    var checksum = addy.slice(-4);\n    addy = addy.slice(0, -4);\n    var new_checksum = (0, _hash2.ripemd160)(addy);\n    new_checksum = new_checksum.slice(0, 4);\n    var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum'\n\n    if (!isEqual) {\n      throw new Error('Checksum did not match');\n    }\n\n    return new Address(addy);\n  };\n\n  /** @return Address - Compressed PTS format (by default) */\n\n\n  Address.fromPublic = function fromPublic(public_key) {\n    var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n    var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56;\n\n    var sha2 = (0, _hash2.sha256)(public_key.toBuffer(compressed));\n    var rep = (0, _hash2.ripemd160)(sha2);\n    var versionBuffer = Buffer.alloc(1);\n    versionBuffer.writeUInt8(0xff & version, 0); // eslint-disable-line\n    var addr = Buffer.concat([versionBuffer, rep]);\n    var check = (0, _hash2.sha256)(addr);\n    check = (0, _hash2.sha256)(check);\n    var buffer = Buffer.concat([addr, check.slice(0, 4)]);\n    return new Address((0, _hash2.ripemd160)(buffer));\n  };\n\n  Address.prototype.toBuffer = function toBuffer() {\n    return this.addy;\n  };\n\n  Address.prototype.toString = function toString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var checksum = (0, _hash2.ripemd160)(this.addy);\n    var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]);\n    return address_prefix + (0, _bs.encode)(addy);\n  };\n\n  return Address;\n}();\n\nexports.default = Address;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _aes = require('crypto-js/aes');\n\nvar _aes2 = _interopRequireDefault(_aes);\n\nvar _encHex = require('crypto-js/enc-hex');\n\nvar _encHex2 = _interopRequireDefault(_encHex);\n\nvar _encBase = require('crypto-js/enc-base64');\n\nvar _encBase2 = _interopRequireDefault(_encBase);\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _hash2 = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } // https://code.google.com/p/crypto-js\n\n\n/** Provides symetric encrypt and decrypt via AES. */\nvar Aes = function () {\n  /** @private */\n  function Aes(iv, key) {\n    _classCallCheck(this, Aes);\n\n    this.iv = iv;\n    this.key = key;\n  }\n\n  /** This is an excellent way to ensure that all references to Aes can not operate anymore\n   * (example: a wallet becomes locked).  An application should ensure there is only one\n   * Aes object instance for a given secret `seed`. */\n\n\n  Aes.prototype.clear = function clear() {\n    this.iv = undefined;\n    this.key = undefined;\n    return undefined;\n  };\n\n  /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */\n\n\n  Aes.fromSeed = function fromSeed(seed) {\n    if (seed === undefined) {\n      throw new Error('seed is required');\n    }\n\n    var _hash = (0, _hash2.sha512)(seed);\n    _hash = _hash.toString('hex');\n    // DEBUG console.log('... fromSeed _hash',_hash)\n    return Aes.fromSha512(_hash);\n  };\n\n  /** @arg {string} hash - A 128 byte hex string, typically one\n   * would call {@link fromSeed} instead. */\n\n\n  Aes.fromSha512 = function fromSha512(hash) {\n    _assert2.default.equal(hash.length, 128, 'A Sha512 in HEX should be 128 characters long, instead got ' + hash.length);\n    var iv = _encHex2.default.parse(hash.substring(64, 96));\n    var key = _encHex2.default.parse(hash.substring(0, 64));\n    return new Aes(iv, key);\n  };\n\n  Aes.fromBuffer = function fromBuffer(buf) {\n    (0, _assert2.default)(Buffer.isBuffer(buf), 'Expecting Buffer');\n    _assert2.default.equal(buf.length, 64, 'A Sha512 Buffer should be 64 characters long, instead got ' + buf.length);\n    return Aes.fromSha512(buf.toString('hex'));\n  };\n\n  /**\n        @throws {Error} - \"Invalid Key, ...\"\n        @arg {PrivateKey} private_key - required and used for decryption\n        @arg {PublicKey} public_key - required and used to calcualte the shared secret\n        @arg {string} [nonce = \"\"] optional but should always be provided and be unique\n        when re-using the same private/public keys more than once.  This nonce is not a secret.\n        @arg {string|Buffer} message - Encrypted message containing a checksum\n        @return {Buffer}\n    */\n\n\n  Aes.decrypt_with_checksum = function decrypt_with_checksum(private_key, public_key, nonce, message) {\n    var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n    // Warning: Do not put `nonce = \"\"` in the arguments, in es6 this will\n    // not convert \"null\" into an emtpy string\n    if (nonce == null) {\n      nonce = '';\n    }\n\n    if (!Buffer.isBuffer(message)) {\n      message = Buffer.from(message, 'hex');\n    }\n\n    var S = private_key.get_shared_secret(public_key, legacy);\n    // D E B U G\n    // console.log('decrypt_with_checksum', {\n    //     priv_to_pub: private_key.toPublicKey().toString(),\n    //     pub: public_key.toPublicKeyString(),\n    //     nonce: nonce,\n    //     message: message.length,\n    //     S: S.toString('hex')\n    // })\n\n    var aes = Aes.fromSeed(Buffer.concat([\n    // A null or empty string nonce will not effect the hash\n    Buffer.from('' + nonce), Buffer.from(S.toString('hex'))]));\n\n    var planebuffer = aes.decrypt(message);\n\n    if (!(planebuffer.length >= 4)) {\n      throw new Error('Invalid key, could not decrypt message(1)');\n    }\n\n    // DEBUG console.log('... planebuffer',planebuffer)\n    var checksum = planebuffer.slice(0, 4);\n    var plaintext = planebuffer.slice(4);\n\n    // console.log('... checksum',checksum.toString('hex'))\n    // console.log('... plaintext',plaintext.toString())\n\n    var new_checksum = (0, _hash2.sha256)(plaintext);\n    new_checksum = new_checksum.slice(0, 4);\n    new_checksum = new_checksum.toString('hex');\n\n    if (!(checksum.toString('hex') === new_checksum)) {\n      throw new Error('Invalid key, could not decrypt message(2)');\n    }\n\n    return plaintext;\n  };\n\n  /** Identical to {@link decrypt_with_checksum} but used to encrypt.  Should not throw an error.\n        @return {Buffer} message - Encrypted message which includes a checksum\n    */\n\n\n  Aes.encrypt_with_checksum = function encrypt_with_checksum(private_key, public_key, nonce, message) {\n    // Warning: Do not put `nonce = \"\"` in the arguments, in es6 this will\n    // not convert \"null\" into an emtpy string\n\n    if (nonce == null) {\n      nonce = '';\n    }\n\n    if (!Buffer.isBuffer(message)) {\n      message = Buffer.from(message, 'binary');\n    }\n\n    var S = private_key.get_shared_secret(public_key);\n\n    // D E B U G\n    // console.log('encrypt_with_checksum', {\n    //     priv_to_pub: private_key.toPublicKey().toString()\n    //     pub: public_key.toPublicKeyString()\n    //     nonce: nonce\n    //     message: message.length\n    //     S: S.toString('hex')\n    // })\n\n    var aes = Aes.fromSeed(Buffer.concat([\n    // A null or empty string nonce will not effect the hash\n    Buffer.from('' + nonce), Buffer.from(S.toString('hex'))]));\n    // DEBUG console.log('... S',S.toString('hex'))\n    var checksum = (0, _hash2.sha256)(message).slice(0, 4);\n    var payload = Buffer.concat([checksum, message]);\n    // DEBUG console.log('... payload',payload.toString())\n    return aes.encrypt(payload);\n  };\n\n  /** @private */\n\n\n  Aes.prototype._decrypt_word_array = function _decrypt_word_array(cipher) {\n    // https://code.google.com/p/crypto-js/#Custom_Key_and_IV\n    // see wallet_records.cpp master_key::decrypt_key\n    return _aes2.default.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv });\n  };\n\n  /** @private */\n\n\n  Aes.prototype._encrypt_word_array = function _encrypt_word_array(plaintext) {\n    // https://code.google.com/p/crypto-js/issues/detail?id=85\n    var cipher = _aes2.default.encrypt(plaintext, this.key, { iv: this.iv });\n    return _encBase2.default.parse(cipher.toString());\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} ciphertext\n        @return {Buffer} binary\n    */\n\n\n  Aes.prototype.decrypt = function decrypt(ciphertext) {\n    if (typeof ciphertext === 'string') {\n      ciphertext = Buffer.from(ciphertext, 'binary');\n    }\n\n    if (!Buffer.isBuffer(ciphertext)) {\n      throw new Error('buffer required');\n    }\n\n    (0, _assert2.default)(ciphertext, 'Missing cipher text');\n    // hex is the only common format\n    var hex = this.decryptHex(ciphertext.toString('hex'));\n    return Buffer.from(hex, 'hex');\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} plaintext\n        @return {Buffer} binary\n    */\n\n\n  Aes.prototype.encrypt = function encrypt(plaintext) {\n    if (typeof plaintext === 'string') {\n      plaintext = Buffer.from(plaintext, 'binary');\n    }\n\n    if (!Buffer.isBuffer(plaintext)) {\n      throw new Error('buffer required');\n    }\n\n    // assert plaintext, \"Missing plain text\"\n    // hex is the only common format\n    var hex = this.encryptHex(plaintext.toString('hex'));\n    return Buffer.from(hex, 'hex');\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string|Buffer} plaintext\n        @return {string} hex\n    */\n\n\n  Aes.prototype.encryptToHex = function encryptToHex(plaintext) {\n    if (typeof plaintext === 'string') {\n      plaintext = Buffer.from(plaintext, 'binary');\n    }\n\n    if (!Buffer.isBuffer(plaintext)) {\n      throw new Error('buffer required');\n    }\n\n    // assert plaintext, \"Missing plain text\"\n    // hex is the only common format\n    return this.encryptHex(plaintext.toString('hex'));\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} cipher - hex\n        @return {string} binary (could easily be readable text)\n    */\n\n\n  Aes.prototype.decryptHex = function decryptHex(cipher) {\n    (0, _assert2.default)(cipher, 'Missing cipher text');\n    // Convert data into word arrays (used by Crypto)\n    var cipher_array = _encHex2.default.parse(cipher);\n    var plainwords = this._decrypt_word_array(cipher_array);\n    return _encHex2.default.stringify(plainwords);\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} cipher - hex\n        @return {Buffer} encoded as specified by the parameter\n    */\n\n\n  Aes.prototype.decryptHexToBuffer = function decryptHexToBuffer(cipher) {\n    (0, _assert2.default)(cipher, 'Missing cipher text');\n    // Convert data into word arrays (used by Crypto)\n    var cipher_array = _encHex2.default.parse(cipher);\n    var plainwords = this._decrypt_word_array(cipher_array);\n    var plainhex = _encHex2.default.stringify(plainwords);\n    return Buffer.from(plainhex, 'hex');\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} cipher - hex\n        @arg {string} [encoding = 'binary'] - a valid Buffer encoding\n        @return {String} encoded as specified by the parameter\n    */\n\n\n  Aes.prototype.decryptHexToText = function decryptHexToText(cipher) {\n    var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary';\n\n    return this.decryptHexToBuffer(cipher).toString(encoding);\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} plainhex - hex format\n        @return {String} hex\n    */\n\n\n  Aes.prototype.encryptHex = function encryptHex(plainhex) {\n    var plain_array = _encHex2.default.parse(plainhex);\n    var cipher_array = this._encrypt_word_array(plain_array);\n    return _encHex2.default.stringify(cipher_array);\n  };\n\n  return Aes;\n}();\n\nexports.default = Aes;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.verifyRaw = exports.verify = exports.sign = exports.recoverPubKey = exports.deterministicGenerateK = exports.calcPubKeyRecoveryParam = undefined;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _hash = require('./hash');\n\nvar _enforce_types = require('./enforce_types');\n\nvar _enforce_types2 = _interopRequireDefault(_enforce_types);\n\nvar _ecsignature = require('./ecsignature');\n\nvar _ecsignature2 = _interopRequireDefault(_ecsignature);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// https://tools.ietf.org/html/rfc6979#section-3.2\n\n// from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa\nfunction deterministicGenerateK(curve, hash, d, checkSig, nonce) {\n  (0, _enforce_types2.default)('Buffer', hash);\n  (0, _enforce_types2.default)(_bigi2.default, d);\n\n  if (nonce) {\n    hash = (0, _hash.sha256)(Buffer.concat([hash, Buffer.alloc(nonce)]));\n  }\n\n  // sanity check\n  _assert2.default.equal(hash.length, 32, 'Hash must be 256 bit');\n\n  var x = d.toBuffer(32);\n  var k = Buffer.alloc(32);\n  var v = Buffer.alloc(32);\n\n  // Step B\n  v.fill(1);\n\n  // Step C\n  k.fill(0);\n\n  // Step D\n  k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0]), x, hash]), k);\n\n  // Step E\n  v = (0, _hash.HmacSHA256)(v, k);\n\n  // Step F\n  k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([1]), x, hash]), k);\n\n  // Step G\n  v = (0, _hash.HmacSHA256)(v, k);\n\n  // Step H1/H2a, ignored as tlen === qlen (256 bit)\n  // Step H2b\n  v = (0, _hash.HmacSHA256)(v, k);\n\n  var T = _bigi2.default.fromBuffer(v);\n\n  // Step H3, repeat until T is within the interval [1, n - 1]\n  while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) {\n    k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0])]), k);\n    v = (0, _hash.HmacSHA256)(v, k);\n\n    // Step H1/H2a, again, ignored as tlen === qlen (256 bit)\n    // Step H2b again\n    v = (0, _hash.HmacSHA256)(v, k);\n\n    T = _bigi2.default.fromBuffer(v);\n  }\n\n  return T;\n}\n\nfunction sign(curve, hash, d, nonce) {\n  var e = _bigi2.default.fromBuffer(hash);\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = void 0;\n  var s = void 0;\n\n  deterministicGenerateK(curve, hash, d, function (key) {\n    // find canonically valid signature\n    var Q = G.multiply(key);\n\n    if (curve.isInfinity(Q)) {\n      return false;\n    }\n\n    r = Q.affineX.mod(n);\n\n    if (r.signum() === 0) {\n      return false;\n    }\n\n    s = key.modInverse(n).multiply(e.add(d.multiply(r))).mod(n);\n\n    if (s.signum() === 0) {\n      return false;\n    }\n\n    return true;\n  }, nonce);\n\n  var N_OVER_TWO = n.shiftRight(1);\n\n  // enforce low S values, see bip62: 'low s values in signatures'\n  if (s.compareTo(N_OVER_TWO) > 0) {\n    s = n.subtract(s);\n  }\n\n  return new _ecsignature2.default(r, s);\n}\n\nfunction verifyRaw(curve, e, signature, Q) {\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = signature.r;\n  var s = signature.s;\n\n  // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]\n  if (r.signum() <= 0 || r.compareTo(n) >= 0) {\n    return false;\n  }\n\n  if (s.signum() <= 0 || s.compareTo(n) >= 0) {\n    return false;\n  }\n\n  // c = s^-1 mod n\n  var c = s.modInverse(n);\n\n  // 1.4.4 Compute u1 = es^−1 mod n\n  //               u2 = rs^−1 mod n\n  var u1 = e.multiply(c).mod(n);\n  var u2 = r.multiply(c).mod(n);\n\n  // 1.4.5 Compute R = (xR, yR) = u1G + u2Q\n  var R = G.multiplyTwo(u1, Q, u2);\n\n  // 1.4.5 (cont.) Enforce R is not at infinity\n  if (curve.isInfinity(R)) {\n    return false;\n  }\n\n  // 1.4.6 Convert the field element R.x to an integer\n  var xR = R.affineX;\n\n  // 1.4.7 Set v = xR mod n\n  var v = xR.mod(n);\n\n  // 1.4.8 If v = r, output \"valid\", and if v != r, output \"invalid\"\n  return v.equals(r);\n}\n\nfunction verify(curve, hash, signature, Q) {\n  // 1.4.2 H = Hash(M), already done by the user\n  // 1.4.3 e = H\n  var e = _bigi2.default.fromBuffer(hash);\n  return verifyRaw(curve, e, signature, Q);\n}\n\n/**\n * Recover a public key from a signature.\n *\n * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, \"Public\n * Key Recovery Operation\".\n *\n * http://www.secg.org/download/aid-780/sec1-v2.pdf\n */\nfunction recoverPubKey(curve, e, signature, i) {\n  _assert2.default.strictEqual(i & 3, i, 'Recovery param is more than two bits'); // eslint-disable-line\n\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = signature.r;\n  var s = signature.s;\n\n  (0, _assert2.default)(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value');\n  (0, _assert2.default)(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value');\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = i & 1; // eslint-disable-line\n\n  // The more significant bit specifies whether we should use the\n  // first or second candidate key.\n  var isSecondKey = i >> 1; // eslint-disable-line\n\n  // 1.1 Let x = r + jn\n  var x = isSecondKey ? r.add(n) : r;\n  var R = curve.pointFromX(isYOdd, x);\n\n  // 1.4 Check that nR is at infinity\n  var nR = R.multiply(n);\n  (0, _assert2.default)(curve.isInfinity(nR), 'nR is not a valid curve point');\n\n  // Compute -e from e\n  var eNeg = e.negate().mod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  var rInv = r.modInverse(n);\n\n  var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv);\n  curve.validate(Q);\n\n  return Q;\n}\n\n/**\n * Calculate pubkey extraction parameter.\n *\n * When extracting a pubkey from a signature, we have to\n * distinguish four different cases. Rather than putting this\n * burden on the verifier, Bitcoin includes a 2-bit value with the\n * signature.\n *\n * This function simply tries all four cases and returns the value\n * that resulted in a successful pubkey recovery.\n */\nfunction calcPubKeyRecoveryParam(curve, e, signature, Q) {\n  for (var i = 0; i < 4; i++) {\n    var Qprime = recoverPubKey(curve, e, signature, i);\n\n    // 1.6.2 Verify Q\n    if (Qprime.equals(Q)) {\n      return i;\n    }\n  }\n\n  throw new Error('Unable to find valid recovery factor');\n}\n\nexports.calcPubKeyRecoveryParam = calcPubKeyRecoveryParam;\nexports.deterministicGenerateK = deterministicGenerateK;\nexports.recoverPubKey = recoverPubKey;\nexports.sign = sign;\nexports.verify = verify;\nexports.verifyRaw = verifyRaw;","'use strict';\n\nexports.__esModule = true;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _enforce_types = require('./enforce_types');\n\nvar _enforce_types2 = _interopRequireDefault(_enforce_types);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// from https://github.com/bitcoinjs/bitcoinjs-lib\nfunction ECSignature(r, s) {\n  (0, _enforce_types2.default)(_bigi2.default, r);\n  (0, _enforce_types2.default)(_bigi2.default, s);\n\n  this.r = r;\n  this.s = s;\n}\n\n// Import operations\n/* eslint no-bitwise: \"off\" */\nECSignature.parseCompact = function (buffer) {\n  _assert2.default.equal(buffer.length, 65, 'Invalid signature length');\n  var i = buffer.readUInt8(0) - 27;\n\n  // At most 3 bits\n  _assert2.default.equal(i, i & 7, 'Invalid signature parameter');\n  var compressed = !!(i & 4);\n\n  // Recovery param only\n  i &= 3;\n\n  var r = _bigi2.default.fromBuffer(buffer.slice(1, 33));\n  var s = _bigi2.default.fromBuffer(buffer.slice(33));\n\n  return {\n    compressed: compressed,\n    i: i,\n    signature: new ECSignature(r, s)\n  };\n};\n\nECSignature.fromDER = function (buffer) {\n  _assert2.default.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence');\n  _assert2.default.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length');\n  _assert2.default.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer');\n\n  var rLen = buffer.readUInt8(3);\n  (0, _assert2.default)(rLen > 0, 'R length is zero');\n\n  var offset = 4 + rLen;\n  _assert2.default.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)');\n\n  var sLen = buffer.readUInt8(offset + 1);\n  (0, _assert2.default)(sLen > 0, 'S length is zero');\n\n  var rB = buffer.slice(4, offset);\n  var sB = buffer.slice(offset + 2);\n  offset += 2 + sLen;\n\n  if (rLen > 1 && rB.readUInt8(0) === 0x00) {\n    (0, _assert2.default)(rB.readUInt8(1) & 0x80, 'R value excessively padded');\n  }\n\n  if (sLen > 1 && sB.readUInt8(0) === 0x00) {\n    (0, _assert2.default)(sB.readUInt8(1) & 0x80, 'S value excessively padded');\n  }\n\n  _assert2.default.equal(offset, buffer.length, 'Invalid DER encoding');\n  var r = _bigi2.default.fromDERInteger(rB);\n  var s = _bigi2.default.fromDERInteger(sB);\n\n  (0, _assert2.default)(r.signum() >= 0, 'R value is negative');\n  (0, _assert2.default)(s.signum() >= 0, 'S value is negative');\n\n  return new ECSignature(r, s);\n};\n\n// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants,\n// importing Transaction causes a circular dependency\nECSignature.parseScriptSignature = function (buffer) {\n  var hashType = buffer.readUInt8(buffer.length - 1);\n  var hashTypeMod = hashType & ~0x80;\n\n  (0, _assert2.default)(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType');\n\n  return {\n    signature: ECSignature.fromDER(buffer.slice(0, -1)),\n    hashType: hashType\n  };\n};\n\n// Export operations\nECSignature.prototype.toCompact = function toCompact(i, compressed) {\n  if (compressed) {\n    i += 4;\n  }\n\n  i += 27;\n\n  var buffer = Buffer.alloc(65);\n  buffer.writeUInt8(i, 0);\n\n  this.r.toBuffer(32).copy(buffer, 1);\n  this.s.toBuffer(32).copy(buffer, 33);\n\n  return buffer;\n};\n\nECSignature.prototype.toDER = function toDER() {\n  var rBa = this.r.toDERInteger();\n  var sBa = this.s.toDERInteger();\n\n  var sequence = [];\n\n  // INTEGER\n  sequence.push(0x02, rBa.length);\n  sequence = sequence.concat(rBa);\n\n  // INTEGER\n  sequence.push(0x02, sBa.length);\n  sequence = sequence.concat(sBa);\n\n  // SEQUENCE\n  sequence.unshift(0x30, sequence.length);\n\n  return Buffer.from(sequence);\n};\n\nECSignature.prototype.toScriptSignature = function toScriptSignature(hashType) {\n  var hashTypeBuffer = Buffer.alloc(1);\n  hashTypeBuffer.writeUInt8(hashType, 0);\n\n  return Buffer.concat([this.toDER(), hashTypeBuffer]);\n};\n\nexports.default = ECSignature;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.default = enforce;\n\nfunction getName(fn) {\n  // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property\n  var match = fn.toString().match(/function (.*?)\\(/);\n  return match ? match[1] : null;\n}\n\nfunction enforce(type, value) {\n  // Copied from https://github.com/bitcoinjs/bitcoinjs-lib\n  switch (type) {\n    case 'Array':\n      {\n        if (Array.isArray(value)) {\n          return;\n        }\n\n        break;\n      }\n\n    case 'Boolean':\n      {\n        if (typeof value === 'boolean') {\n          return;\n        }\n\n        break;\n      }\n\n    case 'Buffer':\n      {\n        if (Buffer.isBuffer(value)) {\n          return;\n        }\n\n        break;\n      }\n\n    case 'Number':\n      {\n        if (typeof value === 'number') {\n          return;\n        }\n\n        break;\n      }\n\n    case 'String':\n      {\n        if (typeof value === 'string') {\n          return;\n        }\n\n        break;\n      }\n\n    default:\n      {\n        if (getName(value.constructor) === getName(type)) {\n          return;\n        }\n      }\n  }\n\n  throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value);\n}\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.ripemd160 = exports.HmacSHA256 = exports.sha512 = exports.sha256 = exports.sha1 = undefined;\n\nvar _createHash = require(41);\n\nvar _createHash2 = _interopRequireDefault(_createHash);\n\nvar _createHmac = require(43);\n\nvar _createHmac2 = _interopRequireDefault(_createHmac);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha1(data, encoding) {\n  return (0, _createHash2.default)('sha1').update(data).digest(encoding);\n}\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha256(data, encoding) {\n  return (0, _createHash2.default)('sha256').update(data).digest(encoding);\n}\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha512(data, encoding) {\n  return (0, _createHash2.default)('sha512').update(data).digest(encoding);\n}\n\nfunction HmacSHA256(buffer, secret) {\n  return (0, _createHmac2.default)('sha256', secret).update(buffer).digest();\n}\n\nfunction ripemd160(data) {\n  return (0, _createHash2.default)('rmd160').update(data).digest();\n}\n\n// function hash160(buffer) {\n//   return ripemd160(sha256(buffer))\n// }\n//\n// function hash256(buffer) {\n//   return sha256(sha256(buffer))\n// }\n\n//\n// function HmacSHA512(buffer, secret) {\n//   return crypto.createHmac('sha512', secret).update(buffer).digest()\n// }\n\nexports.sha1 = sha1;\nexports.sha256 = sha256;\nexports.sha512 = sha512;\nexports.HmacSHA256 = HmacSHA256;\nexports.ripemd160 = ripemd160;","'use strict';\n\nexports.__esModule = true;\n\nvar _ecurve = require('ecurve');\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _hash2 = require('./hash');\n\nvar _ecdsa = require('./ecdsa');\n\nvar _PublicKey = require('./PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global ByteBuffer */\n\n\nvar secp256k1 = (0, _ecurve.getCurveByName)('secp256k1');\n\nvar Signature = function () {\n  function Signature(r1, s1, i1) {\n    _classCallCheck(this, Signature);\n\n    this.r = r1;\n    this.s = s1;\n    this.i = i1;\n    _assert2.default.equal(this.r != null, true, 'Missing parameter');\n    _assert2.default.equal(this.s != null, true, 'Missing parameter');\n    _assert2.default.equal(this.i != null, true, 'Missing parameter');\n  }\n\n  Signature.fromBuffer = function fromBuffer(buf) {\n    var i = void 0;\n    var r = void 0;\n    var s = void 0;\n    _assert2.default.equal(buf.length, 65, 'Invalid signature length');\n    i = buf.readUInt8(0);\n    _assert2.default.equal(i - 27, i - 27 & 7, 'Invalid signature parameter'); // eslint-disable-line\n    r = _bigi2.default.fromBuffer(buf.slice(1, 33));\n    s = _bigi2.default.fromBuffer(buf.slice(33));\n    return new Signature(r, s, i);\n  };\n\n  Signature.prototype.toBuffer = function toBuffer() {\n    var buf = void 0;\n    buf = Buffer.alloc(65);\n    buf.writeUInt8(this.i, 0);\n    this.r.toBuffer(32).copy(buf, 1);\n    this.s.toBuffer(32).copy(buf, 33);\n    return buf;\n  };\n\n  Signature.prototype.recoverPublicKeyFromBuffer = function recoverPublicKeyFromBuffer(buffer) {\n    return this.recoverPublicKey((0, _hash2.sha256)(buffer));\n  };\n\n  /**\n        @return {PublicKey}\n    */\n\n\n  Signature.prototype.recoverPublicKey = function recoverPublicKey(sha256_buffer) {\n    var Q = void 0;\n    var e = void 0;\n    var i = void 0;\n    e = _bigi2.default.fromBuffer(sha256_buffer);\n    i = this.i;\n    i -= 27;\n    i &= 3; // eslint-disable-line\n    Q = (0, _ecdsa.recoverPubKey)(secp256k1, e, this, i);\n    return _PublicKey2.default.fromPoint(Q);\n  };\n\n  /**\n        @param {Buffer} buf\n        @param {PrivateKey} private_key\n        @return {Signature}\n    */\n\n\n  Signature.signBuffer = function signBuffer(buf, private_key) {\n    var _hash = (0, _hash2.sha256)(buf);\n    return Signature.signBufferSha256(_hash, private_key);\n  };\n\n  /** Sign a buffer of exactally 32 bytes in size (sha256(text))\n        @param {Buffer} buf - 32 bytes binary\n        @param {PrivateKey} private_key\n        @return {Signature}\n    */\n\n\n  Signature.signBufferSha256 = function signBufferSha256(buf_sha256, private_key) {\n    if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) {\n      throw new Error('buf_sha256: 32 byte buffer requred');\n    }\n\n    var der = void 0;\n    var e = void 0;\n    var ecsignature = void 0;\n    var i = void 0;\n    var lenR = void 0;\n    var lenS = void 0;\n    var nonce = void 0;\n    i = null;\n    nonce = 0;\n    e = _bigi2.default.fromBuffer(buf_sha256);\n\n    var loop = true;\n\n    while (loop) {\n      ecsignature = (0, _ecdsa.sign)(secp256k1, buf_sha256, private_key.d, nonce++);\n      der = ecsignature.toDER();\n      lenR = der[3];\n      lenS = der[5 + lenR];\n\n      if (lenR === 32 && lenS === 32) {\n        i = (0, _ecdsa.calcPubKeyRecoveryParam)(secp256k1, e, ecsignature, private_key.toPublicKey().Q);\n        i += 4; // compressed\n        i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)\n        loop = false;\n        break;\n      }\n\n      if (nonce % 10 === 0) {\n        console.log('WARN: ' + nonce + ' attempts to find canonical signature');\n      }\n    }\n\n    return new Signature(ecsignature.r, ecsignature.s, i);\n  };\n\n  Signature.sign = function sign(string, private_key) {\n    return Signature.signBuffer(Buffer.from(string), private_key);\n  };\n\n  /**\n        @param {Buffer} un-hashed\n        @param {./PublicKey}\n        @return {boolean}\n    */\n\n\n  Signature.prototype.verifyBuffer = function verifyBuffer(buf, public_key) {\n    var _hash = (0, _hash2.sha256)(buf);\n    return this.verifyHash(_hash, public_key);\n  };\n\n  Signature.prototype.verifyHash = function verifyHash(hash, public_key) {\n    _assert2.default.equal(hash.length, 32, 'A SHA 256 should be 32 bytes long, instead got ' + hash.length);\n    return (0, _ecdsa.verify)(secp256k1, hash, {\n      r: this.r,\n      s: this.s\n    }, public_key.Q);\n  };\n\n  /* <HEX> */\n\n  Signature.prototype.toByteBuffer = function toByteBuffer() {\n    var b = void 0;\n    b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    this.appendByteBuffer(b);\n    return b.copy(0, b.offset);\n  };\n\n  Signature.fromHex = function fromHex(hex) {\n    return Signature.fromBuffer(Buffer.from(hex, 'hex'));\n  };\n\n  Signature.prototype.toHex = function toHex() {\n    return this.toBuffer().toString('hex');\n  };\n\n  Signature.signHex = function signHex(hex, private_key) {\n    var buf = void 0;\n    buf = Buffer.from(hex, 'hex');\n    return Signature.signBuffer(buf, private_key);\n  };\n\n  Signature.prototype.verifyHex = function verifyHex(hex, public_key) {\n    var buf = void 0;\n    buf = Buffer.from(hex, 'hex');\n    return this.verifyBuffer(buf, public_key);\n  };\n\n  return Signature;\n}();\n\nexports.default = Signature;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.SerializerValidation = exports.template = exports.ops = exports.types = exports.fp = exports.Serializer = undefined;\n\nvar _serializer = require(24);\n\nvar _serializer2 = _interopRequireDefault(_serializer);\n\nvar _FastParser = require(20);\n\nvar _FastParser2 = _interopRequireDefault(_FastParser);\n\nvar _types = require(26);\n\nvar _types2 = _interopRequireDefault(_types);\n\nvar _operations = require(23);\n\nvar ops = _interopRequireWildcard(_operations);\n\nvar _template = require(25);\n\nvar _template2 = _interopRequireDefault(_template);\n\nvar _SerializerValidation = require(21);\n\nvar _SerializerValidation2 = _interopRequireDefault(_SerializerValidation);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Serializer = _serializer2.default;\nexports.fp = _FastParser2.default;\nexports.types = _types2.default;\nexports.ops = ops;\nexports.template = _template2.default;\nexports.SerializerValidation = _SerializerValidation2.default;","'use strict';\n\nexports.__esModule = true;\n\nvar _PublicKey = require('../../ecc/src/PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar FastParser = function () {\n  function FastParser() {\n    _classCallCheck(this, FastParser);\n  }\n\n  FastParser.fixed_data = function fixed_data(b, len, buffer) {\n    if (!b) {\n      return;\n    }\n    if (buffer) {\n      var data = buffer.slice(0, len).toString('binary');\n      b.append(data, 'binary');\n      while (len-- > data.length) {\n        b.writeUint8(0);\n      }\n    } else {\n      var b_copy = b.copy(b.offset, b.offset + len);\n      b.skip(len);\n      return Buffer.from(b_copy.toBinary(), 'binary');\n    }\n  };\n\n  FastParser.public_key = function public_key(b, _public_key) {\n    var buffer = void 0;\n    if (!b) {\n      return;\n    }\n    if (_public_key) {\n      buffer = _public_key.toBuffer();\n      b.append(buffer.toString('binary'), 'binary');\n    } else {\n      buffer = FastParser.fixed_data(b, 33);\n      return _PublicKey2.default.fromBuffer(buffer);\n    }\n  };\n\n  FastParser.ripemd160 = function ripemd160(b, _ripemd) {\n    if (!b) {\n      return;\n    }\n    if (_ripemd) {\n      FastParser.fixed_data(b, 20, _ripemd);\n    } else {\n      return FastParser.fixed_data(b, 20);\n    }\n  };\n\n  FastParser.sha256 = function sha256(b, _sha) {\n    if (!b) {\n      return;\n    }\n    if (_sha) {\n      FastParser.fixed_data(b, 32, _sha);\n    } else {\n      return FastParser.fixed_data(b, 32);\n    }\n  };\n\n  FastParser.time_point_sec = function time_point_sec(b, epoch) {\n    if (epoch) {\n      epoch = Math.ceil(epoch / 1000);\n      b.writeInt32(epoch);\n    } else {\n      epoch = b.readInt32(); // fc::time_point_sec\n      return new Date(epoch * 1000);\n    }\n  };\n\n  return FastParser;\n}();\n\nexports.default = FastParser;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _bytebuffer = require(38);\n\nvar _ChainTypes = require(3);\n\nvar _ChainTypes2 = _interopRequireDefault(_ChainTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar MAX_SAFE_INT = 9007199254740991;\nvar MIN_SAFE_INT = -9007199254740991;\n\n/**\n    Most validations are skipped and the value returned unchanged when an empty string,\n    null, or undefined is encountered (except \"required\").\n    Validations support a string format for dealing with large numbers.\n*/\nvar _my = {\n  is_empty: function is_empty(value) {\n    return value === null || value === undefined;\n  },\n  required: function required(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      throw new Error('value required ' + field_name + ' | ' + value);\n    }\n\n    return value;\n  },\n  require_long: function require_long(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (!_bytebuffer.Long.isLong(value)) {\n      throw new Error('Long value required ' + field_name + ' | ' + value);\n    }\n\n    return value;\n  },\n  string: function string(value) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (typeof value !== 'string') {\n      throw new Error('string required: ' + value);\n    }\n\n    return value;\n  },\n  number: function number(value) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (typeof value !== 'number') {\n      throw new Error('number required: ' + value);\n    }\n\n    return value;\n  },\n  whole_number: function whole_number(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (/\\./.test(value)) {\n      throw new Error('whole number required ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  unsigned: function unsigned(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (/-/.test(value)) {\n      throw new Error('unsigned required ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  is_digits: function is_digits(value) {\n    if (typeof value === 'number') {\n      return true;\n    }\n\n    return (/^[0-9]+$/.test(value)\n    );\n  },\n  to_number: function to_number(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.no_overflow53(value, field_name);\n    var int_value = function () {\n      if (typeof value === 'number') {\n        return value;\n      }\n\n      return parseInt(value, 10);\n    }();\n    return int_value;\n  },\n  to_long: function to_long(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      return value;\n    }\n\n    this.no_overflow64(value, field_name);\n\n    if (typeof value === 'number') {\n      value = '' + value;\n    }\n\n    return _bytebuffer.Long.fromString(value);\n  },\n  to_ulong: function to_ulong(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      return value;\n    }\n\n    this.no_overflow64(value, field_name, true);\n\n    if (typeof value === 'number') {\n      value = '' + value;\n    }\n\n    return _bytebuffer.Long.fromString(value, true);\n  },\n  to_string: function to_string(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (typeof value === 'string') {\n      return value;\n    }\n\n    if (typeof value === 'number') {\n      this.no_overflow53(value, field_name);\n      return '' + value;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      return value.toString();\n    }\n\n    throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value);\n  },\n  require_test: function require_test(regex, value) {\n    var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (!regex.test(value)) {\n      throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  require_match: function require_match(regex, value) {\n    var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var match = value.match(regex);\n\n    if (match === null) {\n      throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value);\n    }\n\n    return match;\n  },\n  require_object_id: function require_object_id(value, field_name) {\n    return this.require_match(/^([0-9]+)\\.([0-9]+)\\.([0-9]+)$/, value, field_name);\n  },\n\n\n  // Does not support over 53 bits\n  require_range: function require_range(min, max, value) {\n    var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var num = this.to_number(value);\n\n    if (num < min || num > max) {\n      throw new Error('out of range ' + value + ' ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  require_object_type: function require_object_type() {\n    var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;\n    var type = arguments[1];\n    var value = arguments[2];\n    var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var object_type = _ChainTypes2.default.object_type[type];\n\n    if (!object_type) {\n      throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value);\n    }\n\n    var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$');\n\n    if (!re.test(value)) {\n      throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value));\n    }\n\n    return value;\n  },\n  get_instance: function get_instance(reserve_spaces, type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(reserve_spaces, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n  require_relative_type: function require_relative_type(type, value, field_name) {\n    this.require_object_type(0, type, value, field_name);\n    return value;\n  },\n  get_relative_instance: function get_relative_instance(type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(0, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n  require_protocol_type: function require_protocol_type(type, value, field_name) {\n    this.require_object_type(1, type, value, field_name);\n    return value;\n  },\n  get_protocol_instance: function get_protocol_instance(type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(1, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n  get_protocol_type: function get_protocol_type(value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_id(value, field_name);\n    var values = value.split('.');\n    return this.to_number(values[1]);\n  },\n  get_protocol_type_name: function get_protocol_type_name(value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var type_id = this.get_protocol_type(value, field_name);\n    return Object.keys(_ChainTypes2.default.object_type)[type_id];\n  },\n  require_implementation_type: function require_implementation_type(type, value, field_name) {\n    this.require_object_type(2, type, value, field_name);\n    return value;\n  },\n  get_implementation_instance: function get_implementation_instance(type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(2, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n\n\n  // signed / unsigned decimal\n  no_overflow53: function no_overflow53(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (typeof value === 'number') {\n      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n        throw new Error('overflow ' + field_name + ' ' + value);\n      }\n\n      return;\n    }\n\n    if (typeof value === 'string') {\n      var int = parseInt(value, 10);\n\n      if (int > MAX_SAFE_INT || int < MIN_SAFE_INT) {\n        throw new Error('overflow ' + field_name + ' ' + int);\n      }\n\n      return;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      // typeof value.toInt() is 'number'\n      this.no_overflow53(value.toInt(), field_name);\n      return;\n    }\n\n    throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value);\n  },\n\n\n  // signed / unsigned whole numbers only\n  no_overflow64: function no_overflow64(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n    var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n    // https://github.com/dcodeIO/Long.js/issues/20\n    if (_bytebuffer.Long.isLong(value)) {\n      return;\n    }\n\n    // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20\n    if (value.t !== undefined && value.s !== undefined) {\n      this.no_overflow64(value.toString(), field_name, unsigned);\n\n      return;\n    }\n\n    if (typeof value === 'string') {\n      // remove leading zeros, will cause a false positive\n      value = value.replace(/^0+/, '');\n\n      // remove trailing zeros\n      while (/0$/.test(value)) {\n        value = value.substring(0, value.length - 1);\n      }\n\n      if (/\\.$/.test(value)) {\n        // remove trailing dot\n        value = value.substring(0, value.length - 1);\n      }\n\n      if (value === '') {\n        value = '0';\n      }\n\n      var long_string = _bytebuffer.Long.fromString(value, unsigned).toString();\n\n      if (long_string !== value.trim()) {\n        throw new Error('overflow ' + field_name + ' ' + value);\n      }\n\n      return;\n    }\n\n    if (typeof value === 'number') {\n      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n        throw new Error('overflow ' + field_name + ' ' + value);\n      }\n\n      return;\n    }\n\n    throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value);\n  }\n};\n\nexports.default = _my;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** Exception nesting.  */\nvar ErrorWithCause = function () {\n  function ErrorWithCause(message, cause) {\n    _classCallCheck(this, ErrorWithCause);\n\n    this.message = message;\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) {\n      this.message = 'cause\\t' + cause.message + '\\t' + this.message;\n    }\n\n    var stack = ''; // (new Error).stack\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) {\n      stack = 'caused by\\n\\t' + cause.stack + '\\t' + stack;\n    }\n\n    this.stack = this.message + '\\n' + stack;\n  }\n\n  ErrorWithCause.throw = function _throw(message, cause) {\n    var msg = message;\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) {\n      msg += '\\t cause: ' + cause.message + ' ';\n    }\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) {\n      msg += '\\n stack: ' + cause.stack + ' ';\n    }\n\n    throw new Error(msg);\n  };\n\n  return ErrorWithCause;\n}();\n\nexports.default = ErrorWithCause;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.stealth_memo_data = exports.global_betting_statistics = exports.betting_market_position = exports.bet = exports.betting_market = exports.betting_market_group = exports.betting_market_rules = exports.event = exports.event_group = exports.sport = exports.signed_transaction = exports.transaction = exports.bet_adjusted = exports.betting_market_update = exports.betting_market_group_update = exports.tournament_leave = exports.tournament_payout = exports.payout_type = exports.bet_canceled = exports.bet_cancel = exports.bet_matched = exports.betting_market_group_cancel_unmatched_bets = exports.betting_market_group_resolved = exports.betting_market_group_resolve = exports.betting_market_resolution_type = exports.bet_place = exports.bet_type = exports.betting_market_create = exports.betting_market_group_create = exports.betting_market_rules_update = exports.betting_market_rules_create = exports.event_update = exports.event_create = exports.event_group_update = exports.event_group_create = exports.sport_update = exports.sport_create = exports.asset_dividend_distribution = exports.asset_update_dividend = exports.dividend_asset_options = exports.game_move = exports.rock_paper_scissors_throw_reveal = exports.rock_paper_scissors_throw_commit = exports.rock_paper_scissors_gesture = exports.tournament_join = exports.tournament_create = exports.tournament_options = exports.rock_paper_scissors_game_options = exports.fba_distribute = exports.asset_claim_fees = exports.asset_settle_cancel = exports.transfer_from_blind = exports.blind_transfer = exports.blind_input = exports.transfer_to_blind = exports.blind_output = exports.stealth_confirmation = exports.override_transfer = exports.balance_claim = exports.assert = exports.block_id_predicate = exports.asset_symbol_eq_lit_predicate = exports.account_name_eq_lit_predicate = exports.custom = exports.worker_create = exports.burn_worker_initializer = exports.vesting_balance_worker_initializer = exports.refund_worker_initializer = exports.vesting_balance_withdraw = exports.vesting_balance_create = exports.cdd_vesting_policy_initializer = exports.linear_vesting_policy_initializer = exports.committee_member_update_global_parameters = exports.chain_parameters = exports.committee_member_update = exports.committee_member_create = exports.withdraw_permission_delete = exports.withdraw_permission_claim = exports.withdraw_permission_update = exports.withdraw_permission_create = exports.proposal_delete = exports.proposal_update = exports.proposal_create = exports.op_wrapper = exports.witness_update = exports.witness_create = exports.asset_publish_feed = exports.price_feed = exports.asset_global_settle = exports.asset_settle = exports.asset_fund_fee_pool = exports.asset_reserve = exports.asset_issue = undefined;\nexports.asset_update_feed_producers = exports.asset_update_bitasset = exports.asset_update = exports.asset_create = exports.bitasset_options = exports.asset_options = exports.price = exports.account_transfer = exports.account_upgrade = exports.account_whitelist = exports.account_update = exports.account_create = exports.account_options = exports.authority = exports.fill_order = exports.call_order_update = exports.limit_order_cancel = exports.limit_order_create = exports.transfer = exports.memo_data = exports.signed_block_header = exports.block_header = exports.signed_block = exports.processed_transaction = exports.asset = exports.void_result = exports.fee_schedule = exports.bet_adjusted_operation_fee_parameters = exports.betting_market_update_operation_fee_parameters = exports.betting_market_group_update_operation_fee_parameters = exports.tournament_leave_operation_fee_parameters = exports.tournament_payout_operation_fee_parameters = exports.game_move_operation_fee_parameters = exports.tournament_join_operation_fee_parameters = exports.tournament_create_operation_fee_parameters = exports.bet_canceled_operation_fee_parameters = exports.bet_cancel_operation_fee_parameters = exports.bet_matched_operation_fee_parameters = exports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = exports.betting_market_group_resolved_operation_fee_parameters = exports.betting_market_group_resolve_operation_fee_parameters = exports.bet_place_operation_fee_parameters = exports.betting_market_create_operation_fee_parameters = exports.betting_market_group_create_operation_fee_parameters = exports.betting_market_rules_update_operation_fee_parameters = exports.betting_market_rules_create_operation_fee_parameters = exports.event_update_operation_fee_parameters = exports.event_create_operation_fee_parameters = exports.event_group_update_operation_fee_parameters = exports.event_group_create_operation_fee_parameters = exports.sport_update_operation_fee_parameters = exports.sport_create_operation_fee_parameters = exports.asset_dividend_distribution_operation_fee_parameters = exports.asset_update_dividend_operation_fee_parameters = exports.fba_distribute_operation_fee_parameters = exports.asset_claim_fees_operation_fee_parameters = exports.asset_settle_cancel_operation_fee_parameters = exports.transfer_from_blind_operation_fee_parameters = exports.blind_transfer_operation_fee_parameters = exports.transfer_to_blind_operation_fee_parameters = exports.override_transfer_operation_fee_parameters = exports.balance_claim_operation_fee_parameters = exports.assert_operation_fee_parameters = exports.custom_operation_fee_parameters = exports.worker_create_operation_fee_parameters = exports.vesting_balance_withdraw_operation_fee_parameters = exports.vesting_balance_create_operation_fee_parameters = exports.committee_member_update_global_parameters_operation_fee_parameters = exports.committee_member_update_operation_fee_parameters = exports.committee_member_create_operation_fee_parameters = exports.withdraw_permission_delete_operation_fee_parameters = exports.withdraw_permission_claim_operation_fee_parameters = exports.withdraw_permission_update_operation_fee_parameters = exports.withdraw_permission_create_operation_fee_parameters = exports.proposal_delete_operation_fee_parameters = exports.proposal_update_operation_fee_parameters = exports.proposal_create_operation_fee_parameters = exports.witness_update_operation_fee_parameters = exports.witness_create_operation_fee_parameters = exports.asset_publish_feed_operation_fee_parameters = exports.asset_global_settle_operation_fee_parameters = exports.asset_settle_operation_fee_parameters = exports.asset_fund_fee_pool_operation_fee_parameters = exports.asset_reserve_operation_fee_parameters = exports.asset_issue_operation_fee_parameters = exports.asset_update_feed_producers_operation_fee_parameters = exports.asset_update_bitasset_operation_fee_parameters = exports.asset_update_operation_fee_parameters = exports.asset_create_operation_fee_parameters = exports.account_transfer_operation_fee_parameters = exports.account_upgrade_operation_fee_parameters = exports.account_whitelist_operation_fee_parameters = exports.account_update_operation_fee_parameters = exports.account_create_operation_fee_parameters = exports.fill_order_operation_fee_parameters = exports.call_order_update_operation_fee_parameters = exports.limit_order_cancel_operation_fee_parameters = exports.limit_order_create_operation_fee_parameters = exports.transfer_operation_fee_parameters = exports.operation = undefined;\n\nvar _types = require(26);\n\nvar _types2 = _interopRequireDefault(_types);\n\nvar _serializer = require(24);\n\nvar _serializer2 = _interopRequireDefault(_serializer);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar uint8 = _types2.default.uint8,\n    uint16 = _types2.default.uint16,\n    uint32 = _types2.default.uint32,\n    int64 = _types2.default.int64,\n    uint64 = _types2.default.uint64,\n    string = _types2.default.string,\n    bytes = _types2.default.bytes,\n    bool = _types2.default.bool,\n    array = _types2.default.array,\n    protocol_id_type = _types2.default.protocol_id_type,\n    object_id_type = _types2.default.object_id_type,\n    vote_id = _types2.default.vote_id,\n    implementation_id_type = _types2.default.implementation_id_type,\n    static_variant = _types2.default.static_variant,\n    map = _types2.default.map,\n    set = _types2.default.set,\n    public_key = _types2.default.public_key,\n    address = _types2.default.address,\n    time_point_sec = _types2.default.time_point_sec,\n    optional = _types2.default.optional,\n    variant_object = _types2.default.variant_object,\n    enumeration = _types2.default.enumeration,\n    sha256 = _types2.default.sha256;\n\n\nvar future_extensions = _types2.default.void;\n\n/*\nWhen updating generated code\nReplace:  operation = static_variant [\nwith:     operation.st_operations = [\n\nDelete:\npublic_key = new Serializer(\n    \"public_key\"\n    key_data: bytes 33\n);\n*/\n\nfunction Serializer(operation_name, serilization_types_object) {\n  return new _serializer2.default(operation_name, serilization_types_object);\n}\n// Place-holder, their are dependencies on \"operation\" .. The final list of\n// operations is not avialble until the very end of the generated code.\n// See: operation.st_operations = ...\n// module.exports[\"operation\"] = operation;\n\nvar operation = static_variant();\n\n// Custom-types follow Generated code:\n\n// ##  Generated code follows\n// # programs/js_operation_serializer > npm i -g decaffeinate\n// ## -------------------------------\nvar transfer_operation_fee_parameters = new Serializer('transfer_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar limit_order_create_operation_fee_parameters = new Serializer('limit_order_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar limit_order_cancel_operation_fee_parameters = new Serializer('limit_order_cancel_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar call_order_update_operation_fee_parameters = new Serializer('call_order_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar fill_order_operation_fee_parameters = new Serializer('fill_order_operation_fee_parameters');\n\nvar account_create_operation_fee_parameters = new Serializer('account_create_operation_fee_parameters', {\n  basic_fee: uint64,\n  premium_fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar account_update_operation_fee_parameters = new Serializer('account_update_operation_fee_parameters', {\n  fee: int64,\n  price_per_kbyte: uint32\n});\n\nvar account_whitelist_operation_fee_parameters = new Serializer('account_whitelist_operation_fee_parameters', {\n  fee: int64\n});\n\nvar account_upgrade_operation_fee_parameters = new Serializer('account_upgrade_operation_fee_parameters', {\n  membership_annual_fee: uint64,\n  membership_lifetime_fee: uint64\n});\n\nvar account_transfer_operation_fee_parameters = new Serializer('account_transfer_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_create_operation_fee_parameters = new Serializer('asset_create_operation_fee_parameters', {\n  symbol3: uint64,\n  symbol4: uint64,\n  long_symbol: uint64,\n  price_per_kbyte: uint32\n});\n\nvar asset_update_operation_fee_parameters = new Serializer('asset_update_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar asset_update_bitasset_operation_fee_parameters = new Serializer('asset_update_bitasset_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_update_feed_producers_operation_fee_parameters = new Serializer('asset_update_feed_producers_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_issue_operation_fee_parameters = new Serializer('asset_issue_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar asset_reserve_operation_fee_parameters = new Serializer('asset_reserve_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_fund_fee_pool_operation_fee_parameters = new Serializer('asset_fund_fee_pool_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_settle_operation_fee_parameters = new Serializer('asset_settle_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_global_settle_operation_fee_parameters = new Serializer('asset_global_settle_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_publish_feed_operation_fee_parameters = new Serializer('asset_publish_feed_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar witness_create_operation_fee_parameters = new Serializer('witness_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar witness_update_operation_fee_parameters = new Serializer('witness_update_operation_fee_parameters', {\n  fee: int64\n});\n\nvar proposal_create_operation_fee_parameters = new Serializer('proposal_create_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar proposal_update_operation_fee_parameters = new Serializer('proposal_update_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar proposal_delete_operation_fee_parameters = new Serializer('proposal_delete_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar withdraw_permission_create_operation_fee_parameters = new Serializer('withdraw_permission_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar withdraw_permission_update_operation_fee_parameters = new Serializer('withdraw_permission_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar withdraw_permission_claim_operation_fee_parameters = new Serializer('withdraw_permission_claim_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar withdraw_permission_delete_operation_fee_parameters = new Serializer('withdraw_permission_delete_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar committee_member_create_operation_fee_parameters = new Serializer('committee_member_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar committee_member_update_operation_fee_parameters = new Serializer('committee_member_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar committee_member_update_global_parameters_operation_fee_parameters = new Serializer('committee_member_update_global_parameters_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar vesting_balance_create_operation_fee_parameters = new Serializer('vesting_balance_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar vesting_balance_withdraw_operation_fee_parameters = new Serializer('vesting_balance_withdraw_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar worker_create_operation_fee_parameters = new Serializer('worker_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar custom_operation_fee_parameters = new Serializer('custom_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar assert_operation_fee_parameters = new Serializer('assert_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar balance_claim_operation_fee_parameters = new Serializer('balance_claim_operation_fee_parameters');\n\nvar override_transfer_operation_fee_parameters = new Serializer('override_transfer_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar transfer_to_blind_operation_fee_parameters = new Serializer('transfer_to_blind_operation_fee_parameters', {\n  fee: uint64,\n  price_per_output: uint32\n});\n\nvar blind_transfer_operation_fee_parameters = new Serializer('blind_transfer_operation_fee_parameters', {\n  fee: uint64,\n  price_per_output: uint32\n});\n\nvar transfer_from_blind_operation_fee_parameters = new Serializer('transfer_from_blind_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_settle_cancel_operation_fee_parameters = new Serializer('asset_settle_cancel_operation_fee_parameters');\n\nvar asset_claim_fees_operation_fee_parameters = new Serializer('asset_claim_fees_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar fba_distribute_operation_fee_parameters = new Serializer('fba_distribute_operation_fee_parameters', {});\n\nvar asset_update_dividend_operation_fee_parameters = new Serializer('asset_update_dividend_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_dividend_distribution_operation_fee_parameters = new Serializer('asset_dividend_distribution_operation_fee_parameters', {\n  distribution_base_fee: uint64,\n  distribution_fee_per_holder: uint32\n});\n\nvar sport_create_operation_fee_parameters = new Serializer('sport_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar sport_update_operation_fee_parameters = new Serializer('sport_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_group_create_operation_fee_parameters = new Serializer('event_group_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_group_update_operation_fee_parameters = new Serializer('event_group_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_create_operation_fee_parameters = new Serializer('event_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_update_operation_fee_parameters = new Serializer('event_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_rules_create_operation_fee_parameters = new Serializer('betting_market_rules_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_rules_update_operation_fee_parameters = new Serializer('betting_market_rules_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_group_create_operation_fee_parameters = new Serializer('betting_market_group_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_create_operation_fee_parameters = new Serializer('betting_market_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_place_operation_fee_parameters = new Serializer('bet_place_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_group_resolve_operation_fee_parameters = new Serializer('betting_market_group_resolve_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_group_resolved_operation_fee_parameters = new Serializer('betting_market_group_resolved_operation_fee_parameters');\n\nvar betting_market_group_cancel_unmatched_bets_operation_fee_parameters = new Serializer('betting_market_group_cancel_unmatched_bets_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_matched_operation_fee_parameters = new Serializer('bet_matched_operation_fee_parameters');\n\nvar bet_cancel_operation_fee_parameters = new Serializer('bet_cancel_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_canceled_operation_fee_parameters = new Serializer('bet_canceled_operation_fee_parameters');\n\nvar tournament_create_operation_fee_parameters = new Serializer('tournament_create_operation_fee_parameters', {\n  fee: int64\n});\n\nvar tournament_join_operation_fee_parameters = new Serializer('tournament_join_operation_fee_parameters', {\n  fee: int64\n});\n\nvar game_move_operation_fee_parameters = new Serializer('game_move_operation_fee_parameters', {\n  fee: int64\n});\n\nvar tournament_payout_operation_fee_parameters = new Serializer('tournament_payout_operation_fee_parameters');\n\nvar tournament_leave_operation_fee_parameters = new Serializer('tournament_leave_operation_fee_parameters', {\n  fee: int64\n});\n\nvar betting_market_group_update_operation_fee_parameters = new Serializer('betting_market_group_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_update_operation_fee_parameters = new Serializer('betting_market_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_adjusted_operation_fee_parameters = new Serializer('bet_adjusted_operation_fee_parameters');\n\nvar fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters, game_move_operation_fee_parameters, asset_update_dividend_operation_fee_parameters, asset_dividend_distribution_operation_fee_parameters, tournament_payout_operation_fee_parameters, tournament_leave_operation_fee_parameters, sport_create_operation_fee_parameters, sport_update_operation_fee_parameters, event_group_create_operation_fee_parameters, event_group_update_operation_fee_parameters, event_create_operation_fee_parameters, event_update_operation_fee_parameters, betting_market_rules_create_operation_fee_parameters, betting_market_rules_update_operation_fee_parameters, betting_market_group_create_operation_fee_parameters, betting_market_create_operation_fee_parameters, bet_place_operation_fee_parameters, betting_market_group_resolve_operation_fee_parameters, betting_market_group_resolved_operation_fee_parameters, bet_adjusted_operation_fee_parameters, betting_market_group_cancel_unmatched_bets_operation_fee_parameters, bet_matched_operation_fee_parameters, bet_cancel_operation_fee_parameters, bet_canceled_operation_fee_parameters, betting_market_group_update_operation_fee_parameters, betting_market_update_operation_fee_parameters\n// Missing event_update_status\n]);\n\nvar fee_schedule = new Serializer('fee_schedule', {\n  parameters: set(fee_parameters),\n  scale: uint32\n});\n\nvar void_result = new Serializer('void_result');\n\nvar asset = new Serializer('asset', {\n  amount: int64,\n  asset_id: protocol_id_type('asset')\n});\n\nvar operation_result = static_variant([void_result, object_id_type, asset]);\n\nvar processed_transaction = new Serializer('processed_transaction', {\n  ref_block_num: uint16,\n  ref_block_prefix: uint32,\n  expiration: time_point_sec,\n  operations: array(operation),\n  extensions: set(future_extensions),\n  signatures: array(bytes(65)),\n  operation_results: array(operation_result)\n});\n\nvar signed_block = new Serializer('signed_block', {\n  previous: bytes(20),\n  timestamp: time_point_sec,\n  witness: protocol_id_type('witness'),\n  next_secret_hash: bytes(20),\n  previous_secret: bytes(20),\n  transaction_merkle_root: bytes(20),\n  extensions: set(future_extensions),\n  witness_signature: bytes(65),\n  transactions: array(processed_transaction)\n});\n\nvar block_header = new Serializer('block_header', {\n  previous: bytes(20),\n  timestamp: time_point_sec,\n  witness: protocol_id_type('witness'),\n  next_secret_hash: bytes(20),\n  previous_secret: bytes(20),\n  transaction_merkle_root: bytes(20),\n  extensions: set(future_extensions)\n});\n\nvar signed_block_header = new Serializer('signed_block_header', {\n  previous: bytes(20),\n  timestamp: time_point_sec,\n  witness: protocol_id_type('witness'),\n  next_secret_hash: bytes(20),\n  previous_secret: bytes(20),\n  transaction_merkle_root: bytes(20),\n  extensions: set(future_extensions),\n  witness_signature: bytes(65)\n});\n\nvar memo_data = new Serializer('memo_data', {\n  from: public_key,\n  to: public_key,\n  nonce: uint64,\n  message: bytes()\n});\n\nvar transfer = new Serializer('transfer', {\n  fee: asset,\n  from: protocol_id_type('account'),\n  to: protocol_id_type('account'),\n  amount: asset,\n  memo: optional(memo_data),\n  extensions: set(future_extensions)\n});\n\nvar limit_order_create = new Serializer('limit_order_create', {\n  fee: asset,\n  seller: protocol_id_type('account'),\n  amount_to_sell: asset,\n  min_to_receive: asset,\n  expiration: time_point_sec,\n  fill_or_kill: bool,\n  extensions: set(future_extensions)\n});\n\nvar limit_order_cancel = new Serializer('limit_order_cancel', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  order: protocol_id_type('limit_order'),\n  extensions: set(future_extensions)\n});\n\nvar call_order_update = new Serializer('call_order_update', {\n  fee: asset,\n  funding_account: protocol_id_type('account'),\n  delta_collateral: asset,\n  delta_debt: asset,\n  extensions: set(future_extensions)\n});\n\nvar fill_order = new Serializer('fill_order', {\n  fee: asset,\n  order_id: object_id_type,\n  account_id: protocol_id_type('account'),\n  pays: asset,\n  receives: asset\n});\n\nvar authority = new Serializer('authority', {\n  weight_threshold: uint32,\n  account_auths: map(protocol_id_type('account'), uint16),\n  key_auths: map(public_key, uint16),\n  address_auths: map(address, uint16)\n});\n\nvar account_options = new Serializer('account_options', {\n  memo_key: public_key,\n  voting_account: protocol_id_type('account'),\n  num_witness: uint16,\n  num_committee: uint16,\n  votes: set(vote_id),\n  extensions: set(future_extensions)\n});\n\nvar account_create = new Serializer('account_create', {\n  fee: asset,\n  registrar: protocol_id_type('account'),\n  referrer: protocol_id_type('account'),\n  referrer_percent: uint16,\n  name: string,\n  owner: authority,\n  active: authority,\n  options: account_options,\n  extensions: set(future_extensions)\n});\n\nvar account_update = new Serializer('account_update', {\n  fee: asset,\n  account: protocol_id_type('account'),\n  owner: optional(authority),\n  active: optional(authority),\n  new_options: optional(account_options),\n  extensions: set(future_extensions)\n});\n\nvar account_whitelist = new Serializer('account_whitelist', {\n  fee: asset,\n  authorizing_account: protocol_id_type('account'),\n  account_to_list: protocol_id_type('account'),\n  new_listing: uint8,\n  extensions: set(future_extensions)\n});\n\nvar account_upgrade = new Serializer('account_upgrade', {\n  fee: asset,\n  account_to_upgrade: protocol_id_type('account'),\n  upgrade_to_lifetime_member: bool,\n  extensions: set(future_extensions)\n});\n\nvar account_transfer = new Serializer('account_transfer', {\n  fee: asset,\n  account_id: protocol_id_type('account'),\n  new_owner: protocol_id_type('account'),\n  extensions: set(future_extensions)\n});\n\nvar price = new Serializer('price', {\n  base: asset,\n  quote: asset\n});\n\nvar asset_options = new Serializer('asset_options', {\n  max_supply: int64,\n  market_fee_percent: uint16,\n  max_market_fee: int64,\n  issuer_permissions: uint16,\n  flags: uint16,\n  core_exchange_rate: price,\n  whitelist_authorities: set(protocol_id_type('account')),\n  blacklist_authorities: set(protocol_id_type('account')),\n  whitelist_markets: set(protocol_id_type('asset')),\n  blacklist_markets: set(protocol_id_type('asset')),\n  description: string,\n  extensions: set(future_extensions)\n});\n\nvar bitasset_options = new Serializer('bitasset_options', {\n  feed_lifetime_sec: uint32,\n  minimum_feeds: uint8,\n  force_settlement_delay_sec: uint32,\n  force_settlement_offset_percent: uint16,\n  maximum_force_settlement_volume: uint16,\n  short_backing_asset: protocol_id_type('asset'),\n  extensions: set(future_extensions)\n});\n\nvar asset_create = new Serializer('asset_create', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  symbol: string,\n  precision: uint8,\n  common_options: asset_options,\n  bitasset_opts: optional(bitasset_options),\n  is_prediction_market: bool,\n  extensions: set(future_extensions)\n});\n\nvar asset_update = new Serializer('asset_update', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_issuer: optional(protocol_id_type('account')),\n  new_options: asset_options,\n  extensions: set(future_extensions)\n});\n\nvar asset_update_bitasset = new Serializer('asset_update_bitasset', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_options: bitasset_options,\n  extensions: set(future_extensions)\n});\n\nvar asset_update_feed_producers = new Serializer('asset_update_feed_producers', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_feed_producers: set(protocol_id_type('account')),\n  extensions: set(future_extensions)\n});\n\nvar asset_issue = new Serializer('asset_issue', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_issue: asset,\n  issue_to_account: protocol_id_type('account'),\n  memo: optional(memo_data),\n  extensions: set(future_extensions)\n});\n\nvar asset_reserve = new Serializer('asset_reserve', {\n  fee: asset,\n  payer: protocol_id_type('account'),\n  amount_to_reserve: asset,\n  extensions: set(future_extensions)\n});\n\nvar asset_fund_fee_pool = new Serializer('asset_fund_fee_pool', {\n  fee: asset,\n  from_account: protocol_id_type('account'),\n  asset_id: protocol_id_type('asset'),\n  amount: int64,\n  extensions: set(future_extensions)\n});\n\nvar asset_settle = new Serializer('asset_settle', {\n  fee: asset,\n  account: protocol_id_type('account'),\n  amount: asset,\n  extensions: set(future_extensions)\n});\n\nvar asset_global_settle = new Serializer('asset_global_settle', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_settle: protocol_id_type('asset'),\n  settle_price: price,\n  extensions: set(future_extensions)\n});\n\nvar price_feed = new Serializer('price_feed', {\n  settlement_price: price,\n  maintenance_collateral_ratio: uint16,\n  maximum_short_squeeze_ratio: uint16,\n  core_exchange_rate: price\n});\n\nvar asset_publish_feed = new Serializer('asset_publish_feed', {\n  fee: asset,\n  publisher: protocol_id_type('account'),\n  asset_id: protocol_id_type('asset'),\n  feed: price_feed,\n  extensions: set(future_extensions)\n});\n\nvar witness_create = new Serializer('witness_create', {\n  fee: asset,\n  witness_account: protocol_id_type('account'),\n  url: string,\n  block_signing_key: public_key,\n  initial_secret: bytes(20)\n});\n\nvar witness_update = new Serializer('witness_update', {\n  fee: asset,\n  witness: protocol_id_type('witness'),\n  witness_account: protocol_id_type('account'),\n  new_url: optional(string),\n  new_signing_key: optional(public_key),\n  new_initial_secret: optional(bytes(20))\n});\n\nvar op_wrapper = new Serializer('op_wrapper', {\n  op: operation\n});\n\nvar proposal_create = new Serializer('proposal_create', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  expiration_time: time_point_sec,\n  proposed_ops: array(op_wrapper),\n  review_period_seconds: optional(uint32),\n  extensions: set(future_extensions)\n});\n\nvar proposal_update = new Serializer('proposal_update', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  proposal: protocol_id_type('proposal'),\n  active_approvals_to_add: set(protocol_id_type('account')),\n  active_approvals_to_remove: set(protocol_id_type('account')),\n  owner_approvals_to_add: set(protocol_id_type('account')),\n  owner_approvals_to_remove: set(protocol_id_type('account')),\n  key_approvals_to_add: set(public_key),\n  key_approvals_to_remove: set(public_key),\n  extensions: set(future_extensions)\n});\n\nvar proposal_delete = new Serializer('proposal_delete', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  using_owner_authority: bool,\n  proposal: protocol_id_type('proposal'),\n  extensions: set(future_extensions)\n});\n\nvar withdraw_permission_create = new Serializer('withdraw_permission_create', {\n  fee: asset,\n  withdraw_from_account: protocol_id_type('account'),\n  authorized_account: protocol_id_type('account'),\n  withdrawal_limit: asset,\n  withdrawal_period_sec: uint32,\n  periods_until_expiration: uint32,\n  period_start_time: time_point_sec\n});\n\nvar withdraw_permission_update = new Serializer('withdraw_permission_update', {\n  fee: asset,\n  withdraw_from_account: protocol_id_type('account'),\n  authorized_account: protocol_id_type('account'),\n  permission_to_update: protocol_id_type('withdraw_permission'),\n  withdrawal_limit: asset,\n  withdrawal_period_sec: uint32,\n  period_start_time: time_point_sec,\n  periods_until_expiration: uint32\n});\n\nvar withdraw_permission_claim = new Serializer('withdraw_permission_claim', {\n  fee: asset,\n  withdraw_permission: protocol_id_type('withdraw_permission'),\n  withdraw_from_account: protocol_id_type('account'),\n  withdraw_to_account: protocol_id_type('account'),\n  amount_to_withdraw: asset,\n  memo: optional(memo_data)\n});\n\nvar withdraw_permission_delete = new Serializer('withdraw_permission_delete', {\n  fee: asset,\n  withdraw_from_account: protocol_id_type('account'),\n  authorized_account: protocol_id_type('account'),\n  withdrawal_permission: protocol_id_type('withdraw_permission')\n});\n\nvar committee_member_create = new Serializer('committee_member_create', {\n  fee: asset,\n  committee_member_account: protocol_id_type('account'),\n  url: string\n});\n\nvar committee_member_update = new Serializer('committee_member_update', {\n  fee: asset,\n  committee_member: protocol_id_type('committee_member'),\n  committee_member_account: protocol_id_type('account'),\n  new_url: optional(string)\n});\n\nvar chain_parameters = new Serializer('chain_parameters', {\n  current_fees: fee_schedule,\n  block_interval: uint8,\n  maintenance_interval: uint32,\n  maintenance_skip_slots: uint8,\n  committee_proposal_review_period: uint32,\n  maximum_transaction_size: uint32,\n  maximum_block_size: uint32,\n  maximum_time_until_expiration: uint32,\n  maximum_proposal_lifetime: uint32,\n  maximum_asset_whitelist_authorities: uint8,\n  maximum_asset_feed_publishers: uint8,\n  maximum_witness_count: uint16,\n  maximum_committee_count: uint16,\n  maximum_authority_membership: uint16,\n  reserve_percent_of_fee: uint16,\n  network_percent_of_fee: uint16,\n  lifetime_referrer_percent_of_fee: uint16,\n  cashback_vesting_period_seconds: uint32,\n  cashback_vesting_threshold: int64,\n  count_non_member_votes: bool,\n  allow_non_member_whitelists: bool,\n  witness_pay_per_block: int64,\n  worker_budget_per_day: int64,\n  max_predicate_opcode: uint16,\n  fee_liquidation_threshold: int64,\n  accounts_per_fee_scale: uint16,\n  account_fee_scale_bitshifts: uint8,\n  max_authority_depth: uint8,\n  min_bet_multiplier: uint32,\n  max_bet_multiplier: uint32,\n  betting_rake_fee_percentage: uint16,\n  permitted_betting_odds_increments: map(uint32, uint32),\n  witness_schedule_algorithm: uint8,\n  live_betting_delay_time: uint16,\n  min_round_delay: uint32,\n  max_round_delay: uint32,\n  min_time_per_commit_move: uint32,\n  max_time_per_commit_move: uint32,\n  min_time_per_reveal_move: uint32,\n  max_time_per_reveal_move: uint32,\n  rake_fee_percentage: uint16,\n  maximum_registration_deadline: uint32,\n  maximum_players_in_tournament: uint16,\n  maximum_tournament_whitelist_length: uint16,\n  maximum_tournament_start_time_in_future: uint32,\n  maximum_tournament_start_delay: uint32,\n  maximum_tournament_number_of_wins: uint16,\n  extensions: set(future_extensions)\n});\n\nvar committee_member_update_global_parameters = new Serializer('committee_member_update_global_parameters', {\n  fee: asset,\n  new_parameters: chain_parameters\n});\n\nvar linear_vesting_policy_initializer = new Serializer('linear_vesting_policy_initializer', {\n  begin_timestamp: time_point_sec,\n  vesting_cliff_seconds: uint32,\n  vesting_duration_seconds: uint32\n});\n\nvar cdd_vesting_policy_initializer = new Serializer('cdd_vesting_policy_initializer', {\n  start_claim: time_point_sec,\n  vesting_seconds: uint32\n});\n\nvar vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]);\n\nvar vesting_balance_create = new Serializer('vesting_balance_create', {\n  fee: asset,\n  creator: protocol_id_type('account'),\n  owner: protocol_id_type('account'),\n  amount: asset,\n  policy: vesting_policy_initializer\n});\n\nvar vesting_balance_withdraw = new Serializer('vesting_balance_withdraw', {\n  fee: asset,\n  vesting_balance: protocol_id_type('vesting_balance'),\n  owner: protocol_id_type('account'),\n  amount: asset\n});\n\nvar refund_worker_initializer = new Serializer('refund_worker_initializer');\n\nvar vesting_balance_worker_initializer = new Serializer('vesting_balance_worker_initializer', {\n  pay_vesting_period_days: uint16\n});\n\nvar burn_worker_initializer = new Serializer('burn_worker_initializer');\n\nvar worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]);\n\nvar worker_create = new Serializer('worker_create', {\n  fee: asset,\n  owner: protocol_id_type('account'),\n  work_begin_date: time_point_sec,\n  work_end_date: time_point_sec,\n  daily_pay: int64,\n  name: string,\n  url: string,\n  initializer: worker_initializer\n});\n\nvar custom = new Serializer('custom', {\n  fee: asset,\n  payer: protocol_id_type('account'),\n  required_auths: set(protocol_id_type('account')),\n  id: uint16,\n  data: bytes()\n});\n\nvar account_name_eq_lit_predicate = new Serializer('account_name_eq_lit_predicate', {\n  account_id: protocol_id_type('account'),\n  name: string\n});\n\nvar asset_symbol_eq_lit_predicate = new Serializer('asset_symbol_eq_lit_predicate', {\n  asset_id: protocol_id_type('asset'),\n  symbol: string\n});\n\nvar block_id_predicate = new Serializer('block_id_predicate', {\n  id: bytes(20)\n});\n\nvar predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]);\n\nvar assert = new Serializer('assert', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  predicates: array(predicate),\n  required_auths: set(protocol_id_type('account')),\n  extensions: set(future_extensions)\n});\n\nvar balance_claim = new Serializer('balance_claim', {\n  fee: asset,\n  deposit_to_account: protocol_id_type('account'),\n  balance_to_claim: protocol_id_type('balance'),\n  balance_owner_key: public_key,\n  total_claimed: asset\n});\n\nvar override_transfer = new Serializer('override_transfer', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  from: protocol_id_type('account'),\n  to: protocol_id_type('account'),\n  amount: asset,\n  memo: optional(memo_data),\n  extensions: set(future_extensions)\n});\n\nvar stealth_confirmation = new Serializer('stealth_confirmation', {\n  one_time_key: public_key,\n  to: optional(public_key),\n  encrypted_memo: bytes()\n});\n\nvar blind_output = new Serializer('blind_output', {\n  commitment: bytes(33),\n  range_proof: bytes(),\n  owner: authority,\n  stealth_memo: optional(stealth_confirmation)\n});\n\nvar transfer_to_blind = new Serializer('transfer_to_blind', {\n  fee: asset,\n  amount: asset,\n  from: protocol_id_type('account'),\n  blinding_factor: bytes(32),\n  outputs: array(blind_output)\n});\n\nvar blind_input = new Serializer('blind_input', {\n  commitment: bytes(33),\n  owner: authority\n});\n\nvar blind_transfer = new Serializer('blind_transfer', {\n  fee: asset,\n  inputs: array(blind_input),\n  outputs: array(blind_output)\n});\n\nvar transfer_from_blind = new Serializer('transfer_from_blind', {\n  fee: asset,\n  amount: asset,\n  to: protocol_id_type('account'),\n  blinding_factor: bytes(32),\n  inputs: array(blind_input)\n});\n\nvar asset_settle_cancel = new Serializer('asset_settle_cancel', {\n  fee: asset,\n  settlement: protocol_id_type('force_settlement'),\n  account: protocol_id_type('account'),\n  amount: asset,\n  extensions: set(future_extensions)\n});\n\nvar asset_claim_fees = new Serializer('asset_claim_fees', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  amount_to_claim: asset,\n  extensions: set(future_extensions)\n});\n\nvar fba_distribute = new Serializer('fba_distribute', {\n  fee: asset,\n  account_id: protocol_id_type('account'),\n  fba_id: protocol_id_type('fba_accumulator'),\n  amount: int64\n});\n\nvar rock_paper_scissors_game_options = new Serializer('rock_paper_scissors_game_options', {\n  insurance_enabled: bool,\n  time_per_commit_move: uint32,\n  time_per_reveal_move: uint32,\n  number_of_gestures: uint8\n});\n\nvar game_specific_details = static_variant([rock_paper_scissors_game_options]);\n\nvar tournament_options = new Serializer('tournament_options', {\n  type_of_game: uint16,\n  registration_deadline: time_point_sec,\n  number_of_players: uint32,\n  buy_in: asset,\n  whitelist: set(protocol_id_type('account')),\n  start_time: optional(time_point_sec),\n  start_delay: optional(uint32),\n  round_delay: uint32,\n  number_of_wins: uint32,\n  meta: variant_object,\n  game_options: game_specific_details\n});\n\nvar tournament_create = new Serializer('tournament_create', {\n  fee: asset,\n  creator: protocol_id_type('account'),\n  options: tournament_options,\n  extensions: set(future_extensions)\n});\n\nvar tournament_join = new Serializer('tournament_join', {\n  fee: asset,\n  payer_account_id: protocol_id_type('account'),\n  player_account_id: protocol_id_type('account'),\n  tournament_id: protocol_id_type('tournament'),\n  buy_in: asset,\n  extensions: set(future_extensions)\n});\n\nvar rock_paper_scissors_gesture = enumeration(['rock', 'paper', 'scissors', 'spock', 'lizard']);\n\nvar rock_paper_scissors_throw_commit = new Serializer('rock_paper_scissors_throw_commit', {\n  nonce1: uint64,\n  throw_hash: sha256\n});\n\nvar rock_paper_scissors_throw_reveal = new Serializer('rock_paper_scissors_throw_reveal', {\n  nonce2: uint64,\n  gesture: rock_paper_scissors_gesture\n});\n\nvar game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]);\n\nvar game_move = new Serializer('game_move', {\n  fee: asset,\n  game_id: protocol_id_type('game'),\n  player_account_id: protocol_id_type('account'),\n  move: game_specific_moves,\n  extensions: set(future_extensions)\n});\n\nvar dividend_asset_options = new Serializer('dividend_asset_options', {\n  next_payout_time: optional(time_point_sec),\n  payout_interval: optional(uint32),\n  minimum_fee_percentage: uint64,\n  minimum_distribution_interval: optional(uint32),\n  extensions: set(future_extensions)\n});\n\nvar asset_update_dividend = new Serializer('asset_update_dividend', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_options: dividend_asset_options,\n  extensions: set(future_extensions)\n});\n\nvar asset_dividend_distribution = new Serializer('asset_dividend_distribution', {\n  fee: asset,\n  dividend_asset_id: protocol_id_type('asset'),\n  account_id: protocol_id_type('account'),\n  amounts: set(asset),\n  extensions: set(future_extensions)\n});\n\nvar sport_create = new Serializer('sport_create', {\n  fee: asset,\n  name: map(string, string),\n  extensions: set(future_extensions)\n});\n\nvar sport_update = new Serializer('sport_update', {\n  fee: asset,\n  sport_id: protocol_id_type('sport'),\n  new_name: optional(map(string, string)),\n  extensions: set(future_extensions)\n});\n\nvar event_group_create = new Serializer('event_group_create', {\n  fee: asset,\n  name: map(string, string),\n  sport_id: object_id_type,\n  extensions: set(future_extensions)\n});\n\nvar event_group_update = new Serializer('event_group_update', {\n  fee: asset,\n  new_sport_id: optional(protocol_id_type('sport')),\n  new_name: optional(map(string, string)),\n  event_group_id: protocol_id_type('event_group'),\n  extensions: set(future_extensions)\n});\n\nvar event_create = new Serializer('event_create', {\n  fee: asset,\n  name: map(string, string),\n  season: map(string, string),\n  start_time: optional(time_point_sec),\n  event_group_id: object_id_type,\n  extensions: set(future_extensions)\n});\n\nvar event_update = new Serializer('event_update', {\n  fee: asset,\n  event_id: protocol_id_type('event'),\n  new_event_group_id: optional(protocol_id_type('event_group')),\n  new_name: optional(map(string, string)),\n  new_season: optional(map(string, string)),\n  new_start_time: optional(time_point_sec),\n  is_live_market: optional(bool),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_rules_create = new Serializer('betting_market_rules_create', {\n  fee: asset,\n  name: map(string, string),\n  description: map(string, string),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_rules_update = new Serializer('betting_market_rules_update', {\n  fee: asset,\n  new_name: optional(map(string, string)),\n  new_description: optional(map(string, string)),\n  extensions: set(future_extensions),\n  betting_market_rules_id: protocol_id_type('betting_market_rules')\n});\n\nvar betting_market_group_create = new Serializer('betting_market_group_create', {\n  fee: asset,\n  description: map(string, string),\n  event_id: object_id_type,\n  rules_id: object_id_type,\n  asset_id: protocol_id_type('asset'),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_create = new Serializer('betting_market_create', {\n  fee: asset,\n  group_id: object_id_type,\n  description: map(string, string),\n  payout_condition: map(string, string),\n  extensions: set(future_extensions)\n});\n\nvar bet_type = enumeration(['back', 'lay']);\n\nvar bet_place = new Serializer('bet_place', {\n  fee: asset,\n  bettor_id: protocol_id_type('account'),\n  betting_market_id: protocol_id_type('betting_market'),\n  amount_to_bet: asset,\n  backer_multiplier: uint32,\n  back_or_lay: bet_type,\n  extensions: set(future_extensions)\n});\n\nvar betting_market_resolution_type = enumeration(['win', 'not_win', 'cancel', 'BETTING_MARKET_RESOLUTION_COUNT']);\n\nvar betting_market_group_resolve = new Serializer('betting_market_group_resolve', {\n  fee: asset,\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_group_resolved = new Serializer('betting_market_group_resolved', {\n  bettor_id: protocol_id_type('account'),\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type),\n  winnings: int64,\n  fees_paid: int64,\n  fee: asset\n});\n\nvar betting_market_group_cancel_unmatched_bets = new Serializer('betting_market_group_cancel_unmatched_bets', {\n  fee: asset,\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  extensions: set(future_extensions)\n});\n\nvar bet_matched = new Serializer('bet_matched', {\n  bettor_id: protocol_id_type('account'),\n  bet_id: protocol_id_type('bet'),\n  betting_market_id: protocol_id_type('betting_market'),\n  amount_bet: asset,\n  fees_paid: int64,\n  backer_multiplier: uint32,\n  guaranteed_winnings_returned: int64\n});\n\nvar bet_cancel = new Serializer('bet_cancel', {\n  fee: asset,\n  bettor_id: protocol_id_type('account'),\n  bet_to_cancel: protocol_id_type('bet'),\n  extensions: set(future_extensions)\n});\n\nvar bet_canceled = new Serializer('bet_canceled', {\n  bettor_id: protocol_id_type('account'),\n  bet_id: protocol_id_type('bet'),\n  stake_returned: asset,\n  unused_fees_returned: asset\n});\n\nvar payout_type = enumeration(['prize_award', 'buyin_refund', 'rake_fee']);\n\nvar tournament_payout = new Serializer('tournament_payout', {\n  fee: asset,\n  payout_account_id: protocol_id_type('account'),\n  tournament_id: protocol_id_type('tournament'),\n  payout_amount: asset,\n  type: payout_type,\n  extensions: set(future_extensions)\n});\n\nvar tournament_leave = new Serializer('tournament_leave', {\n  fee: asset,\n  canceling_account_id: protocol_id_type('account'),\n  player_account_id: protocol_id_type('account'),\n  tournament_id: protocol_id_type('tournament'),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_group_update = new Serializer('betting_market_group_update', {\n  fee: asset,\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  new_description: optional(map(string, string)),\n  new_rules_id: optional(protocol_id_type('betting_market_rules')),\n  freeze: optional(bool),\n  delay_bets: optional(bool),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_update = new Serializer('betting_market_update', {\n  fee: asset,\n  betting_market_id: protocol_id_type('betting_market'),\n  new_group_id: optional(protocol_id_type('betting_market_group')),\n  new_description: optional(map(string, string)),\n  new_payout_condition: optional(map(string, string)),\n  extensions: set(future_extensions)\n});\n\nvar bet_adjusted = new Serializer('bet_adjusted', {\n  bettor_id: protocol_id_type('account'),\n  bet_id: protocol_id_type('bet'),\n  stake_returned: asset\n});\n\noperation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend, asset_dividend_distribution, tournament_payout, tournament_leave, sport_create, sport_update, event_group_create, event_group_update, event_create, event_update, betting_market_rules_create, betting_market_rules_update, betting_market_group_create, betting_market_create, bet_place, betting_market_group_resolve, betting_market_group_resolved, bet_adjusted, betting_market_group_cancel_unmatched_bets, bet_matched, bet_cancel, bet_canceled, betting_market_group_update, betting_market_update];\n\nvar transaction = new Serializer('transaction', {\n  ref_block_num: uint16,\n  ref_block_prefix: uint32,\n  expiration: time_point_sec,\n  operations: array(operation),\n  extensions: set(future_extensions)\n});\n\nvar signed_transaction = new Serializer('signed_transaction', {\n  ref_block_num: uint16,\n  ref_block_prefix: uint32,\n  expiration: time_point_sec,\n  operations: array(operation),\n  extensions: set(future_extensions),\n  signatures: array(bytes(65))\n});\n// # -------------------------------\n// #  Generated code end\n// # -------------------------------\n\n// Betting Objects\n\nvar sport = new Serializer('sport', {\n  id: protocol_id_type('sport'),\n  name: map(string, string)\n});\n\nvar event_group = new Serializer('event_group', {\n  id: protocol_id_type('event_group'),\n  name: map(string, string),\n  sport_id: protocol_id_type('sport')\n});\n\nvar event_status = enumeration(['upcoming', 'in_progress', 'frozen', 'finished', 'completed', 'canceled', 'STATUS_COUNT']);\n\nvar betting_market_status = enumeration(['unresolved', 'frozen', 'graded', 'canceled', 'settled']);\n\nvar betting_market_group_status = enumeration(['upcoming', 'in_play', 'closed', 'graded', 're-grading', 'settled', 'frozen', 'canceled']);\n\nvar event = new Serializer('event', {\n  id: protocol_id_type('event'),\n  name: map(string, string),\n  season: map(string, string),\n  start_time: optional(time_point_sec),\n  event_group_id: protocol_id_type('event_group'),\n  is_live_market: bool,\n  status: event_status,\n  scores: array(string)\n});\n\nvar betting_market_rules = new Serializer('betting_market_rules', {\n  id: protocol_id_type('betting_market_rules'),\n  name: map(string, string),\n  description: map(string, string)\n});\n\nvar betting_market_group = new Serializer('betting_market_group', {\n  id: protocol_id_type('betting_market_group'),\n  description: map(string, string),\n  event_id: protocol_id_type('event'),\n  rules_id: protocol_id_type('betting_market_rules'),\n  asset_id: protocol_id_type('asset'),\n  total_matched_bets_amount: uint64,\n  frozen: bool,\n  delay_bets: bool,\n  status: betting_market_group_status\n});\n\nvar betting_market = new Serializer('betting_market', {\n  id: protocol_id_type('betting_market'),\n  group_id: protocol_id_type('betting_market_group'),\n  description: map(string, string),\n  payout_condition: map(string, string),\n  status: betting_market_status\n});\n\nvar bet = new Serializer('bet', {\n  id: protocol_id_type('bet'),\n  bettor_id: protocol_id_type('account'),\n  betting_market_id: protocol_id_type('betting_market'),\n  amount_to_bet: asset,\n  backer_multiplier: uint32,\n  back_or_lay: bet_type\n});\n\nvar betting_market_position = new Serializer('betting_market_position', {\n  id: implementation_id_type('betting_market_position'),\n  bettor_id: protocol_id_type('account'),\n  betting_market_id: protocol_id_type('betting_market'),\n  pay_if_payout_condition: int64,\n  pay_if_not_payout_condition: int64,\n  pay_if_canceled: int64,\n  pay_if_not_canceled: int64,\n  fees_collected: int64\n});\n\nvar global_betting_statistics = new Serializer('global_betting_statistics', {\n  id: implementation_id_type('global_betting_statistics'),\n  number_of_active_events: uint32,\n  total_amount_staked: map(protocol_id_type('asset'), int64)\n});\n\n// eof Betting Objects\n\n// Custom Types\n\nvar stealth_memo_data = new Serializer('stealth_memo_data', {\n  from: optional(public_key),\n  amount: asset,\n  blinding_factor: bytes(32),\n  commitment: bytes(33),\n  check: uint32\n});\n// var stealth_confirmation = new Serializer(\n//     \"stealth_confirmation\", {\n//     one_time_key: public_key,\n//     to: optional( public_key ),\n//     encrypted_memo: stealth_memo_data\n// })\n\nexports.operation = operation;\nexports.transfer_operation_fee_parameters = transfer_operation_fee_parameters;\nexports.limit_order_create_operation_fee_parameters = limit_order_create_operation_fee_parameters;\nexports.limit_order_cancel_operation_fee_parameters = limit_order_cancel_operation_fee_parameters;\nexports.call_order_update_operation_fee_parameters = call_order_update_operation_fee_parameters;\nexports.fill_order_operation_fee_parameters = fill_order_operation_fee_parameters;\nexports.account_create_operation_fee_parameters = account_create_operation_fee_parameters;\nexports.account_update_operation_fee_parameters = account_update_operation_fee_parameters;\nexports.account_whitelist_operation_fee_parameters = account_whitelist_operation_fee_parameters;\nexports.account_upgrade_operation_fee_parameters = account_upgrade_operation_fee_parameters;\nexports.account_transfer_operation_fee_parameters = account_transfer_operation_fee_parameters;\nexports.asset_create_operation_fee_parameters = asset_create_operation_fee_parameters;\nexports.asset_update_operation_fee_parameters = asset_update_operation_fee_parameters;\nexports.asset_update_bitasset_operation_fee_parameters = asset_update_bitasset_operation_fee_parameters;\nexports.asset_update_feed_producers_operation_fee_parameters = asset_update_feed_producers_operation_fee_parameters;\nexports.asset_issue_operation_fee_parameters = asset_issue_operation_fee_parameters;\nexports.asset_reserve_operation_fee_parameters = asset_reserve_operation_fee_parameters;\nexports.asset_fund_fee_pool_operation_fee_parameters = asset_fund_fee_pool_operation_fee_parameters;\nexports.asset_settle_operation_fee_parameters = asset_settle_operation_fee_parameters;\nexports.asset_global_settle_operation_fee_parameters = asset_global_settle_operation_fee_parameters;\nexports.asset_publish_feed_operation_fee_parameters = asset_publish_feed_operation_fee_parameters;\nexports.witness_create_operation_fee_parameters = witness_create_operation_fee_parameters;\nexports.witness_update_operation_fee_parameters = witness_update_operation_fee_parameters;\nexports.proposal_create_operation_fee_parameters = proposal_create_operation_fee_parameters;\nexports.proposal_update_operation_fee_parameters = proposal_update_operation_fee_parameters;\nexports.proposal_delete_operation_fee_parameters = proposal_delete_operation_fee_parameters;\nexports.withdraw_permission_create_operation_fee_parameters = withdraw_permission_create_operation_fee_parameters;\nexports.withdraw_permission_update_operation_fee_parameters = withdraw_permission_update_operation_fee_parameters;\nexports.withdraw_permission_claim_operation_fee_parameters = withdraw_permission_claim_operation_fee_parameters;\nexports.withdraw_permission_delete_operation_fee_parameters = withdraw_permission_delete_operation_fee_parameters;\nexports.committee_member_create_operation_fee_parameters = committee_member_create_operation_fee_parameters;\nexports.committee_member_update_operation_fee_parameters = committee_member_update_operation_fee_parameters;\nexports.committee_member_update_global_parameters_operation_fee_parameters = committee_member_update_global_parameters_operation_fee_parameters;\nexports.vesting_balance_create_operation_fee_parameters = vesting_balance_create_operation_fee_parameters;\nexports.vesting_balance_withdraw_operation_fee_parameters = vesting_balance_withdraw_operation_fee_parameters;\nexports.worker_create_operation_fee_parameters = worker_create_operation_fee_parameters;\nexports.custom_operation_fee_parameters = custom_operation_fee_parameters;\nexports.assert_operation_fee_parameters = assert_operation_fee_parameters;\nexports.balance_claim_operation_fee_parameters = balance_claim_operation_fee_parameters;\nexports.override_transfer_operation_fee_parameters = override_transfer_operation_fee_parameters;\nexports.transfer_to_blind_operation_fee_parameters = transfer_to_blind_operation_fee_parameters;\nexports.blind_transfer_operation_fee_parameters = blind_transfer_operation_fee_parameters;\nexports.transfer_from_blind_operation_fee_parameters = transfer_from_blind_operation_fee_parameters;\nexports.asset_settle_cancel_operation_fee_parameters = asset_settle_cancel_operation_fee_parameters;\nexports.asset_claim_fees_operation_fee_parameters = asset_claim_fees_operation_fee_parameters;\nexports.fba_distribute_operation_fee_parameters = fba_distribute_operation_fee_parameters;\nexports.asset_update_dividend_operation_fee_parameters = asset_update_dividend_operation_fee_parameters;\nexports.asset_dividend_distribution_operation_fee_parameters = asset_dividend_distribution_operation_fee_parameters;\nexports.sport_create_operation_fee_parameters = sport_create_operation_fee_parameters;\nexports.sport_update_operation_fee_parameters = sport_update_operation_fee_parameters;\nexports.event_group_create_operation_fee_parameters = event_group_create_operation_fee_parameters;\nexports.event_group_update_operation_fee_parameters = event_group_update_operation_fee_parameters;\nexports.event_create_operation_fee_parameters = event_create_operation_fee_parameters;\nexports.event_update_operation_fee_parameters = event_update_operation_fee_parameters;\nexports.betting_market_rules_create_operation_fee_parameters = betting_market_rules_create_operation_fee_parameters;\nexports.betting_market_rules_update_operation_fee_parameters = betting_market_rules_update_operation_fee_parameters;\nexports.betting_market_group_create_operation_fee_parameters = betting_market_group_create_operation_fee_parameters;\nexports.betting_market_create_operation_fee_parameters = betting_market_create_operation_fee_parameters;\nexports.bet_place_operation_fee_parameters = bet_place_operation_fee_parameters;\nexports.betting_market_group_resolve_operation_fee_parameters = betting_market_group_resolve_operation_fee_parameters;\nexports.betting_market_group_resolved_operation_fee_parameters = betting_market_group_resolved_operation_fee_parameters;\nexports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = betting_market_group_cancel_unmatched_bets_operation_fee_parameters;\nexports.bet_matched_operation_fee_parameters = bet_matched_operation_fee_parameters;\nexports.bet_cancel_operation_fee_parameters = bet_cancel_operation_fee_parameters;\nexports.bet_canceled_operation_fee_parameters = bet_canceled_operation_fee_parameters;\nexports.tournament_create_operation_fee_parameters = tournament_create_operation_fee_parameters;\nexports.tournament_join_operation_fee_parameters = tournament_join_operation_fee_parameters;\nexports.game_move_operation_fee_parameters = game_move_operation_fee_parameters;\nexports.tournament_payout_operation_fee_parameters = tournament_payout_operation_fee_parameters;\nexports.tournament_leave_operation_fee_parameters = tournament_leave_operation_fee_parameters;\nexports.betting_market_group_update_operation_fee_parameters = betting_market_group_update_operation_fee_parameters;\nexports.betting_market_update_operation_fee_parameters = betting_market_update_operation_fee_parameters;\nexports.bet_adjusted_operation_fee_parameters = bet_adjusted_operation_fee_parameters;\nexports.fee_schedule = fee_schedule;\nexports.void_result = void_result;\nexports.asset = asset;\nexports.processed_transaction = processed_transaction;\nexports.signed_block = signed_block;\nexports.block_header = block_header;\nexports.signed_block_header = signed_block_header;\nexports.memo_data = memo_data;\nexports.transfer = transfer;\nexports.limit_order_create = limit_order_create;\nexports.limit_order_cancel = limit_order_cancel;\nexports.call_order_update = call_order_update;\nexports.fill_order = fill_order;\nexports.authority = authority;\nexports.account_options = account_options;\nexports.account_create = account_create;\nexports.account_update = account_update;\nexports.account_whitelist = account_whitelist;\nexports.account_upgrade = account_upgrade;\nexports.account_transfer = account_transfer;\nexports.price = price;\nexports.asset_options = asset_options;\nexports.bitasset_options = bitasset_options;\nexports.asset_create = asset_create;\nexports.asset_update = asset_update;\nexports.asset_update_bitasset = asset_update_bitasset;\nexports.asset_update_feed_producers = asset_update_feed_producers;\nexports.asset_issue = asset_issue;\nexports.asset_reserve = asset_reserve;\nexports.asset_fund_fee_pool = asset_fund_fee_pool;\nexports.asset_settle = asset_settle;\nexports.asset_global_settle = asset_global_settle;\nexports.price_feed = price_feed;\nexports.asset_publish_feed = asset_publish_feed;\nexports.witness_create = witness_create;\nexports.witness_update = witness_update;\nexports.op_wrapper = op_wrapper;\nexports.proposal_create = proposal_create;\nexports.proposal_update = proposal_update;\nexports.proposal_delete = proposal_delete;\nexports.withdraw_permission_create = withdraw_permission_create;\nexports.withdraw_permission_update = withdraw_permission_update;\nexports.withdraw_permission_claim = withdraw_permission_claim;\nexports.withdraw_permission_delete = withdraw_permission_delete;\nexports.committee_member_create = committee_member_create;\nexports.committee_member_update = committee_member_update;\nexports.chain_parameters = chain_parameters;\nexports.committee_member_update_global_parameters = committee_member_update_global_parameters;\nexports.linear_vesting_policy_initializer = linear_vesting_policy_initializer;\nexports.cdd_vesting_policy_initializer = cdd_vesting_policy_initializer;\nexports.vesting_balance_create = vesting_balance_create;\nexports.vesting_balance_withdraw = vesting_balance_withdraw;\nexports.refund_worker_initializer = refund_worker_initializer;\nexports.vesting_balance_worker_initializer = vesting_balance_worker_initializer;\nexports.burn_worker_initializer = burn_worker_initializer;\nexports.worker_create = worker_create;\nexports.custom = custom;\nexports.account_name_eq_lit_predicate = account_name_eq_lit_predicate;\nexports.asset_symbol_eq_lit_predicate = asset_symbol_eq_lit_predicate;\nexports.block_id_predicate = block_id_predicate;\nexports.assert = assert;\nexports.balance_claim = balance_claim;\nexports.override_transfer = override_transfer;\nexports.stealth_confirmation = stealth_confirmation;\nexports.blind_output = blind_output;\nexports.transfer_to_blind = transfer_to_blind;\nexports.blind_input = blind_input;\nexports.blind_transfer = blind_transfer;\nexports.transfer_from_blind = transfer_from_blind;\nexports.asset_settle_cancel = asset_settle_cancel;\nexports.asset_claim_fees = asset_claim_fees;\nexports.fba_distribute = fba_distribute;\nexports.rock_paper_scissors_game_options = rock_paper_scissors_game_options;\nexports.tournament_options = tournament_options;\nexports.tournament_create = tournament_create;\nexports.tournament_join = tournament_join;\nexports.rock_paper_scissors_gesture = rock_paper_scissors_gesture;\nexports.rock_paper_scissors_throw_commit = rock_paper_scissors_throw_commit;\nexports.rock_paper_scissors_throw_reveal = rock_paper_scissors_throw_reveal;\nexports.game_move = game_move;\nexports.dividend_asset_options = dividend_asset_options;\nexports.asset_update_dividend = asset_update_dividend;\nexports.asset_dividend_distribution = asset_dividend_distribution;\nexports.sport_create = sport_create;\nexports.sport_update = sport_update;\nexports.event_group_create = event_group_create;\nexports.event_group_update = event_group_update;\nexports.event_create = event_create;\nexports.event_update = event_update;\nexports.betting_market_rules_create = betting_market_rules_create;\nexports.betting_market_rules_update = betting_market_rules_update;\nexports.betting_market_group_create = betting_market_group_create;\nexports.betting_market_create = betting_market_create;\nexports.bet_type = bet_type;\nexports.bet_place = bet_place;\nexports.betting_market_resolution_type = betting_market_resolution_type;\nexports.betting_market_group_resolve = betting_market_group_resolve;\nexports.betting_market_group_resolved = betting_market_group_resolved;\nexports.betting_market_group_cancel_unmatched_bets = betting_market_group_cancel_unmatched_bets;\nexports.bet_matched = bet_matched;\nexports.bet_cancel = bet_cancel;\nexports.bet_canceled = bet_canceled;\nexports.payout_type = payout_type;\nexports.tournament_payout = tournament_payout;\nexports.tournament_leave = tournament_leave;\nexports.betting_market_group_update = betting_market_group_update;\nexports.betting_market_update = betting_market_update;\nexports.bet_adjusted = bet_adjusted;\nexports.transaction = transaction;\nexports.signed_transaction = signed_transaction;\nexports.sport = sport;\nexports.event_group = event_group;\nexports.event = event;\nexports.betting_market_rules = betting_market_rules;\nexports.betting_market_group = betting_market_group;\nexports.betting_market = betting_market;\nexports.bet = bet;\nexports.betting_market_position = betting_market_position;\nexports.global_betting_statistics = global_betting_statistics;\nexports.stealth_memo_data = stealth_memo_data;","'use strict';\n\nexports.__esModule = true;\n\nvar _bytebuffer = require('bytebuffer');\n\nvar _bytebuffer2 = _interopRequireDefault(_bytebuffer);\n\nvar _error_with_cause = require('./error_with_cause');\n\nvar _error_with_cause2 = _interopRequireDefault(_error_with_cause);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump;\n\nvar Serializer = function () {\n  function Serializer(operation_name, types) {\n    _classCallCheck(this, Serializer);\n\n    this.operation_name = operation_name;\n    this.types = types;\n\n    if (this.types) {\n      this.keys = Object.keys(this.types);\n    }\n\n    Serializer.printDebug = true;\n  }\n\n  Serializer.prototype.fromByteBuffer = function fromByteBuffer(b) {\n    var object = {};\n    var field = null;\n\n    try {\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n\n        try {\n          if (HEX_DUMP) {\n            if (type.operation_name) {\n              console.error(type.operation_name);\n            } else {\n              var o1 = b.offset;\n              type.fromByteBuffer(b);\n              var o2 = b.offset;\n              b.offset = o1;\n              // b.reset()\n              var _b = b.copy(o1, o2);\n              console.error(this.operation_name + '.' + field + '\\t', _b.toHex());\n            }\n          }\n\n          object[field] = type.fromByteBuffer(b);\n        } catch (e) {\n          if (Serializer.printDebug) {\n            console.error('Error reading ' + this.operation_name + '.' + field + ' in data:');\n            b.printDebug();\n          }\n\n          throw e;\n        }\n      }\n    } catch (error) {\n      _error_with_cause2.default.throw(this.operation_name + '.' + field, error);\n    }\n\n    return object;\n  };\n\n  Serializer.prototype.appendByteBuffer = function appendByteBuffer(b, object) {\n    var field = null;\n\n    try {\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n        type.appendByteBuffer(b, object[field]);\n      }\n    } catch (error) {\n      try {\n        _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + JSON.stringify(object[field]), error);\n      } catch (e) {\n        // circular ref\n        _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + object[field], error);\n      }\n    }\n  };\n\n  Serializer.prototype.fromObject = function fromObject(serialized_object) {\n    var result = {};\n    var field = null;\n\n    try {\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n        var value = serialized_object[field];\n        // DEBUG value = value.resolve if value.resolve\n        // DEBUG console.log('... value',field,value)\n        var object = type.fromObject(value);\n        result[field] = object;\n      }\n    } catch (error) {\n      _error_with_cause2.default.throw(this.operation_name + '.' + field, error);\n    }\n\n    return result;\n  };\n\n  /**\n        @arg {boolean} [debug.use_default = false] - more template friendly\n        @arg {boolean} [debug.annotate = false] - add user-friendly information\n    */\n\n\n  Serializer.prototype.toObject = function toObject() {\n    var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false };\n\n    var result = {};\n    var field = null;\n\n    try {\n      if (!this.types) {\n        return result;\n      }\n\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n        var object = type.toObject(typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined, debug);\n        result[field] = object;\n\n        if (HEX_DUMP) {\n          var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN);\n          type.appendByteBuffer(b, typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined);\n          b = b.copy(0, b.offset);\n          console.error(this.operation_name + '.' + field, b.toHex());\n        }\n      }\n    } catch (error) {\n      _error_with_cause2.default.throw(this.operation_name + '.' + field, error);\n    }\n\n    return result;\n  };\n\n  /** Sort by the first element in a operation */\n\n\n  Serializer.prototype.compare = function compare(a, b) {\n    var first_key = this.keys[0];\n    var first_type = this.types[first_key];\n\n    var valA = a[first_key];\n    var valB = b[first_key];\n\n    if (first_type.compare) {\n      return first_type.compare(valA, valB);\n    }\n\n    if (typeof valA === 'number' && typeof valB === 'number') {\n      return valA - valB;\n    }\n\n    var encoding = void 0;\n\n    if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) {\n      // A binary string compare does not work.  If localeCompare is well supported that could\n      // replace HEX.  Performanance is very good so comparing HEX works.\n      encoding = 'hex';\n    }\n\n    var strA = valA.toString(encoding);\n    var strB = valB.toString(encoding);\n\n    var result = 0;\n\n    if (strA > strB) {\n      result = 1;\n    }\n\n    if (strA < strB) {\n      result = -1;\n    }\n\n    return result;\n  };\n\n  // <helper_functions>\n\n  Serializer.prototype.fromHex = function fromHex(hex) {\n    var b = _bytebuffer2.default.fromHex(hex, _bytebuffer2.default.LITTLE_ENDIAN);\n    return this.fromByteBuffer(b);\n  };\n\n  Serializer.prototype.fromBuffer = function fromBuffer(buffer) {\n    var b = _bytebuffer2.default.fromBinary(buffer.toString('binary'), _bytebuffer2.default.LITTLE_ENDIAN);\n    return this.fromByteBuffer(b);\n  };\n\n  Serializer.prototype.toHex = function toHex(object) {\n    // return this.toBuffer(object).toString(\"hex\")\n    var b = this.toByteBuffer(object);\n    return b.toHex();\n  };\n\n  Serializer.prototype.toByteBuffer = function toByteBuffer(object) {\n    var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN);\n    this.appendByteBuffer(b, object);\n    return b.copy(0, b.offset);\n  };\n\n  Serializer.prototype.toBuffer = function toBuffer(object) {\n    return Buffer.from(this.toByteBuffer(object).toBinary(), 'binary');\n  };\n\n  return Serializer;\n}();\n\nexports.default = Serializer;\nmodule.exports = exports['default'];","\"use strict\";\n\nexports.__esModule = true;\nexports.default = template;\n/** Console print any transaction object with zero default values. */\nfunction template(op) {\n  var object = op.toObject(undefined, { use_default: true, annotate: true });\n\n  // visual (with descriptions)\n  console.error(JSON.stringify(object, null, 4));\n\n  // usable in a copy-paste\n\n  object = op.toObject(undefined, { use_default: true, annotate: false });\n\n  // copy-paste one-lineer\n  console.error(JSON.stringify(object));\n}\nmodule.exports = exports[\"default\"];","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; // Low-level types that make up operations\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _SerializerValidation = require('./SerializerValidation');\n\nvar _SerializerValidation2 = _interopRequireDefault(_SerializerValidation);\n\nvar _FastParser = require('./FastParser');\n\nvar _FastParser2 = _interopRequireDefault(_FastParser);\n\nvar _ChainTypes = require('../../chain/src/ChainTypes');\n\nvar _ChainTypes2 = _interopRequireDefault(_ChainTypes);\n\nvar _ObjectId = require('../../chain/src/ObjectId');\n\nvar _ObjectId2 = _interopRequireDefault(_ObjectId);\n\nvar _ecc = require('../../ecc');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar MIN_SIGNED_32 = -1 * Math.pow(2, 31);\nvar MAX_SIGNED_32 = Math.pow(2, 31) - 1;\n\nvar HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump;\n\nvar strCmp = function strCmp(a, b) {\n  var result = 0;\n\n  if (a > b) {\n    result = 1;\n  }\n\n  if (a < b) {\n    result = -1;\n  }\n\n  return result;\n};\n\nvar firstEl = function firstEl(el) {\n  return Array.isArray(el) ? el[0] : el;\n};\n\nvar sortOperation = function sortOperation(array, st_operation) {\n  if (!st_operation.nosort) {\n    // If the operation has its own compare function.\n    if (st_operation.compare) {\n      return array.sort(function (a, b) {\n        return st_operation.compare(firstEl(a), firstEl(b));\n      });\n    }\n\n    return array.sort(function (a, b) {\n      var aFirst = firstEl(a);\n      var bFirst = firstEl(b);\n\n      // If both of the first elements are numbers.\n      if (typeof aFirst === 'number' && typeof bFirst === 'number') {\n        return aFirst - bFirst;\n      }\n\n      // If they are both buffers.\n      if (Buffer.isBuffer(aFirst) && Buffer.isBuffer(bFirst)) {\n        return strCmp(aFirst.toString('hex'), bFirst.toString('hex'));\n      }\n\n      // Otherwise\n      return strCmp(aFirst.toString(), bFirst.toString());\n    });\n  }\n\n  return array;\n};\n\nvar Types = {};\n\nTypes.uint8 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint8();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object);\n    b.writeUint8(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.uint16 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint16();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object);\n    b.writeUint16(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.uint32 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint32();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object);\n    b.writeUint32(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.varint32 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readVarint32();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n    b.writeVarint32(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.int64 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readInt64();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n    b.writeInt64(_SerializerValidation2.default.to_long(object));\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n    return _SerializerValidation2.default.to_long(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0';\n    }\n\n    _SerializerValidation2.default.required(object);\n    return _SerializerValidation2.default.to_long(object).toString();\n  }\n};\n\nTypes.uint64 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint64();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    b.writeUint64(_SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object)));\n  },\n  fromObject: function fromObject(object) {\n    return _SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object));\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0';\n    }\n\n    return _SerializerValidation2.default.to_ulong(object).toString();\n  }\n};\n\nTypes.string = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    var b_copy = void 0;\n    var len = b.readVarint32();\n    b_copy = b.copy(b.offset, b.offset + len);\n    b.skip(len);\n    return Buffer.from(b_copy.toBinary(), 'binary');\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n    b.writeVarint32(object.length);\n    b.append(object.toString('binary'), 'binary');\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n    return Buffer.from(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '';\n    }\n\n    return object.toString();\n  }\n};\n\nTypes.bytes = function (size) {\n  var bytes = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      if (size === undefined) {\n        var _b_copy = void 0;\n        var len = b.readVarint32();\n        _b_copy = b.copy(b.offset, b.offset + len);\n        b.skip(len);\n        return Buffer.from(_b_copy.toBinary(), 'binary');\n      }\n\n      var b_copy = b.copy(b.offset, b.offset + size);\n      b.skip(size);\n      return Buffer.from(b_copy.toBinary(), 'binary');\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n\n      if (typeof object === 'string') {\n        object = Buffer.from(object, 'hex');\n      }\n\n      if (size === undefined) {\n        b.writeVarint32(object.length);\n      }\n\n      b.append(object.toString('binary'), 'binary');\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n\n      if (Buffer.isBuffer(object)) {\n        return object;\n      }\n\n      return Buffer.from(object, 'hex');\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return new Array(size).join('00');\n      }\n\n      _SerializerValidation2.default.required(object);\n      return object.toString('hex');\n    }\n  };\n\n  return bytes;\n};\n\nTypes.bool = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint8() === 1;\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    // supports boolean or integer\n    b.writeUint8(JSON.parse(object) ? 1 : 0);\n  },\n  fromObject: function fromObject(object) {\n    return !!JSON.parse(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return false;\n    }\n\n    return !!JSON.parse(object);\n  }\n};\n\nTypes.void = {\n  fromByteBuffer: function fromByteBuffer() {\n    throw new Error('(void) undefined type');\n  },\n  appendByteBuffer: function appendByteBuffer() {\n    throw new Error('(void) undefined type');\n  },\n  fromObject: function fromObject() {\n    throw new Error('(void) undefined type');\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return undefined;\n    }\n\n    throw new Error('(void) undefined type');\n  }\n};\n\nTypes.array = function (st_operation) {\n  var array = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      var size = b.readVarint32();\n\n      if (HEX_DUMP) {\n        console.log('varint32 size = ' + size.toString(16));\n      }\n\n      var result = [];\n\n      for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) {\n        result.push(st_operation.fromByteBuffer(b));\n      }\n\n      return sortOperation(result, st_operation);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n      object = sortOperation(object, st_operation);\n      b.writeVarint32(object.length);\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        st_operation.appendByteBuffer(b, o);\n      }\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n      object = sortOperation(object, st_operation);\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push(st_operation.fromObject(o));\n      }\n\n      return result;\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [st_operation.toObject(object, debug)];\n      }\n\n      _SerializerValidation2.default.required(object);\n      object = sortOperation(object, st_operation);\n\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push(st_operation.toObject(o, debug));\n      }\n\n      return result;\n    }\n  };\n\n  return array;\n};\n\nTypes.time_point_sec = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint32();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    if (typeof object !== 'number') {\n      object = Types.time_point_sec.fromObject(object);\n    }\n\n    b.writeUint32(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (typeof object === 'number') {\n      return object;\n    }\n\n    if (object.getTime) {\n      return Math.floor(object.getTime() / 1000);\n    }\n\n    if (typeof object !== 'string') {\n      throw new Error('Unknown date type: ' + object);\n    }\n\n    // if(typeof object === \"string\" && !/Z$/.test(object))\n    //     object = object + \"Z\"\n\n    return Math.floor(new Date(object).getTime() / 1000);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return new Date(0).toISOString().split('.')[0];\n    }\n\n    _SerializerValidation2.default.required(object);\n\n    if (typeof object === 'string') {\n      return object;\n    }\n\n    if (object.getTime) {\n      return object.toISOString().split('.')[0];\n    }\n\n    var int = parseInt(object, 10);\n    _SerializerValidation2.default.require_range(0, 0xffffffff, int, 'uint32 ' + object);\n    return new Date(int * 1000).toISOString().split('.')[0];\n  }\n};\n\nTypes.set = function (st_operation) {\n  var set_object = {\n    validate: function validate(array) {\n      var dup_map = {};\n\n      for (var i = 0, len = array.length; i < len; i++) {\n        var o = array[i];\n        var ref = typeof o === 'undefined' ? 'undefined' : _typeof(o);\n\n        if (['string', 'number'].indexOf(ref) >= 0) {\n          if (dup_map[o] !== undefined) {\n            throw new Error('duplicate (set)');\n          }\n\n          dup_map[o] = true;\n        }\n      }\n\n      return sortOperation(array, st_operation);\n    },\n    fromByteBuffer: function fromByteBuffer(b) {\n      var size = b.readVarint32();\n\n      if (HEX_DUMP) {\n        console.log('varint32 size = ' + size.toString(16));\n      }\n\n      return this.validate(function () {\n        var result = [];\n\n        for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) {\n          result.push(st_operation.fromByteBuffer(b));\n        }\n\n        return result;\n      }());\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      if (!object) {\n        object = [];\n      }\n\n      b.writeVarint32(object.length);\n      var iterable = this.validate(object);\n\n      for (var i = 0, len = iterable.length; i < len; i++) {\n        var o = iterable[i];\n        st_operation.appendByteBuffer(b, o);\n      }\n    },\n    fromObject: function fromObject(object) {\n      if (!object) {\n        object = [];\n      }\n\n      return this.validate(function () {\n        var result = [];\n\n        for (var i = 0, len = object.length; i < len; i++) {\n          var o = object[i];\n          result.push(st_operation.fromObject(o));\n        }\n\n        return result;\n      }());\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [st_operation.toObject(object, debug)];\n      }\n\n      if (!object) {\n        object = [];\n      }\n\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push(st_operation.toObject(o, debug));\n      }\n\n      return this.validate(result);\n    }\n  };\n\n  return set_object;\n};\n\nTypes.fixed_array = function (count, st_operation) {\n  var fixed_array = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      var results = [];\n\n      for (var i = 0, ref = count; i < ref; i++) {\n        results.push(st_operation.fromByteBuffer(b));\n      }\n\n      return sortOperation(results, st_operation);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      if (count !== 0) {\n        _SerializerValidation2.default.required(object);\n        object = sortOperation(object, st_operation);\n      }\n\n      for (var i = 0, ref = count; i < ref; i++) {\n        st_operation.appendByteBuffer(b, object[i]);\n      }\n    },\n    fromObject: function fromObject(object) {\n      if (count !== 0) {\n        _SerializerValidation2.default.required(object);\n      }\n\n      var results = [];\n\n      for (var i = 0, ref = count; i < ref; i++) {\n        results.push(st_operation.fromObject(object[i]));\n      }\n\n      return results;\n    },\n    toObject: function toObject(object, debug) {\n      if (debug == null) {\n        debug = {};\n      }\n\n      var results = void 0;\n\n      if (debug.use_default && object === undefined) {\n        results = [];\n\n        for (var i = 0, ref = count; i < ref; i++) {\n          results.push(st_operation.toObject(undefined, debug));\n        }\n\n        return results;\n      }\n\n      if (count !== 0) {\n        _SerializerValidation2.default.required(object);\n      }\n\n      results = [];\n\n      for (var _i = 0, _ref = count; _i < _ref; _i++) {\n        results.push(st_operation.toObject(object[_i], debug));\n      }\n\n      return results;\n    }\n  };\n\n  return fixed_array;\n};\n\n/* Supports instance numbers (11) or object types (1.2.11).  Object type\nValidation is enforced when an object type is used. */\nTypes.id_type = function (reserved_spaces, object_type) {\n  _SerializerValidation2.default.required(reserved_spaces, 'reserved_spaces');\n  _SerializerValidation2.default.required(object_type, 'object_type');\n\n  var id_type_object = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      return b.readVarint32();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n\n      if (object.resolve !== undefined) {\n        object = object.resolve;\n      }\n\n      // convert 1.2.n into just n\n      if (/^[0-9]+\\.[0-9]+\\.[0-9]+$/.test(object)) {\n        object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object);\n      }\n\n      b.writeVarint32(_SerializerValidation2.default.to_number(object));\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n\n      if (object.resolve !== undefined) {\n        object = object.resolve;\n      }\n\n      if (_SerializerValidation2.default.is_digits(object)) {\n        return _SerializerValidation2.default.to_number(object);\n      }\n\n      return _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object);\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      var object_type_id = _ChainTypes2.default.object_type[object_type];\n\n      if (debug.use_default && object === undefined) {\n        return reserved_spaces + '.' + object_type_id + '.0';\n      }\n\n      _SerializerValidation2.default.required(object);\n\n      if (object.resolve !== undefined) {\n        object = object.resolve;\n      }\n\n      if (/^[0-9]+\\.[0-9]+\\.[0-9]+$/.test(object)) {\n        object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object);\n      }\n\n      return reserved_spaces + '.' + object_type_id + '.' + object;\n    }\n  };\n\n  return id_type_object;\n};\n\nTypes.protocol_id_type = function (name) {\n  _SerializerValidation2.default.required(name, 'name');\n  return Types.id_type(_ChainTypes2.default.reserved_spaces.protocol_ids, name);\n};\n\nTypes.implementation_id_type = function (name) {\n  var result = Types.id_type(_ChainTypes2.default.reserved_spaces.implementation_ids, name);\n  return result;\n};\n\nTypes.object_id_type = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return _ObjectId2.default.fromByteBuffer(b);\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    object = _ObjectId2.default.fromString(object);\n    object.appendByteBuffer(b);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    return _ObjectId2.default.fromString(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0.0.0';\n    }\n\n    _SerializerValidation2.default.required(object);\n\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    object = _ObjectId2.default.fromString(object);\n    return object.toString();\n  }\n};\n\nTypes.vote_id = {\n  TYPE: 0x000000ff,\n  ID: 0xffffff00,\n  fromByteBuffer: function fromByteBuffer(b) {\n    var value = b.readUint32();\n    return {\n      type: value & this.TYPE, // eslint-disable-line\n      id: value & this.ID // eslint-disable-line\n    };\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object === 'string') {\n      object = Types.vote_id.fromObject(object);\n    }\n\n    var value = object.id << 8 | object.type; // eslint-disable-line\n    b.writeUint32(value);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object, '(type vote_id)');\n\n    if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object') {\n      _SerializerValidation2.default.required(object.type, 'type');\n      _SerializerValidation2.default.required(object.id, 'id');\n      return object;\n    }\n\n    _SerializerValidation2.default.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object);\n\n    var _object$split = object.split(':'),\n        type = _object$split[0],\n        id = _object$split[1];\n\n    _SerializerValidation2.default.require_range(0, 0xff, type, 'vote type ' + object);\n    _SerializerValidation2.default.require_range(0, 0xffffff, id, 'vote id ' + object);\n    return { type: type, id: id };\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0:0';\n    }\n\n    _SerializerValidation2.default.required(object);\n\n    if (typeof object === 'string') {\n      object = Types.vote_id.fromObject(object);\n    }\n\n    return object.type + ':' + object.id;\n  },\n  compare: function compare(a, b) {\n    if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== 'object') {\n      a = Types.vote_id.fromObject(a);\n    }\n\n    if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== 'object') {\n      b = Types.vote_id.fromObject(b);\n    }\n\n    return parseInt(a.id, 10) - parseInt(b.id, 10);\n  }\n};\n\nTypes.optional = function (st_operation) {\n  _SerializerValidation2.default.required(st_operation, 'st_operation');\n  return {\n    fromByteBuffer: function fromByteBuffer(b) {\n      if (!(b.readUint8() === 1)) {\n        return undefined;\n      }\n\n      return st_operation.fromByteBuffer(b);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      if (object !== null && object !== undefined) {\n        b.writeUint8(1);\n        st_operation.appendByteBuffer(b, object);\n      } else {\n        b.writeUint8(0);\n      }\n    },\n    fromObject: function fromObject(object) {\n      if (object === undefined) {\n        return undefined;\n      }\n\n      return st_operation.fromObject(object);\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      // toObject is only null save if use_default is true\n      var result_object = function () {\n        if (!debug.use_default && object === undefined) {\n          return undefined;\n        }\n\n        return st_operation.toObject(object, debug);\n      }();\n\n      if (debug.annotate) {\n        if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === 'object') {\n          result_object.__optional = 'parent is optional';\n        } else {\n          result_object = { __optional: result_object };\n        }\n      }\n\n      return result_object;\n    }\n  };\n};\n\nTypes.static_variant = function (_st_operations) {\n  var static_variant = {\n    nosort: true,\n    st_operations: _st_operations,\n    fromByteBuffer: function fromByteBuffer(b) {\n      var type_id = b.readVarint32();\n      var st_operation = this.st_operations[type_id];\n\n      if (HEX_DUMP) {\n        console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')');\n      }\n\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      return [type_id, st_operation.fromByteBuffer(b)];\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n      var type_id = object[0];\n      var st_operation = this.st_operations[type_id];\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      b.writeVarint32(type_id);\n      st_operation.appendByteBuffer(b, object[1]);\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n      var type_id = object[0];\n      var st_operation = this.st_operations[type_id];\n\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      return [type_id, st_operation.fromObject(object[1])];\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [0, this.st_operations[0].toObject(undefined, debug)];\n      }\n\n      _SerializerValidation2.default.required(object);\n      var type_id = object[0];\n      var st_operation = this.st_operations[type_id];\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      return [type_id, st_operation.toObject(object[1], debug)];\n    }\n  };\n\n  return static_variant;\n};\n\nTypes.map = function (key_st_operation, value_st_operation) {\n  var map_object = {\n    validate: function validate(array) {\n      if (!Array.isArray(array)) {\n        throw new Error('expecting array');\n      }\n\n      var dup_map = {};\n\n      for (var i = 0, len = array.length; i < len; i++) {\n        var o = array[i];\n        var ref = void 0;\n\n        if (!(o.length === 2)) {\n          throw new Error('expecting two elements');\n        }\n\n        ref = _typeof(o[0]);\n\n        if (ref && ['number', 'string'].indexOf(ref) >= 0) {\n          if (dup_map[o[0]] !== undefined) {\n            throw new Error('duplicate (map)');\n          }\n\n          dup_map[o[0]] = true;\n        }\n      }\n\n      return sortOperation(array, key_st_operation);\n    },\n    fromByteBuffer: function fromByteBuffer(b) {\n      var result = [];\n      var end = b.readVarint32();\n\n      for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) {\n        result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]);\n      }\n\n      return this.validate(result);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      this.validate(object);\n      b.writeVarint32(object.length);\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        key_st_operation.appendByteBuffer(b, o[0]);\n        value_st_operation.appendByteBuffer(b, o[1]);\n      }\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]);\n      }\n\n      return this.validate(result);\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]];\n      }\n\n      _SerializerValidation2.default.required(object);\n      object = this.validate(object);\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]);\n      }\n\n      return result;\n    }\n  };\n\n  return map_object;\n};\n\nTypes.public_key = {\n  toPublic: function toPublic(object) {\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    if (object instanceof _ecc.PublicKey) {\n      return object;\n    }\n\n    var result = object;\n\n    if (!object) {\n      return null;\n    }\n\n    if (!object.Q) {\n      result = _ecc.PublicKey.fromStringOrThrow(object);\n    }\n\n    return result;\n  },\n  fromByteBuffer: function fromByteBuffer(b) {\n    return _FastParser2.default.public_key(b);\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n    _FastParser2.default.public_key(b, Types.public_key.toPublic(object));\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.Q) {\n      return object;\n    }\n\n    return Types.public_key.toPublic(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return _peerplaysjsWs.ChainConfig.address_prefix + '859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM';\n    }\n\n    _SerializerValidation2.default.required(object);\n    return object.toString();\n  },\n  compare: function compare(a, b) {\n    return strCmp(a.toAddressString(), b.toAddressString());\n  }\n};\n\nTypes.address = {\n  _to_address: function _to_address(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.addy) {\n      return object;\n    }\n\n    return _ecc.Address.fromString(object);\n  },\n  fromByteBuffer: function fromByteBuffer(b) {\n    return new _ecc.Address(_FastParser2.default.ripemd160(b));\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _FastParser2.default.ripemd160(b, Types.address._to_address(object).toBuffer());\n  },\n  fromObject: function fromObject(object) {\n    return Types.address._to_address(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return _peerplaysjsWs.ChainConfig.address_prefix + '664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S';\n    }\n\n    return Types.address._to_address(object).toString();\n  },\n  compare: function compare(a, b) {\n    return strCmp(a.toString(), b.toString());\n  }\n};\n\nTypes.variant = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    var type = b.readUint8();\n\n    switch (type) {\n      case 0:\n        return null;\n      case 1:\n        return Types.int64.fromByteBuffer(b);\n      case 2:\n        return Types.uint64.fromByteBuffer(b);\n      case 3:\n        return b.readDouble();\n      case 4:\n        return Types.bool.fromByteBuffer(b);\n      case 5:\n        return Types.string.fromByteBuffer(b);\n      case 6:\n        return Types.array(Types.variant).fromByteBuffer(b);\n      case 7:\n      default:\n        return Types.variant_object.fromByteBuffer(b);\n    }\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    if (typeof object === 'number') {\n      if (Number.isInteger(object)) {\n        if (object >= 0) {\n          b.writeUint8(2);\n          Types.uint64.appendByteBuffer(b, object);\n        } else {\n          b.writeUint8(1);\n          Types.int64.appendByteBuffer(b, object);\n        }\n      } else {\n        b.writeUint8(3);\n        b.writeDouble(Number.parseFloat(object));\n      }\n    } else if (typeof object === 'boolean') {\n      b.writeUint8(4);\n      Types.bool.appendByteBuffer(b, object);\n    } else if (typeof object === 'string') {\n      b.writeUint8(5);\n      Types.string.appendByteBuffer(b, object);\n    } else if (Array.isArray(object)) {\n      b.writeUint8(6);\n      Types.array(Types.variant).appendByteBuffer(b, object);\n    } else {\n      b.writeUint8(7);\n      Types.variant_object.appendByteBuffer(b, object);\n    }\n  },\n  fromObject: function fromObject(object) {\n    return JSON.parse(object);\n  },\n  toObject: function toObject(object) {\n    return JSON.parse(object);\n  }\n};\n\nTypes.variant_object = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    var count = b.readVarint32();\n    var result = {};\n\n    for (var i = 0; i < count; ++i) {\n      var key = Types.string.fromByteBuffer(b);\n      result[key] = Types.variant.fromByteBuffer(b);\n    }\n\n    return result;\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    var keys = Object.keys(object);\n\n    b.writeVarint32(keys.length); // number of key/value pairs\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var key = keys[i];\n      Types.string.appendByteBuffer(b, key);\n      Types.variant.appendByteBuffer(b, object[key]);\n    }\n  },\n  fromObject: function fromObject(object) {\n    var newObject = {};\n\n    var keys = Object.keys(object);\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var key = keys[i];\n      newObject[key] = object[key];\n    }\n\n    return newObject;\n  },\n  toObject: function toObject(object) {\n    var newObject = {};\n\n    var keys = Object.keys(object);\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var key = keys[i];\n      newObject[key] = object[key];\n    }\n\n    return newObject;\n  }\n};\n\nTypes.enumeration = function (values) {\n  var enumeration = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      return values[b.readVarint32ZigZag()];\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      b.writeVarint32ZigZag(values.indexOf(object));\n    },\n    fromObject: function fromObject(object) {\n      return object;\n    },\n    toObject: function toObject(object) {\n      return object;\n    }\n  };\n\n  return enumeration;\n};\n\nTypes.sha256 = Types.bytes(32);\n\nexports.default = Types;\nmodule.exports = exports['default'];","'use strict';\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","// base-x encoding\n// Forked from https://github.com/cryptocoinjs/bs58\n// Originally written by Mike Hearn for BitcoinJ\n// Copyright (c) 2011 Google Inc\n// Ported to JavaScript by Stefan Thomas\n// Merged Buffer refactorings from base58-native by Stephen Pair\n// Copyright (c) 2013 BitPay Inc\n\nmodule.exports = function base (ALPHABET) {\n  var ALPHABET_MAP = {}\n  var BASE = ALPHABET.length\n  var LEADER = ALPHABET.charAt(0)\n\n  // pre-compute lookup table\n  for (var i = 0; i < ALPHABET.length; i++) {\n    ALPHABET_MAP[ALPHABET.charAt(i)] = i\n  }\n\n  function encode (source) {\n    if (source.length === 0) return ''\n\n    var digits = [0]\n    for (var i = 0; i < source.length; ++i) {\n      for (var j = 0, carry = source[i]; j < digits.length; ++j) {\n        carry += digits[j] << 8\n        digits[j] = carry % BASE\n        carry = (carry / BASE) | 0\n      }\n\n      while (carry > 0) {\n        digits.push(carry % BASE)\n        carry = (carry / BASE) | 0\n      }\n    }\n\n    var string = ''\n\n    // deal with leading zeros\n    for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) string += ALPHABET[0]\n    // convert digits to a string\n    for (var q = digits.length - 1; q >= 0; --q) string += ALPHABET[digits[q]]\n\n    return string\n  }\n\n  function decodeUnsafe (string) {\n    if (string.length === 0) return []\n\n    var bytes = [0]\n    for (var i = 0; i < string.length; i++) {\n      var value = ALPHABET_MAP[string[i]]\n      if (value === undefined) return\n\n      for (var j = 0, carry = value; j < bytes.length; ++j) {\n        carry += bytes[j] * BASE\n        bytes[j] = carry & 0xff\n        carry >>= 8\n      }\n\n      while (carry > 0) {\n        bytes.push(carry & 0xff)\n        carry >>= 8\n      }\n    }\n\n    // deal with leading zeros\n    for (var k = 0; string[k] === LEADER && k < string.length - 1; ++k) {\n      bytes.push(0)\n    }\n\n    return bytes.reverse()\n  }\n\n  function decode (string) {\n    var array = decodeUnsafe(string)\n    if (array) return array\n\n    throw new Error('Non-base' + BASE + ' character')\n  }\n\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","// (public) Constructor\nfunction BigInteger(a, b, c) {\n  if (!(this instanceof BigInteger))\n    return new BigInteger(a, b, c)\n\n  if (a != null) {\n    if (\"number\" == typeof a) this.fromNumber(a, b, c)\n    else if (b == null && \"string\" != typeof a) this.fromString(a, 256)\n    else this.fromString(a, b)\n  }\n}\n\nvar proto = BigInteger.prototype\n\n// duck-typed isBigInteger\nproto.__bigi = require(33).version\nBigInteger.isBigInteger = function (obj, check_ver) {\n  return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi)\n}\n\n// Bits per digit\nvar dbits\n\n// am: Compute w_j += (x*this_i), propagate carries,\n// c is initial carry, returns final carry.\n// c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n// We need to select the fastest one that works in this environment.\n\n// am1: use a single mult and divide to get the high bits,\n// max digit bits should be 26 because\n// max internal value = 2*dvalue^2-2*dvalue (< 2^53)\nfunction am1(i, x, w, j, c, n) {\n  while (--n >= 0) {\n    var v = x * this[i++] + w[j] + c\n    c = Math.floor(v / 0x4000000)\n    w[j++] = v & 0x3ffffff\n  }\n  return c\n}\n// am2 avoids a big mult-and-extract completely.\n// Max digit bits should be <= 30 because we do bitwise ops\n// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\nfunction am2(i, x, w, j, c, n) {\n  var xl = x & 0x7fff,\n    xh = x >> 15\n  while (--n >= 0) {\n    var l = this[i] & 0x7fff\n    var h = this[i++] >> 15\n    var m = xh * l + h * xl\n    l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)\n    c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)\n    w[j++] = l & 0x3fffffff\n  }\n  return c\n}\n// Alternately, set max digit bits to 28 since some\n// browsers slow down when dealing with 32-bit numbers.\nfunction am3(i, x, w, j, c, n) {\n  var xl = x & 0x3fff,\n    xh = x >> 14\n  while (--n >= 0) {\n    var l = this[i] & 0x3fff\n    var h = this[i++] >> 14\n    var m = xh * l + h * xl\n    l = xl * l + ((m & 0x3fff) << 14) + w[j] + c\n    c = (l >> 28) + (m >> 14) + xh * h\n    w[j++] = l & 0xfffffff\n  }\n  return c\n}\n\n// wtf?\nBigInteger.prototype.am = am1\ndbits = 26\n\nBigInteger.prototype.DB = dbits\nBigInteger.prototype.DM = ((1 << dbits) - 1)\nvar DV = BigInteger.prototype.DV = (1 << dbits)\n\nvar BI_FP = 52\nBigInteger.prototype.FV = Math.pow(2, BI_FP)\nBigInteger.prototype.F1 = BI_FP - dbits\nBigInteger.prototype.F2 = 2 * dbits - BI_FP\n\n// Digit conversions\nvar BI_RM = \"0123456789abcdefghijklmnopqrstuvwxyz\"\nvar BI_RC = new Array()\nvar rr, vv\nrr = \"0\".charCodeAt(0)\nfor (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv\nrr = \"a\".charCodeAt(0)\nfor (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv\nrr = \"A\".charCodeAt(0)\nfor (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv\n\nfunction int2char(n) {\n  return BI_RM.charAt(n)\n}\n\nfunction intAt(s, i) {\n  var c = BI_RC[s.charCodeAt(i)]\n  return (c == null) ? -1 : c\n}\n\n// (protected) copy this to r\nfunction bnpCopyTo(r) {\n  for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]\n  r.t = this.t\n  r.s = this.s\n}\n\n// (protected) set from integer value x, -DV <= x < DV\nfunction bnpFromInt(x) {\n  this.t = 1\n  this.s = (x < 0) ? -1 : 0\n  if (x > 0) this[0] = x\n  else if (x < -1) this[0] = x + DV\n  else this.t = 0\n}\n\n// return bigint initialized to value\nfunction nbv(i) {\n  var r = new BigInteger()\n  r.fromInt(i)\n  return r\n}\n\n// (protected) set from string and radix\nfunction bnpFromString(s, b) {\n  var self = this\n\n  var k\n  if (b == 16) k = 4\n  else if (b == 8) k = 3\n  else if (b == 256) k = 8; // byte array\n  else if (b == 2) k = 1\n  else if (b == 32) k = 5\n  else if (b == 4) k = 2\n  else {\n    self.fromRadix(s, b)\n    return\n  }\n  self.t = 0\n  self.s = 0\n  var i = s.length,\n    mi = false,\n    sh = 0\n  while (--i >= 0) {\n    var x = (k == 8) ? s[i] & 0xff : intAt(s, i)\n    if (x < 0) {\n      if (s.charAt(i) == \"-\") mi = true\n      continue\n    }\n    mi = false\n    if (sh == 0)\n      self[self.t++] = x\n    else if (sh + k > self.DB) {\n      self[self.t - 1] |= (x & ((1 << (self.DB - sh)) - 1)) << sh\n      self[self.t++] = (x >> (self.DB - sh))\n    } else\n      self[self.t - 1] |= x << sh\n    sh += k\n    if (sh >= self.DB) sh -= self.DB\n  }\n  if (k == 8 && (s[0] & 0x80) != 0) {\n    self.s = -1\n    if (sh > 0) self[self.t - 1] |= ((1 << (self.DB - sh)) - 1) << sh\n  }\n  self.clamp()\n  if (mi) BigInteger.ZERO.subTo(self, self)\n}\n\n// (protected) clamp off excess high words\nfunction bnpClamp() {\n  var c = this.s & this.DM\n  while (this.t > 0 && this[this.t - 1] == c)--this.t\n}\n\n// (public) return string representation in given radix\nfunction bnToString(b) {\n  var self = this\n  if (self.s < 0) return \"-\" + self.negate()\n    .toString(b)\n  var k\n  if (b == 16) k = 4\n  else if (b == 8) k = 3\n  else if (b == 2) k = 1\n  else if (b == 32) k = 5\n  else if (b == 4) k = 2\n  else return self.toRadix(b)\n  var km = (1 << k) - 1,\n    d, m = false,\n    r = \"\",\n    i = self.t\n  var p = self.DB - (i * self.DB) % k\n  if (i-- > 0) {\n    if (p < self.DB && (d = self[i] >> p) > 0) {\n      m = true\n      r = int2char(d)\n    }\n    while (i >= 0) {\n      if (p < k) {\n        d = (self[i] & ((1 << p) - 1)) << (k - p)\n        d |= self[--i] >> (p += self.DB - k)\n      } else {\n        d = (self[i] >> (p -= k)) & km\n        if (p <= 0) {\n          p += self.DB\n          --i\n        }\n      }\n      if (d > 0) m = true\n      if (m) r += int2char(d)\n    }\n  }\n  return m ? r : \"0\"\n}\n\n// (public) -this\nfunction bnNegate() {\n  var r = new BigInteger()\n  BigInteger.ZERO.subTo(this, r)\n  return r\n}\n\n// (public) |this|\nfunction bnAbs() {\n  return (this.s < 0) ? this.negate() : this\n}\n\n// (public) return + if this > a, - if this < a, 0 if equal\nfunction bnCompareTo(a) {\n  var r = this.s - a.s\n  if (r != 0) return r\n  var i = this.t\n  r = i - a.t\n  if (r != 0) return (this.s < 0) ? -r : r\n  while (--i >= 0)\n    if ((r = this[i] - a[i]) != 0) return r\n  return 0\n}\n\n// returns bit length of the integer x\nfunction nbits(x) {\n  var r = 1,\n    t\n  if ((t = x >>> 16) != 0) {\n    x = t\n    r += 16\n  }\n  if ((t = x >> 8) != 0) {\n    x = t\n    r += 8\n  }\n  if ((t = x >> 4) != 0) {\n    x = t\n    r += 4\n  }\n  if ((t = x >> 2) != 0) {\n    x = t\n    r += 2\n  }\n  if ((t = x >> 1) != 0) {\n    x = t\n    r += 1\n  }\n  return r\n}\n\n// (public) return the number of bits in \"this\"\nfunction bnBitLength() {\n  if (this.t <= 0) return 0\n  return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))\n}\n\n// (public) return the number of bytes in \"this\"\nfunction bnByteLength() {\n  return this.bitLength() >> 3\n}\n\n// (protected) r = this << n*DB\nfunction bnpDLShiftTo(n, r) {\n  var i\n  for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]\n  for (i = n - 1; i >= 0; --i) r[i] = 0\n  r.t = this.t + n\n  r.s = this.s\n}\n\n// (protected) r = this >> n*DB\nfunction bnpDRShiftTo(n, r) {\n  for (var i = n; i < this.t; ++i) r[i - n] = this[i]\n  r.t = Math.max(this.t - n, 0)\n  r.s = this.s\n}\n\n// (protected) r = this << n\nfunction bnpLShiftTo(n, r) {\n  var self = this\n  var bs = n % self.DB\n  var cbs = self.DB - bs\n  var bm = (1 << cbs) - 1\n  var ds = Math.floor(n / self.DB),\n    c = (self.s << bs) & self.DM,\n    i\n  for (i = self.t - 1; i >= 0; --i) {\n    r[i + ds + 1] = (self[i] >> cbs) | c\n    c = (self[i] & bm) << bs\n  }\n  for (i = ds - 1; i >= 0; --i) r[i] = 0\n  r[ds] = c\n  r.t = self.t + ds + 1\n  r.s = self.s\n  r.clamp()\n}\n\n// (protected) r = this >> n\nfunction bnpRShiftTo(n, r) {\n  var self = this\n  r.s = self.s\n  var ds = Math.floor(n / self.DB)\n  if (ds >= self.t) {\n    r.t = 0\n    return\n  }\n  var bs = n % self.DB\n  var cbs = self.DB - bs\n  var bm = (1 << bs) - 1\n  r[0] = self[ds] >> bs\n  for (var i = ds + 1; i < self.t; ++i) {\n    r[i - ds - 1] |= (self[i] & bm) << cbs\n    r[i - ds] = self[i] >> bs\n  }\n  if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs\n  r.t = self.t - ds\n  r.clamp()\n}\n\n// (protected) r = this - a\nfunction bnpSubTo(a, r) {\n  var self = this\n  var i = 0,\n    c = 0,\n    m = Math.min(a.t, self.t)\n  while (i < m) {\n    c += self[i] - a[i]\n    r[i++] = c & self.DM\n    c >>= self.DB\n  }\n  if (a.t < self.t) {\n    c -= a.s\n    while (i < self.t) {\n      c += self[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += self.s\n  } else {\n    c += self.s\n    while (i < a.t) {\n      c -= a[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c -= a.s\n  }\n  r.s = (c < 0) ? -1 : 0\n  if (c < -1) r[i++] = self.DV + c\n  else if (c > 0) r[i++] = c\n  r.t = i\n  r.clamp()\n}\n\n// (protected) r = this * a, r != this,a (HAC 14.12)\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyTo(a, r) {\n  var x = this.abs(),\n    y = a.abs()\n  var i = x.t\n  r.t = i + y.t\n  while (--i >= 0) r[i] = 0\n  for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)\n  r.s = 0\n  r.clamp()\n  if (this.s != a.s) BigInteger.ZERO.subTo(r, r)\n}\n\n// (protected) r = this^2, r != this (HAC 14.16)\nfunction bnpSquareTo(r) {\n  var x = this.abs()\n  var i = r.t = 2 * x.t\n  while (--i >= 0) r[i] = 0\n  for (i = 0; i < x.t - 1; ++i) {\n    var c = x.am(i, x[i], r, 2 * i, 0, 1)\n    if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {\n      r[i + x.t] -= x.DV\n      r[i + x.t + 1] = 1\n    }\n  }\n  if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)\n  r.s = 0\n  r.clamp()\n}\n\n// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n// r != q, this != m.  q or r may be null.\nfunction bnpDivRemTo(m, q, r) {\n  var self = this\n  var pm = m.abs()\n  if (pm.t <= 0) return\n  var pt = self.abs()\n  if (pt.t < pm.t) {\n    if (q != null) q.fromInt(0)\n    if (r != null) self.copyTo(r)\n    return\n  }\n  if (r == null) r = new BigInteger()\n  var y = new BigInteger(),\n    ts = self.s,\n    ms = m.s\n  var nsh = self.DB - nbits(pm[pm.t - 1]); // normalize modulus\n  if (nsh > 0) {\n    pm.lShiftTo(nsh, y)\n    pt.lShiftTo(nsh, r)\n  } else {\n    pm.copyTo(y)\n    pt.copyTo(r)\n  }\n  var ys = y.t\n  var y0 = y[ys - 1]\n  if (y0 == 0) return\n  var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0)\n  var d1 = self.FV / yt,\n    d2 = (1 << self.F1) / yt,\n    e = 1 << self.F2\n  var i = r.t,\n    j = i - ys,\n    t = (q == null) ? new BigInteger() : q\n  y.dlShiftTo(j, t)\n  if (r.compareTo(t) >= 0) {\n    r[r.t++] = 1\n    r.subTo(t, r)\n  }\n  BigInteger.ONE.dlShiftTo(ys, t)\n  t.subTo(y, y); // \"negative\" y so we can replace sub with am later\n  while (y.t < ys) y[y.t++] = 0\n  while (--j >= 0) {\n    // Estimate quotient digit\n    var qd = (r[--i] == y0) ? self.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)\n    if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out\n      y.dlShiftTo(j, t)\n      r.subTo(t, r)\n      while (r[i] < --qd) r.subTo(t, r)\n    }\n  }\n  if (q != null) {\n    r.drShiftTo(ys, q)\n    if (ts != ms) BigInteger.ZERO.subTo(q, q)\n  }\n  r.t = ys\n  r.clamp()\n  if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder\n  if (ts < 0) BigInteger.ZERO.subTo(r, r)\n}\n\n// (public) this mod a\nfunction bnMod(a) {\n  var r = new BigInteger()\n  this.abs()\n    .divRemTo(a, null, r)\n  if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r)\n  return r\n}\n\n// Modular reduction using \"classic\" algorithm\nfunction Classic(m) {\n  this.m = m\n}\n\nfunction cConvert(x) {\n  if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m)\n  else return x\n}\n\nfunction cRevert(x) {\n  return x\n}\n\nfunction cReduce(x) {\n  x.divRemTo(this.m, null, x)\n}\n\nfunction cMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nfunction cSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\nClassic.prototype.convert = cConvert\nClassic.prototype.revert = cRevert\nClassic.prototype.reduce = cReduce\nClassic.prototype.mulTo = cMulTo\nClassic.prototype.sqrTo = cSqrTo\n\n// (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n// justification:\n//         xy == 1 (mod m)\n//         xy =  1+km\n//   xy(2-xy) = (1+km)(1-km)\n// x[y(2-xy)] = 1-k^2m^2\n// x[y(2-xy)] == 1 (mod m^2)\n// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n// JS multiply \"overflows\" differently from C/C++, so care is needed here.\nfunction bnpInvDigit() {\n  if (this.t < 1) return 0\n  var x = this[0]\n  if ((x & 1) == 0) return 0\n  var y = x & 3; // y == 1/x mod 2^2\n  y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4\n  y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8\n  y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16\n  // last step - calculate inverse mod DV directly\n  // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n  y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits\n  // we really want the negative inverse, and -DV < y < DV\n  return (y > 0) ? this.DV - y : -y\n}\n\n// Montgomery reduction\nfunction Montgomery(m) {\n  this.m = m\n  this.mp = m.invDigit()\n  this.mpl = this.mp & 0x7fff\n  this.mph = this.mp >> 15\n  this.um = (1 << (m.DB - 15)) - 1\n  this.mt2 = 2 * m.t\n}\n\n// xR mod m\nfunction montConvert(x) {\n  var r = new BigInteger()\n  x.abs()\n    .dlShiftTo(this.m.t, r)\n  r.divRemTo(this.m, null, r)\n  if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)\n  return r\n}\n\n// x/R mod m\nfunction montRevert(x) {\n  var r = new BigInteger()\n  x.copyTo(r)\n  this.reduce(r)\n  return r\n}\n\n// x = x/R mod m (HAC 14.32)\nfunction montReduce(x) {\n  while (x.t <= this.mt2) // pad x so am has enough room later\n    x[x.t++] = 0\n  for (var i = 0; i < this.m.t; ++i) {\n    // faster way of calculating u0 = x[i]*mp mod DV\n    var j = x[i] & 0x7fff\n    var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM\n    // use am to combine the multiply-shift-add into one call\n    j = i + this.m.t\n    x[j] += this.m.am(0, u0, x, i, 0, this.m.t)\n    // propagate carry\n    while (x[j] >= x.DV) {\n      x[j] -= x.DV\n      x[++j]++\n    }\n  }\n  x.clamp()\n  x.drShiftTo(this.m.t, x)\n  if (x.compareTo(this.m) >= 0) x.subTo(this.m, x)\n}\n\n// r = \"x^2/R mod m\"; x != r\nfunction montSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\n// r = \"xy/R mod m\"; x,y != r\nfunction montMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nMontgomery.prototype.convert = montConvert\nMontgomery.prototype.revert = montRevert\nMontgomery.prototype.reduce = montReduce\nMontgomery.prototype.mulTo = montMulTo\nMontgomery.prototype.sqrTo = montSqrTo\n\n// (protected) true iff this is even\nfunction bnpIsEven() {\n  return ((this.t > 0) ? (this[0] & 1) : this.s) == 0\n}\n\n// (protected) this^e, e < 2^32, doing sqr and mul with \"r\" (HAC 14.79)\nfunction bnpExp(e, z) {\n  if (e > 0xffffffff || e < 1) return BigInteger.ONE\n  var r = new BigInteger(),\n    r2 = new BigInteger(),\n    g = z.convert(this),\n    i = nbits(e) - 1\n  g.copyTo(r)\n  while (--i >= 0) {\n    z.sqrTo(r, r2)\n    if ((e & (1 << i)) > 0) z.mulTo(r2, g, r)\n    else {\n      var t = r\n      r = r2\n      r2 = t\n    }\n  }\n  return z.revert(r)\n}\n\n// (public) this^e % m, 0 <= e < 2^32\nfunction bnModPowInt(e, m) {\n  var z\n  if (e < 256 || m.isEven()) z = new Classic(m)\n  else z = new Montgomery(m)\n  return this.exp(e, z)\n}\n\n// protected\nproto.copyTo = bnpCopyTo\nproto.fromInt = bnpFromInt\nproto.fromString = bnpFromString\nproto.clamp = bnpClamp\nproto.dlShiftTo = bnpDLShiftTo\nproto.drShiftTo = bnpDRShiftTo\nproto.lShiftTo = bnpLShiftTo\nproto.rShiftTo = bnpRShiftTo\nproto.subTo = bnpSubTo\nproto.multiplyTo = bnpMultiplyTo\nproto.squareTo = bnpSquareTo\nproto.divRemTo = bnpDivRemTo\nproto.invDigit = bnpInvDigit\nproto.isEven = bnpIsEven\nproto.exp = bnpExp\n\n// public\nproto.toString = bnToString\nproto.negate = bnNegate\nproto.abs = bnAbs\nproto.compareTo = bnCompareTo\nproto.bitLength = bnBitLength\nproto.byteLength = bnByteLength\nproto.mod = bnMod\nproto.modPowInt = bnModPowInt\n\n// (public)\nfunction bnClone() {\n  var r = new BigInteger()\n  this.copyTo(r)\n  return r\n}\n\n// (public) return value as integer\nfunction bnIntValue() {\n  if (this.s < 0) {\n    if (this.t == 1) return this[0] - this.DV\n    else if (this.t == 0) return -1\n  } else if (this.t == 1) return this[0]\n  else if (this.t == 0) return 0\n  // assumes 16 < DB < 32\n  return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]\n}\n\n// (public) return value as byte\nfunction bnByteValue() {\n  return (this.t == 0) ? this.s : (this[0] << 24) >> 24\n}\n\n// (public) return value as short (assumes DB>=16)\nfunction bnShortValue() {\n  return (this.t == 0) ? this.s : (this[0] << 16) >> 16\n}\n\n// (protected) return x s.t. r^x < DV\nfunction bnpChunkSize(r) {\n  return Math.floor(Math.LN2 * this.DB / Math.log(r))\n}\n\n// (public) 0 if this == 0, 1 if this > 0\nfunction bnSigNum() {\n  if (this.s < 0) return -1\n  else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0\n  else return 1\n}\n\n// (protected) convert to radix string\nfunction bnpToRadix(b) {\n  if (b == null) b = 10\n  if (this.signum() == 0 || b < 2 || b > 36) return \"0\"\n  var cs = this.chunkSize(b)\n  var a = Math.pow(b, cs)\n  var d = nbv(a),\n    y = new BigInteger(),\n    z = new BigInteger(),\n    r = \"\"\n  this.divRemTo(d, y, z)\n  while (y.signum() > 0) {\n    r = (a + z.intValue())\n      .toString(b)\n      .substr(1) + r\n    y.divRemTo(d, y, z)\n  }\n  return z.intValue()\n    .toString(b) + r\n}\n\n// (protected) convert from radix string\nfunction bnpFromRadix(s, b) {\n  var self = this\n  self.fromInt(0)\n  if (b == null) b = 10\n  var cs = self.chunkSize(b)\n  var d = Math.pow(b, cs),\n    mi = false,\n    j = 0,\n    w = 0\n  for (var i = 0; i < s.length; ++i) {\n    var x = intAt(s, i)\n    if (x < 0) {\n      if (s.charAt(i) == \"-\" && self.signum() == 0) mi = true\n      continue\n    }\n    w = b * w + x\n    if (++j >= cs) {\n      self.dMultiply(d)\n      self.dAddOffset(w, 0)\n      j = 0\n      w = 0\n    }\n  }\n  if (j > 0) {\n    self.dMultiply(Math.pow(b, j))\n    self.dAddOffset(w, 0)\n  }\n  if (mi) BigInteger.ZERO.subTo(self, self)\n}\n\n// (protected) alternate constructor\nfunction bnpFromNumber(a, b, c) {\n  var self = this\n  if (\"number\" == typeof b) {\n    // new BigInteger(int,int,RNG)\n    if (a < 2) self.fromInt(1)\n    else {\n      self.fromNumber(a, c)\n      if (!self.testBit(a - 1)) // force MSB set\n        self.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, self)\n      if (self.isEven()) self.dAddOffset(1, 0); // force odd\n      while (!self.isProbablePrime(b)) {\n        self.dAddOffset(2, 0)\n        if (self.bitLength() > a) self.subTo(BigInteger.ONE.shiftLeft(a - 1), self)\n      }\n    }\n  } else {\n    // new BigInteger(int,RNG)\n    var x = new Array(),\n      t = a & 7\n    x.length = (a >> 3) + 1\n    b.nextBytes(x)\n    if (t > 0) x[0] &= ((1 << t) - 1)\n    else x[0] = 0\n    self.fromString(x, 256)\n  }\n}\n\n// (public) convert to bigendian byte array\nfunction bnToByteArray() {\n  var self = this\n  var i = self.t,\n    r = new Array()\n  r[0] = self.s\n  var p = self.DB - (i * self.DB) % 8,\n    d, k = 0\n  if (i-- > 0) {\n    if (p < self.DB && (d = self[i] >> p) != (self.s & self.DM) >> p)\n      r[k++] = d | (self.s << (self.DB - p))\n    while (i >= 0) {\n      if (p < 8) {\n        d = (self[i] & ((1 << p) - 1)) << (8 - p)\n        d |= self[--i] >> (p += self.DB - 8)\n      } else {\n        d = (self[i] >> (p -= 8)) & 0xff\n        if (p <= 0) {\n          p += self.DB\n          --i\n        }\n      }\n      if ((d & 0x80) != 0) d |= -256\n      if (k === 0 && (self.s & 0x80) != (d & 0x80))++k\n      if (k > 0 || d != self.s) r[k++] = d\n    }\n  }\n  return r\n}\n\nfunction bnEquals(a) {\n  return (this.compareTo(a) == 0)\n}\n\nfunction bnMin(a) {\n  return (this.compareTo(a) < 0) ? this : a\n}\n\nfunction bnMax(a) {\n  return (this.compareTo(a) > 0) ? this : a\n}\n\n// (protected) r = this op a (bitwise)\nfunction bnpBitwiseTo(a, op, r) {\n  var self = this\n  var i, f, m = Math.min(a.t, self.t)\n  for (i = 0; i < m; ++i) r[i] = op(self[i], a[i])\n  if (a.t < self.t) {\n    f = a.s & self.DM\n    for (i = m; i < self.t; ++i) r[i] = op(self[i], f)\n    r.t = self.t\n  } else {\n    f = self.s & self.DM\n    for (i = m; i < a.t; ++i) r[i] = op(f, a[i])\n    r.t = a.t\n  }\n  r.s = op(self.s, a.s)\n  r.clamp()\n}\n\n// (public) this & a\nfunction op_and(x, y) {\n  return x & y\n}\n\nfunction bnAnd(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_and, r)\n  return r\n}\n\n// (public) this | a\nfunction op_or(x, y) {\n  return x | y\n}\n\nfunction bnOr(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_or, r)\n  return r\n}\n\n// (public) this ^ a\nfunction op_xor(x, y) {\n  return x ^ y\n}\n\nfunction bnXor(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_xor, r)\n  return r\n}\n\n// (public) this & ~a\nfunction op_andnot(x, y) {\n  return x & ~y\n}\n\nfunction bnAndNot(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_andnot, r)\n  return r\n}\n\n// (public) ~this\nfunction bnNot() {\n  var r = new BigInteger()\n  for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i]\n  r.t = this.t\n  r.s = ~this.s\n  return r\n}\n\n// (public) this << n\nfunction bnShiftLeft(n) {\n  var r = new BigInteger()\n  if (n < 0) this.rShiftTo(-n, r)\n  else this.lShiftTo(n, r)\n  return r\n}\n\n// (public) this >> n\nfunction bnShiftRight(n) {\n  var r = new BigInteger()\n  if (n < 0) this.lShiftTo(-n, r)\n  else this.rShiftTo(n, r)\n  return r\n}\n\n// return index of lowest 1-bit in x, x < 2^31\nfunction lbit(x) {\n  if (x == 0) return -1\n  var r = 0\n  if ((x & 0xffff) == 0) {\n    x >>= 16\n    r += 16\n  }\n  if ((x & 0xff) == 0) {\n    x >>= 8\n    r += 8\n  }\n  if ((x & 0xf) == 0) {\n    x >>= 4\n    r += 4\n  }\n  if ((x & 3) == 0) {\n    x >>= 2\n    r += 2\n  }\n  if ((x & 1) == 0)++r\n  return r\n}\n\n// (public) returns index of lowest 1-bit (or -1 if none)\nfunction bnGetLowestSetBit() {\n  for (var i = 0; i < this.t; ++i)\n    if (this[i] != 0) return i * this.DB + lbit(this[i])\n  if (this.s < 0) return this.t * this.DB\n  return -1\n}\n\n// return number of 1 bits in x\nfunction cbit(x) {\n  var r = 0\n  while (x != 0) {\n    x &= x - 1\n    ++r\n  }\n  return r\n}\n\n// (public) return number of set bits\nfunction bnBitCount() {\n  var r = 0,\n    x = this.s & this.DM\n  for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x)\n  return r\n}\n\n// (public) true iff nth bit is set\nfunction bnTestBit(n) {\n  var j = Math.floor(n / this.DB)\n  if (j >= this.t) return (this.s != 0)\n  return ((this[j] & (1 << (n % this.DB))) != 0)\n}\n\n// (protected) this op (1<<n)\nfunction bnpChangeBit(n, op) {\n  var r = BigInteger.ONE.shiftLeft(n)\n  this.bitwiseTo(r, op, r)\n  return r\n}\n\n// (public) this | (1<<n)\nfunction bnSetBit(n) {\n  return this.changeBit(n, op_or)\n}\n\n// (public) this & ~(1<<n)\nfunction bnClearBit(n) {\n  return this.changeBit(n, op_andnot)\n}\n\n// (public) this ^ (1<<n)\nfunction bnFlipBit(n) {\n  return this.changeBit(n, op_xor)\n}\n\n// (protected) r = this + a\nfunction bnpAddTo(a, r) {\n  var self = this\n\n  var i = 0,\n    c = 0,\n    m = Math.min(a.t, self.t)\n  while (i < m) {\n    c += self[i] + a[i]\n    r[i++] = c & self.DM\n    c >>= self.DB\n  }\n  if (a.t < self.t) {\n    c += a.s\n    while (i < self.t) {\n      c += self[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += self.s\n  } else {\n    c += self.s\n    while (i < a.t) {\n      c += a[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += a.s\n  }\n  r.s = (c < 0) ? -1 : 0\n  if (c > 0) r[i++] = c\n  else if (c < -1) r[i++] = self.DV + c\n  r.t = i\n  r.clamp()\n}\n\n// (public) this + a\nfunction bnAdd(a) {\n  var r = new BigInteger()\n  this.addTo(a, r)\n  return r\n}\n\n// (public) this - a\nfunction bnSubtract(a) {\n  var r = new BigInteger()\n  this.subTo(a, r)\n  return r\n}\n\n// (public) this * a\nfunction bnMultiply(a) {\n  var r = new BigInteger()\n  this.multiplyTo(a, r)\n  return r\n}\n\n// (public) this^2\nfunction bnSquare() {\n  var r = new BigInteger()\n  this.squareTo(r)\n  return r\n}\n\n// (public) this / a\nfunction bnDivide(a) {\n  var r = new BigInteger()\n  this.divRemTo(a, r, null)\n  return r\n}\n\n// (public) this % a\nfunction bnRemainder(a) {\n  var r = new BigInteger()\n  this.divRemTo(a, null, r)\n  return r\n}\n\n// (public) [this/a,this%a]\nfunction bnDivideAndRemainder(a) {\n  var q = new BigInteger(),\n    r = new BigInteger()\n  this.divRemTo(a, q, r)\n  return new Array(q, r)\n}\n\n// (protected) this *= n, this >= 0, 1 < n < DV\nfunction bnpDMultiply(n) {\n  this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)\n  ++this.t\n  this.clamp()\n}\n\n// (protected) this += n << w words, this >= 0\nfunction bnpDAddOffset(n, w) {\n  if (n == 0) return\n  while (this.t <= w) this[this.t++] = 0\n  this[w] += n\n  while (this[w] >= this.DV) {\n    this[w] -= this.DV\n    if (++w >= this.t) this[this.t++] = 0\n    ++this[w]\n  }\n}\n\n// A \"null\" reducer\nfunction NullExp() {}\n\nfunction nNop(x) {\n  return x\n}\n\nfunction nMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n}\n\nfunction nSqrTo(x, r) {\n  x.squareTo(r)\n}\n\nNullExp.prototype.convert = nNop\nNullExp.prototype.revert = nNop\nNullExp.prototype.mulTo = nMulTo\nNullExp.prototype.sqrTo = nSqrTo\n\n// (public) this^e\nfunction bnPow(e) {\n  return this.exp(e, new NullExp())\n}\n\n// (protected) r = lower n words of \"this * a\", a.t <= n\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyLowerTo(a, n, r) {\n  var i = Math.min(this.t + a.t, n)\n  r.s = 0; // assumes a,this >= 0\n  r.t = i\n  while (i > 0) r[--i] = 0\n  var j\n  for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t)\n  for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i)\n  r.clamp()\n}\n\n// (protected) r = \"this * a\" without lower n words, n > 0\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyUpperTo(a, n, r) {\n  --n\n  var i = r.t = this.t + a.t - n\n  r.s = 0; // assumes a,this >= 0\n  while (--i >= 0) r[i] = 0\n  for (i = Math.max(n - this.t, 0); i < a.t; ++i)\n    r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n)\n  r.clamp()\n  r.drShiftTo(1, r)\n}\n\n// Barrett modular reduction\nfunction Barrett(m) {\n  // setup Barrett\n  this.r2 = new BigInteger()\n  this.q3 = new BigInteger()\n  BigInteger.ONE.dlShiftTo(2 * m.t, this.r2)\n  this.mu = this.r2.divide(m)\n  this.m = m\n}\n\nfunction barrettConvert(x) {\n  if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m)\n  else if (x.compareTo(this.m) < 0) return x\n  else {\n    var r = new BigInteger()\n    x.copyTo(r)\n    this.reduce(r)\n    return r\n  }\n}\n\nfunction barrettRevert(x) {\n  return x\n}\n\n// x = x mod m (HAC 14.42)\nfunction barrettReduce(x) {\n  var self = this\n  x.drShiftTo(self.m.t - 1, self.r2)\n  if (x.t > self.m.t + 1) {\n    x.t = self.m.t + 1\n    x.clamp()\n  }\n  self.mu.multiplyUpperTo(self.r2, self.m.t + 1, self.q3)\n  self.m.multiplyLowerTo(self.q3, self.m.t + 1, self.r2)\n  while (x.compareTo(self.r2) < 0) x.dAddOffset(1, self.m.t + 1)\n  x.subTo(self.r2, x)\n  while (x.compareTo(self.m) >= 0) x.subTo(self.m, x)\n}\n\n// r = x^2 mod m; x != r\nfunction barrettSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\n// r = x*y mod m; x,y != r\nfunction barrettMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nBarrett.prototype.convert = barrettConvert\nBarrett.prototype.revert = barrettRevert\nBarrett.prototype.reduce = barrettReduce\nBarrett.prototype.mulTo = barrettMulTo\nBarrett.prototype.sqrTo = barrettSqrTo\n\n// (public) this^e % m (HAC 14.85)\nfunction bnModPow(e, m) {\n  var i = e.bitLength(),\n    k, r = nbv(1),\n    z\n  if (i <= 0) return r\n  else if (i < 18) k = 1\n  else if (i < 48) k = 3\n  else if (i < 144) k = 4\n  else if (i < 768) k = 5\n  else k = 6\n  if (i < 8)\n    z = new Classic(m)\n  else if (m.isEven())\n    z = new Barrett(m)\n  else\n    z = new Montgomery(m)\n\n  // precomputation\n  var g = new Array(),\n    n = 3,\n    k1 = k - 1,\n    km = (1 << k) - 1\n  g[1] = z.convert(this)\n  if (k > 1) {\n    var g2 = new BigInteger()\n    z.sqrTo(g[1], g2)\n    while (n <= km) {\n      g[n] = new BigInteger()\n      z.mulTo(g2, g[n - 2], g[n])\n      n += 2\n    }\n  }\n\n  var j = e.t - 1,\n    w, is1 = true,\n    r2 = new BigInteger(),\n    t\n  i = nbits(e[j]) - 1\n  while (j >= 0) {\n    if (i >= k1) w = (e[j] >> (i - k1)) & km\n    else {\n      w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)\n      if (j > 0) w |= e[j - 1] >> (this.DB + i - k1)\n    }\n\n    n = k\n    while ((w & 1) == 0) {\n      w >>= 1\n      --n\n    }\n    if ((i -= n) < 0) {\n      i += this.DB\n      --j\n    }\n    if (is1) { // ret == 1, don't bother squaring or multiplying it\n      g[w].copyTo(r)\n      is1 = false\n    } else {\n      while (n > 1) {\n        z.sqrTo(r, r2)\n        z.sqrTo(r2, r)\n        n -= 2\n      }\n      if (n > 0) z.sqrTo(r, r2)\n      else {\n        t = r\n        r = r2\n        r2 = t\n      }\n      z.mulTo(r2, g[w], r)\n    }\n\n    while (j >= 0 && (e[j] & (1 << i)) == 0) {\n      z.sqrTo(r, r2)\n      t = r\n      r = r2\n      r2 = t\n      if (--i < 0) {\n        i = this.DB - 1\n        --j\n      }\n    }\n  }\n  return z.revert(r)\n}\n\n// (public) gcd(this,a) (HAC 14.54)\nfunction bnGCD(a) {\n  var x = (this.s < 0) ? this.negate() : this.clone()\n  var y = (a.s < 0) ? a.negate() : a.clone()\n  if (x.compareTo(y) < 0) {\n    var t = x\n    x = y\n    y = t\n  }\n  var i = x.getLowestSetBit(),\n    g = y.getLowestSetBit()\n  if (g < 0) return x\n  if (i < g) g = i\n  if (g > 0) {\n    x.rShiftTo(g, x)\n    y.rShiftTo(g, y)\n  }\n  while (x.signum() > 0) {\n    if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x)\n    if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y)\n    if (x.compareTo(y) >= 0) {\n      x.subTo(y, x)\n      x.rShiftTo(1, x)\n    } else {\n      y.subTo(x, y)\n      y.rShiftTo(1, y)\n    }\n  }\n  if (g > 0) y.lShiftTo(g, y)\n  return y\n}\n\n// (protected) this % n, n < 2^26\nfunction bnpModInt(n) {\n  if (n <= 0) return 0\n  var d = this.DV % n,\n    r = (this.s < 0) ? n - 1 : 0\n  if (this.t > 0)\n    if (d == 0) r = this[0] % n\n    else\n      for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n\n  return r\n}\n\n// (public) 1/this % m (HAC 14.61)\nfunction bnModInverse(m) {\n  var ac = m.isEven()\n  if (this.signum() === 0) throw new Error('division by zero')\n  if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO\n  var u = m.clone(),\n    v = this.clone()\n  var a = nbv(1),\n    b = nbv(0),\n    c = nbv(0),\n    d = nbv(1)\n  while (u.signum() != 0) {\n    while (u.isEven()) {\n      u.rShiftTo(1, u)\n      if (ac) {\n        if (!a.isEven() || !b.isEven()) {\n          a.addTo(this, a)\n          b.subTo(m, b)\n        }\n        a.rShiftTo(1, a)\n      } else if (!b.isEven()) b.subTo(m, b)\n      b.rShiftTo(1, b)\n    }\n    while (v.isEven()) {\n      v.rShiftTo(1, v)\n      if (ac) {\n        if (!c.isEven() || !d.isEven()) {\n          c.addTo(this, c)\n          d.subTo(m, d)\n        }\n        c.rShiftTo(1, c)\n      } else if (!d.isEven()) d.subTo(m, d)\n      d.rShiftTo(1, d)\n    }\n    if (u.compareTo(v) >= 0) {\n      u.subTo(v, u)\n      if (ac) a.subTo(c, a)\n      b.subTo(d, b)\n    } else {\n      v.subTo(u, v)\n      if (ac) c.subTo(a, c)\n      d.subTo(b, d)\n    }\n  }\n  if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO\n  while (d.compareTo(m) >= 0) d.subTo(m, d)\n  while (d.signum() < 0) d.addTo(m, d)\n  return d\n}\n\nvar lowprimes = [\n  2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,\n  73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,\n  157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,\n  239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,\n  331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,\n  421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,\n  509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,\n  613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,\n  709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,\n  821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,\n  919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997\n]\n\nvar lplim = (1 << 26) / lowprimes[lowprimes.length - 1]\n\n// (public) test primality with certainty >= 1-.5^t\nfunction bnIsProbablePrime(t) {\n  var i, x = this.abs()\n  if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {\n    for (i = 0; i < lowprimes.length; ++i)\n      if (x[0] == lowprimes[i]) return true\n    return false\n  }\n  if (x.isEven()) return false\n  i = 1\n  while (i < lowprimes.length) {\n    var m = lowprimes[i],\n      j = i + 1\n    while (j < lowprimes.length && m < lplim) m *= lowprimes[j++]\n    m = x.modInt(m)\n    while (i < j) if (m % lowprimes[i++] == 0) return false\n  }\n  return x.millerRabin(t)\n}\n\n// (protected) true if probably prime (HAC 4.24, Miller-Rabin)\nfunction bnpMillerRabin(t) {\n  var n1 = this.subtract(BigInteger.ONE)\n  var k = n1.getLowestSetBit()\n  if (k <= 0) return false\n  var r = n1.shiftRight(k)\n  t = (t + 1) >> 1\n  if (t > lowprimes.length) t = lowprimes.length\n  var a = new BigInteger(null)\n  var j, bases = []\n  for (var i = 0; i < t; ++i) {\n    for (;;) {\n      j = lowprimes[Math.floor(Math.random() * lowprimes.length)]\n      if (bases.indexOf(j) == -1) break\n    }\n    bases.push(j)\n    a.fromInt(j)\n    var y = a.modPow(r, this)\n    if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {\n      var j = 1\n      while (j++ < k && y.compareTo(n1) != 0) {\n        y = y.modPowInt(2, this)\n        if (y.compareTo(BigInteger.ONE) == 0) return false\n      }\n      if (y.compareTo(n1) != 0) return false\n    }\n  }\n  return true\n}\n\n// protected\nproto.chunkSize = bnpChunkSize\nproto.toRadix = bnpToRadix\nproto.fromRadix = bnpFromRadix\nproto.fromNumber = bnpFromNumber\nproto.bitwiseTo = bnpBitwiseTo\nproto.changeBit = bnpChangeBit\nproto.addTo = bnpAddTo\nproto.dMultiply = bnpDMultiply\nproto.dAddOffset = bnpDAddOffset\nproto.multiplyLowerTo = bnpMultiplyLowerTo\nproto.multiplyUpperTo = bnpMultiplyUpperTo\nproto.modInt = bnpModInt\nproto.millerRabin = bnpMillerRabin\n\n// public\nproto.clone = bnClone\nproto.intValue = bnIntValue\nproto.byteValue = bnByteValue\nproto.shortValue = bnShortValue\nproto.signum = bnSigNum\nproto.toByteArray = bnToByteArray\nproto.equals = bnEquals\nproto.min = bnMin\nproto.max = bnMax\nproto.and = bnAnd\nproto.or = bnOr\nproto.xor = bnXor\nproto.andNot = bnAndNot\nproto.not = bnNot\nproto.shiftLeft = bnShiftLeft\nproto.shiftRight = bnShiftRight\nproto.getLowestSetBit = bnGetLowestSetBit\nproto.bitCount = bnBitCount\nproto.testBit = bnTestBit\nproto.setBit = bnSetBit\nproto.clearBit = bnClearBit\nproto.flipBit = bnFlipBit\nproto.add = bnAdd\nproto.subtract = bnSubtract\nproto.multiply = bnMultiply\nproto.divide = bnDivide\nproto.remainder = bnRemainder\nproto.divideAndRemainder = bnDivideAndRemainder\nproto.modPow = bnModPow\nproto.modInverse = bnModInverse\nproto.pow = bnPow\nproto.gcd = bnGCD\nproto.isProbablePrime = bnIsProbablePrime\n\n// JSBN-specific extension\nproto.square = bnSquare\n\n// constants\nBigInteger.ZERO = nbv(0)\nBigInteger.ONE = nbv(1)\nBigInteger.valueOf = nbv\n\nmodule.exports = BigInteger\n","// FIXME: Kind of a weird way to throw exceptions, consider removing\nvar assert = require('assert')\nvar BigInteger = require('./bigi')\n\n/**\n * Turns a byte array into a big integer.\n *\n * This function will interpret a byte array as a big integer in big\n * endian notation.\n */\nBigInteger.fromByteArrayUnsigned = function(byteArray) {\n  // BigInteger expects a DER integer conformant byte array\n  if (byteArray[0] & 0x80) {\n    return new BigInteger([0].concat(byteArray))\n  }\n\n  return new BigInteger(byteArray)\n}\n\n/**\n * Returns a byte array representation of the big integer.\n *\n * This returns the absolute of the contained value in big endian\n * form. A value of zero results in an empty array.\n */\nBigInteger.prototype.toByteArrayUnsigned = function() {\n  var byteArray = this.toByteArray()\n  return byteArray[0] === 0 ? byteArray.slice(1) : byteArray\n}\n\nBigInteger.fromDERInteger = function(byteArray) {\n  return new BigInteger(byteArray)\n}\n\n/*\n * Converts BigInteger to a DER integer representation.\n *\n * The format for this value uses the most significant bit as a sign\n * bit.  If the most significant bit is already set and the integer is\n * positive, a 0x00 is prepended.\n *\n * Examples:\n *\n *      0 =>     0x00\n *      1 =>     0x01\n *     -1 =>     0xff\n *    127 =>     0x7f\n *   -127 =>     0x81\n *    128 =>   0x0080\n *   -128 =>     0x80\n *    255 =>   0x00ff\n *   -255 =>   0xff01\n *  16300 =>   0x3fac\n * -16300 =>   0xc054\n *  62300 => 0x00f35c\n * -62300 => 0xff0ca4\n*/\nBigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray\n\nBigInteger.fromBuffer = function(buffer) {\n  // BigInteger expects a DER integer conformant byte array\n  if (buffer[0] & 0x80) {\n    var byteArray = Array.prototype.slice.call(buffer)\n\n    return new BigInteger([0].concat(byteArray))\n  }\n\n  return new BigInteger(buffer)\n}\n\nBigInteger.fromHex = function(hex) {\n  if (hex === '') return BigInteger.ZERO\n\n  assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')\n  assert.equal(hex.length % 2, 0, 'Incomplete hex')\n  return new BigInteger(hex, 16)\n}\n\nBigInteger.prototype.toBuffer = function(size) {\n  var byteArray = this.toByteArrayUnsigned()\n  var zeros = []\n\n  var padding = size - byteArray.length\n  while (zeros.length < padding) zeros.push(0)\n\n  return new Buffer(zeros.concat(byteArray))\n}\n\nBigInteger.prototype.toHex = function(size) {\n  return this.toBuffer(size).toString('hex')\n}\n","var BigInteger = require(30)\n\n//addons\nrequire(31)\n\nmodule.exports = BigInteger","module.exports={\n  \"bugs\": {\n    \"url\": \"https://github.com/cryptocoinjs/bigi/issues\"\n  },\n  \"bundleDependencies\": false,\n  \"dependencies\": {},\n  \"deprecated\": false,\n  \"description\": \"Big integers.\",\n  \"devDependencies\": {\n    \"coveralls\": \"^2.11.2\",\n    \"istanbul\": \"^0.3.5\",\n    \"jshint\": \"^2.5.1\",\n    \"mocha\": \"^2.1.0\",\n    \"mochify\": \"^2.1.0\"\n  },\n  \"homepage\": \"https://github.com/cryptocoinjs/bigi#readme\",\n  \"keywords\": [\n    \"cryptography\",\n    \"math\",\n    \"bitcoin\",\n    \"arbitrary\",\n    \"precision\",\n    \"arithmetic\",\n    \"big\",\n    \"integer\",\n    \"int\",\n    \"number\",\n    \"biginteger\",\n    \"bigint\",\n    \"bignumber\",\n    \"decimal\",\n    \"float\"\n  ],\n  \"main\": \"./lib/index.js\",\n  \"name\": \"bigi\",\n  \"repository\": {\n    \"url\": \"git+https://github.com/cryptocoinjs/bigi.git\",\n    \"type\": \"git\"\n  },\n  \"scripts\": {\n    \"browser-test\": \"mochify --wd -R spec\",\n    \"coverage\": \"istanbul cover ./node_modules/.bin/_mocha -- --reporter list test/*.js\",\n    \"coveralls\": \"npm run-script coverage && node ./node_modules/.bin/coveralls < coverage/lcov.info\",\n    \"jshint\": \"jshint --config jshint.json lib/*.js ; true\",\n    \"test\": \"_mocha -- test/*.js\",\n    \"unit\": \"mocha\"\n  },\n  \"testling\": {\n    \"files\": \"test/*.js\",\n    \"harness\": \"mocha\",\n    \"browsers\": [\n      \"ie/9..latest\",\n      \"firefox/latest\",\n      \"chrome/latest\",\n      \"safari/6.0..latest\",\n      \"iphone/6.0..latest\",\n      \"android-browser/4.2..latest\"\n    ]\n  },\n  \"version\": \"1.4.2\"\n}","","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar Buffer = require(35).Buffer;\n\nvar isBufferEncoding = Buffer.isEncoding\n  || function(encoding) {\n       switch (encoding && encoding.toLowerCase()) {\n         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;\n         default: return false;\n       }\n     }\n\n\nfunction assertEncoding(encoding) {\n  if (encoding && !isBufferEncoding(encoding)) {\n    throw new Error('Unknown encoding: ' + encoding);\n  }\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters. CESU-8 is handled as part of the UTF-8 encoding.\n//\n// @TODO Handling all encodings inside a single object makes it very difficult\n// to reason about this code, so it should be split up in the future.\n// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code\n// points as used by CESU-8.\nvar StringDecoder = exports.StringDecoder = function(encoding) {\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\n  assertEncoding(encoding);\n  switch (this.encoding) {\n    case 'utf8':\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\n      this.surrogateSize = 3;\n      break;\n    case 'ucs2':\n    case 'utf16le':\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\n      this.surrogateSize = 2;\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\n      break;\n    case 'base64':\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\n      this.surrogateSize = 3;\n      this.detectIncompleteChar = base64DetectIncompleteChar;\n      break;\n    default:\n      this.write = passThroughWrite;\n      return;\n  }\n\n  // Enough space to store all bytes of a single character. UTF-8 needs 4\n  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).\n  this.charBuffer = new Buffer(6);\n  // Number of bytes received for the current incomplete multi-byte character.\n  this.charReceived = 0;\n  // Number of bytes expected for the current incomplete multi-byte character.\n  this.charLength = 0;\n};\n\n\n// write decodes the given buffer and returns it as JS string that is\n// guaranteed to not contain any partial multi-byte characters. Any partial\n// character found at the end of the buffer is buffered up, and will be\n// returned when calling write again with the remaining bytes.\n//\n// Note: Converting a Buffer containing an orphan surrogate to a String\n// currently works, but converting a String to a Buffer (via `new Buffer`, or\n// Buffer#write) will replace incomplete surrogates with the unicode\n// replacement character. See https://codereview.chromium.org/121173009/ .\nStringDecoder.prototype.write = function(buffer) {\n  var charStr = '';\n  // if our last write ended with an incomplete multibyte character\n  while (this.charLength) {\n    // determine how many remaining bytes this buffer has to offer for this char\n    var available = (buffer.length >= this.charLength - this.charReceived) ?\n        this.charLength - this.charReceived :\n        buffer.length;\n\n    // add the new bytes to the char buffer\n    buffer.copy(this.charBuffer, this.charReceived, 0, available);\n    this.charReceived += available;\n\n    if (this.charReceived < this.charLength) {\n      // still not enough chars in this buffer? wait for more ...\n      return '';\n    }\n\n    // remove bytes belonging to the current character from the buffer\n    buffer = buffer.slice(available, buffer.length);\n\n    // get the character that was split\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\n\n    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n    var charCode = charStr.charCodeAt(charStr.length - 1);\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n      this.charLength += this.surrogateSize;\n      charStr = '';\n      continue;\n    }\n    this.charReceived = this.charLength = 0;\n\n    // if there are no more bytes in this buffer, just emit our char\n    if (buffer.length === 0) {\n      return charStr;\n    }\n    break;\n  }\n\n  // determine and set charLength / charReceived\n  this.detectIncompleteChar(buffer);\n\n  var end = buffer.length;\n  if (this.charLength) {\n    // buffer the incomplete character bytes we got\n    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);\n    end -= this.charReceived;\n  }\n\n  charStr += buffer.toString(this.encoding, 0, end);\n\n  var end = charStr.length - 1;\n  var charCode = charStr.charCodeAt(end);\n  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n    var size = this.surrogateSize;\n    this.charLength += size;\n    this.charReceived += size;\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\n    buffer.copy(this.charBuffer, 0, 0, size);\n    return charStr.substring(0, end);\n  }\n\n  // or just emit the charStr\n  return charStr;\n};\n\n// detectIncompleteChar determines if there is an incomplete UTF-8 character at\n// the end of the given buffer. If so, it sets this.charLength to the byte\n// length that character, and sets this.charReceived to the number of bytes\n// that are available for this character.\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\n  // determine how many bytes we have to check at the end of this buffer\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\n\n  // Figure out if one of the last i bytes of our buffer announces an\n  // incomplete char.\n  for (; i > 0; i--) {\n    var c = buffer[buffer.length - i];\n\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\n\n    // 110XXXXX\n    if (i == 1 && c >> 5 == 0x06) {\n      this.charLength = 2;\n      break;\n    }\n\n    // 1110XXXX\n    if (i <= 2 && c >> 4 == 0x0E) {\n      this.charLength = 3;\n      break;\n    }\n\n    // 11110XXX\n    if (i <= 3 && c >> 3 == 0x1E) {\n      this.charLength = 4;\n      break;\n    }\n  }\n  this.charReceived = i;\n};\n\nStringDecoder.prototype.end = function(buffer) {\n  var res = '';\n  if (buffer && buffer.length)\n    res = this.write(buffer);\n\n  if (this.charReceived) {\n    var cr = this.charReceived;\n    var buf = this.charBuffer;\n    var enc = this.encoding;\n    res += buf.slice(0, cr).toString(enc);\n  }\n\n  return res;\n};\n\nfunction passThroughWrite(buffer) {\n  return buffer.toString(this.encoding);\n}\n\nfunction utf16DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 2;\n  this.charLength = this.charReceived ? 2 : 0;\n}\n\nfunction base64DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 3;\n  this.charLength = this.charReceived ? 3 : 0;\n}\n","var basex = require(28)\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","/*\r\n Copyright 2013-2014 Daniel Wirtz <dcode@dcode.io>\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license bytebuffer.js (c) 2015 Daniel Wirtz <dcode@dcode.io>\r\n * Backing buffer: ArrayBuffer, Accessor: Uint8Array\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/bytebuffer.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([\"long\"], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module['exports'] = (function() {\r\n            var Long; try { Long = require(68); } catch (e) {}\r\n            return factory(Long);\r\n        })();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"ByteBuffer\"] = factory(global[\"dcodeIO\"][\"Long\"]);\r\n\r\n})(this, function(Long) {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a new ByteBuffer.\r\n     * @class The swiss army knife for binary data in JavaScript.\r\n     * @exports ByteBuffer\r\n     * @constructor\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @expose\r\n     */\r\n    var ByteBuffer = function(capacity, littleEndian, noAssert) {\r\n        if (typeof capacity === 'undefined')\r\n            capacity = ByteBuffer.DEFAULT_CAPACITY;\r\n        if (typeof littleEndian === 'undefined')\r\n            littleEndian = ByteBuffer.DEFAULT_ENDIAN;\r\n        if (typeof noAssert === 'undefined')\r\n            noAssert = ByteBuffer.DEFAULT_NOASSERT;\r\n        if (!noAssert) {\r\n            capacity = capacity | 0;\r\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity\");\r\n            littleEndian = !!littleEndian;\r\n            noAssert = !!noAssert;\r\n        }\r\n\r\n        /**\r\n         * Backing ArrayBuffer.\r\n         * @type {!ArrayBuffer}\r\n         * @expose\r\n         */\r\n        this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);\r\n\r\n        /**\r\n         * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.\r\n         * @type {?Uint8Array}\r\n         * @expose\r\n         */\r\n        this.view = capacity === 0 ? null : new Uint8Array(this.buffer);\r\n\r\n        /**\r\n         * Absolute read/write offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.offset = 0;\r\n\r\n        /**\r\n         * Marked offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#mark\r\n         * @see ByteBuffer#reset\r\n         */\r\n        this.markedOffset = -1;\r\n\r\n        /**\r\n         * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.limit = capacity;\r\n\r\n        /**\r\n         * Whether to use little endian byte order, defaults to `false` for big endian.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.littleEndian = littleEndian;\r\n\r\n        /**\r\n         * Whether to skip assertions of offsets and values, defaults to `false`.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.noAssert = noAssert;\r\n    };\r\n\r\n    /**\r\n     * ByteBuffer version.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.VERSION = \"5.0.1\";\r\n\r\n    /**\r\n     * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.LITTLE_ENDIAN = true;\r\n\r\n    /**\r\n     * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.BIG_ENDIAN = false;\r\n\r\n    /**\r\n     * Default initial capacity of `16`.\r\n     * @type {number}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_CAPACITY = 16;\r\n\r\n    /**\r\n     * Default endianess of `false` for big endian.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;\r\n\r\n    /**\r\n     * Default no assertions flag of `false`.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_NOASSERT = false;\r\n\r\n    /**\r\n     * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded\r\n     *  and int64 support is not available.\r\n     * @type {?Long}\r\n     * @const\r\n     * @see https://github.com/dcodeIO/long.js\r\n     * @expose\r\n     */\r\n    ByteBuffer.Long = Long || null;\r\n\r\n    /**\r\n     * @alias ByteBuffer.prototype\r\n     * @inner\r\n     */\r\n    var ByteBufferPrototype = ByteBuffer.prototype;\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a ByteBuffer or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     * @private\r\n     */\r\n    ByteBufferPrototype.__isByteBuffer__;\r\n\r\n    Object.defineProperty(ByteBufferPrototype, \"__isByteBuffer__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    // helpers\r\n\r\n    /**\r\n     * @type {!ArrayBuffer}\r\n     * @inner\r\n     */\r\n    var EMPTY_BUFFER = new ArrayBuffer(0);\r\n\r\n    /**\r\n     * String.fromCharCode reference for compile-time renaming.\r\n     * @type {function(...number):string}\r\n     * @inner\r\n     */\r\n    var stringFromCharCode = String.fromCharCode;\r\n\r\n    /**\r\n     * Creates a source function for a string.\r\n     * @param {string} s String to read from\r\n     * @returns {function():number|null} Source function returning the next char code respectively `null` if there are\r\n     *  no more characters left.\r\n     * @throws {TypeError} If the argument is invalid\r\n     * @inner\r\n     */\r\n    function stringSource(s) {\r\n        var i=0; return function() {\r\n            return i < s.length ? s.charCodeAt(i++) : null;\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Creates a destination function for a string.\r\n     * @returns {function(number=):undefined|string} Destination function successively called with the next char code.\r\n     *  Returns the final string when called without arguments.\r\n     * @inner\r\n     */\r\n    function stringDestination() {\r\n        var cs = [], ps = []; return function() {\r\n            if (arguments.length === 0)\r\n                return ps.join('')+stringFromCharCode.apply(String, cs);\r\n            if (cs.length + arguments.length > 1024)\r\n                ps.push(stringFromCharCode.apply(String, cs)),\r\n                    cs.length = 0;\r\n            Array.prototype.push.apply(cs, arguments);\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Gets the accessor type.\r\n     * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.accessor = function() {\r\n        return Uint8Array;\r\n    };\r\n    /**\r\n     * Allocates a new ByteBuffer backed by a buffer of the specified capacity.\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {\r\n        return new ByteBuffer(capacity, littleEndian, noAssert);\r\n    };\r\n\r\n    /**\r\n     * Concatenates multiple ByteBuffers into one.\r\n     * @param {!Array.<!ByteBuffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate\r\n     * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string (\"base64\", \"hex\", \"binary\",\r\n     *  defaults to \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults\r\n     *  to {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} Concatenated ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding === 'boolean' || typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var capacity = 0;\r\n        for (var i=0, k=buffers.length, length; i<k; ++i) {\r\n            if (!ByteBuffer.isByteBuffer(buffers[i]))\r\n                buffers[i] = ByteBuffer.wrap(buffers[i], encoding);\r\n            length = buffers[i].limit - buffers[i].offset;\r\n            if (length > 0) capacity += length;\r\n        }\r\n        if (capacity === 0)\r\n            return new ByteBuffer(0, littleEndian, noAssert);\r\n        var bb = new ByteBuffer(capacity, littleEndian, noAssert),\r\n            bi;\r\n        i=0; while (i<k) {\r\n            bi = buffers[i++];\r\n            length = bi.limit - bi.offset;\r\n            if (length <= 0) continue;\r\n            bb.view.set(bi.view.subarray(bi.offset, bi.limit), bb.offset);\r\n            bb.offset += length;\r\n        }\r\n        bb.limit = bb.offset;\r\n        bb.offset = 0;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Tests if the specified type is a ByteBuffer.\r\n     * @param {*} bb ByteBuffer to test\r\n     * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`\r\n     * @expose\r\n     */\r\n    ByteBuffer.isByteBuffer = function(bb) {\r\n        return (bb && bb[\"__isByteBuffer__\"]) === true;\r\n    };\r\n    /**\r\n     * Gets the backing buffer type.\r\n     * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.type = function() {\r\n        return ArrayBuffer;\r\n    };\r\n    /**\r\n     * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its\r\n     *  {@link ByteBuffer#limit} to the length of the wrapped data.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped\r\n     * @param {(string|boolean)=} encoding String encoding if `buffer` is a string (\"base64\", \"hex\", \"binary\", defaults to\r\n     *  \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`\r\n     * @expose\r\n     */\r\n    ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        if (typeof buffer === 'string') {\r\n            if (typeof encoding === 'undefined')\r\n                encoding = \"utf8\";\r\n            switch (encoding) {\r\n                case \"base64\":\r\n                    return ByteBuffer.fromBase64(buffer, littleEndian);\r\n                case \"hex\":\r\n                    return ByteBuffer.fromHex(buffer, littleEndian);\r\n                case \"binary\":\r\n                    return ByteBuffer.fromBinary(buffer, littleEndian);\r\n                case \"utf8\":\r\n                    return ByteBuffer.fromUTF8(buffer, littleEndian);\r\n                case \"debug\":\r\n                    return ByteBuffer.fromDebug(buffer, littleEndian);\r\n                default:\r\n                    throw Error(\"Unsupported encoding: \"+encoding);\r\n            }\r\n        }\r\n        if (buffer === null || typeof buffer !== 'object')\r\n            throw TypeError(\"Illegal buffer\");\r\n        var bb;\r\n        if (ByteBuffer.isByteBuffer(buffer)) {\r\n            bb = ByteBufferPrototype.clone.call(buffer);\r\n            bb.markedOffset = -1;\r\n            return bb;\r\n        }\r\n        if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER\r\n                bb.buffer = buffer.buffer;\r\n                bb.offset = buffer.byteOffset;\r\n                bb.limit = buffer.byteOffset + buffer.byteLength;\r\n                bb.view = new Uint8Array(buffer.buffer);\r\n            }\r\n        } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.byteLength > 0) {\r\n                bb.buffer = buffer;\r\n                bb.offset = 0;\r\n                bb.limit = buffer.byteLength;\r\n                bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null;\r\n            }\r\n        } else if (Object.prototype.toString.call(buffer) === \"[object Array]\") { // Create from octets\r\n            bb = new ByteBuffer(buffer.length, littleEndian, noAssert);\r\n            bb.limit = buffer.length;\r\n            for (var i=0; i<buffer.length; ++i)\r\n                bb.view[i] = buffer[i];\r\n        } else\r\n            throw TypeError(\"Illegal buffer\"); // Otherwise fail\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Writes the array as a bitset.\r\n     * @param {Array<boolean>} value Array of booleans to write\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBitSet = function(value, offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n      if (!this.noAssert) {\r\n        if (!(value instanceof Array))\r\n          throw TypeError(\"Illegal BitSet: Not an array\");\r\n        if (typeof offset !== 'number' || offset % 1 !== 0)\n            throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n        offset >>>= 0;\n        if (offset < 0 || offset + 0 > this.buffer.byteLength)\n            throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n      }\r\n\r\n      var start = offset,\r\n          bits = value.length,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          k;\r\n\r\n      offset += this.writeVarint32(bits,offset);\r\n\r\n      while(bytes--) {\r\n        k = (!!value[bit++] & 1) |\r\n            ((!!value[bit++] & 1) << 1) |\r\n            ((!!value[bit++] & 1) << 2) |\r\n            ((!!value[bit++] & 1) << 3) |\r\n            ((!!value[bit++] & 1) << 4) |\r\n            ((!!value[bit++] & 1) << 5) |\r\n            ((!!value[bit++] & 1) << 6) |\r\n            ((!!value[bit++] & 1) << 7);\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0; k = 0;\r\n        while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n        return this;\r\n      }\r\n      return offset - start;\r\n    }\r\n\r\n    /**\r\n     * Reads a BitSet as an array of booleans.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {Array<boolean>\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBitSet = function(offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n\r\n      var ret = this.readVarint32(offset),\r\n          bits = ret.value,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          value = [],\r\n          k;\r\n\r\n      offset += ret.length;\r\n\r\n      while(bytes--) {\r\n        k = this.readByte(offset++);\r\n        value[bit++] = !!(k & 0x01);\r\n        value[bit++] = !!(k & 0x02);\r\n        value[bit++] = !!(k & 0x04);\r\n        value[bit++] = !!(k & 0x08);\r\n        value[bit++] = !!(k & 0x10);\r\n        value[bit++] = !!(k & 0x20);\r\n        value[bit++] = !!(k & 0x40);\r\n        value[bit++] = !!(k & 0x80);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0;\r\n        k = this.readByte(offset++);\r\n        while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n      }\r\n      return value;\r\n    }\r\n    /**\r\n     * Reads the specified number of bytes.\r\n     * @param {number} length Number of bytes to read\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBytes = function(length, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + length > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n        }\r\n        var slice = this.slice(offset, offset + length);\r\n        if (relative) this.offset += length;\n        return slice;\r\n    };\r\n\r\n    /**\r\n     * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.\r\n     * @function\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;\r\n\r\n    // types/ints/int8\r\n\r\n    /**\r\n     * Writes an 8bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity0 = this.buffer.byteLength;\n        if (offset > capacity0)\n            this.resize((capacity0 *= 2) > offset ? capacity0 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;\r\n\r\n    /**\r\n     * Reads an 8bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity1 = this.buffer.byteLength;\n        if (offset > capacity1)\n            this.resize((capacity1 *= 2) > offset ? capacity1 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;\r\n\r\n    // types/ints/int16\r\n\r\n    /**\r\n     * Writes a 16bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity2 = this.buffer.byteLength;\n        if (offset > capacity2)\n            this.resize((capacity2 *= 2) > offset ? capacity2 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;\r\n\r\n    /**\r\n     * Reads a 16bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity3 = this.buffer.byteLength;\n        if (offset > capacity3)\n            this.resize((capacity3 *= 2) > offset ? capacity3 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;\r\n\r\n    // types/ints/int32\r\n\r\n    /**\r\n     * Writes a 32bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity4 = this.buffer.byteLength;\n        if (offset > capacity4)\n            this.resize((capacity4 *= 2) > offset ? capacity4 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;\r\n\r\n    /**\r\n     * Reads a 32bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        value |= 0; // Cast to signed\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity5 = this.buffer.byteLength;\n        if (offset > capacity5)\n            this.resize((capacity5 *= 2) > offset ? capacity5 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;\r\n\r\n    // types/ints/int64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Writes a 64bit signed integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeInt64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity6 = this.buffer.byteLength;\n            if (offset > capacity6)\n                this.resize((capacity6 *= 2) > offset ? capacity6 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;\r\n\r\n        /**\r\n         * Reads a 64bit signed integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readInt64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, false);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity7 = this.buffer.byteLength;\n            if (offset > capacity7)\n                this.resize((capacity7 *= 2) > offset ? capacity7 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.\r\n         * @function\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, true);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.\r\n         * @function\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;\r\n\r\n    } // Long\r\n\r\n\r\n    // types/floats/float32\r\n\r\n    /*\r\n     ieee754 - https://github.com/feross/ieee754\r\n\r\n     The MIT License (MIT)\r\n\r\n     Copyright (c) Feross Aboukhadijeh\r\n\r\n     Permission is hereby granted, free of charge, to any person obtaining a copy\r\n     of this software and associated documentation files (the \"Software\"), to deal\r\n     in the Software without restriction, including without limitation the rights\r\n     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n     copies of the Software, and to permit persons to whom the Software is\r\n     furnished to do so, subject to the following conditions:\r\n\r\n     The above copyright notice and this permission notice shall be included in\r\n     all copies or substantial portions of the Software.\r\n\r\n     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n     THE SOFTWARE.\r\n    */\r\n\r\n    /**\r\n     * Reads an IEEE754 float from a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    function ieee754_read(buffer, offset, isLE, mLen, nBytes) {\r\n        var e, m,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            nBits = -7,\r\n            i = isLE ? (nBytes - 1) : 0,\r\n            d = isLE ? -1 : 1,\r\n            s = buffer[offset + i];\r\n\r\n        i += d;\r\n\r\n        e = s & ((1 << (-nBits)) - 1);\r\n        s >>= (-nBits);\r\n        nBits += eLen;\r\n        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        m = e & ((1 << (-nBits)) - 1);\r\n        e >>= (-nBits);\r\n        nBits += mLen;\r\n        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        if (e === 0) {\r\n            e = 1 - eBias;\r\n        } else if (e === eMax) {\r\n            return m ? NaN : ((s ? -1 : 1) * Infinity);\r\n        } else {\r\n            m = m + Math.pow(2, mLen);\r\n            e = e - eBias;\r\n        }\r\n        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\r\n    }\r\n\r\n    /**\r\n     * Writes an IEEE754 float to a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} value\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @inner\r\n     */\r\n    function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) {\r\n        var e, m, c,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),\r\n            i = isLE ? 0 : (nBytes - 1),\r\n            d = isLE ? 1 : -1,\r\n            s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\r\n\r\n        value = Math.abs(value);\r\n\r\n        if (isNaN(value) || value === Infinity) {\r\n            m = isNaN(value) ? 1 : 0;\r\n            e = eMax;\r\n        } else {\r\n            e = Math.floor(Math.log(value) / Math.LN2);\r\n            if (value * (c = Math.pow(2, -e)) < 1) {\r\n                e--;\r\n                c *= 2;\r\n            }\r\n            if (e + eBias >= 1) {\r\n                value += rt / c;\r\n            } else {\r\n                value += rt * Math.pow(2, 1 - eBias);\r\n            }\r\n            if (value * c >= 2) {\r\n                e++;\r\n                c /= 2;\r\n            }\r\n\r\n            if (e + eBias >= eMax) {\r\n                m = 0;\r\n                e = eMax;\r\n            } else if (e + eBias >= 1) {\r\n                m = (value * c - 1) * Math.pow(2, mLen);\r\n                e = e + eBias;\r\n            } else {\r\n                m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\r\n                e = 0;\r\n            }\r\n        }\r\n\r\n        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\r\n\r\n        e = (e << mLen) | m;\r\n        eLen += mLen;\r\n        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\r\n\r\n        buffer[offset + i - d] |= s * 128;\r\n    }\r\n\r\n    /**\r\n     * Writes a 32bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity8 = this.buffer.byteLength;\n        if (offset > capacity8)\n            this.resize((capacity8 *= 2) > offset ? capacity8 : offset);\n        offset -= 4;\n        ieee754_write(this.view, value, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;\r\n\r\n    /**\r\n     * Reads a 32bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;\r\n\r\n    // types/floats/float64\r\n\r\n    /**\r\n     * Writes a 64bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat64 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 8;\n        var capacity9 = this.buffer.byteLength;\n        if (offset > capacity9)\n            this.resize((capacity9 *= 2) > offset ? capacity9 : offset);\n        offset -= 8;\n        ieee754_write(this.view, value, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64;\r\n\r\n    /**\r\n     * Reads a 64bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat64 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;\r\n\r\n\r\n    // types/varints/varint32\r\n\r\n    /**\r\n     * Maximum number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @type {number}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.MAX_VARINT32_BYTES = 5;\r\n\r\n    /**\r\n     * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to encode\r\n     * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateVarint32 = function(value) {\r\n        // ref: src/google/protobuf/io/coded_stream.cc\r\n        value = value >>> 0;\r\n             if (value < 1 << 7 ) return 1;\r\n        else if (value < 1 << 14) return 2;\r\n        else if (value < 1 << 21) return 3;\r\n        else if (value < 1 << 28) return 4;\r\n        else                      return 5;\r\n    };\r\n\r\n    /**\r\n     * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.\r\n     * @param {number} n Signed 32bit integer\r\n     * @returns {number} Unsigned zigzag encoded 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagEncode32 = function(n) {\r\n        return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Decodes a zigzag encoded signed 32bit integer.\r\n     * @param {number} n Unsigned zigzag encoded 32bit integer\r\n     * @returns {number} Signed 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagDecode32 = function(n) {\r\n        return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var size = ByteBuffer.calculateVarint32(value),\r\n            b;\r\n        offset += size;\n        var capacity10 = this.buffer.byteLength;\n        if (offset > capacity10)\n            this.resize((capacity10 *= 2) > offset ? capacity10 : offset);\n        offset -= size;\n        value >>>= 0;\r\n        while (value >= 0x80) {\r\n            b = (value & 0x7f) | 0x80;\r\n            this.view[offset++] = b;\r\n            value >>>= 7;\r\n        }\r\n        this.view[offset++] = value;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return size;\r\n    };\r\n\r\n    /**\r\n     * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {\r\n        return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available\r\n     *  to fully decode the varint.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var c = 0,\r\n            value = 0 >>> 0,\r\n            b;\r\n        do {\r\n            if (!this.noAssert && offset > this.limit) {\r\n                var err = Error(\"Truncated\");\r\n                err['truncated'] = true;\r\n                throw err;\r\n            }\r\n            b = this.view[offset++];\r\n            if (c < 5)\r\n                value |= (b & 0x7f) << (7*c);\r\n            ++c;\r\n        } while ((b & 0x80) !== 0);\r\n        value |= 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return value;\r\n        }\r\n        return {\r\n            \"value\": value,\r\n            \"length\": c\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32ZigZag = function(offset) {\r\n        var val = this.readVarint32(offset);\r\n        if (typeof val === 'object')\r\n            val[\"value\"] = ByteBuffer.zigZagDecode32(val[\"value\"]);\r\n        else\r\n            val = ByteBuffer.zigZagDecode32(val);\r\n        return val;\r\n    };\r\n\r\n    // types/varints/varint64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Maximum number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @type {number}\r\n         * @const\r\n         * @expose\r\n         */\r\n        ByteBuffer.MAX_VARINT64_BYTES = 10;\r\n\r\n        /**\r\n         * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @param {number|!Long} value Value to encode\r\n         * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}\r\n         * @expose\r\n         */\r\n        ByteBuffer.calculateVarint64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            if (part2 == 0) {\r\n                if (part1 == 0) {\r\n                    if (part0 < 1 << 14)\r\n                        return part0 < 1 << 7 ? 1 : 2;\r\n                    else\r\n                        return part0 < 1 << 21 ? 3 : 4;\r\n                } else {\r\n                    if (part1 < 1 << 14)\r\n                        return part1 < 1 << 7 ? 5 : 6;\r\n                    else\r\n                        return part1 < 1 << 21 ? 7 : 8;\r\n                }\r\n            } else\r\n                return part2 < 1 << 7 ? 9 : 10;\r\n        };\r\n\r\n        /**\r\n         * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.\r\n         * @param {number|!Long} value Signed long\r\n         * @returns {!Long} Unsigned zigzag encoded long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagEncode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();\r\n        };\r\n\r\n        /**\r\n         * Decodes a zigzag encoded signed 64bit integer.\r\n         * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number\r\n         * @returns {!Long} Signed long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagDecode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            var size = ByteBuffer.calculateVarint64(value),\r\n                part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            offset += size;\n            var capacity11 = this.buffer.byteLength;\n            if (offset > capacity11)\n                this.resize((capacity11 *= 2) > offset ? capacity11 : offset);\n            offset -= size;\n            switch (size) {\r\n                case 10: this.view[offset+9] = (part2 >>>  7) & 0x01;\r\n                case 9 : this.view[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;\r\n                case 8 : this.view[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;\r\n                case 7 : this.view[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;\r\n                case 6 : this.view[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;\r\n                case 5 : this.view[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;\r\n                case 4 : this.view[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;\r\n                case 3 : this.view[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;\r\n                case 2 : this.view[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;\r\n                case 1 : this.view[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;\r\n            }\r\n            if (relative) {\r\n                this.offset += size;\r\n                return this;\r\n            } else {\r\n                return size;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Writes a zig-zag encoded 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {\r\n            return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n            }\r\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var start = offset,\r\n                part0 = 0,\r\n                part1 = 0,\r\n                part2 = 0,\r\n                b  = 0;\r\n            b = this.view[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            throw Error(\"Buffer overrun\"); }}}}}}}}}}\r\n            var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return value;\r\n            } else {\r\n                return {\r\n                    'value': value,\r\n                    'length': offset-start\r\n                };\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64ZigZag = function(offset) {\r\n            var val = this.readVarint64(offset);\r\n            if (val && val['value'] instanceof Long)\r\n                val[\"value\"] = ByteBuffer.zigZagDecode64(val[\"value\"]);\r\n            else\r\n                val = ByteBuffer.zigZagDecode64(val);\r\n            return val;\r\n        };\r\n\r\n    } // Long\r\n\r\n\r\n    // types/strings/cstring\r\n\r\n    /**\r\n     * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL\r\n     *  characters itself.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  contained in `str` + 1 if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeCString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        var i,\r\n            k = str.length;\r\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            for (i=0; i<k; ++i) {\r\n                if (str.charCodeAt(i) === 0)\r\n                    throw RangeError(\"Illegal str: Contains NULL-characters\");\r\n            }\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character, so:\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k+1;\n        var capacity12 = this.buffer.byteLength;\n        if (offset > capacity12)\n            this.resize((capacity12 *= 2) > offset ? capacity12 : offset);\n        offset -= k+1;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        this.view[offset++] = 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return k;\r\n    };\r\n\r\n    /**\r\n     * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters\r\n     *  itself.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readCString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            temp;\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:\r\n        var sd, b = -1;\r\n        utfx.decodeUTF8toUTF16(function() {\r\n            if (b === 0) return null;\r\n            if (offset >= this.limit)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" < \"+this.limit);\r\n            b = this.view[offset++];\r\n            return b === 0 ? null : b;\r\n        }.bind(this), sd = stringDestination(), true);\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return sd();\r\n        } else {\r\n            return {\r\n                \"string\": sd(),\r\n                \"length\": offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/istring\r\n\r\n    /**\r\n     * Writes a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeIString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        offset += 4+k;\n        var capacity13 = this.buffer.byteLength;\n        if (offset > capacity13)\n            this.resize((capacity13 *= 2) > offset ? capacity13 : offset);\n        offset -= 4+k;\n        if (this.littleEndian) {\n            this.view[offset+3] = (k >>> 24) & 0xFF;\n            this.view[offset+2] = (k >>> 16) & 0xFF;\n            this.view[offset+1] = (k >>>  8) & 0xFF;\n            this.view[offset  ] =  k         & 0xFF;\n        } else {\n            this.view[offset  ] = (k >>> 24) & 0xFF;\n            this.view[offset+1] = (k >>> 16) & 0xFF;\n            this.view[offset+2] = (k >>>  8) & 0xFF;\n            this.view[offset+3] =  k         & 0xFF;\n        }\n        offset += 4;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start + 4 + k)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+4+k));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readIString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readUint32(offset);\r\n        var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/utf8string\r\n\r\n    /**\r\n     * Metrics representing number of UTF8 characters. Evaluates to `c`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_CHARS = 'c';\r\n\r\n    /**\r\n     * Metrics representing number of bytes. Evaluates to `b`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_BYTES = 'b';\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUTF8String = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var k;\r\n        var start = offset;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k;\n        var capacity14 = this.buffer.byteLength;\n        if (offset > capacity14)\n            this.resize((capacity14 *= 2) > offset ? capacity14 : offset);\n        offset -= k;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.\r\n     * @function\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;\r\n\r\n    /**\r\n     * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's\r\n     *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 characters\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Chars = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[0];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Bytes = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.\r\n     * @function\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string.\r\n     * @param {number} length Number of characters or bytes to read.\r\n     * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {\r\n        if (typeof metrics === 'number') {\r\n            offset = metrics;\r\n            metrics = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var i = 0,\r\n            start = offset,\r\n            sd;\r\n        if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser\r\n            sd = stringDestination();\r\n            utfx.decodeUTF8(function() {\r\n                return i < length && offset < this.limit ? this.view[offset++] : null;\r\n            }.bind(this), function(cp) {\r\n                ++i; utfx.UTF8toUTF16(cp, sd);\r\n            });\r\n            if (i !== length)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+i+\" == \"+length);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    \"string\": sd(),\r\n                    \"length\": offset - start\r\n                };\r\n            }\r\n        } else if (metrics === ByteBuffer.METRICS_BYTES) {\r\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + length > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n            }\r\n            var k = offset + length;\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return offset < k ? this.view[offset++] : null;\r\n            }.bind(this), sd = stringDestination(), this.noAssert);\r\n            if (offset !== k)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+k);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    'string': sd(),\r\n                    'length': offset - start\r\n                };\r\n            }\r\n        } else\r\n            throw TypeError(\"Unsupported metrics: \"+metrics);\r\n    };\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.\r\n     * @function\r\n     * @param {number} length Number of characters or bytes to read\r\n     * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;\r\n\r\n    // types/strings/vstring\r\n\r\n    /**\r\n     * Writes a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeVString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k, l;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        l = ByteBuffer.calculateVarint32(k);\r\n        offset += l+k;\n        var capacity15 = this.buffer.byteLength;\n        if (offset > capacity15)\n            this.resize((capacity15 *= 2) > offset ? capacity15 : offset);\n        offset -= l+k;\n        offset += this.writeVarint32(k, offset);\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start+k+l)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+k+l));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readVString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readVarint32(offset);\r\n        var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n\r\n    /**\r\n     * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended\r\n     *  data's length.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`\r\n     * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`\r\n     */\r\n    ByteBufferPrototype.append = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var length = source.limit - source.offset;\r\n        if (length <= 0) return this; // Nothing to append\r\n        offset += length;\n        var capacity16 = this.buffer.byteLength;\n        if (offset > capacity16)\n            this.resize((capacity16 *= 2) > offset ? capacity16 : offset);\n        offset -= length;\n        this.view.set(source.view.subarray(source.offset, source.limit), offset);\r\n        source.offset += length;\r\n        if (relative) this.offset += length;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the\r\n        specified offset up to the length of this ByteBuffer's data.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#append\r\n     */\r\n    ByteBufferPrototype.appendTo = function(target, offset) {\r\n        target.append(this, offset);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to\r\n     *  disable them if your code already makes sure that everything is valid.\r\n     * @param {boolean} assert `true` to enable assertions, otherwise `false`\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.assert = function(assert) {\r\n        this.noAssert = !assert;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Gets the capacity of this ByteBuffer's backing buffer.\r\n     * @returns {number} Capacity of the backing buffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.capacity = function() {\r\n        return this.buffer.byteLength;\r\n    };\r\n    /**\r\n     * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the\r\n     *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clear = function() {\r\n        this.offset = 0;\r\n        this.limit = this.buffer.byteLength;\r\n        this.markedOffset = -1;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},\r\n     *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`\r\n     * @returns {!ByteBuffer} Cloned instance\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clone = function(copy) {\r\n        var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        if (copy) {\r\n            bb.buffer = new ArrayBuffer(this.buffer.byteLength);\r\n            bb.view = new Uint8Array(bb.buffer);\r\n        } else {\r\n            bb.buffer = this.buffer;\r\n            bb.view = this.view;\r\n        }\r\n        bb.offset = this.offset;\r\n        bb.markedOffset = this.markedOffset;\r\n        bb.limit = this.limit;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes\r\n     *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and\r\n     *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.compact = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === 0 && end === this.buffer.byteLength)\r\n            return this; // Already compacted\r\n        var len = end - begin;\r\n        if (len === 0) {\r\n            this.buffer = EMPTY_BUFFER;\r\n            this.view = null;\r\n            if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n            this.offset = 0;\r\n            this.limit = 0;\r\n            return this;\r\n        }\r\n        var buffer = new ArrayBuffer(len);\r\n        var view = new Uint8Array(buffer);\r\n        view.set(this.view.subarray(begin, end));\r\n        this.buffer = buffer;\r\n        this.view = view;\r\n        if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n        this.offset = 0;\r\n        this.limit = len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Copy\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copy = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        var capacity = end - begin,\r\n            bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);\r\n        bb.offset = 0;\r\n        bb.limit = capacity;\r\n        if (bb.markedOffset >= 0) bb.markedOffset -= begin;\r\n        this.copyTo(bb, 0, begin, end);\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}\r\n     *  by the number of bytes copied if omitted.\r\n     * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the\r\n     *  number of bytes copied if omitted.\r\n     * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {\r\n        var relative,\r\n            targetRelative;\r\n        if (!this.noAssert) {\r\n            if (!ByteBuffer.isByteBuffer(target))\r\n                throw TypeError(\"Illegal target: Not a ByteBuffer\");\r\n        }\r\n        targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;\r\n        sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;\r\n        sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;\r\n\r\n        if (targetOffset < 0 || targetOffset > target.buffer.byteLength)\r\n            throw RangeError(\"Illegal target range: 0 <= \"+targetOffset+\" <= \"+target.buffer.byteLength);\r\n        if (sourceOffset < 0 || sourceLimit > this.buffer.byteLength)\r\n            throw RangeError(\"Illegal source range: 0 <= \"+sourceOffset+\" <= \"+this.buffer.byteLength);\r\n\r\n        var len = sourceLimit - sourceOffset;\r\n        if (len === 0)\r\n            return target; // Nothing to copy\r\n\r\n        target.ensureCapacity(targetOffset + len);\r\n\r\n        target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset);\r\n\r\n        if (relative) this.offset += len;\r\n        if (targetRelative) target.offset += len;\r\n\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the\r\n     *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,\r\n     *  the required capacity will be used instead.\r\n     * @param {number} capacity Required capacity\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.ensureCapacity = function(capacity) {\r\n        var current = this.buffer.byteLength;\r\n        if (current < capacity)\r\n            return this.resize((current *= 2) > capacity ? current : capacity);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {number|string} value Byte value to fill with. If given as a string, the first character is used.\r\n     * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted. defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes\r\n     */\r\n    ByteBufferPrototype.fill = function(value, begin, end) {\r\n        var relative = typeof begin === 'undefined';\n        if (relative) begin = this.offset;\n        if (typeof value === 'string' && value.length > 0)\r\n            value = value.charCodeAt(0);\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin >= end)\r\n            return this; // Nothing to fill\r\n        while (begin < end) this.view[begin++] = value;\r\n        if (relative) this.offset = begin;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and\r\n     *  `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.flip = function() {\r\n        this.limit = this.offset;\r\n        this.offset = 0;\r\n        return this;\r\n    };\r\n    /**\r\n     * Marks an offset on this ByteBuffer to be used later.\r\n     * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @see ByteBuffer#reset\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.mark = function(offset) {\r\n        offset = typeof offset === 'undefined' ? this.offset : offset;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        this.markedOffset = offset;\r\n        return this;\r\n    };\r\n    /**\r\n     * Sets the byte order.\r\n     * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.order = function(littleEndian) {\r\n        if (!this.noAssert) {\r\n            if (typeof littleEndian !== 'boolean')\r\n                throw TypeError(\"Illegal littleEndian: Not a boolean\");\r\n        }\r\n        this.littleEndian = !!littleEndian;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) little endian byte order.\r\n     * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.LE = function(littleEndian) {\r\n        this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) big endian byte order.\r\n     * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.BE = function(bigEndian) {\r\n        this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false;\r\n        return this;\r\n    };\r\n    /**\r\n     * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer|string|!ArrayBuffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be\r\n     *  modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|`\r\n     * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|`\r\n     */\r\n    ByteBufferPrototype.prepend = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var len = source.limit - source.offset;\r\n        if (len <= 0) return this; // Nothing to prepend\r\n        var diff = len - offset;\r\n        if (diff > 0) { // Not enough space before offset, so resize + move\r\n            var buffer = new ArrayBuffer(this.buffer.byteLength + diff);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view.subarray(offset, this.buffer.byteLength), len);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n            this.offset += diff;\r\n            if (this.markedOffset >= 0) this.markedOffset += diff;\r\n            this.limit += diff;\r\n            offset += diff;\r\n        } else {\r\n            var arrayView = new Uint8Array(this.buffer);\r\n        }\r\n        this.view.set(source.view.subarray(source.offset, source.limit), offset - len);\r\n\r\n        source.offset = source.limit;\r\n        if (relative)\r\n            this.offset -= len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#prepend\r\n     */\r\n    ByteBufferPrototype.prependTo = function(target, offset) {\r\n        target.prepend(this, offset);\r\n        return this;\r\n    };\r\n    /**\r\n     * Prints debug information about this ByteBuffer's contents.\r\n     * @param {function(string)=} out Output function to call, defaults to console.log\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.printDebug = function(out) {\r\n        if (typeof out !== 'function') out = console.log.bind(console);\r\n        out(\r\n            this.toString()+\"\\n\"+\r\n            \"-------------------------------------------------------------------\\n\"+\r\n            this.toDebug(/* columns */ true)\r\n        );\r\n    };\r\n\r\n    /**\r\n     * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}, so this returns `limit - offset`.\r\n     * @returns {number} Remaining readable bytes. May be negative if `offset > limit`.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.remaining = function() {\r\n        return this.limit - this.offset;\r\n    };\r\n    /**\r\n     * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark}\r\n     *  before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been\r\n     *  marked, sets `offset = 0`.\r\n     * @returns {!ByteBuffer} this\r\n     * @see ByteBuffer#mark\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reset = function() {\r\n        if (this.markedOffset >= 0) {\r\n            this.offset = this.markedOffset;\r\n            this.markedOffset = -1;\r\n        } else {\r\n            this.offset = 0;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that\r\n     *  large or larger.\r\n     * @param {number} capacity Capacity required\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `capacity` is not a number\r\n     * @throws {RangeError} If `capacity < 0`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.resize = function(capacity) {\r\n        if (!this.noAssert) {\r\n            if (typeof capacity !== 'number' || capacity % 1 !== 0)\n                throw TypeError(\"Illegal capacity: \"+capacity+\" (not an integer)\");\n            capacity |= 0;\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity: 0 <= \"+capacity);\r\n        }\r\n        if (this.buffer.byteLength < capacity) {\r\n            var buffer = new ArrayBuffer(capacity);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Reverses this ByteBuffer's contents.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reverse = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return this; // Nothing to reverse\r\n        Array.prototype.reverse.call(this.view.subarray(begin, end));\r\n        return this;\r\n    };\r\n    /**\r\n     * Skips the next `length` bytes. This will just advance\r\n     * @param {number} length Number of bytes to skip. May also be negative to move the offset back.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.skip = function(length) {\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n        }\r\n        var offset = this.offset + length;\r\n        if (!this.noAssert) {\r\n            if (offset < 0 || offset > this.buffer.byteLength)\r\n                throw RangeError(\"Illegal length: 0 <= \"+this.offset+\" + \"+length+\" <= \"+this.buffer.byteLength);\r\n        }\r\n        this.offset = offset;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.slice = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var bb = this.clone();\r\n        bb.offset = begin;\r\n        bb.limit = end;\r\n        return bb;\r\n    };\r\n    /**\r\n     * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if\r\n     *  possible. Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBuffer = function(forceCopy) {\r\n        var offset = this.offset,\r\n            limit = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: Not an integer\");\n            offset >>>= 0;\n            if (typeof limit !== 'number' || limit % 1 !== 0)\n                throw TypeError(\"Illegal limit: Not an integer\");\n            limit >>>= 0;\n            if (offset < 0 || offset > limit || limit > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+offset+\" <= \"+limit+\" <= \"+this.buffer.byteLength);\n        }\r\n        // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is\r\n        // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So:\r\n        if (!forceCopy && offset === 0 && limit === this.buffer.byteLength)\r\n            return this.buffer;\r\n        if (offset === limit)\r\n            return EMPTY_BUFFER;\r\n        var buffer = new ArrayBuffer(limit - offset);\r\n        new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0);\r\n        return buffer;\r\n    };\r\n\r\n    /**\r\n     * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}.\r\n     * @function\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory.\r\n     *  Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer;\r\n\r\n    /**\r\n     * Converts the ByteBuffer's contents to a string.\r\n     * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows\r\n     *  direct conversion to \"utf8\", \"hex\", \"base64\" and \"binary\" encoding. \"debug\" returns a hex representation with\r\n     *  highlighted offsets.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {string} String representation\r\n     * @throws {Error} If `encoding` is invalid\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toString = function(encoding, begin, end) {\r\n        if (typeof encoding === 'undefined')\r\n            return \"ByteBufferAB(offset=\"+this.offset+\",markedOffset=\"+this.markedOffset+\",limit=\"+this.limit+\",capacity=\"+this.capacity()+\")\";\r\n        if (typeof encoding === 'number')\r\n            encoding = \"utf8\",\r\n            begin = encoding,\r\n            end = begin;\r\n        switch (encoding) {\r\n            case \"utf8\":\r\n                return this.toUTF8(begin, end);\r\n            case \"base64\":\r\n                return this.toBase64(begin, end);\r\n            case \"hex\":\r\n                return this.toHex(begin, end);\r\n            case \"binary\":\r\n                return this.toBinary(begin, end);\r\n            case \"debug\":\r\n                return this.toDebug();\r\n            case \"columns\":\r\n                return this.toColumns();\r\n            default:\r\n                throw Error(\"Unsupported encoding: \"+encoding);\r\n        }\r\n    };\r\n\r\n    // lxiv-embeddable\r\n\r\n    /**\r\n     * lxiv-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/lxiv for details\r\n     */\r\n    var lxiv = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * lxiv namespace.\r\n         * @type {!Object.<string,*>}\r\n         * @exports lxiv\r\n         */\r\n        var lxiv = {};\r\n\r\n        /**\r\n         * Character codes for output.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var aout = [\r\n            65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,\r\n            81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102,\r\n            103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,\r\n            119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47\r\n        ];\r\n\r\n        /**\r\n         * Character codes for input.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var ain = [];\r\n        for (var i=0, k=aout.length; i<k; ++i)\r\n            ain[aout[i]] = i;\r\n\r\n        /**\r\n         * Encodes bytes to base64 char codes.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if\r\n         *  there are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each encoded char\r\n         *  code.\r\n         */\r\n        lxiv.encode = function(src, dst) {\r\n            var b, t;\r\n            while ((b = src()) !== null) {\r\n                dst(aout[(b>>2)&0x3f]);\r\n                t = (b&0x3)<<4;\r\n                if ((b = src()) !== null) {\r\n                    t |= (b>>4)&0xf;\r\n                    dst(aout[(t|((b>>4)&0xf))&0x3f]);\r\n                    t = (b&0xf)<<2;\r\n                    if ((b = src()) !== null)\r\n                        dst(aout[(t|((b>>6)&0x3))&0x3f]),\r\n                        dst(aout[b&0x3f]);\r\n                    else\r\n                        dst(aout[t&0x3f]),\r\n                        dst(61);\r\n                } else\r\n                    dst(aout[t&0x3f]),\r\n                    dst(61),\r\n                    dst(61);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes base64 char codes to bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         * @throws {Error} If a character code is invalid\r\n         */\r\n        lxiv.decode = function(src, dst) {\r\n            var c, t1, t2;\r\n            function fail(c) {\r\n                throw Error(\"Illegal character code: \"+c);\r\n            }\r\n            while ((c = src()) !== null) {\r\n                t1 = ain[c];\r\n                if (typeof t1 === 'undefined') fail(c);\r\n                if ((c = src()) !== null) {\r\n                    t2 = ain[c];\r\n                    if (typeof t2 === 'undefined') fail(c);\r\n                    dst((t1<<2)>>>0|(t2&0x30)>>4);\r\n                    if ((c = src()) !== null) {\r\n                        t1 = ain[c];\r\n                        if (typeof t1 === 'undefined')\r\n                            if (c === 61) break; else fail(c);\r\n                        dst(((t2&0xf)<<4)>>>0|(t1&0x3c)>>2);\r\n                        if ((c = src()) !== null) {\r\n                            t2 = ain[c];\r\n                            if (typeof t2 === 'undefined')\r\n                                if (c === 61) break; else fail(c);\r\n                            dst(((t1&0x3)<<6)>>>0|t2);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Tests if a string is valid base64.\r\n         * @param {string} str String to test\r\n         * @returns {boolean} `true` if valid, otherwise `false`\r\n         */\r\n        lxiv.test = function(str) {\r\n            return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(str);\r\n        };\r\n\r\n        return lxiv;\r\n    }();\r\n\r\n    // encodings/base64\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a base64 encoded string.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Base64 encoded string\r\n     * @throws {RangeError} If `begin` or `end` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBase64 = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin = begin | 0; end = end | 0;\r\n        if (begin < 0 || end > this.capacity || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        var sd; lxiv.encode(function() {\r\n            return begin < end ? this.view[begin++] : null;\r\n        }.bind(this), sd = stringDestination());\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBase64 = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var bb = new ByteBuffer(str.length/4*3, littleEndian),\r\n            i = 0;\r\n        lxiv.decode(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Encodes a binary string to base64 like `window.btoa` does.\r\n     * @param {string} str Binary string\r\n     * @returns {string} Base64 encoded string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa\r\n     * @expose\r\n     */\r\n    ByteBuffer.btoa = function(str) {\r\n        return ByteBuffer.fromBinary(str).toBase64();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to binary like `window.atob` does.\r\n     * @param {string} b64 Base64 encoded string\r\n     * @returns {string} Binary string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob\r\n     * @expose\r\n     */\r\n    ByteBuffer.atob = function(b64) {\r\n        return ByteBuffer.fromBase64(b64).toBinary();\r\n    };\r\n\r\n    // encodings/binary\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Binary encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBinary = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin |= 0; end |= 0;\r\n        if (begin < 0 || end > this.capacity() || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        if (begin === end)\r\n            return \"\";\r\n        var chars = [],\r\n            parts = [];\r\n        while (begin < end) {\r\n            chars.push(this.view[begin++]);\r\n            if (chars.length >= 1024)\r\n                parts.push(String.fromCharCode.apply(String, chars)),\r\n                chars = [];\r\n        }\r\n        return parts.join('') + String.fromCharCode.apply(String, chars);\r\n    };\r\n\r\n    /**\r\n     * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBinary = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var i = 0,\r\n            k = str.length,\r\n            charCode,\r\n            bb = new ByteBuffer(k, littleEndian);\r\n        while (i<k) {\r\n            charCode = str.charCodeAt(i);\r\n            if (charCode > 0xff)\r\n                throw RangeError(\"illegal char code: \"+charCode);\r\n            bb.view[i++] = charCode;\r\n        }\r\n        bb.limit = k;\r\n        return bb;\r\n    };\r\n\r\n    // encodings/debug\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are:\r\n     * * `<` : offset,\r\n     * * `'` : markedOffset,\r\n     * * `>` : limit,\r\n     * * `|` : offset and limit,\r\n     * * `[` : offset and markedOffset,\r\n     * * `]` : markedOffset and limit,\r\n     * * `!` : offset, markedOffset and limit\r\n     * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false`\r\n     * @returns {string|!Array.<string>} Debug string or array of lines if `asArray = true`\r\n     * @expose\r\n     * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3`\r\n     * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4`\r\n     * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1`\r\n     * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1`\r\n     */\r\n    ByteBufferPrototype.toDebug = function(columns) {\r\n        var i = -1,\r\n            k = this.buffer.byteLength,\r\n            b,\r\n            hex = \"\",\r\n            asc = \"\",\r\n            out = \"\";\r\n        while (i<k) {\r\n            if (i !== -1) {\r\n                b = this.view[i];\r\n                if (b < 0x10) hex += \"0\"+b.toString(16).toUpperCase();\r\n                else hex += b.toString(16).toUpperCase();\r\n                if (columns)\r\n                    asc += b > 32 && b < 127 ? String.fromCharCode(b) : '.';\r\n            }\r\n            ++i;\r\n            if (columns) {\r\n                if (i > 0 && i % 16 === 0 && i !== k) {\r\n                    while (hex.length < 3*16+3) hex += \" \";\r\n                    out += hex+asc+\"\\n\";\r\n                    hex = asc = \"\";\r\n                }\r\n            }\r\n            if (i === this.offset && i === this.limit)\r\n                hex += i === this.markedOffset ? \"!\" : \"|\";\r\n            else if (i === this.offset)\r\n                hex += i === this.markedOffset ? \"[\" : \"<\";\r\n            else if (i === this.limit)\r\n                hex += i === this.markedOffset ? \"]\" : \">\";\r\n            else\r\n                hex += i === this.markedOffset ? \"'\" : (columns || (i !== 0 && i !== k) ? \" \" : \"\");\r\n        }\r\n        if (columns && hex !== \" \") {\r\n            while (hex.length < 3*16+3)\r\n                hex += \" \";\r\n            out += hex + asc + \"\\n\";\r\n        }\r\n        return columns ? out : hex;\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string with marked offsets to a ByteBuffer.\r\n     * @param {string} str Debug string to decode (not be generated with `columns = true`)\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     * @see ByteBuffer#toDebug\r\n     */\r\n    ByteBuffer.fromDebug = function(str, littleEndian, noAssert) {\r\n        var k = str.length,\r\n            bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert);\r\n        var i = 0, j = 0, ch, b,\r\n            rs = false, // Require symbol next\r\n            ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)?\r\n            fail = false;\r\n        while (i<k) {\r\n            switch (ch = str.charAt(i++)) {\r\n                case '!':\r\n                    if (!noAssert) {\r\n                        if (ho || hm || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = hl = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '|':\r\n                    if (!noAssert) {\r\n                        if (ho || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hl = true;\r\n                    }\r\n                    bb.offset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '[':\r\n                    if (!noAssert) {\r\n                        if (ho || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '<':\r\n                    if (!noAssert) {\r\n                        if (ho) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = true;\r\n                    }\r\n                    bb.offset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ']':\r\n                    if (!noAssert) {\r\n                        if (hl || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = hm = true;\r\n                    }\r\n                    bb.limit = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '>':\r\n                    if (!noAssert) {\r\n                        if (hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = true;\r\n                    }\r\n                    bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case \"'\":\r\n                    if (!noAssert) {\r\n                        if (hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hm = true;\r\n                    }\r\n                    bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ' ':\r\n                    rs = false;\r\n                    break;\r\n                default:\r\n                    if (!noAssert) {\r\n                        if (rs) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                    }\r\n                    b = parseInt(ch+str.charAt(i++), 16);\r\n                    if (!noAssert) {\r\n                        if (isNaN(b) || b < 0 || b > 255)\r\n                            throw TypeError(\"Illegal str: Not a debug encoded string\");\r\n                    }\r\n                    bb.view[j++] = b;\r\n                    rs = true;\r\n            }\r\n            if (fail)\r\n                throw TypeError(\"Illegal str: Invalid symbol at \"+i);\r\n        }\r\n        if (!noAssert) {\r\n            if (!ho || !hl)\r\n                throw TypeError(\"Illegal str: Missing offset or limit\");\r\n            if (j<bb.buffer.byteLength)\r\n                throw TypeError(\"Illegal str: Not a debug encoded string (is it hex?) \"+j+\" < \"+k);\r\n        }\r\n        return bb;\r\n    };\r\n\r\n    // encodings/hex\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a hex encoded string.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Hex encoded string\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toHex = function(begin, end) {\r\n        begin = typeof begin === 'undefined' ? this.offset : begin;\r\n        end = typeof end === 'undefined' ? this.limit : end;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var out = new Array(end - begin),\r\n            b;\r\n        while (begin < end) {\r\n            b = this.view[begin++];\r\n            if (b < 0x10)\r\n                out.push(\"0\", b.toString(16));\r\n            else out.push(b.toString(16));\r\n        }\r\n        return out.join('');\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromHex = function(str, littleEndian, noAssert) {\r\n        if (!noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (str.length % 2 !== 0)\r\n                throw TypeError(\"Illegal str: Length not a multiple of 2\");\r\n        }\r\n        var k = str.length,\r\n            bb = new ByteBuffer((k / 2) | 0, littleEndian),\r\n            b;\r\n        for (var i=0, j=0; i<k; i+=2) {\r\n            b = parseInt(str.substring(i, i+2), 16);\r\n            if (!noAssert)\r\n                if (!isFinite(b) || b < 0 || b > 255)\r\n                    throw TypeError(\"Illegal str: Contains non-hex characters\");\r\n            bb.view[j++] = b;\r\n        }\r\n        bb.limit = j;\r\n        return bb;\r\n    };\r\n\r\n    // utfx-embeddable\r\n\r\n    /**\r\n     * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/utfx for details\r\n     */\r\n    var utfx = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * utfx namespace.\r\n         * @inner\r\n         * @type {!Object.<string,*>}\r\n         */\r\n        var utfx = {};\r\n\r\n        /**\r\n         * Maximum valid code point.\r\n         * @type {number}\r\n         * @const\r\n         */\r\n        utfx.MAX_CODEPOINT = 0x10FFFF;\r\n\r\n        /**\r\n         * Encodes UTF8 code points to UTF8 bytes.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte\r\n         */\r\n        utfx.encodeUTF8 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src,\r\n                src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp < 0x80)\r\n                    dst(cp&0x7F);\r\n                else if (cp < 0x800)\r\n                    dst(((cp>>6)&0x1F)|0xC0),\r\n                    dst((cp&0x3F)|0x80);\r\n                else if (cp < 0x10000)\r\n                    dst(((cp>>12)&0x0F)|0xE0),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                else\r\n                    dst(((cp>>18)&0x07)|0xF0),\r\n                    dst(((cp>>12)&0x3F)|0x80),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes UTF8 bytes to UTF8 code points.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the\r\n         *  remaining bytes.\r\n         */\r\n        utfx.decodeUTF8 = function(src, dst) {\r\n            var a, b, c, d, fail = function(b) {\r\n                b = b.slice(0, b.indexOf(null));\r\n                var err = Error(b.toString());\r\n                err.name = \"TruncatedError\";\r\n                err['bytes'] = b;\r\n                throw err;\r\n            };\r\n            while ((a = src()) !== null) {\r\n                if ((a&0x80) === 0)\r\n                    dst(a);\r\n                else if ((a&0xE0) === 0xC0)\r\n                    ((b = src()) === null) && fail([a, b]),\r\n                    dst(((a&0x1F)<<6) | (b&0x3F));\r\n                else if ((a&0xF0) === 0xE0)\r\n                    ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),\r\n                    dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));\r\n                else if ((a&0xF8) === 0xF0)\r\n                    ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),\r\n                    dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));\r\n                else throw RangeError(\"Illegal starting byte: \"+a);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts UTF16 characters to UTF8 code points.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each converted code\r\n         *  point.\r\n         */\r\n        utfx.UTF16toUTF8 = function(src, dst) {\r\n            var c1, c2 = null;\r\n            while (true) {\r\n                if ((c1 = c2 !== null ? c2 : src()) === null)\r\n                    break;\r\n                if (c1 >= 0xD800 && c1 <= 0xDFFF) {\r\n                    if ((c2 = src()) !== null) {\r\n                        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {\r\n                            dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);\r\n                            c2 = null; continue;\r\n                        }\r\n                    }\r\n                }\r\n                dst(c1);\r\n            }\r\n            if (c2 !== null) dst(c2);\r\n        };\r\n\r\n        /**\r\n         * Converts UTF8 code points to UTF16 characters.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a code point is out of range\r\n         */\r\n        utfx.UTF8toUTF16 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src, src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp <= 0xFFFF)\r\n                    dst(cp);\r\n                else\r\n                    cp -= 0x10000,\r\n                    dst((cp>>10)+0xD800),\r\n                    dst((cp%0x400)+0xDC00);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts and encodes UTF16 characters to UTF8 bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`\r\n         *  if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         */\r\n        utfx.encodeUTF16toUTF8 = function(src, dst) {\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                utfx.encodeUTF8(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Decodes and converts UTF8 bytes to UTF16 characters.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.\r\n         */\r\n        utfx.decodeUTF8toUTF16 = function(src, dst) {\r\n            utfx.decodeUTF8(src, function(cp) {\r\n                utfx.UTF8toUTF16(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Calculates the byte length of an UTF8 code point.\r\n         * @param {number} cp UTF8 code point\r\n         * @returns {number} Byte length\r\n         */\r\n        utfx.calculateCodePoint = function(cp) {\r\n            return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 bytes required to store UTF8 code points.\r\n         * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively\r\n         *  `null` if there are no more code points left.\r\n         * @returns {number} The number of UTF8 bytes required\r\n         */\r\n        utfx.calculateUTF8 = function(src) {\r\n            var cp, l=0;\r\n            while ((cp = src()) !== null)\r\n                l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            return l;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.\r\n         * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.\r\n         */\r\n        utfx.calculateUTF16asUTF8 = function(src) {\r\n            var n=0, l=0;\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            });\r\n            return [n,l];\r\n        };\r\n\r\n        return utfx;\r\n    }();\r\n\r\n    // encodings/utf8\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded\r\n     *  string.\r\n     * @returns {string} Hex encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toUTF8 = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var sd; try {\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return begin < end ? this.view[begin++] : null;\r\n            }.bind(this), sd = stringDestination());\r\n        } catch (e) {\r\n            if (begin !== end)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+begin+\" != \"+end);\r\n        }\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes an UTF8 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) {\r\n        if (!noAssert)\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n        var bb = new ByteBuffer(utfx.calculateUTF16asUTF8(stringSource(str), true)[1], littleEndian, noAssert),\r\n            i = 0;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    return ByteBuffer;\r\n});\r\n","var Buffer = require(93).Buffer\nvar Transform = require(103).Transform\nvar StringDecoder = require(36).StringDecoder\nvar inherits = require(65)\n\nfunction CipherBase (hashMode) {\n  Transform.call(this)\n  this.hashMode = typeof hashMode === 'string'\n  if (this.hashMode) {\n    this[hashMode] = this._finalOrDigest\n  } else {\n    this.final = this._finalOrDigest\n  }\n  if (this._final) {\n    this.__final = this._final\n    this._final = null\n  }\n  this._decoder = null\n  this._encoding = null\n}\ninherits(CipherBase, Transform)\n\nCipherBase.prototype.update = function (data, inputEnc, outputEnc) {\n  if (typeof data === 'string') {\n    data = Buffer.from(data, inputEnc)\n  }\n\n  var outData = this._update(data)\n  if (this.hashMode) return this\n\n  if (outputEnc) {\n    outData = this._toString(outData, outputEnc)\n  }\n\n  return outData\n}\n\nCipherBase.prototype.setAutoPadding = function () {}\nCipherBase.prototype.getAuthTag = function () {\n  throw new Error('trying to get auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAuthTag = function () {\n  throw new Error('trying to set auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAAD = function () {\n  throw new Error('trying to set aad in unsupported state')\n}\n\nCipherBase.prototype._transform = function (data, _, next) {\n  var err\n  try {\n    if (this.hashMode) {\n      this._update(data)\n    } else {\n      this.push(this._update(data))\n    }\n  } catch (e) {\n    err = e\n  } finally {\n    next(err)\n  }\n}\nCipherBase.prototype._flush = function (done) {\n  var err\n  try {\n    this.push(this.__final())\n  } catch (e) {\n    err = e\n  }\n\n  done(err)\n}\nCipherBase.prototype._finalOrDigest = function (outputEnc) {\n  var outData = this.__final() || Buffer.alloc(0)\n  if (outputEnc) {\n    outData = this._toString(outData, outputEnc, true)\n  }\n  return outData\n}\n\nCipherBase.prototype._toString = function (value, enc, fin) {\n  if (!this._decoder) {\n    this._decoder = new StringDecoder(enc)\n    this._encoding = enc\n  }\n\n  if (this._encoding !== enc) throw new Error('can\\'t switch encodings')\n\n  var out = this._decoder.write(value)\n  if (fin) {\n    out += this._decoder.end()\n  }\n\n  return out\n}\n\nmodule.exports = CipherBase\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","'use strict'\nvar inherits = require(65)\nvar MD5 = require(69)\nvar RIPEMD160 = require(92)\nvar sha = require(96)\nvar Base = require(39)\n\nfunction Hash (hash) {\n  Base.call(this, 'digest')\n\n  this._hash = hash\n}\n\ninherits(Hash, Base)\n\nHash.prototype._update = function (data) {\n  this._hash.update(data)\n}\n\nHash.prototype._final = function () {\n  return this._hash.digest()\n}\n\nmodule.exports = function createHash (alg) {\n  alg = alg.toLowerCase()\n  if (alg === 'md5') return new MD5()\n  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()\n\n  return new Hash(sha(alg))\n}\n","var MD5 = require(69)\n\nmodule.exports = function (buffer) {\n  return new MD5().update(buffer).digest()\n}\n","'use strict'\nvar inherits = require(65)\nvar Legacy = require(44)\nvar Base = require(39)\nvar Buffer = require(93).Buffer\nvar md5 = require(42)\nvar RIPEMD160 = require(92)\n\nvar sha = require(96)\n\nvar ZEROS = Buffer.alloc(128)\n\nfunction Hmac (alg, key) {\n  Base.call(this, 'digest')\n  if (typeof key === 'string') {\n    key = Buffer.from(key)\n  }\n\n  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64\n\n  this._alg = alg\n  this._key = key\n  if (key.length > blocksize) {\n    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n    key = hash.update(key).digest()\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n  var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n  this._hash.update(ipad)\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n  this._hash.update(data)\n}\n\nHmac.prototype._final = function () {\n  var h = this._hash.digest()\n  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)\n  return hash.update(this._opad).update(h).digest()\n}\n\nmodule.exports = function createHmac (alg, key) {\n  alg = alg.toLowerCase()\n  if (alg === 'rmd160' || alg === 'ripemd160') {\n    return new Hmac('rmd160', key)\n  }\n  if (alg === 'md5') {\n    return new Legacy(md5, key)\n  }\n  return new Hmac(alg, key)\n}\n","'use strict'\nvar inherits = require(65)\nvar Buffer = require(93).Buffer\n\nvar Base = require(39)\n\nvar ZEROS = Buffer.alloc(128)\nvar blocksize = 64\n\nfunction Hmac (alg, key) {\n  Base.call(this, 'digest')\n  if (typeof key === 'string') {\n    key = Buffer.from(key)\n  }\n\n  this._alg = alg\n  this._key = key\n\n  if (key.length > blocksize) {\n    key = alg(key)\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n  var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n\n  this._hash = [ipad]\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n  this._hash.push(data)\n}\n\nHmac.prototype._final = function () {\n  var h = this._alg(Buffer.concat(this._hash))\n  return this._alg(Buffer.concat([this._opad, h]))\n}\nmodule.exports = Hmac\n",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47), require(48), require(52), require(50), require(46));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./enc-base64\", \"./md5\", \"./evpkdf\", \"./cipher-core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var BlockCipher = C_lib.BlockCipher;\n\t    var C_algo = C.algo;\n\n\t    // Lookup tables\n\t    var SBOX = [];\n\t    var INV_SBOX = [];\n\t    var SUB_MIX_0 = [];\n\t    var SUB_MIX_1 = [];\n\t    var SUB_MIX_2 = [];\n\t    var SUB_MIX_3 = [];\n\t    var INV_SUB_MIX_0 = [];\n\t    var INV_SUB_MIX_1 = [];\n\t    var INV_SUB_MIX_2 = [];\n\t    var INV_SUB_MIX_3 = [];\n\n\t    // Compute lookup tables\n\t    (function () {\n\t        // Compute double table\n\t        var d = [];\n\t        for (var i = 0; i < 256; i++) {\n\t            if (i < 128) {\n\t                d[i] = i << 1;\n\t            } else {\n\t                d[i] = (i << 1) ^ 0x11b;\n\t            }\n\t        }\n\n\t        // Walk GF(2^8)\n\t        var x = 0;\n\t        var xi = 0;\n\t        for (var i = 0; i < 256; i++) {\n\t            // Compute sbox\n\t            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);\n\t            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;\n\t            SBOX[x] = sx;\n\t            INV_SBOX[sx] = x;\n\n\t            // Compute multiplication\n\t            var x2 = d[x];\n\t            var x4 = d[x2];\n\t            var x8 = d[x4];\n\n\t            // Compute sub bytes, mix columns tables\n\t            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);\n\t            SUB_MIX_0[x] = (t << 24) | (t >>> 8);\n\t            SUB_MIX_1[x] = (t << 16) | (t >>> 16);\n\t            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);\n\t            SUB_MIX_3[x] = t;\n\n\t            // Compute inv sub bytes, inv mix columns tables\n\t            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);\n\t            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);\n\t            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);\n\t            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);\n\t            INV_SUB_MIX_3[sx] = t;\n\n\t            // Compute next counter\n\t            if (!x) {\n\t                x = xi = 1;\n\t            } else {\n\t                x = x2 ^ d[d[d[x8 ^ x2]]];\n\t                xi ^= d[d[xi]];\n\t            }\n\t        }\n\t    }());\n\n\t    // Precomputed Rcon lookup\n\t    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];\n\n\t    /**\n\t     * AES block cipher algorithm.\n\t     */\n\t    var AES = C_algo.AES = BlockCipher.extend({\n\t        _doReset: function () {\n\t            // Skip reset of nRounds has been set before and key did not change\n\t            if (this._nRounds && this._keyPriorReset === this._key) {\n\t                return;\n\t            }\n\n\t            // Shortcuts\n\t            var key = this._keyPriorReset = this._key;\n\t            var keyWords = key.words;\n\t            var keySize = key.sigBytes / 4;\n\n\t            // Compute number of rounds\n\t            var nRounds = this._nRounds = keySize + 6;\n\n\t            // Compute number of key schedule rows\n\t            var ksRows = (nRounds + 1) * 4;\n\n\t            // Compute key schedule\n\t            var keySchedule = this._keySchedule = [];\n\t            for (var ksRow = 0; ksRow < ksRows; ksRow++) {\n\t                if (ksRow < keySize) {\n\t                    keySchedule[ksRow] = keyWords[ksRow];\n\t                } else {\n\t                    var t = keySchedule[ksRow - 1];\n\n\t                    if (!(ksRow % keySize)) {\n\t                        // Rot word\n\t                        t = (t << 8) | (t >>> 24);\n\n\t                        // Sub word\n\t                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\n\t                        // Mix Rcon\n\t                        t ^= RCON[(ksRow / keySize) | 0] << 24;\n\t                    } else if (keySize > 6 && ksRow % keySize == 4) {\n\t                        // Sub word\n\t                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\t                    }\n\n\t                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;\n\t                }\n\t            }\n\n\t            // Compute inv key schedule\n\t            var invKeySchedule = this._invKeySchedule = [];\n\t            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {\n\t                var ksRow = ksRows - invKsRow;\n\n\t                if (invKsRow % 4) {\n\t                    var t = keySchedule[ksRow];\n\t                } else {\n\t                    var t = keySchedule[ksRow - 4];\n\t                }\n\n\t                if (invKsRow < 4 || ksRow <= 4) {\n\t                    invKeySchedule[invKsRow] = t;\n\t                } else {\n\t                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^\n\t                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];\n\t                }\n\t            }\n\t        },\n\n\t        encryptBlock: function (M, offset) {\n\t            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);\n\t        },\n\n\t        decryptBlock: function (M, offset) {\n\t            // Swap 2nd and 4th rows\n\t            var t = M[offset + 1];\n\t            M[offset + 1] = M[offset + 3];\n\t            M[offset + 3] = t;\n\n\t            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);\n\n\t            // Inv swap 2nd and 4th rows\n\t            var t = M[offset + 1];\n\t            M[offset + 1] = M[offset + 3];\n\t            M[offset + 3] = t;\n\t        },\n\n\t        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {\n\t            // Shortcut\n\t            var nRounds = this._nRounds;\n\n\t            // Get input, add round key\n\t            var s0 = M[offset]     ^ keySchedule[0];\n\t            var s1 = M[offset + 1] ^ keySchedule[1];\n\t            var s2 = M[offset + 2] ^ keySchedule[2];\n\t            var s3 = M[offset + 3] ^ keySchedule[3];\n\n\t            // Key schedule row counter\n\t            var ksRow = 4;\n\n\t            // Rounds\n\t            for (var round = 1; round < nRounds; round++) {\n\t                // Shift rows, sub bytes, mix columns, add round key\n\t                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];\n\t                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];\n\t                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];\n\t                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];\n\n\t                // Update state\n\t                s0 = t0;\n\t                s1 = t1;\n\t                s2 = t2;\n\t                s3 = t3;\n\t            }\n\n\t            // Shift rows, sub bytes, add round key\n\t            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];\n\n\t            // Set output\n\t            M[offset]     = t0;\n\t            M[offset + 1] = t1;\n\t            M[offset + 2] = t2;\n\t            M[offset + 3] = t3;\n\t        },\n\n\t        keySize: 256/32\n\t    });\n\n\t    /**\n\t     * Shortcut functions to the cipher's object interface.\n\t     *\n\t     * @example\n\t     *\n\t     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);\n\t     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);\n\t     */\n\t    C.AES = BlockCipher._createHelper(AES);\n\t}());\n\n\n\treturn CryptoJS.AES;\n\n}));",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47), require(50));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./evpkdf\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t/**\n\t * Cipher core components.\n\t */\n\tCryptoJS.lib.Cipher || (function (undefined) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var WordArray = C_lib.WordArray;\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;\n\t    var C_enc = C.enc;\n\t    var Utf8 = C_enc.Utf8;\n\t    var Base64 = C_enc.Base64;\n\t    var C_algo = C.algo;\n\t    var EvpKDF = C_algo.EvpKDF;\n\n\t    /**\n\t     * Abstract base cipher template.\n\t     *\n\t     * @property {number} keySize This cipher's key size. Default: 4 (128 bits)\n\t     * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)\n\t     * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.\n\t     * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.\n\t     */\n\t    var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {WordArray} iv The IV to use for this operation.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Creates this cipher in encryption mode.\n\t         *\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {Cipher} A cipher instance.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });\n\t         */\n\t        createEncryptor: function (key, cfg) {\n\t            return this.create(this._ENC_XFORM_MODE, key, cfg);\n\t        },\n\n\t        /**\n\t         * Creates this cipher in decryption mode.\n\t         *\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {Cipher} A cipher instance.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });\n\t         */\n\t        createDecryptor: function (key, cfg) {\n\t            return this.create(this._DEC_XFORM_MODE, key, cfg);\n\t        },\n\n\t        /**\n\t         * Initializes a newly created cipher.\n\t         *\n\t         * @param {number} xformMode Either the encryption or decryption transormation mode constant.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });\n\t         */\n\t        init: function (xformMode, key, cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Store transform mode and key\n\t            this._xformMode = xformMode;\n\t            this._key = key;\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this cipher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     cipher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-cipher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Adds data to be encrypted or decrypted.\n\t         *\n\t         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.\n\t         *\n\t         * @return {WordArray} The data after processing.\n\t         *\n\t         * @example\n\t         *\n\t         *     var encrypted = cipher.process('data');\n\t         *     var encrypted = cipher.process(wordArray);\n\t         */\n\t        process: function (dataUpdate) {\n\t            // Append\n\t            this._append(dataUpdate);\n\n\t            // Process available blocks\n\t            return this._process();\n\t        },\n\n\t        /**\n\t         * Finalizes the encryption or decryption process.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.\n\t         *\n\t         * @return {WordArray} The data after final processing.\n\t         *\n\t         * @example\n\t         *\n\t         *     var encrypted = cipher.finalize();\n\t         *     var encrypted = cipher.finalize('data');\n\t         *     var encrypted = cipher.finalize(wordArray);\n\t         */\n\t        finalize: function (dataUpdate) {\n\t            // Final data update\n\t            if (dataUpdate) {\n\t                this._append(dataUpdate);\n\t            }\n\n\t            // Perform concrete-cipher logic\n\t            var finalProcessedData = this._doFinalize();\n\n\t            return finalProcessedData;\n\t        },\n\n\t        keySize: 128/32,\n\n\t        ivSize: 128/32,\n\n\t        _ENC_XFORM_MODE: 1,\n\n\t        _DEC_XFORM_MODE: 2,\n\n\t        /**\n\t         * Creates shortcut functions to a cipher's object interface.\n\t         *\n\t         * @param {Cipher} cipher The cipher to create a helper for.\n\t         *\n\t         * @return {Object} An object with encrypt and decrypt shortcut functions.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);\n\t         */\n\t        _createHelper: (function () {\n\t            function selectCipherStrategy(key) {\n\t                if (typeof key == 'string') {\n\t                    return PasswordBasedCipher;\n\t                } else {\n\t                    return SerializableCipher;\n\t                }\n\t            }\n\n\t            return function (cipher) {\n\t                return {\n\t                    encrypt: function (message, key, cfg) {\n\t                        return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);\n\t                    },\n\n\t                    decrypt: function (ciphertext, key, cfg) {\n\t                        return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);\n\t                    }\n\t                };\n\t            };\n\t        }())\n\t    });\n\n\t    /**\n\t     * Abstract base stream cipher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)\n\t     */\n\t    var StreamCipher = C_lib.StreamCipher = Cipher.extend({\n\t        _doFinalize: function () {\n\t            // Process partial blocks\n\t            var finalProcessedBlocks = this._process(!!'flush');\n\n\t            return finalProcessedBlocks;\n\t        },\n\n\t        blockSize: 1\n\t    });\n\n\t    /**\n\t     * Mode namespace.\n\t     */\n\t    var C_mode = C.mode = {};\n\n\t    /**\n\t     * Abstract base block cipher mode template.\n\t     */\n\t    var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({\n\t        /**\n\t         * Creates this mode for encryption.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);\n\t         */\n\t        createEncryptor: function (cipher, iv) {\n\t            return this.Encryptor.create(cipher, iv);\n\t        },\n\n\t        /**\n\t         * Creates this mode for decryption.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);\n\t         */\n\t        createDecryptor: function (cipher, iv) {\n\t            return this.Decryptor.create(cipher, iv);\n\t        },\n\n\t        /**\n\t         * Initializes a newly created mode.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);\n\t         */\n\t        init: function (cipher, iv) {\n\t            this._cipher = cipher;\n\t            this._iv = iv;\n\t        }\n\t    });\n\n\t    /**\n\t     * Cipher Block Chaining mode.\n\t     */\n\t    var CBC = C_mode.CBC = (function () {\n\t        /**\n\t         * Abstract base CBC mode.\n\t         */\n\t        var CBC = BlockCipherMode.extend();\n\n\t        /**\n\t         * CBC encryptor.\n\t         */\n\t        CBC.Encryptor = CBC.extend({\n\t            /**\n\t             * Processes the data block at offset.\n\t             *\n\t             * @param {Array} words The data words to operate on.\n\t             * @param {number} offset The offset where the block starts.\n\t             *\n\t             * @example\n\t             *\n\t             *     mode.processBlock(data.words, offset);\n\t             */\n\t            processBlock: function (words, offset) {\n\t                // Shortcuts\n\t                var cipher = this._cipher;\n\t                var blockSize = cipher.blockSize;\n\n\t                // XOR and encrypt\n\t                xorBlock.call(this, words, offset, blockSize);\n\t                cipher.encryptBlock(words, offset);\n\n\t                // Remember this block to use with next block\n\t                this._prevBlock = words.slice(offset, offset + blockSize);\n\t            }\n\t        });\n\n\t        /**\n\t         * CBC decryptor.\n\t         */\n\t        CBC.Decryptor = CBC.extend({\n\t            /**\n\t             * Processes the data block at offset.\n\t             *\n\t             * @param {Array} words The data words to operate on.\n\t             * @param {number} offset The offset where the block starts.\n\t             *\n\t             * @example\n\t             *\n\t             *     mode.processBlock(data.words, offset);\n\t             */\n\t            processBlock: function (words, offset) {\n\t                // Shortcuts\n\t                var cipher = this._cipher;\n\t                var blockSize = cipher.blockSize;\n\n\t                // Remember this block to use with next block\n\t                var thisBlock = words.slice(offset, offset + blockSize);\n\n\t                // Decrypt and XOR\n\t                cipher.decryptBlock(words, offset);\n\t                xorBlock.call(this, words, offset, blockSize);\n\n\t                // This block becomes the previous block\n\t                this._prevBlock = thisBlock;\n\t            }\n\t        });\n\n\t        function xorBlock(words, offset, blockSize) {\n\t            // Shortcut\n\t            var iv = this._iv;\n\n\t            // Choose mixing block\n\t            if (iv) {\n\t                var block = iv;\n\n\t                // Remove IV for subsequent blocks\n\t                this._iv = undefined;\n\t            } else {\n\t                var block = this._prevBlock;\n\t            }\n\n\t            // XOR blocks\n\t            for (var i = 0; i < blockSize; i++) {\n\t                words[offset + i] ^= block[i];\n\t            }\n\t        }\n\n\t        return CBC;\n\t    }());\n\n\t    /**\n\t     * Padding namespace.\n\t     */\n\t    var C_pad = C.pad = {};\n\n\t    /**\n\t     * PKCS #5/7 padding strategy.\n\t     */\n\t    var Pkcs7 = C_pad.Pkcs7 = {\n\t        /**\n\t         * Pads data using the algorithm defined in PKCS #5/7.\n\t         *\n\t         * @param {WordArray} data The data to pad.\n\t         * @param {number} blockSize The multiple that the data should be padded to.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);\n\t         */\n\t        pad: function (data, blockSize) {\n\t            // Shortcut\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count padding bytes\n\t            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;\n\n\t            // Create padding word\n\t            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;\n\n\t            // Create padding\n\t            var paddingWords = [];\n\t            for (var i = 0; i < nPaddingBytes; i += 4) {\n\t                paddingWords.push(paddingWord);\n\t            }\n\t            var padding = WordArray.create(paddingWords, nPaddingBytes);\n\n\t            // Add padding\n\t            data.concat(padding);\n\t        },\n\n\t        /**\n\t         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.\n\t         *\n\t         * @param {WordArray} data The data to unpad.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     CryptoJS.pad.Pkcs7.unpad(wordArray);\n\t         */\n\t        unpad: function (data) {\n\t            // Get number of padding bytes from last byte\n\t            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;\n\n\t            // Remove padding\n\t            data.sigBytes -= nPaddingBytes;\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract base block cipher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)\n\t     */\n\t    var BlockCipher = C_lib.BlockCipher = Cipher.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {Mode} mode The block mode to use. Default: CBC\n\t         * @property {Padding} padding The padding strategy to use. Default: Pkcs7\n\t         */\n\t        cfg: Cipher.cfg.extend({\n\t            mode: CBC,\n\t            padding: Pkcs7\n\t        }),\n\n\t        reset: function () {\n\t            // Reset cipher\n\t            Cipher.reset.call(this);\n\n\t            // Shortcuts\n\t            var cfg = this.cfg;\n\t            var iv = cfg.iv;\n\t            var mode = cfg.mode;\n\n\t            // Reset block mode\n\t            if (this._xformMode == this._ENC_XFORM_MODE) {\n\t                var modeCreator = mode.createEncryptor;\n\t            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n\t                var modeCreator = mode.createDecryptor;\n\t                // Keep at least one block in the buffer for unpadding\n\t                this._minBufferSize = 1;\n\t            }\n\n\t            if (this._mode && this._mode.__creator == modeCreator) {\n\t                this._mode.init(this, iv && iv.words);\n\t            } else {\n\t                this._mode = modeCreator.call(mode, this, iv && iv.words);\n\t                this._mode.__creator = modeCreator;\n\t            }\n\t        },\n\n\t        _doProcessBlock: function (words, offset) {\n\t            this._mode.processBlock(words, offset);\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcut\n\t            var padding = this.cfg.padding;\n\n\t            // Finalize\n\t            if (this._xformMode == this._ENC_XFORM_MODE) {\n\t                // Pad data\n\t                padding.pad(this._data, this.blockSize);\n\n\t                // Process final blocks\n\t                var finalProcessedBlocks = this._process(!!'flush');\n\t            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n\t                // Process final blocks\n\t                var finalProcessedBlocks = this._process(!!'flush');\n\n\t                // Unpad data\n\t                padding.unpad(finalProcessedBlocks);\n\t            }\n\n\t            return finalProcessedBlocks;\n\t        },\n\n\t        blockSize: 128/32\n\t    });\n\n\t    /**\n\t     * A collection of cipher parameters.\n\t     *\n\t     * @property {WordArray} ciphertext The raw ciphertext.\n\t     * @property {WordArray} key The key to this ciphertext.\n\t     * @property {WordArray} iv The IV used in the ciphering operation.\n\t     * @property {WordArray} salt The salt used with a key derivation function.\n\t     * @property {Cipher} algorithm The cipher algorithm.\n\t     * @property {Mode} mode The block mode used in the ciphering operation.\n\t     * @property {Padding} padding The padding scheme used in the ciphering operation.\n\t     * @property {number} blockSize The block size of the cipher.\n\t     * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.\n\t     */\n\t    var CipherParams = C_lib.CipherParams = Base.extend({\n\t        /**\n\t         * Initializes a newly created cipher params object.\n\t         *\n\t         * @param {Object} cipherParams An object with any of the possible cipher parameters.\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipherParams = CryptoJS.lib.CipherParams.create({\n\t         *         ciphertext: ciphertextWordArray,\n\t         *         key: keyWordArray,\n\t         *         iv: ivWordArray,\n\t         *         salt: saltWordArray,\n\t         *         algorithm: CryptoJS.algo.AES,\n\t         *         mode: CryptoJS.mode.CBC,\n\t         *         padding: CryptoJS.pad.PKCS7,\n\t         *         blockSize: 4,\n\t         *         formatter: CryptoJS.format.OpenSSL\n\t         *     });\n\t         */\n\t        init: function (cipherParams) {\n\t            this.mixIn(cipherParams);\n\t        },\n\n\t        /**\n\t         * Converts this cipher params object to a string.\n\t         *\n\t         * @param {Format} formatter (Optional) The formatting strategy to use.\n\t         *\n\t         * @return {string} The stringified cipher params.\n\t         *\n\t         * @throws Error If neither the formatter nor the default formatter is set.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = cipherParams + '';\n\t         *     var string = cipherParams.toString();\n\t         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);\n\t         */\n\t        toString: function (formatter) {\n\t            return (formatter || this.formatter).stringify(this);\n\t        }\n\t    });\n\n\t    /**\n\t     * Format namespace.\n\t     */\n\t    var C_format = C.format = {};\n\n\t    /**\n\t     * OpenSSL formatting strategy.\n\t     */\n\t    var OpenSSLFormatter = C_format.OpenSSL = {\n\t        /**\n\t         * Converts a cipher params object to an OpenSSL-compatible string.\n\t         *\n\t         * @param {CipherParams} cipherParams The cipher params object.\n\t         *\n\t         * @return {string} The OpenSSL-compatible string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);\n\t         */\n\t        stringify: function (cipherParams) {\n\t            // Shortcuts\n\t            var ciphertext = cipherParams.ciphertext;\n\t            var salt = cipherParams.salt;\n\n\t            // Format\n\t            if (salt) {\n\t                var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);\n\t            } else {\n\t                var wordArray = ciphertext;\n\t            }\n\n\t            return wordArray.toString(Base64);\n\t        },\n\n\t        /**\n\t         * Converts an OpenSSL-compatible string to a cipher params object.\n\t         *\n\t         * @param {string} openSSLStr The OpenSSL-compatible string.\n\t         *\n\t         * @return {CipherParams} The cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);\n\t         */\n\t        parse: function (openSSLStr) {\n\t            // Parse base64\n\t            var ciphertext = Base64.parse(openSSLStr);\n\n\t            // Shortcut\n\t            var ciphertextWords = ciphertext.words;\n\n\t            // Test for salt\n\t            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {\n\t                // Extract salt\n\t                var salt = WordArray.create(ciphertextWords.slice(2, 4));\n\n\t                // Remove salt from ciphertext\n\t                ciphertextWords.splice(0, 4);\n\t                ciphertext.sigBytes -= 16;\n\t            }\n\n\t            return CipherParams.create({ ciphertext: ciphertext, salt: salt });\n\t        }\n\t    };\n\n\t    /**\n\t     * A cipher wrapper that returns ciphertext as a serializable cipher params object.\n\t     */\n\t    var SerializableCipher = C_lib.SerializableCipher = Base.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL\n\t         */\n\t        cfg: Base.extend({\n\t            format: OpenSSLFormatter\n\t        }),\n\n\t        /**\n\t         * Encrypts a message.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {WordArray|string} message The message to encrypt.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {CipherParams} A cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         */\n\t        encrypt: function (cipher, message, key, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Encrypt\n\t            var encryptor = cipher.createEncryptor(key, cfg);\n\t            var ciphertext = encryptor.finalize(message);\n\n\t            // Shortcut\n\t            var cipherCfg = encryptor.cfg;\n\n\t            // Create and return serializable cipher params\n\t            return CipherParams.create({\n\t                ciphertext: ciphertext,\n\t                key: key,\n\t                iv: cipherCfg.iv,\n\t                algorithm: cipher,\n\t                mode: cipherCfg.mode,\n\t                padding: cipherCfg.padding,\n\t                blockSize: cipher.blockSize,\n\t                formatter: cfg.format\n\t            });\n\t        },\n\n\t        /**\n\t         * Decrypts serialized ciphertext.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {WordArray} The plaintext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         */\n\t        decrypt: function (cipher, ciphertext, key, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Convert string to CipherParams\n\t            ciphertext = this._parse(ciphertext, cfg.format);\n\n\t            // Decrypt\n\t            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);\n\n\t            return plaintext;\n\t        },\n\n\t        /**\n\t         * Converts serialized ciphertext to CipherParams,\n\t         * else assumed CipherParams already and returns ciphertext unchanged.\n\t         *\n\t         * @param {CipherParams|string} ciphertext The ciphertext.\n\t         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.\n\t         *\n\t         * @return {CipherParams} The unserialized ciphertext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);\n\t         */\n\t        _parse: function (ciphertext, format) {\n\t            if (typeof ciphertext == 'string') {\n\t                return format.parse(ciphertext, this);\n\t            } else {\n\t                return ciphertext;\n\t            }\n\t        }\n\t    });\n\n\t    /**\n\t     * Key derivation function namespace.\n\t     */\n\t    var C_kdf = C.kdf = {};\n\n\t    /**\n\t     * OpenSSL key derivation function.\n\t     */\n\t    var OpenSSLKdf = C_kdf.OpenSSL = {\n\t        /**\n\t         * Derives a key and IV from a password.\n\t         *\n\t         * @param {string} password The password to derive from.\n\t         * @param {number} keySize The size in words of the key to generate.\n\t         * @param {number} ivSize The size in words of the IV to generate.\n\t         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.\n\t         *\n\t         * @return {CipherParams} A cipher params object with the key, IV, and salt.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);\n\t         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');\n\t         */\n\t        execute: function (password, keySize, ivSize, salt) {\n\t            // Generate random salt\n\t            if (!salt) {\n\t                salt = WordArray.random(64/8);\n\t            }\n\n\t            // Derive key and IV\n\t            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);\n\n\t            // Separate key and IV\n\t            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);\n\t            key.sigBytes = keySize * 4;\n\n\t            // Return params\n\t            return CipherParams.create({ key: key, iv: iv, salt: salt });\n\t        }\n\t    };\n\n\t    /**\n\t     * A serializable cipher wrapper that derives the key from a password,\n\t     * and returns ciphertext as a serializable cipher params object.\n\t     */\n\t    var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL\n\t         */\n\t        cfg: SerializableCipher.cfg.extend({\n\t            kdf: OpenSSLKdf\n\t        }),\n\n\t        /**\n\t         * Encrypts a message using a password.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {WordArray|string} message The message to encrypt.\n\t         * @param {string} password The password.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {CipherParams} A cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');\n\t         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });\n\t         */\n\t        encrypt: function (cipher, message, password, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Derive key and other params\n\t            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);\n\n\t            // Add IV to config\n\t            cfg.iv = derivedParams.iv;\n\n\t            // Encrypt\n\t            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);\n\n\t            // Mix in derived params\n\t            ciphertext.mixIn(derivedParams);\n\n\t            return ciphertext;\n\t        },\n\n\t        /**\n\t         * Decrypts serialized ciphertext using a password.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n\t         * @param {string} password The password.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {WordArray} The plaintext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });\n\t         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });\n\t         */\n\t        decrypt: function (cipher, ciphertext, password, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Convert string to CipherParams\n\t            ciphertext = this._parse(ciphertext, cfg.format);\n\n\t            // Derive key and other params\n\t            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);\n\n\t            // Add IV to config\n\t            cfg.iv = derivedParams.iv;\n\n\t            // Decrypt\n\t            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);\n\n\t            return plaintext;\n\t        }\n\t    });\n\t}());\n\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory();\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\troot.CryptoJS = factory();\n\t}\n}(this, function () {\n\n\t/**\n\t * CryptoJS core components.\n\t */\n\tvar CryptoJS = CryptoJS || (function (Math, undefined) {\n\t    /*\n\t     * Local polyfil of Object.create\n\t     */\n\t    var create = Object.create || (function () {\n\t        function F() {};\n\n\t        return function (obj) {\n\t            var subtype;\n\n\t            F.prototype = obj;\n\n\t            subtype = new F();\n\n\t            F.prototype = null;\n\n\t            return subtype;\n\t        };\n\t    }())\n\n\t    /**\n\t     * CryptoJS namespace.\n\t     */\n\t    var C = {};\n\n\t    /**\n\t     * Library namespace.\n\t     */\n\t    var C_lib = C.lib = {};\n\n\t    /**\n\t     * Base object for prototypal inheritance.\n\t     */\n\t    var Base = C_lib.Base = (function () {\n\n\n\t        return {\n\t            /**\n\t             * Creates a new object that inherits from this object.\n\t             *\n\t             * @param {Object} overrides Properties to copy into the new object.\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         field: 'value',\n\t             *\n\t             *         method: function () {\n\t             *         }\n\t             *     });\n\t             */\n\t            extend: function (overrides) {\n\t                // Spawn\n\t                var subtype = create(this);\n\n\t                // Augment\n\t                if (overrides) {\n\t                    subtype.mixIn(overrides);\n\t                }\n\n\t                // Create default initializer\n\t                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n\t                    subtype.init = function () {\n\t                        subtype.$super.init.apply(this, arguments);\n\t                    };\n\t                }\n\n\t                // Initializer's prototype is the subtype object\n\t                subtype.init.prototype = subtype;\n\n\t                // Reference supertype\n\t                subtype.$super = this;\n\n\t                return subtype;\n\t            },\n\n\t            /**\n\t             * Extends this object and runs the init method.\n\t             * Arguments to create() will be passed to init().\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var instance = MyType.create();\n\t             */\n\t            create: function () {\n\t                var instance = this.extend();\n\t                instance.init.apply(instance, arguments);\n\n\t                return instance;\n\t            },\n\n\t            /**\n\t             * Initializes a newly created object.\n\t             * Override this method to add some logic when your objects are created.\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         init: function () {\n\t             *             // ...\n\t             *         }\n\t             *     });\n\t             */\n\t            init: function () {\n\t            },\n\n\t            /**\n\t             * Copies properties into this object.\n\t             *\n\t             * @param {Object} properties The properties to mix in.\n\t             *\n\t             * @example\n\t             *\n\t             *     MyType.mixIn({\n\t             *         field: 'value'\n\t             *     });\n\t             */\n\t            mixIn: function (properties) {\n\t                for (var propertyName in properties) {\n\t                    if (properties.hasOwnProperty(propertyName)) {\n\t                        this[propertyName] = properties[propertyName];\n\t                    }\n\t                }\n\n\t                // IE won't copy toString using the loop above\n\t                if (properties.hasOwnProperty('toString')) {\n\t                    this.toString = properties.toString;\n\t                }\n\t            },\n\n\t            /**\n\t             * Creates a copy of this object.\n\t             *\n\t             * @return {Object} The clone.\n\t             *\n\t             * @example\n\t             *\n\t             *     var clone = instance.clone();\n\t             */\n\t            clone: function () {\n\t                return this.init.prototype.extend(this);\n\t            }\n\t        };\n\t    }());\n\n\t    /**\n\t     * An array of 32-bit words.\n\t     *\n\t     * @property {Array} words The array of 32-bit words.\n\t     * @property {number} sigBytes The number of significant bytes in this word array.\n\t     */\n\t    var WordArray = C_lib.WordArray = Base.extend({\n\t        /**\n\t         * Initializes a newly created word array.\n\t         *\n\t         * @param {Array} words (Optional) An array of 32-bit words.\n\t         * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.create();\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n\t         */\n\t        init: function (words, sigBytes) {\n\t            words = this.words = words || [];\n\n\t            if (sigBytes != undefined) {\n\t                this.sigBytes = sigBytes;\n\t            } else {\n\t                this.sigBytes = words.length * 4;\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts this word array to a string.\n\t         *\n\t         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n\t         *\n\t         * @return {string} The stringified word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = wordArray + '';\n\t         *     var string = wordArray.toString();\n\t         *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n\t         */\n\t        toString: function (encoder) {\n\t            return (encoder || Hex).stringify(this);\n\t        },\n\n\t        /**\n\t         * Concatenates a word array to this word array.\n\t         *\n\t         * @param {WordArray} wordArray The word array to append.\n\t         *\n\t         * @return {WordArray} This word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray1.concat(wordArray2);\n\t         */\n\t        concat: function (wordArray) {\n\t            // Shortcuts\n\t            var thisWords = this.words;\n\t            var thatWords = wordArray.words;\n\t            var thisSigBytes = this.sigBytes;\n\t            var thatSigBytes = wordArray.sigBytes;\n\n\t            // Clamp excess bits\n\t            this.clamp();\n\n\t            // Concat\n\t            if (thisSigBytes % 4) {\n\t                // Copy one byte at a time\n\t                for (var i = 0; i < thatSigBytes; i++) {\n\t                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n\t                }\n\t            } else {\n\t                // Copy one word at a time\n\t                for (var i = 0; i < thatSigBytes; i += 4) {\n\t                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n\t                }\n\t            }\n\t            this.sigBytes += thatSigBytes;\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Removes insignificant bits.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray.clamp();\n\t         */\n\t        clamp: function () {\n\t            // Shortcuts\n\t            var words = this.words;\n\t            var sigBytes = this.sigBytes;\n\n\t            // Clamp\n\t            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n\t            words.length = Math.ceil(sigBytes / 4);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this word array.\n\t         *\n\t         * @return {WordArray} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = wordArray.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone.words = this.words.slice(0);\n\n\t            return clone;\n\t        },\n\n\t        /**\n\t         * Creates a word array filled with random bytes.\n\t         *\n\t         * @param {number} nBytes The number of random bytes to generate.\n\t         *\n\t         * @return {WordArray} The random word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.random(16);\n\t         */\n\t        random: function (nBytes) {\n\t            var words = [];\n\n\t            var r = (function (m_w) {\n\t                var m_w = m_w;\n\t                var m_z = 0x3ade68b1;\n\t                var mask = 0xffffffff;\n\n\t                return function () {\n\t                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;\n\t                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;\n\t                    var result = ((m_z << 0x10) + m_w) & mask;\n\t                    result /= 0x100000000;\n\t                    result += 0.5;\n\t                    return result * (Math.random() > .5 ? 1 : -1);\n\t                }\n\t            });\n\n\t            for (var i = 0, rcache; i < nBytes; i += 4) {\n\t                var _r = r((rcache || Math.random()) * 0x100000000);\n\n\t                rcache = _r() * 0x3ade67b7;\n\t                words.push((_r() * 0x100000000) | 0);\n\t            }\n\n\t            return new WordArray.init(words, nBytes);\n\t        }\n\t    });\n\n\t    /**\n\t     * Encoder namespace.\n\t     */\n\t    var C_enc = C.enc = {};\n\n\t    /**\n\t     * Hex encoding strategy.\n\t     */\n\t    var Hex = C_enc.Hex = {\n\t        /**\n\t         * Converts a word array to a hex string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The hex string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var hexChars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                hexChars.push((bite >>> 4).toString(16));\n\t                hexChars.push((bite & 0x0f).toString(16));\n\t            }\n\n\t            return hexChars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a hex string to a word array.\n\t         *\n\t         * @param {string} hexStr The hex string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n\t         */\n\t        parse: function (hexStr) {\n\t            // Shortcut\n\t            var hexStrLength = hexStr.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < hexStrLength; i += 2) {\n\t                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n\t            }\n\n\t            return new WordArray.init(words, hexStrLength / 2);\n\t        }\n\t    };\n\n\t    /**\n\t     * Latin1 encoding strategy.\n\t     */\n\t    var Latin1 = C_enc.Latin1 = {\n\t        /**\n\t         * Converts a word array to a Latin1 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Latin1 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var latin1Chars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                latin1Chars.push(String.fromCharCode(bite));\n\t            }\n\n\t            return latin1Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Latin1 string to a word array.\n\t         *\n\t         * @param {string} latin1Str The Latin1 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n\t         */\n\t        parse: function (latin1Str) {\n\t            // Shortcut\n\t            var latin1StrLength = latin1Str.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < latin1StrLength; i++) {\n\t                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n\t            }\n\n\t            return new WordArray.init(words, latin1StrLength);\n\t        }\n\t    };\n\n\t    /**\n\t     * UTF-8 encoding strategy.\n\t     */\n\t    var Utf8 = C_enc.Utf8 = {\n\t        /**\n\t         * Converts a word array to a UTF-8 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The UTF-8 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            try {\n\t                return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n\t            } catch (e) {\n\t                throw new Error('Malformed UTF-8 data');\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts a UTF-8 string to a word array.\n\t         *\n\t         * @param {string} utf8Str The UTF-8 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n\t         */\n\t        parse: function (utf8Str) {\n\t            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract buffered block algorithm template.\n\t     *\n\t     * The property blockSize must be implemented in a concrete subtype.\n\t     *\n\t     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n\t     */\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\t        /**\n\t         * Resets this block algorithm's data buffer to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm.reset();\n\t         */\n\t        reset: function () {\n\t            // Initial values\n\t            this._data = new WordArray.init();\n\t            this._nDataBytes = 0;\n\t        },\n\n\t        /**\n\t         * Adds new data to this block algorithm's buffer.\n\t         *\n\t         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm._append('data');\n\t         *     bufferedBlockAlgorithm._append(wordArray);\n\t         */\n\t        _append: function (data) {\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof data == 'string') {\n\t                data = Utf8.parse(data);\n\t            }\n\n\t            // Append\n\t            this._data.concat(data);\n\t            this._nDataBytes += data.sigBytes;\n\t        },\n\n\t        /**\n\t         * Processes available data blocks.\n\t         *\n\t         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n\t         *\n\t         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n\t         *\n\t         * @return {WordArray} The processed data.\n\t         *\n\t         * @example\n\t         *\n\t         *     var processedData = bufferedBlockAlgorithm._process();\n\t         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n\t         */\n\t        _process: function (doFlush) {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\t            var dataSigBytes = data.sigBytes;\n\t            var blockSize = this.blockSize;\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count blocks ready\n\t            var nBlocksReady = dataSigBytes / blockSizeBytes;\n\t            if (doFlush) {\n\t                // Round up to include partial blocks\n\t                nBlocksReady = Math.ceil(nBlocksReady);\n\t            } else {\n\t                // Round down to include only full blocks,\n\t                // less the number of blocks that must remain in the buffer\n\t                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n\t            }\n\n\t            // Count words ready\n\t            var nWordsReady = nBlocksReady * blockSize;\n\n\t            // Count bytes ready\n\t            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n\t            // Process blocks\n\t            if (nWordsReady) {\n\t                for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n\t                    // Perform concrete-algorithm logic\n\t                    this._doProcessBlock(dataWords, offset);\n\t                }\n\n\t                // Remove processed words\n\t                var processedWords = dataWords.splice(0, nWordsReady);\n\t                data.sigBytes -= nBytesReady;\n\t            }\n\n\t            // Return processed words\n\t            return new WordArray.init(processedWords, nBytesReady);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this object.\n\t         *\n\t         * @return {Object} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = bufferedBlockAlgorithm.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone._data = this._data.clone();\n\n\t            return clone;\n\t        },\n\n\t        _minBufferSize: 0\n\t    });\n\n\t    /**\n\t     * Abstract hasher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n\t     */\n\t    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Initializes a newly created hasher.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hasher = CryptoJS.algo.SHA256.create();\n\t         */\n\t        init: function (cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this hasher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-hasher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Updates this hasher with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {Hasher} This hasher.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.update('message');\n\t         *     hasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            // Append\n\t            this._append(messageUpdate);\n\n\t            // Update the hash\n\t            this._process();\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the hash computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The hash.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hash = hasher.finalize();\n\t         *     var hash = hasher.finalize('message');\n\t         *     var hash = hasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Final message update\n\t            if (messageUpdate) {\n\t                this._append(messageUpdate);\n\t            }\n\n\t            // Perform concrete-hasher logic\n\t            var hash = this._doFinalize();\n\n\t            return hash;\n\t        },\n\n\t        blockSize: 512/32,\n\n\t        /**\n\t         * Creates a shortcut function to a hasher's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to create a helper for.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHelper: function (hasher) {\n\t            return function (message, cfg) {\n\t                return new hasher.init(cfg).finalize(message);\n\t            };\n\t        },\n\n\t        /**\n\t         * Creates a shortcut function to the HMAC's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to use in this HMAC helper.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHmacHelper: function (hasher) {\n\t            return function (message, key) {\n\t                return new C_algo.HMAC.init(hasher, key).finalize(message);\n\t            };\n\t        }\n\t    });\n\n\t    /**\n\t     * Algorithm namespace.\n\t     */\n\t    var C_algo = C.algo = {};\n\n\t    return C;\n\t}(Math));\n\n\n\treturn CryptoJS;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var C_enc = C.enc;\n\n\t    /**\n\t     * Base64 encoding strategy.\n\t     */\n\t    var Base64 = C_enc.Base64 = {\n\t        /**\n\t         * Converts a word array to a Base64 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Base64 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\t            var map = this._map;\n\n\t            // Clamp excess bits\n\t            wordArray.clamp();\n\n\t            // Convert\n\t            var base64Chars = [];\n\t            for (var i = 0; i < sigBytes; i += 3) {\n\t                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;\n\t                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n\t                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n\t                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n\t                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {\n\t                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n\t                }\n\t            }\n\n\t            // Add padding\n\t            var paddingChar = map.charAt(64);\n\t            if (paddingChar) {\n\t                while (base64Chars.length % 4) {\n\t                    base64Chars.push(paddingChar);\n\t                }\n\t            }\n\n\t            return base64Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Base64 string to a word array.\n\t         *\n\t         * @param {string} base64Str The Base64 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);\n\t         */\n\t        parse: function (base64Str) {\n\t            // Shortcuts\n\t            var base64StrLength = base64Str.length;\n\t            var map = this._map;\n\t            var reverseMap = this._reverseMap;\n\n\t            if (!reverseMap) {\n\t                    reverseMap = this._reverseMap = [];\n\t                    for (var j = 0; j < map.length; j++) {\n\t                        reverseMap[map.charCodeAt(j)] = j;\n\t                    }\n\t            }\n\n\t            // Ignore padding\n\t            var paddingChar = map.charAt(64);\n\t            if (paddingChar) {\n\t                var paddingIndex = base64Str.indexOf(paddingChar);\n\t                if (paddingIndex !== -1) {\n\t                    base64StrLength = paddingIndex;\n\t                }\n\t            }\n\n\t            // Convert\n\t            return parseLoop(base64Str, base64StrLength, reverseMap);\n\n\t        },\n\n\t        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='\n\t    };\n\n\t    function parseLoop(base64Str, base64StrLength, reverseMap) {\n\t      var words = [];\n\t      var nBytes = 0;\n\t      for (var i = 0; i < base64StrLength; i++) {\n\t          if (i % 4) {\n\t              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);\n\t              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);\n\t              words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);\n\t              nBytes++;\n\t          }\n\t      }\n\t      return WordArray.create(words, nBytes);\n\t    }\n\t}());\n\n\n\treturn CryptoJS.enc.Base64;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\treturn CryptoJS.enc.Hex;\n\n}));",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47), require(53), require(51));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./sha1\", \"./hmac\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var WordArray = C_lib.WordArray;\n\t    var C_algo = C.algo;\n\t    var MD5 = C_algo.MD5;\n\n\t    /**\n\t     * This key derivation function is meant to conform with EVP_BytesToKey.\n\t     * www.openssl.org/docs/crypto/EVP_BytesToKey.html\n\t     */\n\t    var EvpKDF = C_algo.EvpKDF = Base.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\n\t         * @property {Hasher} hasher The hash algorithm to use. Default: MD5\n\t         * @property {number} iterations The number of iterations to perform. Default: 1\n\t         */\n\t        cfg: Base.extend({\n\t            keySize: 128/32,\n\t            hasher: MD5,\n\t            iterations: 1\n\t        }),\n\n\t        /**\n\t         * Initializes a newly created key derivation function.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for the derivation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create();\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });\n\t         */\n\t        init: function (cfg) {\n\t            this.cfg = this.cfg.extend(cfg);\n\t        },\n\n\t        /**\n\t         * Derives a key from a password.\n\t         *\n\t         * @param {WordArray|string} password The password.\n\t         * @param {WordArray|string} salt A salt.\n\t         *\n\t         * @return {WordArray} The derived key.\n\t         *\n\t         * @example\n\t         *\n\t         *     var key = kdf.compute(password, salt);\n\t         */\n\t        compute: function (password, salt) {\n\t            // Shortcut\n\t            var cfg = this.cfg;\n\n\t            // Init hasher\n\t            var hasher = cfg.hasher.create();\n\n\t            // Initial values\n\t            var derivedKey = WordArray.create();\n\n\t            // Shortcuts\n\t            var derivedKeyWords = derivedKey.words;\n\t            var keySize = cfg.keySize;\n\t            var iterations = cfg.iterations;\n\n\t            // Generate key\n\t            while (derivedKeyWords.length < keySize) {\n\t                if (block) {\n\t                    hasher.update(block);\n\t                }\n\t                var block = hasher.update(password).finalize(salt);\n\t                hasher.reset();\n\n\t                // Iterations\n\t                for (var i = 1; i < iterations; i++) {\n\t                    block = hasher.finalize(block);\n\t                    hasher.reset();\n\t                }\n\n\t                derivedKey.concat(block);\n\t            }\n\t            derivedKey.sigBytes = keySize * 4;\n\n\t            return derivedKey;\n\t        }\n\t    });\n\n\t    /**\n\t     * Derives a key from a password.\n\t     *\n\t     * @param {WordArray|string} password The password.\n\t     * @param {WordArray|string} salt A salt.\n\t     * @param {Object} cfg (Optional) The configuration options to use for this computation.\n\t     *\n\t     * @return {WordArray} The derived key.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var key = CryptoJS.EvpKDF(password, salt);\n\t     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });\n\t     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });\n\t     */\n\t    C.EvpKDF = function (password, salt, cfg) {\n\t        return EvpKDF.create(cfg).compute(password, salt);\n\t    };\n\t}());\n\n\n\treturn CryptoJS.EvpKDF;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var C_enc = C.enc;\n\t    var Utf8 = C_enc.Utf8;\n\t    var C_algo = C.algo;\n\n\t    /**\n\t     * HMAC algorithm.\n\t     */\n\t    var HMAC = C_algo.HMAC = Base.extend({\n\t        /**\n\t         * Initializes a newly created HMAC.\n\t         *\n\t         * @param {Hasher} hasher The hash algorithm to use.\n\t         * @param {WordArray|string} key The secret key.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);\n\t         */\n\t        init: function (hasher, key) {\n\t            // Init hasher\n\t            hasher = this._hasher = new hasher.init();\n\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof key == 'string') {\n\t                key = Utf8.parse(key);\n\t            }\n\n\t            // Shortcuts\n\t            var hasherBlockSize = hasher.blockSize;\n\t            var hasherBlockSizeBytes = hasherBlockSize * 4;\n\n\t            // Allow arbitrary length keys\n\t            if (key.sigBytes > hasherBlockSizeBytes) {\n\t                key = hasher.finalize(key);\n\t            }\n\n\t            // Clamp excess bits\n\t            key.clamp();\n\n\t            // Clone key for inner and outer pads\n\t            var oKey = this._oKey = key.clone();\n\t            var iKey = this._iKey = key.clone();\n\n\t            // Shortcuts\n\t            var oKeyWords = oKey.words;\n\t            var iKeyWords = iKey.words;\n\n\t            // XOR keys with pad constants\n\t            for (var i = 0; i < hasherBlockSize; i++) {\n\t                oKeyWords[i] ^= 0x5c5c5c5c;\n\t                iKeyWords[i] ^= 0x36363636;\n\t            }\n\t            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this HMAC to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hmacHasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Shortcut\n\t            var hasher = this._hasher;\n\n\t            // Reset\n\t            hasher.reset();\n\t            hasher.update(this._iKey);\n\t        },\n\n\t        /**\n\t         * Updates this HMAC with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {HMAC} This HMAC instance.\n\t         *\n\t         * @example\n\t         *\n\t         *     hmacHasher.update('message');\n\t         *     hmacHasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            this._hasher.update(messageUpdate);\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the HMAC computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The HMAC.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hmac = hmacHasher.finalize();\n\t         *     var hmac = hmacHasher.finalize('message');\n\t         *     var hmac = hmacHasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Shortcut\n\t            var hasher = this._hasher;\n\n\t            // Compute HMAC\n\t            var innerHash = hasher.finalize(messageUpdate);\n\t            hasher.reset();\n\t            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));\n\n\t            return hmac;\n\t        }\n\t    });\n\t}());\n\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function (Math) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Constants table\n\t    var T = [];\n\n\t    // Compute constants\n\t    (function () {\n\t        for (var i = 0; i < 64; i++) {\n\t            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n\t        }\n\t    }());\n\n\t    /**\n\t     * MD5 hash algorithm.\n\t     */\n\t    var MD5 = C_algo.MD5 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Swap endian\n\t            for (var i = 0; i < 16; i++) {\n\t                // Shortcuts\n\t                var offset_i = offset + i;\n\t                var M_offset_i = M[offset_i];\n\n\t                M[offset_i] = (\n\t                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |\n\t                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)\n\t                );\n\t            }\n\n\t            // Shortcuts\n\t            var H = this._hash.words;\n\n\t            var M_offset_0  = M[offset + 0];\n\t            var M_offset_1  = M[offset + 1];\n\t            var M_offset_2  = M[offset + 2];\n\t            var M_offset_3  = M[offset + 3];\n\t            var M_offset_4  = M[offset + 4];\n\t            var M_offset_5  = M[offset + 5];\n\t            var M_offset_6  = M[offset + 6];\n\t            var M_offset_7  = M[offset + 7];\n\t            var M_offset_8  = M[offset + 8];\n\t            var M_offset_9  = M[offset + 9];\n\t            var M_offset_10 = M[offset + 10];\n\t            var M_offset_11 = M[offset + 11];\n\t            var M_offset_12 = M[offset + 12];\n\t            var M_offset_13 = M[offset + 13];\n\t            var M_offset_14 = M[offset + 14];\n\t            var M_offset_15 = M[offset + 15];\n\n\t            // Working varialbes\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\n\t            // Computation\n\t            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);\n\t            d = FF(d, a, b, c, M_offset_1,  12, T[1]);\n\t            c = FF(c, d, a, b, M_offset_2,  17, T[2]);\n\t            b = FF(b, c, d, a, M_offset_3,  22, T[3]);\n\t            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);\n\t            d = FF(d, a, b, c, M_offset_5,  12, T[5]);\n\t            c = FF(c, d, a, b, M_offset_6,  17, T[6]);\n\t            b = FF(b, c, d, a, M_offset_7,  22, T[7]);\n\t            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);\n\t            d = FF(d, a, b, c, M_offset_9,  12, T[9]);\n\t            c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n\t            b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n\t            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);\n\t            d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n\t            c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n\t            b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\n\t            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);\n\t            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);\n\t            c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n\t            b = GG(b, c, d, a, M_offset_0,  20, T[19]);\n\t            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);\n\t            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);\n\t            c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n\t            b = GG(b, c, d, a, M_offset_4,  20, T[23]);\n\t            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);\n\t            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);\n\t            c = GG(c, d, a, b, M_offset_3,  14, T[26]);\n\t            b = GG(b, c, d, a, M_offset_8,  20, T[27]);\n\t            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);\n\t            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);\n\t            c = GG(c, d, a, b, M_offset_7,  14, T[30]);\n\t            b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\n\t            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);\n\t            d = HH(d, a, b, c, M_offset_8,  11, T[33]);\n\t            c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n\t            b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n\t            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);\n\t            d = HH(d, a, b, c, M_offset_4,  11, T[37]);\n\t            c = HH(c, d, a, b, M_offset_7,  16, T[38]);\n\t            b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n\t            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);\n\t            d = HH(d, a, b, c, M_offset_0,  11, T[41]);\n\t            c = HH(c, d, a, b, M_offset_3,  16, T[42]);\n\t            b = HH(b, c, d, a, M_offset_6,  23, T[43]);\n\t            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);\n\t            d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n\t            c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n\t            b = HH(b, c, d, a, M_offset_2,  23, T[47]);\n\n\t            a = II(a, b, c, d, M_offset_0,  6,  T[48]);\n\t            d = II(d, a, b, c, M_offset_7,  10, T[49]);\n\t            c = II(c, d, a, b, M_offset_14, 15, T[50]);\n\t            b = II(b, c, d, a, M_offset_5,  21, T[51]);\n\t            a = II(a, b, c, d, M_offset_12, 6,  T[52]);\n\t            d = II(d, a, b, c, M_offset_3,  10, T[53]);\n\t            c = II(c, d, a, b, M_offset_10, 15, T[54]);\n\t            b = II(b, c, d, a, M_offset_1,  21, T[55]);\n\t            a = II(a, b, c, d, M_offset_8,  6,  T[56]);\n\t            d = II(d, a, b, c, M_offset_15, 10, T[57]);\n\t            c = II(c, d, a, b, M_offset_6,  15, T[58]);\n\t            b = II(b, c, d, a, M_offset_13, 21, T[59]);\n\t            a = II(a, b, c, d, M_offset_4,  6,  T[60]);\n\t            d = II(d, a, b, c, M_offset_11, 10, T[61]);\n\t            c = II(c, d, a, b, M_offset_2,  15, T[62]);\n\t            b = II(b, c, d, a, M_offset_9,  21, T[63]);\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\n\t            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n\t            var nBitsTotalL = nBitsTotal;\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n\t                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)\n\t            );\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n\t                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)\n\t            );\n\n\t            data.sigBytes = (dataWords.length + 1) * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Shortcuts\n\t            var hash = this._hash;\n\t            var H = hash.words;\n\n\t            // Swap endian\n\t            for (var i = 0; i < 4; i++) {\n\t                // Shortcut\n\t                var H_i = H[i];\n\n\t                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |\n\t                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);\n\t            }\n\n\t            // Return final computed hash\n\t            return hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    function FF(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & c) | (~b & d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function GG(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & d) | (c & ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function HH(a, b, c, d, x, s, t) {\n\t        var n = a + (b ^ c ^ d) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function II(a, b, c, d, x, s, t) {\n\t        var n = a + (c ^ (b | ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.MD5('message');\n\t     *     var hash = CryptoJS.MD5(wordArray);\n\t     */\n\t    C.MD5 = Hasher._createHelper(MD5);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacMD5(message, key);\n\t     */\n\t    C.HmacMD5 = Hasher._createHmacHelper(MD5);\n\t}(Math));\n\n\n\treturn CryptoJS.MD5;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Reusable object\n\t    var W = [];\n\n\t    /**\n\t     * SHA-1 hash algorithm.\n\t     */\n\t    var SHA1 = C_algo.SHA1 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476,\n\t                0xc3d2e1f0\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Shortcut\n\t            var H = this._hash.words;\n\n\t            // Working variables\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\t            var e = H[4];\n\n\t            // Computation\n\t            for (var i = 0; i < 80; i++) {\n\t                if (i < 16) {\n\t                    W[i] = M[offset + i] | 0;\n\t                } else {\n\t                    var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n\t                    W[i] = (n << 1) | (n >>> 31);\n\t                }\n\n\t                var t = ((a << 5) | (a >>> 27)) + e + W[i];\n\t                if (i < 20) {\n\t                    t += ((b & c) | (~b & d)) + 0x5a827999;\n\t                } else if (i < 40) {\n\t                    t += (b ^ c ^ d) + 0x6ed9eba1;\n\t                } else if (i < 60) {\n\t                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;\n\t                } else /* if (i < 80) */ {\n\t                    t += (b ^ c ^ d) - 0x359d3e2a;\n\t                }\n\n\t                e = d;\n\t                d = c;\n\t                c = (b << 30) | (b >>> 2);\n\t                b = a;\n\t                a = t;\n\t            }\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t            H[4] = (H[4] + e) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n\t            data.sigBytes = dataWords.length * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Return final computed hash\n\t            return this._hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.SHA1('message');\n\t     *     var hash = CryptoJS.SHA1(wordArray);\n\t     */\n\t    C.SHA1 = Hasher._createHelper(SHA1);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacSHA1(message, key);\n\t     */\n\t    C.HmacSHA1 = Hasher._createHmacHelper(SHA1);\n\t}());\n\n\n\treturn CryptoJS.SHA1;\n\n}));","var pSlice = Array.prototype.slice;\nvar objectKeys = require(56);\nvar isArguments = require(55);\n\nvar deepEqual = module.exports = function (actual, expected, opts) {\n  if (!opts) opts = {};\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n\n  } else if (actual instanceof Date && expected instanceof Date) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {\n    return opts.strict ? actual === expected : actual == expected;\n\n  // 7.4. For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else {\n    return objEquiv(actual, expected, opts);\n  }\n}\n\nfunction isUndefinedOrNull(value) {\n  return value === null || value === undefined;\n}\n\nfunction isBuffer (x) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false;\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') return false;\n  return true;\n}\n\nfunction objEquiv(a, b, opts) {\n  var i, key;\n  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))\n    return false;\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) return false;\n  //~~~I've managed to break Object.keys through screwy arguments passing.\n  //   Converting to array solves the problem.\n  if (isArguments(a)) {\n    if (!isArguments(b)) {\n      return false;\n    }\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return deepEqual(a, b, opts);\n  }\n  if (isBuffer(a)) {\n    if (!isBuffer(b)) {\n      return false;\n    }\n    if (a.length !== b.length) return false;\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) return false;\n    }\n    return true;\n  }\n  try {\n    var ka = objectKeys(a),\n        kb = objectKeys(b);\n  } catch (e) {//happens when one is a string literal and the other isn't\n    return false;\n  }\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length != kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], opts)) return false;\n  }\n  return typeof a === typeof b;\n}\n","var supportsArgumentsClass = (function(){\n  return Object.prototype.toString.call(arguments)\n})() == '[object Arguments]';\n\nexports = module.exports = supportsArgumentsClass ? supported : unsupported;\n\nexports.supported = supported;\nfunction supported(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n};\n\nexports.unsupported = unsupported;\nfunction unsupported(object){\n  return object &&\n    typeof object == 'object' &&\n    typeof object.length == 'number' &&\n    Object.prototype.hasOwnProperty.call(object, 'callee') &&\n    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||\n    false;\n};\n","exports = module.exports = typeof Object.keys === 'function'\n  ? Object.keys : shim;\n\nexports.shim = shim;\nfunction shim (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n}\n","var assert = require(27)\nvar BigInteger = require(32)\n\nvar Point = require(61)\n\nfunction Curve (p, a, b, Gx, Gy, n, h) {\n  this.p = p\n  this.a = a\n  this.b = b\n  this.G = Point.fromAffine(this, Gx, Gy)\n  this.n = n\n  this.h = h\n\n  this.infinity = new Point(this, null, null, BigInteger.ZERO)\n\n  // result caching\n  this.pOverFour = p.add(BigInteger.ONE).shiftRight(2)\n\n  // determine size of p in bytes\n  this.pLength = Math.floor((this.p.bitLength() + 7) / 8)\n}\n\nCurve.prototype.pointFromX = function (isOdd, x) {\n  var alpha = x.pow(3).add(this.a.multiply(x)).add(this.b).mod(this.p)\n  var beta = alpha.modPow(this.pOverFour, this.p) // XXX: not compatible with all curves\n\n  var y = beta\n  if (beta.isEven() ^ !isOdd) {\n    y = this.p.subtract(y) // -y % p\n  }\n\n  return Point.fromAffine(this, x, y)\n}\n\nCurve.prototype.isInfinity = function (Q) {\n  if (Q === this.infinity) return true\n\n  return Q.z.signum() === 0 && Q.y.signum() !== 0\n}\n\nCurve.prototype.isOnCurve = function (Q) {\n  if (this.isInfinity(Q)) return true\n\n  var x = Q.affineX\n  var y = Q.affineY\n  var a = this.a\n  var b = this.b\n  var p = this.p\n\n  // Check that xQ and yQ are integers in the interval [0, p - 1]\n  if (x.signum() < 0 || x.compareTo(p) >= 0) return false\n  if (y.signum() < 0 || y.compareTo(p) >= 0) return false\n\n  // and check that y^2 = x^3 + ax + b (mod p)\n  var lhs = y.square().mod(p)\n  var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p)\n  return lhs.equals(rhs)\n}\n\n/**\n * Validate an elliptic curve point.\n *\n * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive\n */\nCurve.prototype.validate = function (Q) {\n  // Check Q != O\n  assert(!this.isInfinity(Q), 'Point is at infinity')\n  assert(this.isOnCurve(Q), 'Point is not on the curve')\n\n  // Check nQ = O (where Q is a scalar multiple of G)\n  var nQ = Q.multiply(this.n)\n  assert(this.isInfinity(nQ), 'Point is not a scalar multiple of G')\n\n  return true\n}\n\nmodule.exports = Curve\n","module.exports={\n  \"secp128r1\": {\n    \"p\": \"fffffffdffffffffffffffffffffffff\",\n    \"a\": \"fffffffdfffffffffffffffffffffffc\",\n    \"b\": \"e87579c11079f43dd824993c2cee5ed3\",\n    \"n\": \"fffffffe0000000075a30d1b9038a115\",\n    \"h\": \"01\",\n    \"Gx\": \"161ff7528b899b2d0c28607ca52c5b86\",\n    \"Gy\": \"cf5ac8395bafeb13c02da292dded7a83\"\n  },\n  \"secp160k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffeffffac73\",\n    \"a\": \"00\",\n    \"b\": \"07\",\n    \"n\": \"0100000000000000000001b8fa16dfab9aca16b6b3\",\n    \"h\": \"01\",\n    \"Gx\": \"3b4c382ce37aa192a4019e763036f4f5dd4d7ebb\",\n    \"Gy\": \"938cf935318fdced6bc28286531733c3f03c4fee\"\n  },\n  \"secp160r1\": {\n    \"p\": \"ffffffffffffffffffffffffffffffff7fffffff\",\n    \"a\": \"ffffffffffffffffffffffffffffffff7ffffffc\",\n    \"b\": \"1c97befc54bd7a8b65acf89f81d4d4adc565fa45\",\n    \"n\": \"0100000000000000000001f4c8f927aed3ca752257\",\n    \"h\": \"01\",\n    \"Gx\": \"4a96b5688ef573284664698968c38bb913cbfc82\",\n    \"Gy\": \"23a628553168947d59dcc912042351377ac5fb32\"\n  },\n  \"secp192k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffffffffffeffffee37\",\n    \"a\": \"00\",\n    \"b\": \"03\",\n    \"n\": \"fffffffffffffffffffffffe26f2fc170f69466a74defd8d\",\n    \"h\": \"01\",\n    \"Gx\": \"db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d\",\n    \"Gy\": \"9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d\"\n  },\n  \"secp192r1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffeffffffffffffffff\",\n    \"a\": \"fffffffffffffffffffffffffffffffefffffffffffffffc\",\n    \"b\": \"64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1\",\n    \"n\": \"ffffffffffffffffffffffff99def836146bc9b1b4d22831\",\n    \"h\": \"01\",\n    \"Gx\": \"188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012\",\n    \"Gy\": \"07192b95ffc8da78631011ed6b24cdd573f977a11e794811\"\n  },\n  \"secp256k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f\",\n    \"a\": \"00\",\n    \"b\": \"07\",\n    \"n\": \"fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141\",\n    \"h\": \"01\",\n    \"Gx\": \"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\n    \"Gy\": \"483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8\"\n  },\n  \"secp256r1\": {\n    \"p\": \"ffffffff00000001000000000000000000000000ffffffffffffffffffffffff\",\n    \"a\": \"ffffffff00000001000000000000000000000000fffffffffffffffffffffffc\",\n    \"b\": \"5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b\",\n    \"n\": \"ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551\",\n    \"h\": \"01\",\n    \"Gx\": \"6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296\",\n    \"Gy\": \"4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5\"\n  }\n}\n","var Point = require(61)\nvar Curve = require(57)\n\nvar getCurveByName = require(60)\n\nmodule.exports = {\n  Curve: Curve,\n  Point: Point,\n  getCurveByName: getCurveByName\n}\n","var BigInteger = require(32)\n\nvar curves = require(58)\nvar Curve = require(57)\n\nfunction getCurveByName (name) {\n  var curve = curves[name]\n  if (!curve) return null\n\n  var p = new BigInteger(curve.p, 16)\n  var a = new BigInteger(curve.a, 16)\n  var b = new BigInteger(curve.b, 16)\n  var n = new BigInteger(curve.n, 16)\n  var h = new BigInteger(curve.h, 16)\n  var Gx = new BigInteger(curve.Gx, 16)\n  var Gy = new BigInteger(curve.Gy, 16)\n\n  return new Curve(p, a, b, Gx, Gy, n, h)\n}\n\nmodule.exports = getCurveByName\n","var assert = require(27)\nvar Buffer = require(93).Buffer\nvar BigInteger = require(32)\n\nvar THREE = BigInteger.valueOf(3)\n\nfunction Point (curve, x, y, z) {\n  assert.notStrictEqual(z, undefined, 'Missing Z coordinate')\n\n  this.curve = curve\n  this.x = x\n  this.y = y\n  this.z = z\n  this._zInv = null\n\n  this.compressed = true\n}\n\nObject.defineProperty(Point.prototype, 'zInv', {\n  get: function () {\n    if (this._zInv === null) {\n      this._zInv = this.z.modInverse(this.curve.p)\n    }\n\n    return this._zInv\n  }\n})\n\nObject.defineProperty(Point.prototype, 'affineX', {\n  get: function () {\n    return this.x.multiply(this.zInv).mod(this.curve.p)\n  }\n})\n\nObject.defineProperty(Point.prototype, 'affineY', {\n  get: function () {\n    return this.y.multiply(this.zInv).mod(this.curve.p)\n  }\n})\n\nPoint.fromAffine = function (curve, x, y) {\n  return new Point(curve, x, y, BigInteger.ONE)\n}\n\nPoint.prototype.equals = function (other) {\n  if (other === this) return true\n  if (this.curve.isInfinity(this)) return this.curve.isInfinity(other)\n  if (this.curve.isInfinity(other)) return this.curve.isInfinity(this)\n\n  // u = Y2 * Z1 - Y1 * Z2\n  var u = other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p)\n\n  if (u.signum() !== 0) return false\n\n  // v = X2 * Z1 - X1 * Z2\n  var v = other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p)\n\n  return v.signum() === 0\n}\n\nPoint.prototype.negate = function () {\n  var y = this.curve.p.subtract(this.y)\n\n  return new Point(this.curve, this.x, y, this.z)\n}\n\nPoint.prototype.add = function (b) {\n  if (this.curve.isInfinity(this)) return b\n  if (this.curve.isInfinity(b)) return this\n\n  var x1 = this.x\n  var y1 = this.y\n  var x2 = b.x\n  var y2 = b.y\n\n  // u = Y2 * Z1 - Y1 * Z2\n  var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p)\n  // v = X2 * Z1 - X1 * Z2\n  var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p)\n\n  if (v.signum() === 0) {\n    if (u.signum() === 0) {\n      return this.twice() // this == b, so double\n    }\n\n    return this.curve.infinity // this = -b, so infinity\n  }\n\n  var v2 = v.square()\n  var v3 = v2.multiply(v)\n  var x1v2 = x1.multiply(v2)\n  var zu2 = u.square().multiply(this.z)\n\n  // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)\n  var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.p)\n  // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3\n  var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.p)\n  // z3 = v^3 * z1 * z2\n  var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.p)\n\n  return new Point(this.curve, x3, y3, z3)\n}\n\nPoint.prototype.twice = function () {\n  if (this.curve.isInfinity(this)) return this\n  if (this.y.signum() === 0) return this.curve.infinity\n\n  var x1 = this.x\n  var y1 = this.y\n\n  var y1z1 = y1.multiply(this.z).mod(this.curve.p)\n  var y1sqz1 = y1z1.multiply(y1).mod(this.curve.p)\n  var a = this.curve.a\n\n  // w = 3 * x1^2 + a * z1^2\n  var w = x1.square().multiply(THREE)\n\n  if (a.signum() !== 0) {\n    w = w.add(this.z.square().multiply(a))\n  }\n\n  w = w.mod(this.curve.p)\n  // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)\n  var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.p)\n  // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3\n  var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.pow(3)).mod(this.curve.p)\n  // z3 = 8 * (y1 * z1)^3\n  var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.p)\n\n  return new Point(this.curve, x3, y3, z3)\n}\n\n// Simple NAF (Non-Adjacent Form) multiplication algorithm\n// TODO: modularize the multiplication algorithm\nPoint.prototype.multiply = function (k) {\n  if (this.curve.isInfinity(this)) return this\n  if (k.signum() === 0) return this.curve.infinity\n\n  var e = k\n  var h = e.multiply(THREE)\n\n  var neg = this.negate()\n  var R = this\n\n  for (var i = h.bitLength() - 2; i > 0; --i) {\n    var hBit = h.testBit(i)\n    var eBit = e.testBit(i)\n\n    R = R.twice()\n\n    if (hBit !== eBit) {\n      R = R.add(hBit ? this : neg)\n    }\n  }\n\n  return R\n}\n\n// Compute this*j + x*k (simultaneous multiplication)\nPoint.prototype.multiplyTwo = function (j, x, k) {\n  var i = Math.max(j.bitLength(), k.bitLength()) - 1\n  var R = this.curve.infinity\n  var both = this.add(x)\n\n  while (i >= 0) {\n    var jBit = j.testBit(i)\n    var kBit = k.testBit(i)\n\n    R = R.twice()\n\n    if (jBit) {\n      if (kBit) {\n        R = R.add(both)\n      } else {\n        R = R.add(this)\n      }\n    } else if (kBit) {\n      R = R.add(x)\n    }\n    --i\n  }\n\n  return R\n}\n\nPoint.prototype.getEncoded = function (compressed) {\n  if (compressed == null) compressed = this.compressed\n  if (this.curve.isInfinity(this)) return Buffer.alloc(1, 0) // Infinity point encoded is simply '00'\n\n  var x = this.affineX\n  var y = this.affineY\n  var byteLength = this.curve.pLength\n  var buffer\n\n  // 0x02/0x03 | X\n  if (compressed) {\n    buffer = Buffer.allocUnsafe(1 + byteLength)\n    buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0)\n\n  // 0x04 | X | Y\n  } else {\n    buffer = Buffer.allocUnsafe(1 + byteLength + byteLength)\n    buffer.writeUInt8(0x04, 0)\n\n    y.toBuffer(byteLength).copy(buffer, 1 + byteLength)\n  }\n\n  x.toBuffer(byteLength).copy(buffer, 1)\n\n  return buffer\n}\n\nPoint.decodeFrom = function (curve, buffer) {\n  var type = buffer.readUInt8(0)\n  var compressed = (type !== 4)\n\n  var byteLength = Math.floor((curve.p.bitLength() + 7) / 8)\n  var x = BigInteger.fromBuffer(buffer.slice(1, 1 + byteLength))\n\n  var Q\n  if (compressed) {\n    assert.equal(buffer.length, byteLength + 1, 'Invalid sequence length')\n    assert(type === 0x02 || type === 0x03, 'Invalid sequence tag')\n\n    var isOdd = (type === 0x03)\n    Q = curve.pointFromX(isOdd, x)\n  } else {\n    assert.equal(buffer.length, 1 + byteLength + byteLength, 'Invalid sequence length')\n\n    var y = BigInteger.fromBuffer(buffer.slice(1 + byteLength))\n    Q = Point.fromAffine(curve, x, y)\n  }\n\n  Q.compressed = compressed\n  return Q\n}\n\nPoint.prototype.toString = function () {\n  if (this.curve.isInfinity(this)) return '(INFINITY)'\n\n  return '(' + this.affineX.toString() + ',' + this.affineY.toString() + ')'\n}\n\nmodule.exports = Point\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","'use strict'\nvar Buffer = require(93).Buffer\nvar Transform = require(103).Transform\nvar inherits = require(65)\n\nfunction throwIfNotStringOrBuffer (val, prefix) {\n  if (!Buffer.isBuffer(val) && typeof val !== 'string') {\n    throw new TypeError(prefix + ' must be a string or a buffer')\n  }\n}\n\nfunction HashBase (blockSize) {\n  Transform.call(this)\n\n  this._block = Buffer.allocUnsafe(blockSize)\n  this._blockSize = blockSize\n  this._blockOffset = 0\n  this._length = [0, 0, 0, 0]\n\n  this._finalized = false\n}\n\ninherits(HashBase, Transform)\n\nHashBase.prototype._transform = function (chunk, encoding, callback) {\n  var error = null\n  try {\n    this.update(chunk, encoding)\n  } catch (err) {\n    error = err\n  }\n\n  callback(error)\n}\n\nHashBase.prototype._flush = function (callback) {\n  var error = null\n  try {\n    this.push(this.digest())\n  } catch (err) {\n    error = err\n  }\n\n  callback(error)\n}\n\nHashBase.prototype.update = function (data, encoding) {\n  throwIfNotStringOrBuffer(data, 'Data')\n  if (this._finalized) throw new Error('Digest already called')\n  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n  // consume data\n  var block = this._block\n  var offset = 0\n  while (this._blockOffset + data.length - offset >= this._blockSize) {\n    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]\n    this._update()\n    this._blockOffset = 0\n  }\n  while (offset < data.length) block[this._blockOffset++] = data[offset++]\n\n  // update length\n  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {\n    this._length[j] += carry\n    carry = (this._length[j] / 0x0100000000) | 0\n    if (carry > 0) this._length[j] -= 0x0100000000 * carry\n  }\n\n  return this\n}\n\nHashBase.prototype._update = function () {\n  throw new Error('_update is not implemented')\n}\n\nHashBase.prototype.digest = function (encoding) {\n  if (this._finalized) throw new Error('Digest already called')\n  this._finalized = true\n\n  var digest = this._digest()\n  if (encoding !== undefined) digest = digest.toString(encoding)\n\n  // reset state\n  this._block.fill(0)\n  this._blockOffset = 0\n  for (var i = 0; i < 4; ++i) this._length[i] = 0\n\n  return digest\n}\n\nHashBase.prototype._digest = function () {\n  throw new Error('_digest is not implemented')\n}\n\nmodule.exports = HashBase\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\r\n Copyright 2013 Daniel Wirtz <dcode@dcode.io>\r\n Copyright 2009 The Closure Library Authors. All Rights Reserved.\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS-IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/long.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module[\"exports\"] = factory();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"Long\"] = factory();\r\n\r\n})(this, function() {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n     *  See the from* functions below for more convenient ways of constructing Longs.\r\n     * @exports Long\r\n     * @class A Long class for representing a 64 bit two's-complement integer value.\r\n     * @param {number} low The low (signed) 32 bits of the long\r\n     * @param {number} high The high (signed) 32 bits of the long\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @constructor\r\n     */\r\n    function Long(low, high, unsigned) {\r\n\r\n        /**\r\n         * The low 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.low = low | 0;\r\n\r\n        /**\r\n         * The high 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.high = high | 0;\r\n\r\n        /**\r\n         * Whether unsigned or not.\r\n         * @type {boolean}\r\n         */\r\n        this.unsigned = !!unsigned;\r\n    }\r\n\r\n    // The internal representation of a long is the two given signed, 32-bit values.\r\n    // We use 32-bit pieces because these are the size of integers on which\r\n    // Javascript performs bit-operations.  For operations like addition and\r\n    // multiplication, we split each number into 16 bit pieces, which can easily be\r\n    // multiplied within Javascript's floating-point representation without overflow\r\n    // or change in sign.\r\n    //\r\n    // In the algorithms below, we frequently reduce the negative case to the\r\n    // positive case by negating the input(s) and then post-processing the result.\r\n    // Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n    // a positive number, it overflows back into a negative).  Not handling this\r\n    // case would often result in infinite recursion.\r\n    //\r\n    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n    // methods on which they depend.\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a Long or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @private\r\n     */\r\n    Long.prototype.__isLong__;\r\n\r\n    Object.defineProperty(Long.prototype, \"__isLong__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    /**\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     * @inner\r\n     */\r\n    function isLong(obj) {\r\n        return (obj && obj[\"__isLong__\"]) === true;\r\n    }\r\n\r\n    /**\r\n     * Tests if the specified object is a Long.\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     */\r\n    Long.isLong = isLong;\r\n\r\n    /**\r\n     * A cache of the Long representations of small integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var INT_CACHE = {};\r\n\r\n    /**\r\n     * A cache of the Long representations of small unsigned integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var UINT_CACHE = {};\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromInt(value, unsigned) {\r\n        var obj, cachedObj, cache;\r\n        if (unsigned) {\r\n            value >>>= 0;\r\n            if (cache = (0 <= value && value < 256)) {\r\n                cachedObj = UINT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n            if (cache)\r\n                UINT_CACHE[value] = obj;\r\n            return obj;\r\n        } else {\r\n            value |= 0;\r\n            if (cache = (-128 <= value && value < 128)) {\r\n                cachedObj = INT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n            if (cache)\r\n                INT_CACHE[value] = obj;\r\n            return obj;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given 32 bit integer value.\r\n     * @function\r\n     * @param {number} value The 32 bit integer in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromInt = fromInt;\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromNumber(value, unsigned) {\r\n        if (isNaN(value) || !isFinite(value))\r\n            return unsigned ? UZERO : ZERO;\r\n        if (unsigned) {\r\n            if (value < 0)\r\n                return UZERO;\r\n            if (value >= TWO_PWR_64_DBL)\r\n                return MAX_UNSIGNED_VALUE;\r\n        } else {\r\n            if (value <= -TWO_PWR_63_DBL)\r\n                return MIN_VALUE;\r\n            if (value + 1 >= TWO_PWR_63_DBL)\r\n                return MAX_VALUE;\r\n        }\r\n        if (value < 0)\r\n            return fromNumber(-value, unsigned).neg();\r\n        return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n     * @function\r\n     * @param {number} value The number in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromNumber = fromNumber;\r\n\r\n    /**\r\n     * @param {number} lowBits\r\n     * @param {number} highBits\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromBits(lowBits, highBits, unsigned) {\r\n        return new Long(lowBits, highBits, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n     *  assumed to use 32 bits.\r\n     * @function\r\n     * @param {number} lowBits The low 32 bits\r\n     * @param {number} highBits The high 32 bits\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromBits = fromBits;\r\n\r\n    /**\r\n     * @function\r\n     * @param {number} base\r\n     * @param {number} exponent\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n    /**\r\n     * @param {string} str\r\n     * @param {(boolean|number)=} unsigned\r\n     * @param {number=} radix\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromString(str, unsigned, radix) {\r\n        if (str.length === 0)\r\n            throw Error('empty string');\r\n        if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n            return ZERO;\r\n        if (typeof unsigned === 'number') {\r\n            // For goog.math.long compatibility\r\n            radix = unsigned,\r\n            unsigned = false;\r\n        } else {\r\n            unsigned = !! unsigned;\r\n        }\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n\r\n        var p;\r\n        if ((p = str.indexOf('-')) > 0)\r\n            throw Error('interior hyphen');\r\n        else if (p === 0) {\r\n            return fromString(str.substring(1), unsigned, radix).neg();\r\n        }\r\n\r\n        // Do several (8) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n        var result = ZERO;\r\n        for (var i = 0; i < str.length; i += 8) {\r\n            var size = Math.min(8, str.length - i),\r\n                value = parseInt(str.substring(i, i + size), radix);\r\n            if (size < 8) {\r\n                var power = fromNumber(pow_dbl(radix, size));\r\n                result = result.mul(power).add(fromNumber(value));\r\n            } else {\r\n                result = result.mul(radixToPower);\r\n                result = result.add(fromNumber(value));\r\n            }\r\n        }\r\n        result.unsigned = unsigned;\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representation of the given string, written using the specified radix.\r\n     * @function\r\n     * @param {string} str The textual representation of the Long\r\n     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromString = fromString;\r\n\r\n    /**\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromValue(val) {\r\n        if (val /* is compatible */ instanceof Long)\r\n            return val;\r\n        if (typeof val === 'number')\r\n            return fromNumber(val);\r\n        if (typeof val === 'string')\r\n            return fromString(val);\r\n        // Throws for non-objects, converts non-instanceof Long:\r\n        return fromBits(val.low, val.high, val.unsigned);\r\n    }\r\n\r\n    /**\r\n     * Converts the specified value to a Long.\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n     * @returns {!Long}\r\n     */\r\n    Long.fromValue = fromValue;\r\n\r\n    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n    // no runtime penalty for these.\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_16_DBL = 1 << 16;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24_DBL = 1 << 24;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ZERO = fromInt(0);\r\n\r\n    /**\r\n     * Signed zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.ZERO = ZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UZERO = fromInt(0, true);\r\n\r\n    /**\r\n     * Unsigned zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.UZERO = UZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ONE = fromInt(1);\r\n\r\n    /**\r\n     * Signed one.\r\n     * @type {!Long}\r\n     */\r\n    Long.ONE = ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UONE = fromInt(1, true);\r\n\r\n    /**\r\n     * Unsigned one.\r\n     * @type {!Long}\r\n     */\r\n    Long.UONE = UONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var NEG_ONE = fromInt(-1);\r\n\r\n    /**\r\n     * Signed negative one.\r\n     * @type {!Long}\r\n     */\r\n    Long.NEG_ONE = NEG_ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n    /**\r\n     * Maximum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_VALUE = MAX_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n    /**\r\n     * Maximum unsigned value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n    /**\r\n     * Minimum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MIN_VALUE = MIN_VALUE;\r\n\r\n    /**\r\n     * @alias Long.prototype\r\n     * @inner\r\n     */\r\n    var LongPrototype = Long.prototype;\r\n\r\n    /**\r\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toInt = function toInt() {\r\n        return this.unsigned ? this.low >>> 0 : this.low;\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toNumber = function toNumber() {\r\n        if (this.unsigned)\r\n            return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a string written in the specified radix.\r\n     * @param {number=} radix Radix (2-36), defaults to 10\r\n     * @returns {string}\r\n     * @override\r\n     * @throws {RangeError} If `radix` is out of range\r\n     */\r\n    LongPrototype.toString = function toString(radix) {\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n        if (this.isZero())\r\n            return '0';\r\n        if (this.isNegative()) { // Unsigned Longs are never negative\r\n            if (this.eq(MIN_VALUE)) {\r\n                // We need to change the Long value before it can be negated, so we remove\r\n                // the bottom-most digit in this base and then recurse to do the rest.\r\n                var radixLong = fromNumber(radix),\r\n                    div = this.div(radixLong),\r\n                    rem1 = div.mul(radixLong).sub(this);\r\n                return div.toString(radix) + rem1.toInt().toString(radix);\r\n            } else\r\n                return '-' + this.neg().toString(radix);\r\n        }\r\n\r\n        // Do several (6) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n            rem = this;\r\n        var result = '';\r\n        while (true) {\r\n            var remDiv = rem.div(radixToPower),\r\n                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n                digits = intval.toString(radix);\r\n            rem = remDiv;\r\n            if (rem.isZero())\r\n                return digits + result;\r\n            else {\r\n                while (digits.length < 6)\r\n                    digits = '0' + digits;\r\n                result = '' + digits + result;\r\n            }\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as a signed integer.\r\n     * @returns {number} Signed high bits\r\n     */\r\n    LongPrototype.getHighBits = function getHighBits() {\r\n        return this.high;\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned high bits\r\n     */\r\n    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n        return this.high >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as a signed integer.\r\n     * @returns {number} Signed low bits\r\n     */\r\n    LongPrototype.getLowBits = function getLowBits() {\r\n        return this.low;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned low bits\r\n     */\r\n    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n        return this.low >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the number of bits needed to represent the absolute value of this Long.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n        if (this.isNegative()) // Unsigned Longs are never negative\r\n            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n        var val = this.high != 0 ? this.high : this.low;\r\n        for (var bit = 31; bit > 0; bit--)\r\n            if ((val & (1 << bit)) != 0)\r\n                break;\r\n        return this.high != 0 ? bit + 33 : bit + 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals zero.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isZero = function isZero() {\r\n        return this.high === 0 && this.low === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is negative.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isNegative = function isNegative() {\r\n        return !this.unsigned && this.high < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is positive.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isPositive = function isPositive() {\r\n        return this.unsigned || this.high >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is odd.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isOdd = function isOdd() {\r\n        return (this.low & 1) === 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is even.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isEven = function isEven() {\r\n        return (this.low & 1) === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.equals = function equals(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n            return false;\r\n        return this.high === other.high && this.low === other.low;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.eq = LongPrototype.equals;\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.notEquals = function notEquals(other) {\r\n        return !this.eq(/* validates */ other);\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.neq = LongPrototype.notEquals;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThan = function lessThan(other) {\r\n        return this.comp(/* validates */ other) < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lt = LongPrototype.lessThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) <= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThan = function greaterThan(other) {\r\n        return this.comp(/* validates */ other) > 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.compare = function compare(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.eq(other))\r\n            return 0;\r\n        var thisNeg = this.isNegative(),\r\n            otherNeg = other.isNegative();\r\n        if (thisNeg && !otherNeg)\r\n            return -1;\r\n        if (!thisNeg && otherNeg)\r\n            return 1;\r\n        // At this point the sign bits are the same\r\n        if (!this.unsigned)\r\n            return this.sub(other).isNegative() ? -1 : 1;\r\n        // Both are positive if at least one is unsigned\r\n        return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n    };\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.comp = LongPrototype.compare;\r\n\r\n    /**\r\n     * Negates this Long's value.\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.negate = function negate() {\r\n        if (!this.unsigned && this.eq(MIN_VALUE))\r\n            return MIN_VALUE;\r\n        return this.not().add(ONE);\r\n    };\r\n\r\n    /**\r\n     * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n     * @function\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.neg = LongPrototype.negate;\r\n\r\n    /**\r\n     * Returns the sum of this and the specified Long.\r\n     * @param {!Long|number|string} addend Addend\r\n     * @returns {!Long} Sum\r\n     */\r\n    LongPrototype.add = function add(addend) {\r\n        if (!isLong(addend))\r\n            addend = fromValue(addend);\r\n\r\n        // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = addend.high >>> 16;\r\n        var b32 = addend.high & 0xFFFF;\r\n        var b16 = addend.low >>> 16;\r\n        var b00 = addend.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 + b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 + b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 + b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 + b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long.\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.subtract = function subtract(subtrahend) {\r\n        if (!isLong(subtrahend))\r\n            subtrahend = fromValue(subtrahend);\r\n        return this.add(subtrahend.neg());\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n     * @function\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.sub = LongPrototype.subtract;\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long.\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.multiply = function multiply(multiplier) {\r\n        if (this.isZero())\r\n            return ZERO;\r\n        if (!isLong(multiplier))\r\n            multiplier = fromValue(multiplier);\r\n        if (multiplier.isZero())\r\n            return ZERO;\r\n        if (this.eq(MIN_VALUE))\r\n            return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n        if (multiplier.eq(MIN_VALUE))\r\n            return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n        if (this.isNegative()) {\r\n            if (multiplier.isNegative())\r\n                return this.neg().mul(multiplier.neg());\r\n            else\r\n                return this.neg().mul(multiplier).neg();\r\n        } else if (multiplier.isNegative())\r\n            return this.mul(multiplier.neg()).neg();\r\n\r\n        // If both longs are small, use float multiplication\r\n        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n            return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n        // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n        // We can skip products that would overflow.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = multiplier.high >>> 16;\r\n        var b32 = multiplier.high & 0xFFFF;\r\n        var b16 = multiplier.low >>> 16;\r\n        var b00 = multiplier.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 * b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 * b00;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c16 += a00 * b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 * b00;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a16 * b16;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a00 * b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n     * @function\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.mul = LongPrototype.multiply;\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n     *  unsigned if this Long is unsigned.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.divide = function divide(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        if (divisor.isZero())\r\n            throw Error('division by zero');\r\n        if (this.isZero())\r\n            return this.unsigned ? UZERO : ZERO;\r\n        var approx, rem, res;\r\n        if (!this.unsigned) {\r\n            // This section is only relevant for signed longs and is derived from the\r\n            // closure library as a whole.\r\n            if (this.eq(MIN_VALUE)) {\r\n                if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                    return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n                else if (divisor.eq(MIN_VALUE))\r\n                    return ONE;\r\n                else {\r\n                    // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                    var halfThis = this.shr(1);\r\n                    approx = halfThis.div(divisor).shl(1);\r\n                    if (approx.eq(ZERO)) {\r\n                        return divisor.isNegative() ? ONE : NEG_ONE;\r\n                    } else {\r\n                        rem = this.sub(divisor.mul(approx));\r\n                        res = approx.add(rem.div(divisor));\r\n                        return res;\r\n                    }\r\n                }\r\n            } else if (divisor.eq(MIN_VALUE))\r\n                return this.unsigned ? UZERO : ZERO;\r\n            if (this.isNegative()) {\r\n                if (divisor.isNegative())\r\n                    return this.neg().div(divisor.neg());\r\n                return this.neg().div(divisor).neg();\r\n            } else if (divisor.isNegative())\r\n                return this.div(divisor.neg()).neg();\r\n            res = ZERO;\r\n        } else {\r\n            // The algorithm below has not been made for unsigned longs. It's therefore\r\n            // required to take special care of the MSB prior to running it.\r\n            if (!divisor.unsigned)\r\n                divisor = divisor.toUnsigned();\r\n            if (divisor.gt(this))\r\n                return UZERO;\r\n            if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n                return UONE;\r\n            res = UZERO;\r\n        }\r\n\r\n        // Repeat the following until the remainder is less than other:  find a\r\n        // floating-point that approximates remainder / other *from below*, add this\r\n        // into the result, and subtract it from the remainder.  It is critical that\r\n        // the approximate value is less than or equal to the real value so that the\r\n        // remainder never becomes negative.\r\n        rem = this;\r\n        while (rem.gte(divisor)) {\r\n            // Approximate the result of division. This may be a little greater or\r\n            // smaller than the actual value.\r\n            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n            // We will tweak the approximate result by changing it in the 48-th digit or\r\n            // the smallest non-fractional digit, whichever is larger.\r\n            var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n                delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n            // Decrease the approximation until it is smaller than the remainder.  Note\r\n            // that if it is too large, the product overflows and is negative.\r\n                approxRes = fromNumber(approx),\r\n                approxRem = approxRes.mul(divisor);\r\n            while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n                approx -= delta;\r\n                approxRes = fromNumber(approx, this.unsigned);\r\n                approxRem = approxRes.mul(divisor);\r\n            }\r\n\r\n            // We know the answer can't be zero... and actually, zero would cause\r\n            // infinite recursion since we would make no progress.\r\n            if (approxRes.isZero())\r\n                approxRes = ONE;\r\n\r\n            res = res.add(approxRes);\r\n            rem = rem.sub(approxRem);\r\n        }\r\n        return res;\r\n    };\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.div = LongPrototype.divide;\r\n\r\n    /**\r\n     * Returns this Long modulo the specified.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.modulo = function modulo(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        return this.sub(this.div(divisor).mul(divisor));\r\n    };\r\n\r\n    /**\r\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.mod = LongPrototype.modulo;\r\n\r\n    /**\r\n     * Returns the bitwise NOT of this Long.\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.not = function not() {\r\n        return fromBits(~this.low, ~this.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise AND of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.and = function and(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise OR of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.or = function or(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise XOR of this Long and the given one.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.xor = function xor(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n        else\r\n            return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRight = function shiftRight(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n        else\r\n            return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        numBits &= 63;\r\n        if (numBits === 0)\r\n            return this;\r\n        else {\r\n            var high = this.high;\r\n            if (numBits < 32) {\r\n                var low = this.low;\r\n                return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n            } else if (numBits === 32)\r\n                return fromBits(high, 0, this.unsigned);\r\n            else\r\n                return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n    /**\r\n     * Converts this Long to signed.\r\n     * @returns {!Long} Signed long\r\n     */\r\n    LongPrototype.toSigned = function toSigned() {\r\n        if (!this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, false);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to unsigned.\r\n     * @returns {!Long} Unsigned long\r\n     */\r\n    LongPrototype.toUnsigned = function toUnsigned() {\r\n        if (this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, true);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to its byte representation.\r\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n     * @returns {!Array.<number>} Byte representation\r\n     */\r\n    LongPrototype.toBytes = function(le) {\r\n        return le ? this.toBytesLE() : this.toBytesBE();\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its little endian byte representation.\r\n     * @returns {!Array.<number>} Little endian byte representation\r\n     */\r\n    LongPrototype.toBytesLE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n             lo         & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n             hi         & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>> 24) & 0xff\r\n        ];\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its big endian byte representation.\r\n     * @returns {!Array.<number>} Big endian byte representation\r\n     */\r\n    LongPrototype.toBytesBE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n            (hi >>> 24) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n             hi         & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n             lo         & 0xff\r\n        ];\r\n    }\r\n\r\n    return Long;\r\n});\r\n","'use strict'\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n  var M = ARRAY16\n  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n  var a = this._a\n  var b = this._b\n  var c = this._c\n  var d = this._d\n\n  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n  c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n  c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n  b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n  a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n  a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n  d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n  c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n  b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n  d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n  d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n  d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n  b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n  a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n  d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n  c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n  this._a = (this._a + a) | 0\n  this._b = (this._b + b) | 0\n  this._c = (this._c + c) | 0\n  this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = new Buffer(16)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n  return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n","'use strict';\n\nexports.__esModule = true;\nexports.Manager = exports.ChainConfig = exports.Apis = undefined;\n\nvar _ApiInstances = require(71);\n\nvar _ApiInstances2 = _interopRequireDefault(_ApiInstances);\n\nvar _ConnectionManager = require(74);\n\nvar _ConnectionManager2 = _interopRequireDefault(_ConnectionManager);\n\nvar _ChainConfig = require(72);\n\nvar _ChainConfig2 = _interopRequireDefault(_ChainConfig);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Apis = _ApiInstances2.default;\nexports.ChainConfig = _ChainConfig2.default;\nexports.Manager = _ConnectionManager2.default;","'use strict';\n\nexports.__esModule = true;\n\nvar _ChainWebSocket = require(73);\n\nvar _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket);\n\nvar _GrapheneApi = require(75);\n\nvar _GrapheneApi2 = _interopRequireDefault(_GrapheneApi);\n\nvar _ChainConfig = require(72);\n\nvar _ChainConfig2 = _interopRequireDefault(_ChainConfig);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar inst = void 0;\n\nvar ApisInstance = function () {\n  function ApisInstance() {\n    _classCallCheck(this, ApisInstance);\n  }\n\n  /** @arg {string} connection .. */\n  ApisInstance.prototype.connect = function connect(cs, connectTimeout) {\n    var _this = this;\n\n    var rpc_user = '';\n    var rpc_password = '';\n\n    if (typeof window !== 'undefined' && window.location && window.location.protocol === 'https:' && cs.indexOf('wss://') < 0) {\n      throw new Error('Secure domains require wss connection');\n    }\n\n    this.ws_rpc = new _ChainWebSocket2.default(cs, this.statusCb, connectTimeout);\n\n    this.init_promise = this.ws_rpc.login(rpc_user, rpc_password).then(function () {\n      console.log('Connected to API node:', cs);\n      _this._db = new _GrapheneApi2.default(_this.ws_rpc, 'database');\n      _this._net = new _GrapheneApi2.default(_this.ws_rpc, 'network_broadcast');\n      _this._hist = new _GrapheneApi2.default(_this.ws_rpc, 'history');\n      _this._crypto = new _GrapheneApi2.default(_this.ws_rpc, 'crypto');\n      _this._bookie = new _GrapheneApi2.default(_this.ws_rpc, 'bookie');\n      var db_promise = _this._db.init().then(function () {\n        return _this._db.exec('get_chain_id', []).then(function (_chain_id) {\n          _this.chain_id = _chain_id;\n          return _ChainConfig2.default.setChainId(_chain_id);\n        });\n      });\n\n      _this.ws_rpc.on_reconnect = function () {\n        _this.ws_rpc.login('', '').then(function () {\n          _this._db.init().then(function () {\n            if (_this.statusCb) {\n              _this.statusCb(_ChainWebSocket2.default.status.RECONNECTED);\n            }\n          });\n          _this._net.init();\n          _this._hist.init();\n          _this._crypto.init();\n          _this._bookie.init();\n        });\n      };\n\n      return Promise.all([db_promise, _this._net.init(), _this._hist.init(),\n      // Temporary squash crypto API error until the API is upgraded everywhere\n      _this._crypto.init().catch(function (e) {\n        return console.error('ApiInstance\\tCrypto API Error', e);\n      }), _this._bookie.init()]);\n    });\n  };\n\n  ApisInstance.prototype.close = function close() {\n    if (this.ws_rpc) {\n      this.ws_rpc.close();\n    }\n\n    this.ws_rpc = null;\n  };\n\n  ApisInstance.prototype.db_api = function db_api() {\n    return this._db;\n  };\n\n  ApisInstance.prototype.network_api = function network_api() {\n    return this._net;\n  };\n\n  ApisInstance.prototype.history_api = function history_api() {\n    return this._hist;\n  };\n\n  ApisInstance.prototype.crypto_api = function crypto_api() {\n    return this._crypto;\n  };\n\n  ApisInstance.prototype.bookie_api = function bookie_api() {\n    return this._bookie;\n  };\n\n  ApisInstance.prototype.setRpcConnectionStatusCallback = function setRpcConnectionStatusCallback(callback) {\n    this.statusCb = callback;\n  };\n\n  return ApisInstance;\n}();\n\n/**\n    Configure: configure as follows `Apis.instance(\"ws://localhost:8090\").init_promise`.  This\n    returns a promise, once resolved the connection is ready.\n\n    Import: import { Apis } from \"@graphene/chain\"\n\n    Short-hand: Apis.db(\"method\", \"parm1\", 2, 3, ...).  Returns a promise with results.\n\n    Additional usage: Apis.instance().db_api().exec(\"method\", [\"method\", \"parm1\", 2, 3, ...]).\n    Returns a promise with results.\n*/\n\nexports.default = {\n  setRpcConnectionStatusCallback: function setRpcConnectionStatusCallback(callback) {\n    this.statusCb = callback;\n\n    if (inst) {\n      inst.setRpcConnectionStatusCallback(callback);\n    }\n  },\n\n  /**\n        @arg {string} cs is only provided in the first call\n        @return {Apis} singleton .. Check Apis.instance().init_promise to\n        know when the connection is established\n    */\n  reset: function reset() {\n    var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090';\n    var connect = arguments[1];\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;\n\n    if (inst) {\n      inst.close();\n      inst = null;\n    }\n\n    inst = new ApisInstance();\n    inst.setRpcConnectionStatusCallback(this.statusCb);\n\n    if (inst && connect) {\n      inst.connect(cs, connectTimeout);\n    }\n\n    return inst;\n  },\n  instance: function instance() {\n    var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090';\n    var connect = arguments[1];\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;\n\n    if (!inst) {\n      inst = new ApisInstance();\n      inst.setRpcConnectionStatusCallback(this.statusCb);\n    }\n\n    if (inst && connect) {\n      inst.connect(cs, connectTimeout);\n    }\n\n    return inst;\n  },\n  chainId: function chainId() {\n    return this.instance().chain_id;\n  },\n  close: function close() {\n    if (inst) {\n      inst.close();\n      inst = null;\n    }\n  }\n  // db: (method, ...args) => Apis.instance().db_api().exec(method, toStrings(args)),\n  // network: (method, ...args) => Apis.instance().network_api().exec(method, toStrings(args)),\n  // history: (method, ...args) => Apis.instance().history_api().exec(method, toStrings(args)),\n  // crypto: (method, ...args) => Apis.instance().crypto_api().exec(method, toStrings(args))\n\n};","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar defaults = {\n  core_asset: 'PPY',\n  address_prefix: 'PPY',\n  expire_in_secs: 15,\n  expire_in_secs_proposal: 24 * 60 * 60,\n  review_in_secs_committee: 24 * 60 * 60\n};\n\nvar networks = {\n  networks: {\n    Peerplays: {\n      core_asset: 'PPY',\n      address_prefix: 'PPY',\n      chain_id: '6b6b5f0ce7a36d323768e534f3edb41c6d6332a541a95725b98e28d140850134'\n    },\n    PeerplaysTestnet: {\n      core_asset: 'PPYTEST',\n      address_prefix: 'PPYTEST',\n      chain_id: 'be6b79295e728406cbb7494bcb626e62ad278fa4018699cf8f75739f4c1a81fd'\n    }\n  }\n};\n\nvar ChainConfig = function () {\n  function ChainConfig() {\n    _classCallCheck(this, ChainConfig);\n\n    this.reset();\n  }\n\n  ChainConfig.prototype.reset = function reset() {\n    Object.assign(this, defaults);\n  };\n\n  ChainConfig.prototype.setChainId = function setChainId(chainID) {\n    var ref = Object.keys(networks);\n\n    for (var i = 0, len = ref.length; i < len; i++) {\n      var network_name = ref[i];\n      var network = networks[network_name];\n\n      if (network.chain_id === chainID) {\n        this.network_name = network_name;\n\n        if (network.address_prefix) {\n          this.address_prefix = network.address_prefix;\n        }\n\n        return {\n          network_name: network_name,\n          network: network\n        };\n      }\n    }\n\n    if (!this.network_name) {\n      console.log('Unknown chain id (this may be a testnet)', chainID);\n    }\n  };\n\n  ChainConfig.prototype.setPrefix = function setPrefix() {\n    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'PPY';\n\n    this.address_prefix = prefix;\n  };\n\n  return ChainConfig;\n}();\n\nexports.default = new ChainConfig();","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar SOCKET_DEBUG = false;\nvar WebSocketClient = null;\n\nif (typeof WebSocket !== 'undefined') {\n  WebSocketClient = WebSocket;\n} else {\n  WebSocketClient = require(34); // eslint-disable-line global-require\n}\n\nvar SUBSCRIBE_OPERATIONS = ['set_subscribe_callback', 'subscribe_to_market', 'broadcast_transaction_with_callback', 'set_pending_transaction_callback'];\n\nvar UNSUBSCRIBE_OPERATIONS = ['unsubscribe_from_market', 'unsubscribe_from_accounts'];\n\nvar HEALTH_CHECK_INTERVAL = 10000;\n\nvar ChainWebSocket = function () {\n  /**\n   *Creates an instance of ChainWebSocket.\n   * @param {string}    serverAddress           The address of the websocket to connect to.\n   * @param {function}  statusCb                Called when status events occur.\n   * @param {number}    [connectTimeout=10000]  The time for a connection attempt to complete.\n   * @memberof ChainWebSocket\n   */\n  function ChainWebSocket(serverAddress, statusCb) {\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10000;\n\n    _classCallCheck(this, ChainWebSocket);\n\n    this.statusCb = statusCb;\n    this.serverAddress = serverAddress;\n    this.timeoutInterval = connectTimeout;\n\n    // The currenct connection state of the websocket.\n    this.connected = false;\n    this.reconnectTimeout = null;\n\n    // Callback to execute when the websocket is reconnected.\n    this.on_reconnect = null;\n\n    // An incrementing ID for each request so that we can pair it with the\n    // response from the websocket.\n    this.cbId = 0;\n\n    // Objects to store key/value pairs for callbacks, subscription callbacks\n    // and unsubscribe callbacks.\n    this.cbs = {};\n    this.subs = {};\n    this.unsub = {};\n\n    // Current connection promises' rejection\n    this.currentResolve = null;\n    this.currentReject = null;\n\n    // Health check for the connection to the BlockChain.\n    this.healthCheck = null;\n\n    // Copy the constants to this instance.\n    this.status = ChainWebSocket.status;\n\n    // Bind the functions to the instance.\n    this.onConnectionOpen = this.onConnectionOpen.bind(this);\n    this.onConnectionClose = this.onConnectionClose.bind(this);\n    this.onConnectionTerminate = this.onConnectionTerminate.bind(this);\n    this.onConnectionError = this.onConnectionError.bind(this);\n    this.onConnectionTimeout = this.onConnectionTimeout.bind(this);\n    this.createConnection = this.createConnection.bind(this);\n    this.createConnectionPromise = this.createConnectionPromise.bind(this);\n    this.listener = this.listener.bind(this);\n\n    // Create the initial connection the blockchain.\n    this.createConnection();\n  }\n\n  /**\n   * Create the connection to the Blockchain.\n   *\n   * @returns\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.createConnection = function createConnection() {\n    this.debug('!!! ChainWebSocket create connection');\n\n    // Clear any possible reconnect timers.\n    this.reconnectTimeout = null;\n\n    // Create the promise for this connection\n    if (!this.connect_promise) {\n      this.connect_promise = new Promise(this.createConnectionPromise);\n    }\n\n    // Attempt to create the websocket\n    try {\n      this.ws = new WebSocketClient(this.serverAddress);\n    } catch (error) {\n      // Set a timeout to try and reconnect here.\n      return this.resetConnection();\n    }\n\n    this.addEventListeners();\n\n    // Handle timeouts to the websocket's initial connection.\n    this.connectionTimeout = setTimeout(this.onConnectionTimeout, this.timeoutInterval);\n  };\n\n  /**\n   * Reset the connection to the BlockChain.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.resetConnection = function resetConnection() {\n    // Close the Websocket if its still 'half-open'\n    this.close();\n\n    // Make sure we only ever have one timeout running to reconnect.\n    if (!this.reconnectTimeout) {\n      this.debug('!!! ChainWebSocket reset connection', this.timeoutInterval);\n      this.reconnectTimeout = setTimeout(this.createConnection, this.timeoutInterval);\n    }\n\n    // Reject the current promise if there is one.\n    if (this.currentReject) {\n      this.currentReject(new Error('Connection attempt failed: ' + this.serverAddress));\n    }\n  };\n\n  /**\n   * Add event listeners to the WebSocket.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.addEventListeners = function addEventListeners() {\n    this.debug('!!! ChainWebSocket add event listeners');\n    this.ws.addEventListener('open', this.onConnectionOpen);\n    this.ws.addEventListener('close', this.onConnectionClose);\n    this.ws.addEventListener('error', this.onConnectionError);\n    this.ws.addEventListener('message', this.listener);\n  };\n\n  /**\n   * Remove the event listers from the WebSocket. Its important to remove the event listerers\n   * for garbaage collection. Because we are creating a new WebSocket on each connection attempt\n   * any listeners that are still attached could prevent the old sockets from\n   * being garbage collected.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.removeEventListeners = function removeEventListeners() {\n    this.debug('!!! ChainWebSocket remove event listeners');\n    this.ws.removeEventListener('open', this.onConnectionOpen);\n    this.ws.removeEventListener('close', this.onConnectionClose);\n    this.ws.removeEventListener('error', this.onConnectionError);\n    this.ws.removeEventListener('message', this.listener);\n  };\n\n  /**\n   * A function that is passed to a new promise that stores the resolve and reject callbacks\n   * in the state.\n   *\n   * @param {function} resolve A callback to be executed when the promise is resolved.\n   * @param {function} reject A callback to be executed when the promise is rejected.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.createConnectionPromise = function createConnectionPromise(resolve, reject) {\n    this.debug('!!! ChainWebSocket createPromise');\n    this.currentResolve = resolve;\n    this.currentReject = reject;\n  };\n\n  /**\n   * Called when a new Websocket connection is opened.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionOpen = function onConnectionOpen() {\n    this.debug('!!! ChainWebSocket Connected ');\n\n    this.connected = true;\n\n    clearTimeout(this.connectionTimeout);\n    this.connectionTimeout = null;\n\n    // This will trigger the login process as well as some additional setup in ApiInstances\n    if (this.on_reconnect) {\n      this.on_reconnect();\n    }\n\n    if (this.currentResolve) {\n      this.currentResolve();\n    }\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.OPEN);\n    }\n  };\n\n  /**\n   * called when the connection attempt times out.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionTimeout = function onConnectionTimeout() {\n    this.debug('!!! ChainWebSocket timeout');\n    this.onConnectionClose(new Error('Connection timed out.'));\n  };\n\n  /**\n   * Called when the Websocket is not responding to the health checks.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionTerminate = function onConnectionTerminate() {\n    this.debug('!!! ChainWebSocket terminate');\n    this.onConnectionClose(new Error('Connection was terminated.'));\n  };\n\n  /**\n   * Called when the connection to the Blockchain is closed.\n   *\n   * @param {*} error\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionClose = function onConnectionClose(error) {\n    this.debug('!!! ChainWebSocket Close ', error);\n\n    this.resetConnection();\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.CLOSED);\n    }\n  };\n\n  /**\n   * Called when the Websocket encounters an error.\n   *\n   * @param {*} error\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionError = function onConnectionError(error) {\n    this.debug('!!! ChainWebSocket On Connection Error ', error);\n\n    this.resetConnection();\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.ERROR);\n    }\n  };\n\n  /**\n   * Entry point to make RPC calls on the BlockChain.\n   *\n   * @param {array} params An array of params to be passed to the rpc call. [method, ...params]\n   * @returns A new promise for this specific call.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.call = function call(params) {\n    var _this = this;\n\n    if (!this.connected) {\n      this.debug('!!! ChainWebSocket Call not connected. ');\n      return Promise.reject(new Error('Disconnected from the BlockChain.'));\n    }\n\n    this.debug('!!! ChainWebSocket Call connected. ', params);\n\n    var request = {\n      method: params[1],\n      params: params,\n      id: this.cbId + 1\n    };\n\n    this.cbId = request.id;\n\n    if (SUBSCRIBE_OPERATIONS.includes(request.method)) {\n      // Store callback in subs map\n      this.subs[request.id] = {\n        callback: request.params[2][0]\n      };\n\n      // Replace callback with the callback id\n      request.params[2][0] = request.id;\n    }\n\n    if (UNSUBSCRIBE_OPERATIONS.includes(request.method)) {\n      if (typeof request.params[2][0] !== 'function') {\n        throw new Error('First parameter of unsub must be the original callback');\n      }\n\n      var unSubCb = request.params[2].splice(0, 1)[0];\n\n      // Find the corresponding subscription\n      for (var id in this.subs) {\n        // eslint-disable-line\n        if (this.subs[id].callback === unSubCb) {\n          this.unsub[request.id] = id;\n          break;\n        }\n      }\n    }\n\n    if (!this.healthCheck) {\n      this.healthCheck = setTimeout(this.onConnectionTerminate.bind(this), HEALTH_CHECK_INTERVAL);\n    }\n\n    return new Promise(function (resolve, reject) {\n      _this.cbs[request.id] = {\n        time: new Date(),\n        resolve: resolve,\n        reject: reject\n      };\n\n      // Set all requests to be 'call' methods.\n      request.method = 'call';\n\n      try {\n        _this.ws.send(JSON.stringify(request));\n      } catch (error) {\n        _this.debug('Caught a nasty error : ', error);\n      }\n    });\n  };\n\n  /**\n   * Called when messages are received on the Websocket.\n   *\n   * @param {*} response The message received.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.listener = function listener(response) {\n    var responseJSON = null;\n\n    try {\n      responseJSON = JSON.parse(response.data);\n    } catch (error) {\n      responseJSON.error = 'Error parsing response: ' + error.stack;\n      this.debug('Error parsing response: ', response);\n    }\n\n    // Clear the health check timeout, we've just received a healthy response from the server.\n    if (this.healthCheck) {\n      clearTimeout(this.healthCheck);\n      this.healthCheck = null;\n    }\n\n    var sub = false;\n    var callback = null;\n\n    if (responseJSON.method === 'notice') {\n      sub = true;\n      responseJSON.id = responseJSON.params[0];\n    }\n\n    if (!sub) {\n      callback = this.cbs[responseJSON.id];\n    } else {\n      callback = this.subs[responseJSON.id].callback;\n    }\n\n    if (callback && !sub) {\n      if (responseJSON.error) {\n        this.debug('----> responseJSON : ', responseJSON);\n        callback.reject(responseJSON.error);\n      } else {\n        callback.resolve(responseJSON.result);\n      }\n\n      delete this.cbs[responseJSON.id];\n\n      if (this.unsub[responseJSON.id]) {\n        delete this.subs[this.unsub[responseJSON.id]];\n        delete this.unsub[responseJSON.id];\n      }\n    } else if (callback && sub) {\n      callback(responseJSON.params[1]);\n    } else {\n      this.debug('Warning: unknown websocket responseJSON: ', responseJSON);\n    }\n  };\n\n  /**\n   * Login to the Blockchain.\n   *\n   * @param {string} user Username\n   * @param {string} password Password\n   * @returns A promise that is fulfilled after login.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.login = function login(user, password) {\n    var _this2 = this;\n\n    this.debug('!!! ChainWebSocket login.', user, password);\n    return this.connect_promise.then(function () {\n      return _this2.call([1, 'login', [user, password]]);\n    });\n  };\n\n  /**\n   * Close the connection to the Blockchain.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.close = function close() {\n    if (this.ws) {\n      this.removeEventListeners();\n\n      // Try and fire close on the connection.\n      this.ws.close();\n\n      // Clear our references so that it can be garbage collected.\n      this.ws = null;\n    }\n\n    // Clear our timeouts for connection timeout and health check.\n    clearTimeout(this.connectionTimeout);\n    this.connectionTimeout = null;\n\n    clearTimeout(this.healthCheck);\n    this.healthCheck = null;\n\n    clearTimeout(this.reconnectTimeout);\n    this.reconnectTimeout = null;\n\n    // Toggle the connected flag.\n    this.connected = false;\n  };\n\n  ChainWebSocket.prototype.debug = function debug() {\n    if (SOCKET_DEBUG) {\n      for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) {\n        params[_key] = arguments[_key];\n      }\n\n      console.log.apply(null, params);\n    }\n  };\n\n  return ChainWebSocket;\n}();\n\n// Constants for STATE\n\n\nChainWebSocket.status = {\n  RECONNECTED: 'reconnected',\n  OPEN: 'open',\n  CLOSED: 'closed',\n  ERROR: 'error'\n};\n\nexports.default = ChainWebSocket;","'use strict';\n\nexports.__esModule = true;\n\nvar _ApiInstances = require(71);\n\nvar _ApiInstances2 = _interopRequireDefault(_ApiInstances);\n\nvar _ChainWebSocket = require(73);\n\nvar _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Manager = function () {\n  function Manager(_ref) {\n    var url = _ref.url,\n        urls = _ref.urls;\n\n    _classCallCheck(this, Manager);\n\n    this.url = url;\n    this.urls = urls.filter(function (a) {\n      return a !== url;\n    });\n  }\n\n  Manager.prototype.logFailure = function logFailure(url) {\n    console.error('Unable to connect to', url + ', skipping to next full node API server');\n  };\n\n  Manager.prototype.connect = function connect() {\n    var _connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n    var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url;\n\n    return new Promise(function (resolve, reject) {\n      _ApiInstances2.default.instance(url, _connect).init_promise.then(resolve).catch(function (error) {\n        _ApiInstances2.default.instance().close();\n        reject(error);\n      });\n    });\n  };\n\n  Manager.prototype.connectWithFallback = function connectWithFallback() {\n    var connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n    var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url;\n    var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n\n    var _this = this;\n\n    var resolve = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    var reject = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n\n    if (reject && index > this.urls.length - 1) {\n      return reject(new Error('Tried ' + (index + 1) + ' connections, none of which worked: ' + JSON.stringify(this.urls.concat(this.url))));\n    }\n\n    var fallback = function fallback(resolve, reject) {\n      _this.logFailure(url);\n      return _this.connectWithFallback(connect, _this.urls[index], index + 1, resolve, reject);\n    };\n\n    if (resolve && reject) {\n      return this.connect(connect, url).then(resolve).catch(function () {\n        fallback(resolve, reject);\n      });\n    }\n\n    return new Promise(function (resolve, reject) {\n      _this.connect(connect).then(resolve).catch(function () {\n        fallback(resolve, reject);\n      });\n    });\n  };\n\n  Manager.prototype.checkConnections = function checkConnections() {\n    var rpc_user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    var rpc_password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    var _this2 = this;\n\n    var resolve = arguments[2];\n    var reject = arguments[3];\n\n    var connectionStartTimes = {};\n\n    var checkFunction = function checkFunction(resolve, reject) {\n      var fullList = _this2.urls.concat(_this2.url);\n      var connectionPromises = [];\n\n      fullList.forEach(function (url) {\n        var conn = new _ChainWebSocket2.default(url, function () {});\n        connectionStartTimes[url] = new Date().getTime();\n        connectionPromises.push(function () {\n          return conn.login(rpc_user, rpc_password).then(function () {\n            var _ref2;\n\n            conn.close();\n            return _ref2 = {}, _ref2[url] = new Date().getTime() - connectionStartTimes[url], _ref2;\n          }).catch(function () {\n            if (url === _this2.url) {\n              _this2.url = _this2.urls[0];\n            } else {\n              _this2.urls = _this2.urls.filter(function (a) {\n                return a !== url;\n              });\n            }\n\n            conn.close();\n            return null;\n          });\n        });\n      });\n\n      Promise.all(connectionPromises.map(function (a) {\n        return a();\n      })).then(function (res) {\n        resolve(res.filter(function (a) {\n          return !!a;\n        }).reduce(function (f, a) {\n          var key = Object.keys(a)[0];\n          f[key] = a[key];\n          return f;\n        }, {}));\n      }).catch(function () {\n        return _this2.checkConnections(rpc_user, rpc_password, resolve, reject);\n      });\n    };\n\n    if (resolve && reject) {\n      checkFunction(resolve, reject);\n    } else {\n      return new Promise(checkFunction);\n    }\n  };\n\n  return Manager;\n}();\n\nexports.default = Manager;","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar GrapheneApi = function () {\n  function GrapheneApi(ws_rpc, api_name) {\n    _classCallCheck(this, GrapheneApi);\n\n    this.ws_rpc = ws_rpc;\n    this.api_name = api_name;\n  }\n\n  GrapheneApi.prototype.init = function init() {\n    var _this = this;\n\n    return this.ws_rpc.call([1, this.api_name, []]).then(function (response) {\n      _this.api_id = response;\n      return _this;\n    });\n  };\n\n  GrapheneApi.prototype.exec = function exec(method, params) {\n    return this.ws_rpc.call([this.api_id, method, params]).catch(function (error) {\n      console.log('!!! GrapheneApi error: ', method, params, error, JSON.stringify(error));\n      throw error;\n    });\n  };\n\n  return GrapheneApi;\n}();\n\nexports.default = GrapheneApi;","'use strict';\n\nif (!process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // 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\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // 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.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = require(79);\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require(76);\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require(40);\nutil.inherits = require(87);\n/*</replacement>*/\n\nvar Readable = require(81);\nvar Writable = require(83);\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require(82);\n\n/*<replacement>*/\nvar util = require(40);\nutil.inherits = require(87);\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  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]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    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);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require(79);\n\n/*<replacement>*/\nvar util = require(40);\nutil.inherits = require(87);\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  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);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require(93).Buffer;\nvar util = require(34);\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","'use strict';\n\n/*<replacement>*/\n\nvar pna = require(76);\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","module.exports = require(62).EventEmitter;\n","module.exports = require(89).PassThrough\n","exports = module.exports = require(81);\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require(83);\nexports.Duplex = require(79);\nexports.Transform = require(82);\nexports.PassThrough = require(80);\n","module.exports = require(89).Transform\n","module.exports = require(83);\n","'use strict'\nvar Buffer = require(35).Buffer\nvar inherits = require(65)\nvar HashBase = require(63)\n\nvar ARRAY16 = new Array(16)\n\nvar zl = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n]\n\nvar zr = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n]\n\nvar sl = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n]\n\nvar sr = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n]\n\nvar hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]\nvar hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]\n\nfunction RIPEMD160 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n}\n\ninherits(RIPEMD160, HashBase)\n\nRIPEMD160.prototype._update = function () {\n  var words = ARRAY16\n  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)\n\n  var al = this._a | 0\n  var bl = this._b | 0\n  var cl = this._c | 0\n  var dl = this._d | 0\n  var el = this._e | 0\n\n  var ar = this._a | 0\n  var br = this._b | 0\n  var cr = this._c | 0\n  var dr = this._d | 0\n  var er = this._e | 0\n\n  // computation\n  for (var i = 0; i < 80; i += 1) {\n    var tl\n    var tr\n    if (i < 16) {\n      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])\n      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])\n    } else if (i < 32) {\n      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])\n      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])\n    } else if (i < 48) {\n      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])\n      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])\n    } else if (i < 64) {\n      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])\n      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])\n    } else { // if (i<80) {\n      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])\n      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])\n    }\n\n    al = el\n    el = dl\n    dl = rotl(cl, 10)\n    cl = bl\n    bl = tl\n\n    ar = er\n    er = dr\n    dr = rotl(cr, 10)\n    cr = br\n    br = tr\n  }\n\n  // update state\n  var t = (this._b + cl + dr) | 0\n  this._b = (this._c + dl + er) | 0\n  this._c = (this._d + el + ar) | 0\n  this._d = (this._e + al + br) | 0\n  this._e = (this._a + bl + cr) | 0\n  this._a = t\n}\n\nRIPEMD160.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  buffer.writeInt32LE(this._e, 16)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fn1 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn2 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn3 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn4 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn5 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0\n}\n\nmodule.exports = RIPEMD160\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require(35)\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","!function(globals){\n'use strict'\n\n//*** UMD BEGIN\nif (typeof define !== 'undefined' && define.amd) { //require.js / AMD\n  define([], function() {\n    return secureRandom\n  })\n} else if (typeof module !== 'undefined' && module.exports) { //CommonJS\n  module.exports = secureRandom\n} else { //script / browser\n  globals.secureRandom = secureRandom\n}\n//*** UMD END\n\n//options.type is the only valid option\nfunction secureRandom(count, options) {\n  options = options || {type: 'Array'}\n  //we check for process.pid to prevent browserify from tricking us\n  if (typeof process != 'undefined' && typeof process.pid == 'number') {\n    return nodeRandom(count, options)\n  } else {\n    var crypto = window.crypto || window.msCrypto\n    if (!crypto) throw new Error(\"Your browser does not support window.crypto.\")\n    return browserRandom(count, options)\n  }\n}\n\nfunction nodeRandom(count, options) {\n  var crypto = require('crypto')\n  var buf = crypto.randomBytes(count)\n\n  switch (options.type) {\n    case 'Array':\n      return [].slice.call(buf)\n    case 'Buffer':\n      return buf\n    case 'Uint8Array':\n      var arr = new Uint8Array(count)\n      for (var i = 0; i < count; ++i) { arr[i] = buf.readUInt8(i) }\n      return arr\n    default:\n      throw new Error(options.type + \" is unsupported.\")\n  }\n}\n\nfunction browserRandom(count, options) {\n  var nativeArr = new Uint8Array(count)\n  var crypto = window.crypto || window.msCrypto\n  crypto.getRandomValues(nativeArr)\n\n  switch (options.type) {\n    case 'Array':\n      return [].slice.call(nativeArr)\n    case 'Buffer':\n      try { var b = new Buffer(1) } catch(e) { throw new Error('Buffer not supported in this environment. Use Node.js or Browserify for browser support.')}\n      return new Buffer(nativeArr)\n    case 'Uint8Array':\n      return nativeArr\n    default:\n      throw new Error(options.type + \" is unsupported.\")\n  }\n}\n\nsecureRandom.randomArray = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Array'})\n}\n\nsecureRandom.randomUint8Array = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Uint8Array'})\n}\n\nsecureRandom.randomBuffer = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Buffer'})\n}\n\n\n}(this);\n","var Buffer = require(93).Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require(97)\nexports.sha1 = require(98)\nexports.sha224 = require(99)\nexports.sha256 = require(100)\nexports.sha384 = require(101)\nexports.sha512 = require(102)\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require(65)\nvar Sha256 = require(100)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\n","var inherits = require(65)\nvar SHA512 = require(102)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","var inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require(62).EventEmitter;\nvar inherits = require(65);\n\ninherits(Stream, EE);\nStream.Readable = require(89);\nStream.Writable = require(91);\nStream.Duplex = require(78);\nStream.Transform = require(90);\nStream.PassThrough = require(88);\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require(93).Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","var nextTick = require('process/browser.js').nextTick;\nvar apply = Function.prototype.apply;\nvar slice = Array.prototype.slice;\nvar immediateIds = {};\nvar nextImmediateId = 0;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) { timeout.close(); };\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// That's not how node.js implements it but the exposed api is the same.\nexports.setImmediate = typeof setImmediate === \"function\" ? setImmediate : function(fn) {\n  var id = nextImmediateId++;\n  var args = arguments.length < 2 ? false : slice.call(arguments, 1);\n\n  immediateIds[id] = true;\n\n  nextTick(function onNextTick() {\n    if (immediateIds[id]) {\n      // fn.call() is faster so we optimize for the common use-case\n      // @see http://jsperf.com/call-apply-segu\n      if (args) {\n        fn.apply(null, args);\n      } else {\n        fn.call(null);\n      }\n      // Prevent ids from leaking\n      exports.clearImmediate(id);\n    }\n  });\n\n  return id;\n};\n\nexports.clearImmediate = typeof clearImmediate === \"function\" ? clearImmediate : function(id) {\n  delete immediateIds[id];\n};","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n"]} diff --git a/build/peerplaysjs-lib.min.js b/build/peerplaysjs-lib.min.js new file mode 100644 index 0000000..2af404d --- /dev/null +++ b/build/peerplaysjs-lib.min.js @@ -0,0 +1 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).peerplays_js=e()}}(function(){return function o(s,a,f){function u(t,e){if(!a[t]){if(!s[t]){var r="function"==typeof require&&require;if(!e&&r)return r(t,!0);if(c)return c(t,!0);var n=new Error("Cannot find module '"+t+"'");throw n.code="MODULE_NOT_FOUND",n}var i=a[t]={exports:{}};s[t][0].call(i.exports,function(e){return u(s[t][1][e]||e)},i,i.exports,o,s,a,f)}return a[t].exports}for(var c="function"==typeof require&&require,e=0;e %s (%d bytes)",o.operation_name,i[1],s,s.length/2)}a.tr_buffer=p.ops.transaction.toBuffer(a)}))})},e.prototype.id=function(){if(!this.tr_buffer)throw new Error("not finalized");return a.hash.sha256(this.tr_buffer).toString("hex").substring(0,40)},e.prototype.add_operation=function(e){if(this.tr_buffer)throw new Error("already finalized");if((0,u.default)(e,"operation"),!Array.isArray(e))throw new Error("Expecting array [operation_id, operation]");this.operations.push(e)},e.prototype.get_type_operation=function(e,t){if(this.tr_buffer)throw new Error("already finalized");(0,u.default)(e,"name"),(0,u.default)(t,"operation");var r=p.ops[e];(0,u.default)(r,"Unknown operation "+e);var n=c.default.operations[r.operation_name];if(void 0===n)throw new Error("unknown operation: "+r.operation_name);if(t.fee||(t.fee={amount:0,asset_id:0}),"proposal_create"===e){var i=!1,o=0;if(t.proposed_ops.forEach(function(e){var t=void 0;switch(e.op[0]){case 0:t="from";break;case 6:case 17:t="account";break;case 10:case 11:case 12:case 13:case 14:case 18:case 43:t="issuer";break;case 15:t="payer";break;case 16:t="from_account";break;case 22:case 23:case 24:t="fee_paying_account";break;case 31:i=!0,o=1123200}t in e.op[1]&&0===e.op[1][t]&&(i=!0)}),!t.expiration_time){var s=this.base_expiration_sec();t.expiration_time=s+l.ChainConfig.expire_in_secs_proposal}if(i){var a=Math.max(this.commitee_min_review,86400,l.ChainConfig.review_in_secs_committee);t.review_period_seconds=o+a,t.expiration_time+=3600+o}}return[n,r.fromObject(t)]},e.prototype.update_head_block=function(){var n=this;return l.Apis.instance().db_api().exec("get_objects",[["2.0.0","2.1.0"]]).then(function(e){var t=e[0],r=e[1];n.head_block_time_string=r[0].time,n.committee_min_review=t[0].parameters.committee_proposal_review_period})},e.prototype.set_expire_seconds=function(e){if(this.tr_buffer)throw new Error("already finalized");return this.expiration=this.base_expiration_sec()+e,this.expiration},e.prototype.propose=function(e){if(this.tr_buffer)throw new Error("already finalized");if(!this.operations.length)throw new Error("add operation first");(0,u.default)(e,"proposal_create_options"),(0,u.default)(e.fee_paying_account,"proposal_create_options.fee_paying_account");var t=this.operations.map(function(e){return{op:e}});return this.operations=[],this.signatures=[],this.signer_private_keys=[],e.proposed_ops=t,this.add_type_operation("proposal_create",e),this},e.prototype.has_proposed_operation=function(){for(var e=!1,t=0;tparseInt(h,10)&&(a=f,u="1.3.0")}var i=[];!function e(t){if(Array.isArray(t))for(var r=0,n=t.length;r>1?s.add(i):s,c=e.pointFromX(f,u),h=c.multiply(i);(0,_.default)(e.isInfinity(h),"nR is not a valid curve point");var l=t.negate().mod(i),p=s.modInverse(i),d=c.multiplyTwo(a,o,l).multiply(p);return e.validate(d),d}r.calcPubKeyRecoveryParam=function(e,t,r,n){for(var i=0;i<4;i++)if(o(e,t,r,i).equals(n))return i;throw new Error("Unable to find valid recovery factor")},r.deterministicGenerateK=d,r.recoverPubKey=o,r.sign=function(r,e,n,t){var i=c.default.fromBuffer(e),o=r.n,s=r.G,a=void 0,f=void 0;d(r,e,n,function(e){var t=s.multiply(e);return!r.isInfinity(t)&&0!==(a=t.affineX.mod(o)).signum()&&0!==(f=e.modInverse(o).multiply(i.add(n.multiply(a))).mod(o)).signum()},t);var u=o.shiftRight(1);return 0i.length;)e.writeUint8(0)}},n.public_key=function(e,t){var r=void 0;if(e)return t?(r=t.toBuffer(),void e.append(r.toString("binary"),"binary")):(r=n.fixed_data(e,33),i.default.fromBuffer(r))},n.ripemd160=function(e,t){if(e)return t?void n.fixed_data(e,20,t):n.fixed_data(e,20)},n.sha256=function(e,t){if(e)return t?void n.fixed_data(e,32,t):n.fixed_data(e,32)},n.time_point_sec=function(e,t){if(!t)return t=e.readInt32(),new Date(1e3*t);t=Math.ceil(t/1e3),e.writeInt32(t)},n}();a.default=r,s.exports=a.default}).call(this,n(35).Buffer)},{11:11,35:35}],21:[function(e,t,r){"use strict";r.__esModule=!0;var n,i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},o=e(38),s=e(3),a=(n=s)&&n.__esModule?n:{default:n};var f=9007199254740991,u=-9007199254740991,c={is_empty:function(e){return null==e},required:function(e){var t=1>=8;for(;0>=8}for(var s=0;e[s]===c&&s>16&255,o[s++]=t>>8&255,o[s++]=255&t;var u,c;2===i&&(t=h[e.charCodeAt(f)]<<2|h[e.charCodeAt(f+1)]>>4,o[s++]=255&t);1===i&&(t=h[e.charCodeAt(f)]<<10|h[e.charCodeAt(f+1)]<<4|h[e.charCodeAt(f+2)]>>2,o[s++]=t>>8&255,o[s++]=255&t);return o},r.fromByteArray=function(e){for(var t,r=e.length,n=r%3,i=[],o=0,s=r-n;o>2]+a[t<<4&63]+"==")):2===n&&(t=(e[r-2]<<8)+e[r-1],i.push(a[t>>10]+a[t>>4&63]+a[t<<2&63]+"="));return i.join("")};for(var a=[],h=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,o=n.length;i>18&63]+a[i>>12&63]+a[i>>6&63]+a[63&i]);return o.join("")}h["-".charCodeAt(0)]=62,h["_".charCodeAt(0)]=63},{}],30:[function(e,t,r){function b(e,t,r){if(!(this instanceof b))return new b(e,t,r);null!=e&&("number"==typeof e?this.fromNumber(e,t,r):null==t&&"string"!=typeof e?this.fromString(e,256):this.fromString(e,t))}var n=b.prototype;n.__bigi=e(33).version,b.isBigInteger=function(e,t){return e&&e.__bigi&&(!t||e.__bigi===n.__bigi)},b.prototype.am=function(e,t,r,n,i,o){for(;0<=--o;){var s=t*this[e++]+r[n]+i;i=Math.floor(s/67108864),r[n++]=67108863&s}return i},b.prototype.DB=26,b.prototype.DM=67108863;var i=b.prototype.DV=1<<26;b.prototype.FV=Math.pow(2,52),b.prototype.F1=26,b.prototype.F2=0;var o,s,a="0123456789abcdefghijklmnopqrstuvwxyz",f=new Array;for(o="0".charCodeAt(0),s=0;s<=9;++s)f[o++]=s;for(o="a".charCodeAt(0),s=10;s<36;++s)f[o++]=s;for(o="A".charCodeAt(0),s=10;s<36;++s)f[o++]=s;function u(e){return a.charAt(e)}function c(e,t){var r=f[e.charCodeAt(t)];return null==r?-1:r}function g(e){var t=new b;return t.fromInt(e),t}function w(e){var t,r=1;return 0!=(t=e>>>16)&&(e=t,r+=16),0!=(t=e>>8)&&(e=t,r+=8),0!=(t=e>>4)&&(e=t,r+=4),0!=(t=e>>2)&&(e=t,r+=2),0!=(t=e>>1)&&(e=t,r+=1),r}function m(e){this.m=e}function v(e){this.m=e,this.mp=e.invDigit(),this.mpl=32767&this.mp,this.mph=this.mp>>15,this.um=(1<>=16,t+=16),0==(255&e)&&(e>>=8,t+=8),0==(15&e)&&(e>>=4,t+=4),0==(3&e)&&(e>>=2,t+=2),0==(1&e)&&++t,t}function y(e){for(var t=0;0!=e;)e&=e-1,++t;return t}function E(){}function B(e){return e}function k(e){this.r2=new b,this.q3=new b,b.ONE.dlShiftTo(2*e.t,this.r2),this.mu=this.r2.divide(e),this.m=e}m.prototype.convert=function(e){return e.s<0||0<=e.compareTo(this.m)?e.mod(this.m):e},m.prototype.revert=function(e){return e},m.prototype.reduce=function(e){e.divRemTo(this.m,null,e)},m.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},m.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)},v.prototype.convert=function(e){var t=new b;return e.abs().dlShiftTo(this.m.t,t),t.divRemTo(this.m,null,t),e.s<0&&0>15)*this.mpl&this.um)<<15)&e.DM;for(e[r=t+this.m.t]+=this.m.am(0,n,e,t,0,this.m.t);e[r]>=e.DV;)e[r]-=e.DV,e[++r]++}e.clamp(),e.drShiftTo(this.m.t,e),0<=e.compareTo(this.m)&&e.subTo(this.m,e)},v.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},v.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)},n.copyTo=function(e){for(var t=this.t-1;0<=t;--t)e[t]=this[t];e.t=this.t,e.s=this.s},n.fromInt=function(e){this.t=1,this.s=e<0?-1:0,0n.DB?(n[n.t-1]|=(a&(1<>n.DB-s):n[n.t-1]|=a<=n.DB&&(s-=n.DB))}8==r&&0!=(128&e[0])&&(n.s=-1,0>o|f,f=(n[r]&s)<=r.t)t.t=0;else{var i=e%r.DB,o=r.DB-i,s=(1<>i;for(var a=n+1;a>i;0>=r.DB;if(e.t>=r.DB;i+=r.s}else{for(i+=r.s;n>=r.DB;i-=e.s}t.s=i<0?-1:0,i<-1?t[n++]=r.DV+i:0=t.DV&&(e[r+t.t]-=t.DV,e[r+t.t+1]=1)}0>n.F2:0),p=n.FV/l,d=(1<>f)&&(o=!0,s=u(n));0<=a;)f>(f+=r.DB-t)):(n=r[a]>>(f-=t)&i,f<=0&&(f+=r.DB,--a)),0>3},n.mod=function(e){var t=new b;return this.abs().divRemTo(e,null,t),this.s<0&&02*this.m.t)return e.mod(this.m);if(e.compareTo(this.m)<0)return e;var t=new b;return e.copyTo(t),this.reduce(t),t},k.prototype.revert=function(e){return e},k.prototype.reduce=function(e){var t=this;for(e.drShiftTo(t.m.t-1,t.r2),e.t>t.m.t+1&&(e.t=t.m.t+1,e.clamp()),t.mu.multiplyUpperTo(t.r2,t.m.t+1,t.q3),t.m.multiplyLowerTo(t.q3,t.m.t+1,t.r2);e.compareTo(t.r2)<0;)e.dAddOffset(1,t.m.t+1);for(e.subTo(t.r2,e);0<=e.compareTo(t.m);)e.subTo(t.m,e)},k.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},k.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)};var T=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997],S=(1<<26)/T[T.length-1];n.chunkSize=function(e){return Math.floor(Math.LN2*this.DB/Math.log(e))},n.toRadix=function(e){if(null==e&&(e=10),0==this.signum()||e<2||36=n&&(r.dMultiply(i),r.dAddOffset(a,0),a=s=0))}0e&&n.subTo(b.ONE.shiftLeft(e-1),n);else{var i=new Array,o=7&e;i.length=1+(e>>3),t.nextBytes(i),0>=r.DB;if(e.t>=r.DB;i+=r.s}else{for(i+=r.s;n>=r.DB;i+=e.s}t.s=i<0?-1:0,0=this.DV;)this[t]-=this.DV,++t>=this.t&&(this[this.t++]=0),++this[t]}},n.multiplyLowerTo=function(e,t,r){var n,i=Math.min(this.t+e.t,t);for(r.s=0,r.t=i;0>1)&&(e=T.length);for(var i=new b(null),o=[],s=0;s>24},n.shortValue=function(){return 0==this.t?this.s:this[0]<<16>>16},n.signum=function(){return this.s<0?-1:this.t<=0||1==this.t&&this[0]<=0?0:1},n.toByteArray=function(){var e=this,t=e.t,r=new Array;r[0]=e.s;var n,i=e.DB-t*e.DB%8,o=0;if(0>i)!=(e.s&e.DM)>>i&&(r[o++]=n|e.s<>(i+=e.DB-8)):(n=e[t]>>(i-=8)&255,i<=0&&(i+=e.DB,--t)),0!=(128&n)&&(n|=-256),0===o&&(128&e.s)!=(128&n)&&++o,(0=this.t?0!=this.s:0!=(this[t]&1<>i-f&u:(h=(e[p]&(1<>this.DB+i-f)),a=r;0==(1&h);)h>>=1,--a;if((i-=a)<0&&(i+=this.DB,--p),d)s[h].copyTo(o),d=!1;else{for(;1=r())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+r().toString(16)+" bytes");return 0|e}function p(e,t){if(h.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return j(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return M(e).length;default:if(n)return j(e).length;t=(""+t).toLowerCase(),n=!0}}function d(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function _(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):2147483647=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=h.from(t,n)),h.isBuffer(t))return 0===t.length?-1:g(e,t,r,n,i);if("number"==typeof t)return t&=255,h.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):g(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function g(e,t,r,n,i){var o,s=1,a=e.length,f=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;a/=s=2,f/=2,r/=2}function u(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var c=-1;for(o=r;o>>10&1023|55296),c=56320|1023&c),n.push(c),i+=h}return function(e){var t=e.length;if(t<=w)return String.fromCharCode.apply(String,e);var r="",n=0;for(;nthis.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return k(this,t,r);case"utf8":case"utf-8":return b(this,t,r);case"ascii":return E(this,t,r);case"latin1":case"binary":return B(this,t,r);case"base64":return y(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return T(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}.apply(this,arguments)},h.prototype.equals=function(e){if(!h.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===h.compare(this,e)},h.prototype.inspect=function(){var e="",t=q.INSPECT_MAX_BYTES;return 0t&&(e+=" ... ")),""},h.prototype.compare=function(e,t,r,n,i){if(!h.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(i<=n&&r<=t)return 0;if(i<=n)return-1;if(r<=t)return 1;if(this===e)return 0;for(var o=(i>>>=0)-(n>>>=0),s=(r>>>=0)-(t>>>=0),a=Math.min(o,s),f=this.slice(n,i),u=e.slice(t,r),c=0;cthis.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var o,s,a,f,u,c,h,l,p,d=!1;;)switch(n){case"hex":return m(this,e,t,r);case"utf8":case"utf-8":return l=t,p=r,D(j(e,(h=this).length-l),h,l,p);case"ascii":return v(this,e,t,r);case"latin1":case"binary":return v(this,e,t,r);case"base64":return f=this,u=t,c=r,D(M(e),f,u,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return s=t,a=r,D(function(e,t){for(var r,n,i,o=[],s=0;s>8,i=r%256,o.push(i),o.push(n);return o}(e,(o=this).length-s),o,s,a);default:if(d)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),d=!0}},h.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var w=4096;function E(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;ie.length)throw new RangeError("Index out of range")}function I(e,t,r,n){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-r,2);i>>8*(n?i:1-i)}function A(e,t,r,n){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-r,4);i>>8*(n?i:3-i)&255}function O(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function L(e,t,r,n,i){return i||O(e,0,r,4),o.write(e,t,r,n,23,4),r+4}function C(e,t,r,n,i){return i||O(e,0,r,8),o.write(e,t,r,n,52,8),r+8}h.prototype.slice=function(e,t){var r,n=this.length;if((e=~~e)<0?(e+=n)<0&&(e=0):n>>8):I(this,e,t,!0),t+2},h.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,2,65535,0),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):I(this,e,t,!1),t+2},h.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,4294967295,0),h.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):A(this,e,t,!0),t+4},h.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,4294967295,0),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):A(this,e,t,!1),t+4},h.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);x(this,e,t,r,i-1,-i)}var o=0,s=1,a=0;for(this[t]=255&e;++o>0)-a&255;return t+r},h.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);x(this,e,t,r,i-1,-i)}var o=r-1,s=1,a=0;for(this[t+o]=255&e;0<=--o&&(s*=256);)e<0&&0===a&&0!==this[t+o+1]&&(a=1),this[t+o]=(e/s>>0)-a&255;return t+r},h.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,1,127,-128),h.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},h.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,2,32767,-32768),h.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):I(this,e,t,!0),t+2},h.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,2,32767,-32768),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):I(this,e,t,!1),t+2},h.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,2147483647,-2147483648),h.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):A(this,e,t,!0),t+4},h.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):A(this,e,t,!1),t+4},h.prototype.writeFloatLE=function(e,t,r){return L(this,e,t,!0,r)},h.prototype.writeFloatBE=function(e,t,r){return L(this,e,t,!1,r)},h.prototype.writeDoubleLE=function(e,t,r){return C(this,e,t,!0,r)},h.prototype.writeDoubleBE=function(e,t,r){return C(this,e,t,!1,r)},h.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),0=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(o=t;o>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function M(e){return n.toByteArray(function(e){var t;if((e=(t=e,t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")).replace(R,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function D(e,t,r,n){for(var i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{29:29,64:64,67:67}],36:[function(e,t,r){var n=e(35).Buffer,i=n.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};var o=r.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),function(e){if(e&&!i(e))throw new Error("Unknown encoding: "+e)}(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=a;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=f;break;default:return void(this.write=s)}this.charBuffer=new n(6),this.charReceived=0,this.charLength=0};function s(e){return e.toString(this.encoding)}function a(e){this.charReceived=e.length%2,this.charLength=this.charReceived?2:0}function f(e){this.charReceived=e.length%3,this.charLength=this.charReceived?3:0}o.prototype.write=function(e){for(var t="";this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived>5==6){this.charLength=2;break}if(t<=2&&r>>4==14){this.charLength=3;break}if(t<=3&&r>>3==30){this.charLength=4;break}}this.charReceived=t},o.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;t+=n.slice(0,r).toString(i)}return t}},{35:35}],37:[function(e,t,r){var n=e(28);t.exports=n("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")},{28:28}],38:[function(t,e,r){var n,i;n=this,i=function(f){"use strict";var d=function(e,t,r){if(void 0===e&&(e=d.DEFAULT_CAPACITY),void 0===t&&(t=d.DEFAULT_ENDIAN),void 0===r&&(r=d.DEFAULT_NOASSERT),!r){if((e|=0)<0)throw RangeError("Illegal capacity");t=!!t,r=!!r}this.buffer=0===e?o:new ArrayBuffer(e),this.view=0===e?null:new Uint8Array(this.buffer),this.offset=0,this.markedOffset=-1,this.limit=e,this.littleEndian=t,this.noAssert=r};d.VERSION="5.0.1",d.LITTLE_ENDIAN=!0,d.BIG_ENDIAN=!1,d.DEFAULT_CAPACITY=16,d.DEFAULT_ENDIAN=d.BIG_ENDIAN,d.DEFAULT_NOASSERT=!1,d.Long=f||null;var s=d.prototype;s.__isByteBuffer__,Object.defineProperty(s,"__isByteBuffer__",{value:!0,enumerable:!1,configurable:!1});var o=new ArrayBuffer(0),r=String.fromCharCode;function a(e){var t=0;return function(){return t>1,c=-7,h=r?i-1:0,l=r?-1:1,p=e[t+h];for(h+=l,o=p&(1<<-c)-1,p>>=-c,c+=a;0>=-c,c+=n;0>1,l=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,_=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(f=Math.pow(2,-s))<1&&(s--,f*=2),2<=(t+=1<=s+h?l/f:l*Math.pow(2,1-h))*f&&(s++,f/=2),c<=s+h?(a=0,s=c):1<=s+h?(a=(t*f-1)*Math.pow(2,i),s+=h):(a=t*Math.pow(2,h-1)*Math.pow(2,i),s=0));8<=i;e[r+p]=255&a,p+=d,a/=256,i-=8);for(s=s<>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=t,o=e.length,s=o>>3,a=0;for(t+=this.writeVarint32(o,t);s--;)n=1&!!e[a++]|(1&!!e[a++])<<1|(1&!!e[a++])<<2|(1&!!e[a++])<<3|(1&!!e[a++])<<4|(1&!!e[a++])<<5|(1&!!e[a++])<<6|(1&!!e[a++])<<7,this.writeByte(n,t++);if(a>3,s=0,a=[];for(e+=n.length;o--;)r=this.readByte(e++),a[s++]=!!(1&r),a[s++]=!!(2&r),a[s++]=!!(4&r),a[s++]=!!(8&r),a[s++]=!!(16&r),a[s++]=!!(32&r),a[s++]=!!(64&r),a[s++]=!!(128&r);if(s>f++&1)}return t&&(this.offset=e),a},s.readBytes=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+e>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+"+e+") <= "+this.buffer.byteLength)}var n=this.slice(t,t+e);return r&&(this.offset+=e),n},s.writeBytes=s.append,s.writeInt8=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=1;var n=this.buffer.byteLength;return nt?n:t),t-=1,this.view[t]=e,r&&(this.offset+=1),this},s.writeByte=s.writeInt8,s.readInt8=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=this.view[e];return 128==(128&r)&&(r=-(255-r+1)),t&&(this.offset+=1),r},s.readByte=s.readInt8,s.writeUint8=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=1;var n=this.buffer.byteLength;return nt?n:t),t-=1,this.view[t]=e,r&&(this.offset+=1),this},s.writeUInt8=s.writeUint8,s.readUint8=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=this.view[e];return t&&(this.offset+=1),r},s.readUInt8=s.readUint8,s.writeInt16=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=2;var n=this.buffer.byteLength;return nt?n:t),t-=2,this.littleEndian?(this.view[t+1]=(65280&e)>>>8,this.view[t]=255&e):(this.view[t]=(65280&e)>>>8,this.view[t+1]=255&e),r&&(this.offset+=2),this},s.writeShort=s.writeInt16,s.readInt16=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+2>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+2) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e],r|=this.view[e+1]<<8):(r=this.view[e]<<8,r|=this.view[e+1]),32768==(32768&r)&&(r=-(65535-r+1)),t&&(this.offset+=2),r},s.readShort=s.readInt16,s.writeUint16=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=2;var n=this.buffer.byteLength;return nt?n:t),t-=2,this.littleEndian?(this.view[t+1]=(65280&e)>>>8,this.view[t]=255&e):(this.view[t]=(65280&e)>>>8,this.view[t+1]=255&e),r&&(this.offset+=2),this},s.writeUInt16=s.writeUint16,s.readUint16=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+2>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+2) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e],r|=this.view[e+1]<<8):(r=this.view[e]<<8,r|=this.view[e+1]),t&&(this.offset+=2),r},s.readUInt16=s.readUint16,s.writeInt32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,this.littleEndian?(this.view[t+3]=e>>>24&255,this.view[t+2]=e>>>16&255,this.view[t+1]=e>>>8&255,this.view[t]=255&e):(this.view[t]=e>>>24&255,this.view[t+1]=e>>>16&255,this.view[t+2]=e>>>8&255,this.view[t+3]=255&e),r&&(this.offset+=4),this},s.writeInt=s.writeInt32,s.readInt32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0):(r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0),r|=0,t&&(this.offset+=4),r},s.readInt=s.readInt32,s.writeUint32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,this.littleEndian?(this.view[t+3]=e>>>24&255,this.view[t+2]=e>>>16&255,this.view[t+1]=e>>>8&255,this.view[t]=255&e):(this.view[t]=e>>>24&255,this.view[t+1]=e>>>16&255,this.view[t+2]=e>>>8&255,this.view[t+3]=255&e),r&&(this.offset+=4),this},s.writeUInt32=s.writeUint32,s.readUint32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0):(r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0),t&&(this.offset+=4),r},s.readUInt32=s.readUint32,f&&(s.writeInt64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e)),t+=8;var n=this.buffer.byteLength;nt?n:t),t-=8;var i=e.low,o=e.high;return this.littleEndian?(this.view[t+3]=i>>>24&255,this.view[t+2]=i>>>16&255,this.view[t+1]=i>>>8&255,this.view[t]=255&i,t+=4,this.view[t+3]=o>>>24&255,this.view[t+2]=o>>>16&255,this.view[t+1]=o>>>8&255,this.view[t]=255&o):(this.view[t]=o>>>24&255,this.view[t+1]=o>>>16&255,this.view[t+2]=o>>>8&255,this.view[t+3]=255&o,t+=4,this.view[t]=i>>>24&255,this.view[t+1]=i>>>16&255,this.view[t+2]=i>>>8&255,this.view[t+3]=255&i),r&&(this.offset+=8),this},s.writeLong=s.writeInt64,s.readInt64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=0,n=0;this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0,e+=4,n=this.view[e+2]<<16,n|=this.view[e+1]<<8,n|=this.view[e],n+=this.view[e+3]<<24>>>0):(n=this.view[e+1]<<16,n|=this.view[e+2]<<8,n|=this.view[e+3],n+=this.view[e]<<24>>>0,e+=4,r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0);var i=new f(r,n,!1);return t&&(this.offset+=8),i},s.readLong=s.readInt64,s.writeUint64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e)),t+=8;var n=this.buffer.byteLength;nt?n:t),t-=8;var i=e.low,o=e.high;return this.littleEndian?(this.view[t+3]=i>>>24&255,this.view[t+2]=i>>>16&255,this.view[t+1]=i>>>8&255,this.view[t]=255&i,t+=4,this.view[t+3]=o>>>24&255,this.view[t+2]=o>>>16&255,this.view[t+1]=o>>>8&255,this.view[t]=255&o):(this.view[t]=o>>>24&255,this.view[t+1]=o>>>16&255,this.view[t+2]=o>>>8&255,this.view[t+3]=255&o,t+=4,this.view[t]=i>>>24&255,this.view[t+1]=i>>>16&255,this.view[t+2]=i>>>8&255,this.view[t+3]=255&i),r&&(this.offset+=8),this},s.writeUInt64=s.writeUint64,s.readUint64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=0,n=0;this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0,e+=4,n=this.view[e+2]<<16,n|=this.view[e+1]<<8,n|=this.view[e],n+=this.view[e+3]<<24>>>0):(n=this.view[e+1]<<16,n|=this.view[e+2]<<8,n|=this.view[e+3],n+=this.view[e]<<24>>>0,e+=4,r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0);var i=new f(r,n,!0);return t&&(this.offset+=8),i},s.readUInt64=s.readUint64),s.writeFloat32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e)throw TypeError("Illegal value: "+e+" (not a number)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,i(this.view,e,t,this.littleEndian,23,4),r&&(this.offset+=4),this},s.writeFloat=s.writeFloat32,s.readFloat32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=n(this.view,e,this.littleEndian,23,4);return t&&(this.offset+=4),r},s.readFloat=s.readFloat32,s.writeFloat64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e)throw TypeError("Illegal value: "+e+" (not a number)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=8;var n=this.buffer.byteLength;return nt?n:t),t-=8,i(this.view,e,t,this.littleEndian,52,8),r&&(this.offset+=8),this},s.writeDouble=s.writeFloat64,s.readFloat64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=n(this.view,e,this.littleEndian,52,8);return t&&(this.offset+=8),r},s.readDouble=s.readFloat64,d.MAX_VARINT32_BYTES=5,d.calculateVarint32=function(e){return(e>>>=0)<128?1:e<16384?2:e<1<<21?3:e<1<<28?4:5},d.zigZagEncode32=function(e){return((e|=0)<<1^e>>31)>>>0},d.zigZagDecode32=function(e){return e>>>1^-(1&e)|0},s.writeVarint32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=d.calculateVarint32(e);t+=i;var o=this.buffer.byteLength;for(ot?o:t),t-=i,e>>>=0;128<=e;)n=127&e|128,this.view[t++]=n,e>>>=7;return this.view[t++]=e,r?(this.offset=t,this):i},s.writeVarint32ZigZag=function(e,t){return this.writeVarint32(d.zigZagEncode32(e),t)},s.readVarint32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r,n=0,i=0;do{if(!this.noAssert&&e>this.limit){var o=Error("Truncated");throw o.truncated=!0,o}r=this.view[e++],n<5&&(i|=(127&r)<<7*n),++n}while(0!=(128&r));return i|=0,t?(this.offset=e,i):{value:i,length:n}},s.readVarint32ZigZag=function(e){var t=this.readVarint32(e);return"object"==typeof t?t.value=d.zigZagDecode32(t.value):t=d.zigZagDecode32(t),t},f&&(d.MAX_VARINT64_BYTES=10,d.calculateVarint64=function(e){"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e));var t=e.toInt()>>>0,r=e.shiftRightUnsigned(28).toInt()>>>0,n=e.shiftRightUnsigned(56).toInt()>>>0;return 0==n?0==r?t<16384?t<128?1:2:t<1<<21?3:4:r<16384?r<128?5:6:r<1<<21?7:8:n<128?9:10},d.zigZagEncode64=function(e){return"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned()),e.shiftLeft(1).xor(e.shiftRight(63)).toUnsigned()},d.zigZagDecode64=function(e){return"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned()),e.shiftRightUnsigned(1).xor(e.and(f.ONE).toSigned().negate()).toSigned()},s.writeVarint64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned());var n=d.calculateVarint64(e),i=e.toInt()>>>0,o=e.shiftRightUnsigned(28).toInt()>>>0,s=e.shiftRightUnsigned(56).toInt()>>>0;t+=n;var a=this.buffer.byteLength;switch(at?a:t),t-=n,n){case 10:this.view[t+9]=s>>>7&1;case 9:this.view[t+8]=9!==n?128|s:127&s;case 8:this.view[t+7]=8!==n?o>>>21|128:o>>>21&127;case 7:this.view[t+6]=7!==n?o>>>14|128:o>>>14&127;case 6:this.view[t+5]=6!==n?o>>>7|128:o>>>7&127;case 5:this.view[t+4]=5!==n?128|o:127&o;case 4:this.view[t+3]=4!==n?i>>>21|128:i>>>21&127;case 3:this.view[t+2]=3!==n?i>>>14|128:i>>>14&127;case 2:this.view[t+1]=2!==n?i>>>7|128:i>>>7&127;case 1:this.view[t]=1!==n?128|i:127&i}return r?(this.offset+=n,this):n},s.writeVarint64ZigZag=function(e,t){return this.writeVarint64(d.zigZagEncode64(e),t)},s.readVarint64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=e,n=0,i=0,o=0,s=0;if(n=127&(s=this.view[e++]),128&s&&(n|=(127&(s=this.view[e++]))<<7,(128&s||this.noAssert&&void 0===s)&&(n|=(127&(s=this.view[e++]))<<14,(128&s||this.noAssert&&void 0===s)&&(n|=(127&(s=this.view[e++]))<<21,(128&s||this.noAssert&&void 0===s)&&(i=127&(s=this.view[e++]),(128&s||this.noAssert&&void 0===s)&&(i|=(127&(s=this.view[e++]))<<7,(128&s||this.noAssert&&void 0===s)&&(i|=(127&(s=this.view[e++]))<<14,(128&s||this.noAssert&&void 0===s)&&(i|=(127&(s=this.view[e++]))<<21,(128&s||this.noAssert&&void 0===s)&&(o=127&(s=this.view[e++]),(128&s||this.noAssert&&void 0===s)&&(o|=(127&(s=this.view[e++]))<<7,128&s||this.noAssert&&void 0===s))))))))))throw Error("Buffer overrun");var a=f.fromBits(n|i<<28,i>>>4|o<<24,!1);return t?(this.offset=e,a):{value:a,length:e-r}},s.readVarint64ZigZag=function(e){var t=this.readVarint64(e);return t&&t.value instanceof f?t.value=d.zigZagDecode64(t.value):t=d.zigZagDecode64(t),t}),s.writeCString=function(e,t){var r=void 0===t;r&&(t=this.offset);var n,i=e.length;if(!this.noAssert){if("string"!=typeof e)throw TypeError("Illegal str: Not a string");for(n=0;n>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}i=l.calculateUTF16asUTF8(a(e))[1],t+=i+1;var o=this.buffer.byteLength;return ot?o:t),t-=i+1,l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),this.view[t++]=0,r?(this.offset=t,this):i},s.readCString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r,n=e,i=-1;return l.decodeUTF8toUTF16(function(){if(0===i)return null;if(e>=this.limit)throw RangeError("Illegal range: Truncated data, "+e+" < "+this.limit);return 0===(i=this.view[e++])?null:i}.bind(this),r=u(),!0),t?(this.offset=e,r()):{string:r(),length:e-n}},s.writeIString=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("string"!=typeof e)throw TypeError("Illegal str: Not a string");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=t;n=l.calculateUTF16asUTF8(a(e),this.noAssert)[1],t+=4+n;var o=this.buffer.byteLength;if(ot?o:t),t-=4+n,this.littleEndian?(this.view[t+3]=n>>>24&255,this.view[t+2]=n>>>16&255,this.view[t+1]=n>>>8&255,this.view[t]=255&n):(this.view[t]=n>>>24&255,this.view[t+1]=n>>>16&255,this.view[t+2]=n>>>8&255,this.view[t+3]=255&n),t+=4,l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),t!==i+4+n)throw RangeError("Illegal range: Truncated data, "+t+" == "+(t+4+n));return r?(this.offset=t,this):t-i},s.readIString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=e,n=this.readUint32(e),i=this.readUTF8String(n,d.METRICS_BYTES,e+=4);return e+=i.length,t?(this.offset=e,i.string):{string:i.string,length:e-r}},d.METRICS_CHARS="c",d.METRICS_BYTES="b",s.writeUTF8String=function(e,t){var r,n=void 0===t;if(n&&(t=this.offset),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var i=t;r=l.calculateUTF16asUTF8(a(e))[1],t+=r;var o=this.buffer.byteLength;return ot?o:t),t-=r,l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),n?(this.offset=t,this):t-i},s.writeString=s.writeUTF8String,d.calculateUTF8Chars=function(e){return l.calculateUTF16asUTF8(a(e))[0]},d.calculateUTF8Bytes=function(e){return l.calculateUTF16asUTF8(a(e))[1]},d.calculateString=d.calculateUTF8Bytes,s.readUTF8String=function(e,t,r){"number"==typeof t&&(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),void 0===t&&(t=d.METRICS_CHARS),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal length: "+e+" (not an integer)");if(e|=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}var i,o=0,s=r;if(t===d.METRICS_CHARS){if(i=u(),l.decodeUTF8(function(){return o>>=0)<0||r+e>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+"+e+") <= "+this.buffer.byteLength)}var a=r+e;if(l.decodeUTF8toUTF16(function(){return r>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i,o=t;n=l.calculateUTF16asUTF8(a(e),this.noAssert)[1],i=d.calculateVarint32(n),t+=i+n;var s=this.buffer.byteLength;if(st?s:t),t-=i+n,t+=this.writeVarint32(n,t),l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),t!==o+n+i)throw RangeError("Illegal range: Truncated data, "+t+" == "+(t+n+i));return r?(this.offset=t,this):t-o},s.readVString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=e,n=this.readVarint32(e),i=this.readUTF8String(n.value,d.METRICS_BYTES,e+=n.length);return e+=i.length,t?(this.offset=e,i.string):{string:i.string,length:e-r}},s.append=function(e,t,r){"number"!=typeof t&&"string"==typeof t||(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),!this.noAssert){if("number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}e instanceof d||(e=d.wrap(e,t));var i=e.limit-e.offset;if(i<=0)return this;r+=i;var o=this.buffer.byteLength;return or?o:r),r-=i,this.view.set(e.view.subarray(e.offset,e.limit),r),e.offset+=i,n&&(this.offset+=i),this},s.appendTo=function(e,t){return e.append(this,t),this},s.assert=function(e){return this.noAssert=!e,this},s.capacity=function(){return this.buffer.byteLength},s.clear=function(){return this.offset=0,this.limit=this.buffer.byteLength,this.markedOffset=-1,this},s.clone=function(e){var t=new d(0,this.littleEndian,this.noAssert);return t.view=e?(t.buffer=new ArrayBuffer(this.buffer.byteLength),new Uint8Array(t.buffer)):(t.buffer=this.buffer,this.view),t.offset=this.offset,t.markedOffset=this.markedOffset,t.limit=this.limit,t},s.compact=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}if(0===e&&t===this.buffer.byteLength)return this;var r=t-e;if(0===r)return this.buffer=o,this.view=null,0<=this.markedOffset&&(this.markedOffset-=e),this.offset=0,this.limit=0,this;var n=new ArrayBuffer(r),i=new Uint8Array(n);return i.set(this.view.subarray(e,t)),this.buffer=n,this.view=i,0<=this.markedOffset&&(this.markedOffset-=e),this.offset=0,this.limit=r,this},s.copy=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}if(e===t)return new d(0,this.littleEndian,this.noAssert);var r=t-e,n=new d(r,this.littleEndian,this.noAssert);return n.offset=0,n.limit=r,0<=n.markedOffset&&(n.markedOffset-=e),this.copyTo(n,0,e,t),n},s.copyTo=function(e,t,r,n){var i,o;if(!this.noAssert&&!d.isByteBuffer(e))throw TypeError("Illegal target: Not a ByteBuffer");if(t=(o=void 0===t)?e.offset:0|t,r=(i=void 0===r)?this.offset:0|r,n=void 0===n?this.limit:0|n,t<0||t>e.buffer.byteLength)throw RangeError("Illegal target range: 0 <= "+t+" <= "+e.buffer.byteLength);if(r<0||n>this.buffer.byteLength)throw RangeError("Illegal source range: 0 <= "+r+" <= "+this.buffer.byteLength);var s=n-r;return 0===s?e:(e.ensureCapacity(t+s),e.view.set(this.view.subarray(r,n),t),i&&(this.offset+=s),o&&(e.offset+=s),this)},s.ensureCapacity=function(e){var t=this.buffer.byteLength;return te?t:e):this},s.fill=function(e,t,r){var n=void 0===t;if(n&&(t=this.offset),"string"==typeof e&&0>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal end: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}if(r<=t)return this;for(;t>>=0)<0||e+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+0) <= "+this.buffer.byteLength)}return this.markedOffset=e,this},s.order=function(e){if(!this.noAssert&&"boolean"!=typeof e)throw TypeError("Illegal littleEndian: Not a boolean");return this.littleEndian=!!e,this},s.LE=function(e){return this.littleEndian=void 0===e||!!e,this},s.BE=function(e){return this.littleEndian=void 0!==e&&!e,this},s.prepend=function(e,t,r){"number"!=typeof t&&"string"==typeof t||(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),!this.noAssert){if("number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}e instanceof d||(e=d.wrap(e,t));var i=e.limit-e.offset;if(i<=0)return this;var o=i-r;if(0>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}return e===t||Array.prototype.reverse.call(this.view.subarray(e,t)),this},s.skip=function(e){if(!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal length: "+e+" (not an integer)");e|=0}var t=this.offset+e;if(!this.noAssert&&(t<0||t>this.buffer.byteLength))throw RangeError("Illegal length: 0 <= "+this.offset+" + "+e+" <= "+this.buffer.byteLength);return this.offset=t,this},s.slice=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}var r=this.clone();return r.offset=e,r.limit=t,r},s.toBuffer=function(e){var t=this.offset,r=this.limit;if(!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: Not an integer");if(t>>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal limit: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}if(!e&&0===t&&r===this.buffer.byteLength)return this.buffer;if(t===r)return o;var n=new ArrayBuffer(r-t);return new Uint8Array(n).set(new Uint8Array(this.buffer).subarray(t,r),0),n},s.toArrayBuffer=s.toBuffer,s.toString=function(e,t,r){if(void 0===e)return"ByteBufferAB(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")";switch("number"==typeof e&&(r=t=e="utf8"),e){case"utf8":return this.toUTF8(t,r);case"base64":return this.toBase64(t,r);case"hex":return this.toHex(t,r);case"binary":return this.toBinary(t,r);case"debug":return this.toDebug();case"columns":return this.toColumns();default:throw Error("Unsupported encoding: "+e)}};var c=function(){for(var e={},i=[65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,54,55,56,57,43,47],s=[],t=0,r=i.length;t>2&63]),n=(3&r)<<4,null!==(r=e())?(t(i[63&((n|=r>>4&15)|r>>4&15)]),n=(15&r)<<2,null!==(r=e())?(t(i[63&(n|r>>6&3)]),t(i[63&r])):(t(i[63&n]),t(61))):(t(i[63&n]),t(61),t(61))},e.decode=function(e,t){var r,n,i;function o(e){throw Error("Illegal character code: "+e)}for(;null!==(r=e());)if(void 0===(n=s[r])&&o(r),null!==(r=e())&&(void 0===(i=s[r])&&o(r),t(n<<2>>>0|(48&i)>>4),null!==(r=e()))){if(void 0===(n=s[r])){if(61===r)break;o(r)}if(t((15&i)<<4>>>0|(60&n)>>2),null!==(r=e())){if(void 0===(i=s[r])){if(61===r)break;o(r)}t((3&n)<<6>>>0|i)}}},e.test=function(e){return/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(e)},e}();s.toBase64=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),t|=0,(e|=0)<0||t>this.capacity||tthis.capacity()||t":i+=r===this.markedOffset?"'":e||0!==r&&r!==n?" ":""}if(e&&" "!==i){for(;i.length<51;)i+=" ";s+=i+o+"\n"}return e?s:i},d.fromDebug=function(e,t,r){for(var n,i,o=e.length,s=new d((o+1)/3|0,t,r),a=0,f=0,u=!1,c=!1,h=!1,l=!1,p=!1;a":if(!r){if(l){p=!0;break}l=!0}s.limit=f,u=!1;break;case"'":if(!r){if(h){p=!0;break}h=!0}s.markedOffset=f,u=!1;break;case" ":u=!1;break;default:if(!r&&u){p=!0;break}if(i=parseInt(n+e.charAt(a++),16),!r&&(isNaN(i)||i<0||255>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}for(var r,n=new Array(t-e);e>6&31|192):(r<65536?t(r>>12&15|224):(t(r>>18&7|240),t(r>>12&63|128)),t(r>>6&63|128)),t(63&r|128)),r=null},decodeUTF8:function(e,t){for(var r,n,i,o,s=function(e){e=e.slice(0,e.indexOf(null));var t=Error(e.toString());throw t.name="TruncatedError",t.bytes=e,t};null!==(r=e());)if(0==(128&r))t(r);else if(192==(224&r))null===(n=e())&&s([r,n]),t((31&r)<<6|63&n);else if(224==(240&r))(null===(n=e())||null===(i=e()))&&s([r,n,i]),t((15&r)<<12|(63&n)<<6|63&i);else{if(240!=(248&r))throw RangeError("Illegal starting byte: "+r);(null===(n=e())||null===(i=e())||null===(o=e()))&&s([r,n,i,o]),t((7&r)<<18|(63&n)<<12|(63&i)<<6|63&o)}},UTF16toUTF8:function(e,t){for(var r,n=null;null!==(r=null!==n?n:e());)55296<=r&&r<=57343&&null!==(n=e())&&56320<=n&&n<=57343?(t(1024*(r-55296)+n-56320+65536),n=null):t(r);null!==n&&t(n)},UTF8toUTF16:function(e,t){var r=null;for("number"==typeof e&&(r=e,e=function(){return null});null!==r||null!==(r=e());)r<=65535?t(r):(t(55296+((r-=65536)>>10)),t(r%1024+56320)),r=null},encodeUTF16toUTF8:function(e,t){h.UTF16toUTF8(e,function(e){h.encodeUTF8(e,t)})},decodeUTF8toUTF16:function(e,t){h.decodeUTF8(e,function(e){h.UTF8toUTF16(e,t)})},calculateCodePoint:function(e){return e<128?1:e<2048?2:e<65536?3:4},calculateUTF8:function(e){for(var t,r=0;null!==(t=e());)r+=t<128?1:t<2048?2:t<65536?3:4;return r},calculateUTF16asUTF8:function(e){var t=0,r=0;return h.UTF16toUTF8(e,function(e){++t,r+=e<128?1:e<2048?2:e<65536?3:4}),[t,r]}};return s.toUTF8=function(t,r){if(void 0===t&&(t=this.offset),void 0===r&&(r=this.limit),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal begin: Not an integer");if(t>>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal end: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}var e;try{l.decodeUTF8toUTF16(function(){return tr)?t=("rmd160"===e?new f:u(e)).update(t).digest():t.length>>8^255&i^99,u[r]=i;var o=e[c[i]=r],s=e[o],a=e[s],f=257*e[i]^16843008*i;h[r]=f<<24|f>>>8,l[r]=f<<16|f>>>16,p[r]=f<<8|f>>>24,d[r]=f;f=16843009*a^65537*s^257*o^16843008*r;_[i]=f<<24|f>>>8,g[i]=f<<16|f>>>16,m[i]=f<<8|f>>>24,v[i]=f,r?(r=o^e[e[e[a^o]]],n^=e[e[n]]):r=n=1}}();var y=[0,1,2,4,8,16,32,64,128,27,54],n=r.AES=t.extend({_doReset:function(){if(!this._nRounds||this._keyPriorReset!==this._key){for(var e=this._keyPriorReset=this._key,t=e.words,r=e.sigBytes/4,n=4*((this._nRounds=r+6)+1),i=this._keySchedule=[],o=0;o>>24]<<24|u[s>>>16&255]<<16|u[s>>>8&255]<<8|u[255&s]):(s=u[(s=s<<8|s>>>24)>>>24]<<24|u[s>>>16&255]<<16|u[s>>>8&255]<<8|u[255&s],s^=y[o/r|0]<<24),i[o]=i[o-r]^s}for(var a=this._invKeySchedule=[],f=0;f>>24]]^g[u[s>>>16&255]]^m[u[s>>>8&255]]^v[u[255&s]]}}},encryptBlock:function(e,t){this._doCryptBlock(e,t,this._keySchedule,h,l,p,d,u)},decryptBlock:function(e,t){var r=e[t+1];e[t+1]=e[t+3],e[t+3]=r,this._doCryptBlock(e,t,this._invKeySchedule,_,g,m,v,c);r=e[t+1];e[t+1]=e[t+3],e[t+3]=r},_doCryptBlock:function(e,t,r,n,i,o,s,a){for(var f=this._nRounds,u=e[t]^r[0],c=e[t+1]^r[1],h=e[t+2]^r[2],l=e[t+3]^r[3],p=4,d=1;d>>24]^i[c>>>16&255]^o[h>>>8&255]^s[255&l]^r[p++],g=n[c>>>24]^i[h>>>16&255]^o[l>>>8&255]^s[255&u]^r[p++],m=n[h>>>24]^i[l>>>16&255]^o[u>>>8&255]^s[255&c]^r[p++],v=n[l>>>24]^i[u>>>16&255]^o[c>>>8&255]^s[255&h]^r[p++];u=_,c=g,h=m,l=v}_=(a[u>>>24]<<24|a[c>>>16&255]<<16|a[h>>>8&255]<<8|a[255&l])^r[p++],g=(a[c>>>24]<<24|a[h>>>16&255]<<16|a[l>>>8&255]<<8|a[255&u])^r[p++],m=(a[h>>>24]<<24|a[l>>>16&255]<<16|a[u>>>8&255]<<8|a[255&c])^r[p++],v=(a[l>>>24]<<24|a[u>>>16&255]<<16|a[c>>>8&255]<<8|a[255&h])^r[p++];e[t]=_,e[t+1]=g,e[t+2]=m,e[t+3]=v},keySize:8});e.AES=t._createHelper(n)}(),i.AES},"object"==typeof r?t.exports=r=i(e(47),e(48),e(52),e(50),e(46)):i(n.CryptoJS)},{46:46,47:47,48:48,50:50,52:52}],46:[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,f,i,o,s,a,u,c,h,l,p,d,_,g,m,v;e.lib.Cipher||(r=(t=e).lib,n=r.Base,f=r.WordArray,i=r.BufferedBlockAlgorithm,(o=t.enc).Utf8,s=o.Base64,a=t.algo.EvpKDF,u=r.Cipher=i.extend({cfg:n.extend(),createEncryptor:function(e,t){return this.create(this._ENC_XFORM_MODE,e,t)},createDecryptor:function(e,t){return this.create(this._DEC_XFORM_MODE,e,t)},init:function(e,t,r){this.cfg=this.cfg.extend(r),this._xformMode=e,this._key=t,this.reset()},reset:function(){i.reset.call(this),this._doReset()},process:function(e){return this._append(e),this._process()},finalize:function(e){return e&&this._append(e),this._doFinalize()},keySize:4,ivSize:4,_ENC_XFORM_MODE:1,_DEC_XFORM_MODE:2,_createHelper:function(){function i(e){return"string"==typeof e?v:g}return function(n){return{encrypt:function(e,t,r){return i(t).encrypt(n,e,t,r)},decrypt:function(e,t,r){return i(t).decrypt(n,e,t,r)}}}}()}),r.StreamCipher=u.extend({_doFinalize:function(){return this._process(!0)},blockSize:1}),c=t.mode={},h=r.BlockCipherMode=n.extend({createEncryptor:function(e,t){return this.Encryptor.create(e,t)},createDecryptor:function(e,t){return this.Decryptor.create(e,t)},init:function(e,t){this._cipher=e,this._iv=t}}),l=c.CBC=function(){var e=h.extend();function o(e,t,r){var n=this._iv;if(n){var i=n;this._iv=void 0}else i=this._prevBlock;for(var o=0;o>>2];e.sigBytes-=t}},r.BlockCipher=u.extend({cfg:u.cfg.extend({mode:l,padding:p}),reset:function(){u.reset.call(this);var e=this.cfg,t=e.iv,r=e.mode;if(this._xformMode==this._ENC_XFORM_MODE)var n=r.createEncryptor;else{n=r.createDecryptor;this._minBufferSize=1}this._mode&&this._mode.__creator==n?this._mode.init(this,t&&t.words):(this._mode=n.call(r,this,t&&t.words),this._mode.__creator=n)},_doProcessBlock:function(e,t){this._mode.processBlock(e,t)},_doFinalize:function(){var e=this.cfg.padding;if(this._xformMode==this._ENC_XFORM_MODE){e.pad(this._data,this.blockSize);var t=this._process(!0)}else{t=this._process(!0);e.unpad(t)}return t},blockSize:4}),d=r.CipherParams=n.extend({init:function(e){this.mixIn(e)},toString:function(e){return(e||this.formatter).stringify(this)}}),_=(t.format={}).OpenSSL={stringify:function(e){var t=e.ciphertext,r=e.salt;if(r)var n=f.create([1398893684,1701076831]).concat(r).concat(t);else n=t;return n.toString(s)},parse:function(e){var t=s.parse(e),r=t.words;if(1398893684==r[0]&&1701076831==r[1]){var n=f.create(r.slice(2,4));r.splice(0,4),t.sigBytes-=16}return d.create({ciphertext:t,salt:n})}},g=r.SerializableCipher=n.extend({cfg:n.extend({format:_}),encrypt:function(e,t,r,n){n=this.cfg.extend(n);var i=e.createEncryptor(r,n),o=i.finalize(t),s=i.cfg;return d.create({ciphertext:o,key:r,iv:s.iv,algorithm:e,mode:s.mode,padding:s.padding,blockSize:e.blockSize,formatter:n.format})},decrypt:function(e,t,r,n){return n=this.cfg.extend(n),t=this._parse(t,n.format),e.createDecryptor(r,n).finalize(t.ciphertext)},_parse:function(e,t){return"string"==typeof e?t.parse(e,this):e}}),m=(t.kdf={}).OpenSSL={execute:function(e,t,r,n){n||(n=f.random(8));var i=a.create({keySize:t+r}).compute(e,n),o=f.create(i.words.slice(t),4*r);return i.sigBytes=4*t,d.create({key:i,iv:o,salt:n})}},v=r.PasswordBasedCipher=g.extend({cfg:g.cfg.extend({kdf:m}),encrypt:function(e,t,r,n){var i=(n=this.cfg.extend(n)).kdf.execute(r,e.keySize,e.ivSize);n.iv=i.iv;var o=g.encrypt.call(this,e,t,i.key,n);return o.mixIn(i),o},decrypt:function(e,t,r,n){n=this.cfg.extend(n),t=this._parse(t,n.format);var i=n.kdf.execute(r,e.keySize,e.ivSize,t.salt);return n.iv=i.iv,g.decrypt.call(this,e,t,i.key,n)}}))},"object"==typeof r?t.exports=r=i(e(47),e(50)):i(n.CryptoJS)},{47:47,50:50}],47:[function(e,t,r){var n,i;n=this,i=function(){var c,r,e,t,n,h,i,o,s,a,f,u,l=l||(c=Math,r=Object.create||function(){function r(){}return function(e){var t;return r.prototype=e,t=new r,r.prototype=null,t}}(),t=(e={}).lib={},n=t.Base={extend:function(e){var t=r(this);return e&&t.mixIn(e),t.hasOwnProperty("init")&&this.init!==t.init||(t.init=function(){t.$super.init.apply(this,arguments)}),(t.init.prototype=t).$super=this,t},create:function(){var e=this.extend();return e.init.apply(e,arguments),e},init:function(){},mixIn:function(e){for(var t in e)e.hasOwnProperty(t)&&(this[t]=e[t]);e.hasOwnProperty("toString")&&(this.toString=e.toString)},clone:function(){return this.init.prototype.extend(this)}},h=t.WordArray=n.extend({init:function(e,t){e=this.words=e||[],this.sigBytes=null!=t?t:4*e.length},toString:function(e){return(e||o).stringify(this)},concat:function(e){var t=this.words,r=e.words,n=this.sigBytes,i=e.sigBytes;if(this.clamp(),n%4)for(var o=0;o>>2]>>>24-o%4*8&255;t[n+o>>>2]|=s<<24-(n+o)%4*8}else for(o=0;o>>2]=r[o>>>2];return this.sigBytes+=i,this},clamp:function(){var e=this.words,t=this.sigBytes;e[t>>>2]&=4294967295<<32-t%4*8,e.length=c.ceil(t/4)},clone:function(){var e=n.clone.call(this);return e.words=this.words.slice(0),e},random:function(e){for(var t,r=[],n=function(t){t=t;var r=987654321,n=4294967295;return function(){var e=((r=36969*(65535&r)+(r>>16)&n)<<16)+(t=18e3*(65535&t)+(t>>16)&n)&n;return e/=4294967296,(e+=.5)*(.5>>2]>>>24-i%4*8&255;n.push((o>>>4).toString(16)),n.push((15&o).toString(16))}return n.join("")},parse:function(e){for(var t=e.length,r=[],n=0;n>>3]|=parseInt(e.substr(n,2),16)<<24-n%8*4;return new h.init(r,t/2)}},s=i.Latin1={stringify:function(e){for(var t=e.words,r=e.sigBytes,n=[],i=0;i>>2]>>>24-i%4*8&255;n.push(String.fromCharCode(o))}return n.join("")},parse:function(e){for(var t=e.length,r=[],n=0;n>>2]|=(255&e.charCodeAt(n))<<24-n%4*8;return new h.init(r,t)}},a=i.Utf8={stringify:function(e){try{return decodeURIComponent(escape(s.stringify(e)))}catch(e){throw new Error("Malformed UTF-8 data")}},parse:function(e){return s.parse(unescape(encodeURIComponent(e)))}},f=t.BufferedBlockAlgorithm=n.extend({reset:function(){this._data=new h.init,this._nDataBytes=0},_append:function(e){"string"==typeof e&&(e=a.parse(e)),this._data.concat(e),this._nDataBytes+=e.sigBytes},_process:function(e){var t=this._data,r=t.words,n=t.sigBytes,i=this.blockSize,o=n/(4*i),s=(o=e?c.ceil(o):c.max((0|o)-this._minBufferSize,0))*i,a=c.min(4*s,n);if(s){for(var f=0;f>>2]>>>24-o%4*8&255)<<16|(t[o+1>>>2]>>>24-(o+1)%4*8&255)<<8|t[o+2>>>2]>>>24-(o+2)%4*8&255,a=0;a<4&&o+.75*a>>6*(3-a)&63));var f=n.charAt(64);if(f)for(;i.length%4;)i.push(f);return i.join("")},parse:function(e){var t=e.length,r=this._map,n=this._reverseMap;if(!n){n=this._reverseMap=[];for(var i=0;i>>6-o%4*2;n[i>>>2]|=(s|a)<<24-i%4*8,i++}return f.create(n,i)}(e,t,n)},_map:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="},e.enc.Base64},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],49:[function(e,t,r){var n,i;n=this,i=function(e){return e.enc.Hex},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],50:[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,c,i,o,s;return r=(t=e).lib,n=r.Base,c=r.WordArray,i=t.algo,o=i.MD5,s=i.EvpKDF=n.extend({cfg:n.extend({keySize:4,hasher:o,iterations:1}),init:function(e){this.cfg=this.cfg.extend(e)},compute:function(e,t){for(var r=this.cfg,n=r.hasher.create(),i=c.create(),o=i.words,s=r.keySize,a=r.iterations;o.lengthn&&(t=e.finalize(t)),t.clamp();for(var i=this._oKey=t.clone(),o=this._iKey=t.clone(),s=i.words,a=o.words,f=0;f>>24)|4278255360&(i<<24|i>>>8)}var o=this._hash.words,s=e[t+0],a=e[t+1],f=e[t+2],u=e[t+3],c=e[t+4],h=e[t+5],l=e[t+6],p=e[t+7],d=e[t+8],_=e[t+9],g=e[t+10],m=e[t+11],v=e[t+12],y=e[t+13],b=e[t+14],w=e[t+15],E=o[0],B=o[1],k=o[2],T=o[3];B=O(B=O(B=O(B=O(B=A(B=A(B=A(B=A(B=I(B=I(B=I(B=I(B=x(B=x(B=x(B=x(B,k=x(k,T=x(T,E=x(E,B,k,T,s,7,S[0]),B,k,a,12,S[1]),E,B,f,17,S[2]),T,E,u,22,S[3]),k=x(k,T=x(T,E=x(E,B,k,T,c,7,S[4]),B,k,h,12,S[5]),E,B,l,17,S[6]),T,E,p,22,S[7]),k=x(k,T=x(T,E=x(E,B,k,T,d,7,S[8]),B,k,_,12,S[9]),E,B,g,17,S[10]),T,E,m,22,S[11]),k=x(k,T=x(T,E=x(E,B,k,T,v,7,S[12]),B,k,y,12,S[13]),E,B,b,17,S[14]),T,E,w,22,S[15]),k=I(k,T=I(T,E=I(E,B,k,T,a,5,S[16]),B,k,l,9,S[17]),E,B,m,14,S[18]),T,E,s,20,S[19]),k=I(k,T=I(T,E=I(E,B,k,T,h,5,S[20]),B,k,g,9,S[21]),E,B,w,14,S[22]),T,E,c,20,S[23]),k=I(k,T=I(T,E=I(E,B,k,T,_,5,S[24]),B,k,b,9,S[25]),E,B,u,14,S[26]),T,E,d,20,S[27]),k=I(k,T=I(T,E=I(E,B,k,T,y,5,S[28]),B,k,f,9,S[29]),E,B,p,14,S[30]),T,E,v,20,S[31]),k=A(k,T=A(T,E=A(E,B,k,T,h,4,S[32]),B,k,d,11,S[33]),E,B,m,16,S[34]),T,E,b,23,S[35]),k=A(k,T=A(T,E=A(E,B,k,T,a,4,S[36]),B,k,c,11,S[37]),E,B,p,16,S[38]),T,E,g,23,S[39]),k=A(k,T=A(T,E=A(E,B,k,T,y,4,S[40]),B,k,s,11,S[41]),E,B,u,16,S[42]),T,E,l,23,S[43]),k=A(k,T=A(T,E=A(E,B,k,T,_,4,S[44]),B,k,v,11,S[45]),E,B,w,16,S[46]),T,E,f,23,S[47]),k=O(k,T=O(T,E=O(E,B,k,T,s,6,S[48]),B,k,p,10,S[49]),E,B,b,15,S[50]),T,E,h,21,S[51]),k=O(k,T=O(T,E=O(E,B,k,T,v,6,S[52]),B,k,u,10,S[53]),E,B,g,15,S[54]),T,E,a,21,S[55]),k=O(k,T=O(T,E=O(E,B,k,T,d,6,S[56]),B,k,w,10,S[57]),E,B,l,15,S[58]),T,E,y,21,S[59]),k=O(k,T=O(T,E=O(E,B,k,T,c,6,S[60]),B,k,m,10,S[61]),E,B,f,15,S[62]),T,E,_,21,S[63]),o[0]=o[0]+E|0,o[1]=o[1]+B|0,o[2]=o[2]+k|0,o[3]=o[3]+T|0},_doFinalize:function(){var e=this._data,t=e.words,r=8*this._nDataBytes,n=8*e.sigBytes;t[n>>>5]|=128<<24-n%32;var i=c.floor(r/4294967296),o=r;t[15+(n+64>>>9<<4)]=16711935&(i<<8|i>>>24)|4278255360&(i<<24|i>>>8),t[14+(n+64>>>9<<4)]=16711935&(o<<8|o>>>24)|4278255360&(o<<24|o>>>8),e.sigBytes=4*(t.length+1),this._process();for(var s=this._hash,a=s.words,f=0;f<4;f++){var u=a[f];a[f]=16711935&(u<<8|u>>>24)|4278255360&(u<<24|u>>>8)}return s},clone:function(){var e=n.clone.call(this);return e._hash=this._hash.clone(),e}});function x(e,t,r,n,i,o,s){var a=e+(t&r|~t&n)+i+s;return(a<>>32-o)+t}function I(e,t,r,n,i,o,s){var a=e+(t&n|r&~n)+i+s;return(a<>>32-o)+t}function A(e,t,r,n,i,o,s){var a=e+(t^r^n)+i+s;return(a<>>32-o)+t}function O(e,t,r,n,i,o,s){var a=e+(r^(t|~n))+i+s;return(a<>>32-o)+t}e.MD5=n._createHelper(o),e.HmacMD5=n._createHmacHelper(o)}(Math),s.MD5},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],53:[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,i,o,h,s;return r=(t=e).lib,n=r.WordArray,i=r.Hasher,o=t.algo,h=[],s=o.SHA1=i.extend({_doReset:function(){this._hash=new n.init([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(e,t){for(var r=this._hash.words,n=r[0],i=r[1],o=r[2],s=r[3],a=r[4],f=0;f<80;f++){if(f<16)h[f]=0|e[t+f];else{var u=h[f-3]^h[f-8]^h[f-14]^h[f-16];h[f]=u<<1|u>>>31}var c=(n<<5|n>>>27)+a+h[f];c+=f<20?1518500249+(i&o|~i&s):f<40?1859775393+(i^o^s):f<60?(i&o|i&s|o&s)-1894007588:(i^o^s)-899497514,a=s,s=o,o=i<<30|i>>>2,i=n,n=c}r[0]=r[0]+n|0,r[1]=r[1]+i|0,r[2]=r[2]+o|0,r[3]=r[3]+s|0,r[4]=r[4]+a|0},_doFinalize:function(){var e=this._data,t=e.words,r=8*this._nDataBytes,n=8*e.sigBytes;return t[n>>>5]|=128<<24-n%32,t[14+(n+64>>>9<<4)]=Math.floor(r/4294967296),t[15+(n+64>>>9<<4)]=r,e.sigBytes=4*t.length,this._process(),this._hash},clone:function(){var e=i.clone.call(this);return e._hash=this._hash.clone(),e}}),t.SHA1=i._createHelper(s),t.HmacSHA1=i._createHmacHelper(s),e.SHA1},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],54:[function(e,t,r){var a=Array.prototype.slice,f=e(56),u=e(55),c=t.exports=function(e,t,r){return r||(r={}),e===t||(e instanceof Date&&t instanceof Date?e.getTime()===t.getTime():!e||!t||"object"!=typeof e&&"object"!=typeof t?r.strict?e===t:e==t:function(e,t,r){var n,i;if(h(e)||h(t))return!1;if(e.prototype!==t.prototype)return!1;if(u(e))return!!u(t)&&(e=a.call(e),t=a.call(t),c(e,t,r));if(l(e)){if(!l(t))return!1;if(e.length!==t.length)return!1;for(n=0;nr&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},n.prototype.once=function(e,t){if(!f(t))throw TypeError("listener must be a function");var r=!1;function n(){this.removeListener(e,n),r||(r=!0,t.apply(this,arguments))}return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var r,n,i,o;if(!f(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(i=(r=this._events[e]).length,n=-1,r===t||f(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(u(r)){for(o=i;0=this._blockSize;){for(var i=this._blockOffset;i>1,c=-7,h=r?i-1:0,l=r?-1:1,p=e[t+h];for(h+=l,o=p&(1<<-c)-1,p>>=-c,c+=a;0>=-c,c+=n;0>1,l=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,_=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(f=Math.pow(2,-s))<1&&(s--,f*=2),2<=(t+=1<=s+h?l/f:l*Math.pow(2,1-h))*f&&(s++,f/=2),c<=s+h?(a=0,s=c):1<=s+h?(a=(t*f-1)*Math.pow(2,i),s+=h):(a=t*Math.pow(2,h-1)*Math.pow(2,i),s=0));8<=i;e[r+p]=255&a,p+=d,a/=256,i-=8);for(s=s<>>=0)&&e<256)&&(n=s[e])?n:(r=_(e,(0|e)<0?-1:0,!0),i&&(s[e]=r),r):(i=-128<=(e|=0)&&e<128)&&(n=o[e])?n:(r=_(e,e<0?-1:0,!1),i&&(o[e]=r),r)}function d(e,t){if(isNaN(e)||!isFinite(e))return t?f:v;if(t){if(e<0)return f;if(i<=e)return w}else{if(e<=-a)return E;if(a<=e+1)return b}return e<0?d(-e,t).neg():_(e%r|0,e/r|0,t)}function _(e,t,r){return new n(e,t,r)}n.fromInt=e,n.fromNumber=d,n.fromBits=_;var c=Math.pow;function h(e,t,r){if(0===e.length)throw Error("empty string");if("NaN"===e||"Infinity"===e||"+Infinity"===e||"-Infinity"===e)return v;if(t="number"==typeof t?(r=t,!1):!!t,(r=r||10)<2||36>>0:this.low},t.toNumber=function(){return this.unsigned?(this.high>>>0)*r+(this.low>>>0):this.high*r+(this.low>>>0)},t.toString=function(e){if((e=e||10)<2||36>>0).toString(e);if((o=a).isZero())return f+s;for(;f.length<6;)f="0"+f;s=""+f+s}},t.getHighBits=function(){return this.high},t.getHighBitsUnsigned=function(){return this.high>>>0},t.getLowBits=function(){return this.low},t.getLowBitsUnsigned=function(){return this.low>>>0},t.getNumBitsAbs=function(){if(this.isNegative())return this.eq(E)?64:this.neg().getNumBitsAbs();for(var e=0!=this.high?this.high:this.low,t=31;0>>31!=1||e.high>>>31!=1)&&(this.high===e.high&&this.low===e.low)},t.eq=t.equals,t.notEquals=function(e){return!this.eq(e)},t.neq=t.notEquals,t.lessThan=function(e){return this.comp(e)<0},t.lt=t.lessThan,t.lessThanOrEqual=function(e){return this.comp(e)<=0},t.lte=t.lessThanOrEqual,t.greaterThan=function(e){return 0>>0>this.high>>>0||e.high===this.high&&e.low>>>0>this.low>>>0?-1:1:this.sub(e).isNegative()?-1:1},t.comp=t.compare,t.negate=function(){return!this.unsigned&&this.eq(E)?E:this.not().add(u)},t.neg=t.negate,t.add=function(e){p(e)||(e=g(e));var t=this.high>>>16,r=65535&this.high,n=this.low>>>16,i=65535&this.low,o=e.high>>>16,s=65535&e.high,a=e.low>>>16,f=0,u=0,c=0,h=0;return c+=(h+=i+(65535&e.low))>>>16,u+=(c+=n+a)>>>16,f+=(u+=r+s)>>>16,f+=t+o,_((c&=65535)<<16|(h&=65535),(f&=65535)<<16|(u&=65535),this.unsigned)},t.subtract=function(e){return p(e)||(e=g(e)),this.add(e.neg())},t.sub=t.subtract,t.multiply=function(e){if(this.isZero())return v;if(p(e)||(e=g(e)),e.isZero())return v;if(this.eq(E))return e.isOdd()?E:v;if(e.eq(E))return this.isOdd()?E:v;if(this.isNegative())return e.isNegative()?this.neg().mul(e.neg()):this.neg().mul(e).neg();if(e.isNegative())return this.mul(e.neg()).neg();if(this.lt(m)&&e.lt(m))return d(this.toNumber()*e.toNumber(),this.unsigned);var t=this.high>>>16,r=65535&this.high,n=this.low>>>16,i=65535&this.low,o=e.high>>>16,s=65535&e.high,a=e.low>>>16,f=65535&e.low,u=0,c=0,h=0,l=0;return h+=(l+=i*f)>>>16,c+=(h+=n*f)>>>16,h&=65535,c+=(h+=i*a)>>>16,u+=(c+=r*f)>>>16,c&=65535,u+=(c+=n*a)>>>16,c&=65535,u+=(c+=i*s)>>>16,u+=t*f+r*a+n*s+i*o,_((h&=65535)<<16|(l&=65535),(u&=65535)<<16|(c&=65535),this.unsigned)},t.mul=t.multiply,t.divide=function(e){if(p(e)||(e=g(e)),e.isZero())throw Error("division by zero");if(this.isZero())return this.unsigned?f:v;var t,r,n;if(this.unsigned){if(e.unsigned||(e=e.toUnsigned()),e.gt(this))return f;if(e.gt(this.shru(1)))return l;n=f}else{if(this.eq(E))return e.eq(u)||e.eq(y)?E:e.eq(E)?u:(t=this.shr(1).div(e).shl(1)).eq(v)?e.isNegative()?u:y:(r=this.sub(e.mul(t)),n=t.add(r.div(e)));else if(e.eq(E))return this.unsigned?f:v;if(this.isNegative())return e.isNegative()?this.neg().div(e.neg()):this.neg().div(e).neg();if(e.isNegative())return this.div(e.neg()).neg();n=v}for(r=this;r.gte(e);){t=Math.max(1,Math.floor(r.toNumber()/e.toNumber()));for(var i=Math.ceil(Math.log(t)/Math.LN2),o=i<=48?1:c(2,i-48),s=d(t),a=s.mul(e);a.isNegative()||a.gt(r);)a=(s=d(t-=o,this.unsigned)).mul(e);s.isZero()&&(s=u),n=n.add(s),r=r.sub(a)}return n},t.div=t.divide,t.modulo=function(e){return p(e)||(e=g(e)),this.sub(this.div(e).mul(e))},t.mod=t.modulo,t.not=function(){return _(~this.low,~this.high,this.unsigned)},t.and=function(e){return p(e)||(e=g(e)),_(this.low&e.low,this.high&e.high,this.unsigned)},t.or=function(e){return p(e)||(e=g(e)),_(this.low|e.low,this.high|e.high,this.unsigned)},t.xor=function(e){return p(e)||(e=g(e)),_(this.low^e.low,this.high^e.high,this.unsigned)},t.shiftLeft=function(e){return p(e)&&(e=e.toInt()),0==(e&=63)?this:e<32?_(this.low<>>32-e,this.unsigned):_(0,this.low<>>e|this.high<<32-e,this.high>>e,this.unsigned):_(this.high>>e-32,0<=this.high?0:-1,this.unsigned)},t.shr=t.shiftRight,t.shiftRightUnsigned=function(e){if(p(e)&&(e=e.toInt()),0===(e&=63))return this;var t=this.high;return e<32?_(this.low>>>e|t<<32-e,t>>>e,this.unsigned):_(32===e?t:t>>>e-32,0,this.unsigned)},t.shru=t.shiftRightUnsigned,t.toSigned=function(){return this.unsigned?_(this.low,this.high,!1):this},t.toUnsigned=function(){return this.unsigned?this:_(this.low,this.high,!0)},t.toBytes=function(e){return e?this.toBytesLE():this.toBytesBE()},t.toBytesLE=function(){var e=this.high,t=this.low;return[255&t,t>>>8&255,t>>>16&255,t>>>24&255,255&e,e>>>8&255,e>>>16&255,e>>>24&255]},t.toBytesBE=function(){var e=this.high,t=this.low;return[e>>>24&255,e>>>16&255,e>>>8&255,255&e,t>>>24&255,t>>>16&255,t>>>8&255,255&t]},n},"function"==typeof e&&"object"==typeof t&&t&&t.exports?t.exports=i():(n.dcodeIO=n.dcodeIO||{}).Long=i()},{}],69:[function(i,o,e){(function(t){"use strict";var e=i(65),r=i(63),s=new Array(16);function n(){r.call(this,64),this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878}function a(e,t){return e<>>32-t}function f(e,t,r,n,i,o,s){return a(e+(t&r|~t&n)+i+o|0,s)+t|0}function u(e,t,r,n,i,o,s){return a(e+(t&n|r&~n)+i+o|0,s)+t|0}function c(e,t,r,n,i,o,s){return a(e+(t^r^n)+i+o|0,s)+t|0}function h(e,t,r,n,i,o,s){return a(e+(r^(t|~n))+i+o|0,s)+t|0}e(n,r),n.prototype._update=function(){for(var e=s,t=0;t<16;++t)e[t]=this._block.readInt32LE(4*t);var r=this._a,n=this._b,i=this._c,o=this._d;n=h(n=h(n=h(n=h(n=c(n=c(n=c(n=c(n=u(n=u(n=u(n=u(n=f(n=f(n=f(n=f(n,i=f(i,o=f(o,r=f(r,n,i,o,e[0],3614090360,7),n,i,e[1],3905402710,12),r,n,e[2],606105819,17),o,r,e[3],3250441966,22),i=f(i,o=f(o,r=f(r,n,i,o,e[4],4118548399,7),n,i,e[5],1200080426,12),r,n,e[6],2821735955,17),o,r,e[7],4249261313,22),i=f(i,o=f(o,r=f(r,n,i,o,e[8],1770035416,7),n,i,e[9],2336552879,12),r,n,e[10],4294925233,17),o,r,e[11],2304563134,22),i=f(i,o=f(o,r=f(r,n,i,o,e[12],1804603682,7),n,i,e[13],4254626195,12),r,n,e[14],2792965006,17),o,r,e[15],1236535329,22),i=u(i,o=u(o,r=u(r,n,i,o,e[1],4129170786,5),n,i,e[6],3225465664,9),r,n,e[11],643717713,14),o,r,e[0],3921069994,20),i=u(i,o=u(o,r=u(r,n,i,o,e[5],3593408605,5),n,i,e[10],38016083,9),r,n,e[15],3634488961,14),o,r,e[4],3889429448,20),i=u(i,o=u(o,r=u(r,n,i,o,e[9],568446438,5),n,i,e[14],3275163606,9),r,n,e[3],4107603335,14),o,r,e[8],1163531501,20),i=u(i,o=u(o,r=u(r,n,i,o,e[13],2850285829,5),n,i,e[2],4243563512,9),r,n,e[7],1735328473,14),o,r,e[12],2368359562,20),i=c(i,o=c(o,r=c(r,n,i,o,e[5],4294588738,4),n,i,e[8],2272392833,11),r,n,e[11],1839030562,16),o,r,e[14],4259657740,23),i=c(i,o=c(o,r=c(r,n,i,o,e[1],2763975236,4),n,i,e[4],1272893353,11),r,n,e[7],4139469664,16),o,r,e[10],3200236656,23),i=c(i,o=c(o,r=c(r,n,i,o,e[13],681279174,4),n,i,e[0],3936430074,11),r,n,e[3],3572445317,16),o,r,e[6],76029189,23),i=c(i,o=c(o,r=c(r,n,i,o,e[9],3654602809,4),n,i,e[12],3873151461,11),r,n,e[15],530742520,16),o,r,e[2],3299628645,23),i=h(i,o=h(o,r=h(r,n,i,o,e[0],4096336452,6),n,i,e[7],1126891415,10),r,n,e[14],2878612391,15),o,r,e[5],4237533241,21),i=h(i,o=h(o,r=h(r,n,i,o,e[12],1700485571,6),n,i,e[3],2399980690,10),r,n,e[10],4293915773,15),o,r,e[1],2240044497,21),i=h(i,o=h(o,r=h(r,n,i,o,e[8],1873313359,6),n,i,e[15],4264355552,10),r,n,e[6],2734768916,15),o,r,e[13],1309151649,21),i=h(i,o=h(o,r=h(r,n,i,o,e[4],4149444226,6),n,i,e[11],3174756917,10),r,n,e[2],718787259,15),o,r,e[9],3951481745,21),this._a=this._a+r|0,this._b=this._b+n|0,this._c=this._c+i|0,this._d=this._d+o|0},n.prototype._digest=function(){this._block[this._blockOffset++]=128,56this.urls.length-1)return t(new Error("Tried "+(i+1)+" connections, none of which worked: "+JSON.stringify(this.urls.concat(this.url))));var s=function(e,t){return o.logFailure(n),o.connectWithFallback(r,o.urls[i],i+1,e,t)};return e&&t?this.connect(r,n).then(e).catch(function(){s(e,t)}):new Promise(function(e,t){o.connect(r).then(e).catch(function(){s(e,t)})})},n.prototype.checkConnections=function(){var i=0t.highWaterMark&&(t.highWaterMark=(_<=(r=e)?r=_:(r--,r|=r>>>1,r|=r>>>2,r|=r>>>4,r|=r>>>8,r|=r>>>16,r++),r)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0));var r}function E(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(b("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?m.nextTick(B,e):B(e))}function B(e){b("emit readable"),e.emit("readable"),I(e)}function k(e,t){t.readingMore||(t.readingMore=!0,m.nextTick(T,e,t))}function T(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var n;eo.length?o.length:e;if(s===o.length?i+=o:i+=o.slice(0,e),0===(e-=s)){s===o.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r).data=o.slice(s);break}++n}return t.length-=n,i}(e,t):function(e,t){var r=u.allocUnsafe(e),n=t.head,i=1;n.data.copy(r),e-=n.data.length;for(;n=n.next;){var o=n.data,s=e>o.length?o.length:e;if(o.copy(r,r.length-e,0,s),0===(e-=s)){s===o.length?(++i,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n).data=o.slice(s);break}++i}return t.length-=i,r}(e,t);return n}(e,t.buffer,t.decoder),r);var r}function O(e){var t=e._readableState;if(0=t.highWaterMark||t.ended))return b("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?O(this):E(this),null;if(0===(e=w(e,t))&&t.ended)return 0===t.length&&O(this),null;var n,i=t.needReadable;return b("need readable",i),(0===t.length||t.length-e>>0),o=this.head,s=0;o;)t=o.data,r=i,n=s,t.copy(r,n),s+=o.data.length,o=o.next;return i},e}(),n&&n.inspect&&n.inspect.custom&&(t.exports.prototype[n.inspect.custom]=function(){var e=n.inspect({length:this.length});return this.constructor.name+" "+e})},{34:34,93:93}],85:[function(e,t,r){"use strict";var o=e(76);function s(e,t){e.emit("error",t)}t.exports={destroy:function(e,t){var r=this,n=this._readableState&&this._readableState.destroyed,i=this._writableState&&this._writableState.destroyed;return n||i?t?t(e):!e||this._writableState&&this._writableState.errorEmitted||o.nextTick(s,this,e):(this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(e||null,function(e){!t&&e?(o.nextTick(s,r,e),r._writableState&&(r._writableState.errorEmitted=!0)):t&&t(e)})),this},undestroy:function(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}}},{76:76}],86:[function(e,t,r){t.exports=e(62).EventEmitter},{62:62}],87:[function(e,t,r){arguments[4][65][0].apply(r,arguments)},{65:65}],88:[function(e,t,r){t.exports=e(89).PassThrough},{89:89}],89:[function(e,t,r){(((r=t.exports=e(81)).Stream=r).Readable=r).Writable=e(83),r.Duplex=e(79),r.Transform=e(82),r.PassThrough=e(80)},{79:79,80:80,81:81,82:82,83:83}],90:[function(e,t,r){t.exports=e(89).Transform},{89:89}],91:[function(e,t,r){t.exports=e(83)},{83:83}],92:[function(e,t,r){"use strict";var n=e(35).Buffer,i=e(65),o=e(63),g=new Array(16),m=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8,3,10,14,4,9,15,8,1,2,7,0,6,13,11,5,12,1,9,11,10,0,8,12,4,13,3,7,15,14,5,6,2,4,0,5,9,7,12,2,10,14,1,3,8,11,6,15,13],v=[5,14,7,0,9,2,11,4,13,6,15,8,1,10,3,12,6,11,3,7,0,13,5,10,14,15,8,12,4,9,1,2,15,5,1,3,7,14,6,9,11,8,12,2,10,0,4,13,8,6,4,1,3,11,15,0,5,12,2,13,9,7,10,14,12,15,10,4,1,5,8,7,6,2,13,14,0,3,9,11],y=[11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8,7,6,8,13,11,9,7,15,7,12,15,9,11,7,13,12,11,13,6,7,14,9,13,15,14,8,13,6,5,12,7,5,11,12,14,15,14,15,9,8,9,14,5,6,8,6,5,12,9,15,5,11,6,8,13,12,5,12,13,14,11,8,5,6],b=[8,9,9,11,13,15,15,5,7,7,8,11,14,14,12,6,9,13,15,7,12,8,9,11,7,7,12,7,6,15,13,11,9,7,15,11,8,6,6,14,12,13,5,14,13,13,7,5,15,5,8,11,14,14,6,14,6,9,12,9,12,5,15,8,8,5,12,9,12,5,14,6,8,13,6,5,15,13,11,11],w=[0,1518500249,1859775393,2400959708,2840853838],E=[1352829926,1548603684,1836072691,2053994217,0];function s(){o.call(this,64),this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520}function B(e,t){return e<>>32-t}function k(e,t,r,n,i,o,s,a){return B(e+(t^r^n)+o+s|0,a)+i|0}function T(e,t,r,n,i,o,s,a){return B(e+(t&r|~t&n)+o+s|0,a)+i|0}function S(e,t,r,n,i,o,s,a){return B(e+((t|~r)^n)+o+s|0,a)+i|0}function x(e,t,r,n,i,o,s,a){return B(e+(t&n|r&~n)+o+s|0,a)+i|0}function I(e,t,r,n,i,o,s,a){return B(e+(t^(r|~n))+o+s|0,a)+i|0}i(s,o),s.prototype._update=function(){for(var e=g,t=0;t<16;++t)e[t]=this._block.readInt32LE(4*t);for(var r=0|this._a,n=0|this._b,i=0|this._c,o=0|this._d,s=0|this._e,a=0|this._a,f=0|this._b,u=0|this._c,c=0|this._d,h=0|this._e,l=0;l<80;l+=1){var p,d;d=l<16?(p=k(r,n,i,o,s,e[m[l]],w[0],y[l]),I(a,f,u,c,h,e[v[l]],E[0],b[l])):l<32?(p=T(r,n,i,o,s,e[m[l]],w[1],y[l]),x(a,f,u,c,h,e[v[l]],E[1],b[l])):l<48?(p=S(r,n,i,o,s,e[m[l]],w[2],y[l]),S(a,f,u,c,h,e[v[l]],E[2],b[l])):l<64?(p=x(r,n,i,o,s,e[m[l]],w[3],y[l]),T(a,f,u,c,h,e[v[l]],E[3],b[l])):(p=I(r,n,i,o,s,e[m[l]],w[4],y[l]),k(a,f,u,c,h,e[v[l]],E[4],b[l])),r=s,s=o,o=B(i,10),i=n,n=p,a=h,h=c,c=B(u,10),u=f,f=d}var _=this._b+i+c|0;this._b=this._c+o+h|0,this._c=this._d+s+a|0,this._d=this._e+r+f|0,this._e=this._a+n+u|0,this._a=_},s.prototype._digest=function(){this._block[this._blockOffset++]=128,56=this._finalSize&&(this._update(this._block),this._block.fill(0));var r=8*this._len;if(r<=4294967295)this._block.writeUInt32BE(r,this._blockSize-4);else{var n=(4294967295&r)>>>0,i=(r-n)/4294967296;this._block.writeUInt32BE(i,this._blockSize-8),this._block.writeUInt32BE(n,this._blockSize-4)}this._update(this._block);var o=this._hash();return e?o.toString(e):o},n.prototype._update=function(){throw new Error("_update must be implemented by subclass")},t.exports=n},{93:93}],96:[function(e,t,r){(r=t.exports=function(e){e=e.toLowerCase();var t=r[e];if(!t)throw new Error(e+" is not supported (we accept pull requests)");return new t}).sha=e(97),r.sha1=e(98),r.sha224=e(99),r.sha256=e(100),r.sha384=e(101),r.sha512=e(102)},{100:100,101:101,102:102,97:97,98:98,99:99}],97:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,m=[1518500249,1859775393,-1894007588,-899497514],s=new Array(80);function a(){this.init(),this._w=s,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a=this._w,f=0|this._a,u=0|this._b,c=0|this._c,h=0|this._d,l=0|this._e,p=0;p<16;++p)a[p]=e.readInt32BE(4*p);for(;p<80;++p)a[p]=a[p-3]^a[p-8]^a[p-14]^a[p-16];for(var d=0;d<80;++d){var _=~~(d/20),g=0|((s=f)<<5|s>>>27)+(n=u,i=c,o=h,0===(r=_)?n&i|~n&o:2===r?n&i|n&o|i&o:n^i^o)+l+a[d]+m[_];l=h,h=c,c=(t=u)<<30|t>>>2,u=f,f=g}this._a=f+this._a|0,this._b=u+this._b|0,this._c=c+this._c|0,this._d=h+this._d|0,this._e=l+this._e|0},a.prototype._hash=function(){var e=o.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},t.exports=a},{65:65,93:93,95:95}],98:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,v=[1518500249,1859775393,-1894007588,-899497514],s=new Array(80);function a(){this.init(),this._w=s,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a,f=this._w,u=0|this._a,c=0|this._b,h=0|this._c,l=0|this._d,p=0|this._e,d=0;d<16;++d)f[d]=e.readInt32BE(4*d);for(;d<80;++d)f[d]=(t=f[d-3]^f[d-8]^f[d-14]^f[d-16])<<1|t>>>31;for(var _=0;_<80;++_){var g=~~(_/20),m=0|((a=u)<<5|a>>>27)+(i=c,o=h,s=l,0===(n=g)?i&o|~i&s:2===n?i&o|i&s|o&s:i^o^s)+p+f[_]+v[g];p=l,l=h,h=(r=c)<<30|r>>>2,c=u,u=m}this._a=u+this._a|0,this._b=c+this._b|0,this._c=h+this._c|0,this._d=l+this._d|0,this._e=p+this._e|0},a.prototype._hash=function(){var e=o.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},t.exports=a},{65:65,93:93,95:95}],99:[function(e,t,r){var n=e(65),i=e(100),o=e(95),s=e(93).Buffer,a=new Array(64);function f(){this.init(),this._w=a,o.call(this,64,56)}n(f,i),f.prototype.init=function(){return this._a=3238371032,this._b=914150663,this._c=812702999,this._d=4144912697,this._e=4290775857,this._f=1750603025,this._g=1694076839,this._h=3204075428,this},f.prototype._hash=function(){var e=s.allocUnsafe(28);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e},t.exports=f},{100:100,65:65,93:93,95:95}],100:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,w=[1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298],s=new Array(64);function a(){this.init(),this._w=s,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1779033703,this._b=3144134277,this._c=1013904242,this._d=2773480762,this._e=1359893119,this._f=2600822924,this._g=528734635,this._h=1541459225,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a,f=this._w,u=0|this._a,c=0|this._b,h=0|this._c,l=0|this._d,p=0|this._e,d=0|this._f,_=0|this._g,g=0|this._h,m=0;m<16;++m)f[m]=e.readInt32BE(4*m);for(;m<64;++m)f[m]=0|(((r=f[m-2])>>>17|r<<15)^(r>>>19|r<<13)^r>>>10)+f[m-7]+(((t=f[m-15])>>>7|t<<25)^(t>>>18|t<<14)^t>>>3)+f[m-16];for(var v=0;v<64;++v){var y=g+(((a=p)>>>6|a<<26)^(a>>>11|a<<21)^(a>>>25|a<<7))+((s=_)^p&(d^s))+w[v]+f[v]|0,b=0|(((o=u)>>>2|o<<30)^(o>>>13|o<<19)^(o>>>22|o<<10))+((n=u)&(i=c)|h&(n|i));g=_,_=d,d=p,p=l+y|0,l=h,h=c,c=u,u=y+b|0}this._a=u+this._a|0,this._b=c+this._b|0,this._c=h+this._c|0,this._d=l+this._d|0,this._e=p+this._e|0,this._f=d+this._f|0,this._g=_+this._g|0,this._h=g+this._h|0},a.prototype._hash=function(){var e=o.allocUnsafe(32);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e.writeInt32BE(this._h,28),e},t.exports=a},{65:65,93:93,95:95}],101:[function(e,t,r){var n=e(65),i=e(102),o=e(95),s=e(93).Buffer,a=new Array(160);function f(){this.init(),this._w=a,o.call(this,128,112)}n(f,i),f.prototype.init=function(){return this._ah=3418070365,this._bh=1654270250,this._ch=2438529370,this._dh=355462360,this._eh=1731405415,this._fh=2394180231,this._gh=3675008525,this._hh=1203062813,this._al=3238371032,this._bl=914150663,this._cl=812702999,this._dl=4144912697,this._el=4290775857,this._fl=1750603025,this._gl=1694076839,this._hl=3204075428,this},f.prototype._hash=function(){var n=s.allocUnsafe(48);function e(e,t,r){n.writeInt32BE(e,r),n.writeInt32BE(t,r+4)}return e(this._ah,this._al,0),e(this._bh,this._bl,8),e(this._ch,this._cl,16),e(this._dh,this._dl,24),e(this._eh,this._el,32),e(this._fh,this._fl,40),n},t.exports=f},{102:102,65:65,93:93,95:95}],102:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,ee=[1116352408,3609767458,1899447441,602891725,3049323471,3964484399,3921009573,2173295548,961987163,4081628472,1508970993,3053834265,2453635748,2937671579,2870763221,3664609560,3624381080,2734883394,310598401,1164996542,607225278,1323610764,1426881987,3590304994,1925078388,4068182383,2162078206,991336113,2614888103,633803317,3248222580,3479774868,3835390401,2666613458,4022224774,944711139,264347078,2341262773,604807628,2007800933,770255983,1495990901,1249150122,1856431235,1555081692,3175218132,1996064986,2198950837,2554220882,3999719339,2821834349,766784016,2952996808,2566594879,3210313671,3203337956,3336571891,1034457026,3584528711,2466948901,113926993,3758326383,338241895,168717936,666307205,1188179964,773529912,1546045734,1294757372,1522805485,1396182291,2643833823,1695183700,2343527390,1986661051,1014477480,2177026350,1206759142,2456956037,344077627,2730485921,1290863460,2820302411,3158454273,3259730800,3505952657,3345764771,106217008,3516065817,3606008344,3600352804,1432725776,4094571909,1467031594,275423344,851169720,430227734,3100823752,506948616,1363258195,659060556,3750685593,883997877,3785050280,958139571,3318307427,1322822218,3812723403,1537002063,2003034995,1747873779,3602036899,1955562222,1575990012,2024104815,1125592928,2227730452,2716904306,2361852424,442776044,2428436474,593698344,2756734187,3733110249,3204031479,2999351573,3329325298,3815920427,3391569614,3928383900,3515267271,566280711,3940187606,3454069534,4118630271,4000239992,116418474,1914138554,174292421,2731055270,289380356,3203993006,460393269,320620315,685471733,587496836,852142971,1086792851,1017036298,365543100,1126000580,2618297676,1288033470,3409855158,1501505948,4234509866,1607167915,987167468,1816402316,1246189591],s=new Array(160);function a(){this.init(),this._w=s,i.call(this,128,112)}function te(e,t,r){return r^e&(t^r)}function re(e,t,r){return e&t|r&(e|t)}function ne(e,t){return(e>>>28|t<<4)^(t>>>2|e<<30)^(t>>>7|e<<25)}function ie(e,t){return(e>>>14|t<<18)^(e>>>18|t<<14)^(t>>>9|e<<23)}function oe(e,t){return e>>>0>>0?1:0}n(a,i),a.prototype.init=function(){return this._ah=1779033703,this._bh=3144134277,this._ch=1013904242,this._dh=2773480762,this._eh=1359893119,this._fh=2600822924,this._gh=528734635,this._hh=1541459225,this._al=4089235720,this._bl=2227873595,this._cl=4271175723,this._dl=1595750129,this._el=2917565137,this._fl=725511199,this._gl=4215389547,this._hl=327033209,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a,f,u=this._w,c=0|this._ah,h=0|this._bh,l=0|this._ch,p=0|this._dh,d=0|this._eh,_=0|this._fh,g=0|this._gh,m=0|this._hh,v=0|this._al,y=0|this._bl,b=0|this._cl,w=0|this._dl,E=0|this._el,B=0|this._fl,k=0|this._gl,T=0|this._hl,S=0;S<32;S+=2)u[S]=e.readInt32BE(4*S),u[S+1]=e.readInt32BE(4*S+4);for(;S<160;S+=2){var x=u[S-30],I=u[S-30+1],A=((a=x)>>>1|(f=I)<<31)^(a>>>8|f<<24)^a>>>7,O=((o=I)>>>1|(s=x)<<31)^(o>>>8|s<<24)^(o>>>7|s<<25);x=u[S-4],I=u[S-4+1];var L=((n=x)>>>19|(i=I)<<13)^(i>>>29|n<<3)^n>>>6,C=((t=I)>>>19|(r=x)<<13)^(r>>>29|t<<3)^(t>>>6|r<<26),R=u[S-14],U=u[S-14+1],j=u[S-32],M=u[S-32+1],D=O+U|0,q=A+R+oe(D,O)|0;q=(q=q+L+oe(D=D+C|0,C)|0)+j+oe(D=D+M|0,M)|0,u[S]=q,u[S+1]=D}for(var P=0;P<160;P+=2){q=u[P],D=u[P+1];var N=re(c,h,l),z=re(v,y,b),F=ne(c,v),H=ne(v,c),V=ie(d,E),Y=ie(E,d),K=ee[P],W=ee[P+1],Z=te(d,_,g),G=te(E,B,k),J=T+Y|0,X=m+V+oe(J,T)|0;X=(X=(X=X+Z+oe(J=J+G|0,G)|0)+K+oe(J=J+W|0,W)|0)+q+oe(J=J+D|0,D)|0;var $=H+z|0,Q=F+N+oe($,H)|0;m=g,T=k,g=_,k=B,_=d,B=E,d=p+X+oe(E=w+J|0,w)|0,p=l,w=b,l=h,b=y,h=c,y=v,c=X+Q+oe(v=J+$|0,J)|0}this._al=this._al+v|0,this._bl=this._bl+y|0,this._cl=this._cl+b|0,this._dl=this._dl+w|0,this._el=this._el+E|0,this._fl=this._fl+B|0,this._gl=this._gl+k|0,this._hl=this._hl+T|0,this._ah=this._ah+c+oe(this._al,v)|0,this._bh=this._bh+h+oe(this._bl,y)|0,this._ch=this._ch+l+oe(this._cl,b)|0,this._dh=this._dh+p+oe(this._dl,w)|0,this._eh=this._eh+d+oe(this._el,E)|0,this._fh=this._fh+_+oe(this._fl,B)|0,this._gh=this._gh+g+oe(this._gl,k)|0,this._hh=this._hh+m+oe(this._hl,T)|0},a.prototype._hash=function(){var n=o.allocUnsafe(64);function e(e,t,r){n.writeInt32BE(e,r),n.writeInt32BE(t,r+4)}return e(this._ah,this._al,0),e(this._bh,this._bl,8),e(this._ch,this._cl,16),e(this._dh,this._dl,24),e(this._eh,this._el,32),e(this._fh,this._fl,40),e(this._gh,this._gl,48),e(this._hh,this._hl,56),n},t.exports=a},{65:65,93:93,95:95}],103:[function(e,t,r){t.exports=n;var c=e(62).EventEmitter;function n(){c.call(this)}e(65)(n,c),n.Readable=e(89),n.Writable=e(91),n.Duplex=e(78),n.Transform=e(90),n.PassThrough=e(88),(n.Stream=n).prototype.pipe=function(t,e){var r=this;function n(e){t.writable&&!1===t.write(e)&&r.pause&&r.pause()}function i(){r.readable&&r.resume&&r.resume()}r.on("data",n),t.on("drain",i),t._isStdio||e&&!1===e.end||(r.on("end",s),r.on("close",a));var o=!1;function s(){o||(o=!0,t.end())}function a(){o||(o=!0,"function"==typeof t.destroy&&t.destroy())}function f(e){if(u(),0===c.listenerCount(this,"error"))throw e}function u(){r.removeListener("data",n),t.removeListener("drain",i),r.removeListener("end",s),r.removeListener("close",a),r.removeListener("error",f),t.removeListener("error",f),r.removeListener("end",u),r.removeListener("close",u),t.removeListener("close",u)}return r.on("error",f),t.on("error",f),r.on("end",u),r.on("close",u),t.on("close",u),t.emit("pipe",r),t}},{62:62,65:65,78:78,88:88,89:89,90:90,91:91}],104:[function(e,t,r){"use strict";var n=e(93).Buffer,i=n.isEncoding||function(e){switch((e=""+e)&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};function o(e){var t;switch(this.encoding=function(e){var t=function(e){if(!e)return"utf8";for(var t;;)switch(e){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return e;default:if(t)return;e=(""+e).toLowerCase(),t=!0}}(e);if("string"!=typeof t&&(n.isEncoding===i||!i(e)))throw new Error("Unknown encoding: "+e);return t||e}(e),this.encoding){case"utf16le":this.text=f,this.end=u,t=4;break;case"utf8":this.fillLast=a,t=4;break;case"base64":this.text=c,this.end=h,t=3;break;default:return this.write=l,void(this.end=p)}this.lastNeed=0,this.lastTotal=0,this.lastChar=n.allocUnsafe(t)}function s(e){return e<=127?0:e>>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function a(e){var t=this.lastTotal-this.lastNeed,r=function(e,t,r){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(1=1.1.13-1 <1.2.0-0", + "xtend": ">=4.0.0 <4.1.0-0" + } + } + } + }, + "combine-source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.6.1.tgz", + "integrity": "sha1-m0oJwxYDPXaODxHgKfonMOB5rZY=", + "dev": true, + "requires": { + "convert-source-map": "~1.1.0", + "inline-source-map": "~0.5.0", + "lodash.memoize": "~3.0.3", + "source-map": "~0.4.2" + } + }, + "convert-source-map": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", + "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=", + "dev": true + }, + "inline-source-map": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.5.0.tgz", + "integrity": "sha1-Skxd2OT7Xps82mDIIt+tyu5m4K8=", + "dev": true, + "requires": { + "source-map": "~0.4.0" + } + }, + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "dev": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + }, + "source-map": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.4.4.tgz", + "integrity": "sha1-66T12pwNyZneaAMti092FzZSA2s=", + "dev": true, + "requires": { + "amdefine": ">=0.0.4" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + } + } + }, "bytebuffer": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/bytebuffer/-/bytebuffer-5.0.1.tgz", @@ -1168,7 +1570,22 @@ "integrity": "sha1-0JxLUoAKpMB44t2BqGmqyQ0uVOc=", "dev": true }, - "caseless": { + "caller-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz", + "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", + "dev": true, + "requires": { + "callsites": "^0.2.0" + } + }, + "callsites": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz", + "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", + "dev": true + }, + "caseless": { "version": "0.12.0", "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=", @@ -1188,6 +1605,12 @@ "supports-color": "^2.0.0" } }, + "chardet": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz", + "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=", + "dev": true + }, "cheerio": { "version": "1.0.0-rc.2", "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.2.tgz", @@ -1229,12 +1652,41 @@ "safe-buffer": "^5.0.1" } }, + "circular-json": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz", + "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==", + "dev": true + }, + "cli-cursor": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", + "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", + "dev": true, + "requires": { + "restore-cursor": "^2.0.0" + } + }, + "cli-width": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz", + "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=", + "dev": true + }, "co": { "version": "4.6.0", "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", + "dev": true + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", "dev": true, - "optional": true + "requires": { + "color-name": "1.1.3" + } }, "color-logger": { "version": "0.0.6", @@ -1242,6 +1694,12 @@ "integrity": "sha1-5WJF7ymCJlcRDHy3WpzXhstp7Rs=", "dev": true }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "dev": true + }, "combine-source-map": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.8.0.tgz", @@ -1337,6 +1795,12 @@ "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", "dev": true }, + "contains-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", + "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=", + "dev": true + }, "convert-source-map": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz", @@ -1390,6 +1854,17 @@ "sha.js": "^2.4.8" } }, + "cross-spawn": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", + "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", + "dev": true, + "requires": { + "lru-cache": "^4.0.1", + "shebang-command": "^1.2.0", + "which": "^1.2.9" + } + }, "crypto-browserify": { "version": "3.12.0", "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", @@ -1410,9 +1885,9 @@ } }, "crypto-js": { - "version": "3.1.8", - "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-3.1.8.tgz", - "integrity": "sha1-cV8HC/YBTyrpkqmLOSkli3E/CNU=" + "version": "3.1.9-1", + "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-3.1.9-1.tgz", + "integrity": "sha1-/aGedh/Ad+Af+/3G6f38WeiAbNg=" }, "css-select": { "version": "1.2.0", @@ -1456,6 +1931,12 @@ "es5-ext": "^0.10.9" } }, + "damerau-levenshtein": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.4.tgz", + "integrity": "sha1-AxkcQyy27qFou3fzpV/9zLiXhRQ=", + "dev": true + }, "dashdash": { "version": "1.14.1", "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", @@ -1490,8 +1971,16 @@ "version": "0.1.3", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", + "dev": true + }, + "define-properties": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", + "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", "dev": true, - "optional": true + "requires": { + "object-keys": "^1.0.12" + } }, "defined": { "version": "1.0.0", @@ -1547,9 +2036,9 @@ } }, "diff": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/diff/-/diff-1.4.0.tgz", - "integrity": "sha1-fyjS657nsVqX79ic5j3P2qPMur8=", + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", "dev": true }, "diffie-hellman": { @@ -1563,6 +2052,15 @@ "randombytes": "^2.0.0" } }, + "doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dev": true, + "requires": { + "esutils": "^2.0.2" + } + }, "dom-serializer": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.0.tgz", @@ -1655,12 +2153,52 @@ "minimalistic-crypto-utils": "^1.0.0" } }, + "emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true + }, "entities": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.1.tgz", "integrity": "sha1-blwtClYhtdra7O+AuQ7ftc13cvA=", "dev": true }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "es-abstract": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.13.0.tgz", + "integrity": "sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==", + "dev": true, + "requires": { + "es-to-primitive": "^1.2.0", + "function-bind": "^1.1.1", + "has": "^1.0.3", + "is-callable": "^1.1.4", + "is-regex": "^1.0.4", + "object-keys": "^1.0.12" + } + }, + "es-to-primitive": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz", + "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==", + "dev": true, + "requires": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + } + }, "es5-ext": { "version": "0.10.45", "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.45.tgz", @@ -1752,6 +2290,314 @@ } } }, + "eslint": { + "version": "4.19.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.19.1.tgz", + "integrity": "sha512-bT3/1x1EbZB7phzYu7vCr1v3ONuzDtX8WjuM9c0iYxe+cq+pwcKEoQjl7zd3RpC6YOLgnSy3cTN58M2jcoPDIQ==", + "dev": true, + "requires": { + "ajv": "^5.3.0", + "babel-code-frame": "^6.22.0", + "chalk": "^2.1.0", + "concat-stream": "^1.6.0", + "cross-spawn": "^5.1.0", + "debug": "^3.1.0", + "doctrine": "^2.1.0", + "eslint-scope": "^3.7.1", + "eslint-visitor-keys": "^1.0.0", + "espree": "^3.5.4", + "esquery": "^1.0.0", + "esutils": "^2.0.2", + "file-entry-cache": "^2.0.0", + "functional-red-black-tree": "^1.0.1", + "glob": "^7.1.2", + "globals": "^11.0.1", + "ignore": "^3.3.3", + "imurmurhash": "^0.1.4", + "inquirer": "^3.0.6", + "is-resolvable": "^1.0.0", + "js-yaml": "^3.9.1", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.3.0", + "lodash": "^4.17.4", + "minimatch": "^3.0.2", + "mkdirp": "^0.5.1", + "natural-compare": "^1.4.0", + "optionator": "^0.8.2", + "path-is-inside": "^1.0.2", + "pluralize": "^7.0.0", + "progress": "^2.0.0", + "regexpp": "^1.0.1", + "require-uncached": "^1.0.3", + "semver": "^5.3.0", + "strip-ansi": "^4.0.0", + "strip-json-comments": "~2.0.1", + "table": "4.0.2", + "text-table": "~0.2.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" + } + }, + "debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "globals": { + "version": "11.10.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.10.0.tgz", + "integrity": "sha512-0GZF1RiPKU97IHUO5TORo9w1PwrH/NBPl+fS7oMLdaTRiYmYbwK4NWoZWrAdd0/abG9R2BU+OiwyQpTpE6pdfQ==", + "dev": true + }, + "ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", + "dev": true + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "^3.0.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "eslint-config-airbnb": { + "version": "17.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb/-/eslint-config-airbnb-17.1.0.tgz", + "integrity": "sha512-R9jw28hFfEQnpPau01NO5K/JWMGLi6aymiF6RsnMURjTk+MqZKllCqGK/0tOvHkPi/NWSSOU2Ced/GX++YxLnw==", + "dev": true, + "requires": { + "eslint-config-airbnb-base": "^13.1.0", + "object.assign": "^4.1.0", + "object.entries": "^1.0.4" + } + }, + "eslint-config-airbnb-base": { + "version": "13.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-13.1.0.tgz", + "integrity": "sha512-XWwQtf3U3zIoKO1BbHh6aUhJZQweOwSt4c2JrPDg9FP3Ltv3+YfEv7jIDB8275tVnO/qOHbfuYg3kzw6Je7uWw==", + "dev": true, + "requires": { + "eslint-restricted-globals": "^0.1.1", + "object.assign": "^4.1.0", + "object.entries": "^1.0.4" + } + }, + "eslint-import-resolver-node": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.2.tgz", + "integrity": "sha512-sfmTqJfPSizWu4aymbPr4Iidp5yKm8yDkHp+Ir3YiTHiiDfxh69mOUsmiqW6RZ9zRXFaF64GtYmN7e+8GHBv6Q==", + "dev": true, + "requires": { + "debug": "^2.6.9", + "resolve": "^1.5.0" + } + }, + "eslint-module-utils": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.3.0.tgz", + "integrity": "sha512-lmDJgeOOjk8hObTysjqH7wyMi+nsHwwvfBykwfhjR1LNdd7C2uFJBvx4OpWYpXOw4df1yE1cDEVd1yLHitk34w==", + "dev": true, + "requires": { + "debug": "^2.6.8", + "pkg-dir": "^2.0.0" + } + }, + "eslint-plugin-import": { + "version": "2.16.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.16.0.tgz", + "integrity": "sha512-z6oqWlf1x5GkHIFgrSvtmudnqM6Q60KM4KvpWi5ubonMjycLjndvd5+8VAZIsTlHC03djdgJuyKG6XO577px6A==", + "dev": true, + "requires": { + "contains-path": "^0.1.0", + "debug": "^2.6.9", + "doctrine": "1.5.0", + "eslint-import-resolver-node": "^0.3.2", + "eslint-module-utils": "^2.3.0", + "has": "^1.0.3", + "lodash": "^4.17.11", + "minimatch": "^3.0.4", + "read-pkg-up": "^2.0.0", + "resolve": "^1.9.0" + }, + "dependencies": { + "doctrine": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz", + "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=", + "dev": true, + "requires": { + "esutils": "^2.0.2", + "isarray": "^1.0.0" + } + }, + "lodash": { + "version": "4.17.11", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz", + "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==", + "dev": true + }, + "path-parse": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "dev": true + }, + "resolve": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.10.0.tgz", + "integrity": "sha512-3sUr9aq5OfSg2S9pNtPA9hL1FVEAjvfOC4leW0SNf/mpnaakz2a9femSd6LqAww2RaFctwyf1lCqnTHuF1rxDg==", + "dev": true, + "requires": { + "path-parse": "^1.0.6" + } + } + } + }, + "eslint-plugin-jsx-a11y": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.2.0.tgz", + "integrity": "sha512-KpibpIdKT0nbDG7G/ILWoZoN5G9cj3h1IHARxzvHk5Nt2LQ7oPUutbO9QbT1FKNHLPZB6BaoA1ASSLOiJZVEUQ==", + "dev": true, + "requires": { + "aria-query": "^3.0.0", + "array-includes": "^3.0.3", + "ast-types-flow": "^0.0.7", + "axobject-query": "^2.0.2", + "damerau-levenshtein": "^1.0.4", + "emoji-regex": "^7.0.2", + "has": "^1.0.3", + "jsx-ast-utils": "^2.0.1" + } + }, + "eslint-plugin-prettier": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-2.7.0.tgz", + "integrity": "sha512-CStQYJgALoQBw3FsBzH0VOVDRnJ/ZimUlpLm226U8qgqYJfPOY/CPK6wyRInMxh73HSKg5wyRwdS4BVYYHwokA==", + "dev": true, + "requires": { + "fast-diff": "^1.1.1", + "jest-docblock": "^21.0.0" + } + }, + "eslint-plugin-react": { + "version": "7.12.4", + "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.12.4.tgz", + "integrity": "sha512-1puHJkXJY+oS1t467MjbqjvX53uQ05HXwjqDgdbGBqf5j9eeydI54G3KwiJmWciQ0HTBacIKw2jgwSBSH3yfgQ==", + "dev": true, + "requires": { + "array-includes": "^3.0.3", + "doctrine": "^2.1.0", + "has": "^1.0.3", + "jsx-ast-utils": "^2.0.1", + "object.fromentries": "^2.0.0", + "prop-types": "^15.6.2", + "resolve": "^1.9.0" + }, + "dependencies": { + "path-parse": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "dev": true + }, + "resolve": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.10.0.tgz", + "integrity": "sha512-3sUr9aq5OfSg2S9pNtPA9hL1FVEAjvfOC4leW0SNf/mpnaakz2a9femSd6LqAww2RaFctwyf1lCqnTHuF1rxDg==", + "dev": true, + "requires": { + "path-parse": "^1.0.6" + } + } + } + }, + "eslint-restricted-globals": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/eslint-restricted-globals/-/eslint-restricted-globals-0.1.1.tgz", + "integrity": "sha1-NfDVy8ZMLj7WLpO0saevBbp+1Nc=", + "dev": true + }, + "eslint-scope": { + "version": "3.7.3", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.3.tgz", + "integrity": "sha512-W+B0SvF4gamyCTmUc+uITPY0989iXVfKvhwtmJocTaYoc/3khEHmEmvfY/Gn9HA9VV75jrQECsHizkNw1b68FA==", + "dev": true, + "requires": { + "esrecurse": "^4.1.0", + "estraverse": "^4.1.1" + } + }, + "eslint-visitor-keys": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz", + "integrity": "sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==", + "dev": true + }, + "espree": { + "version": "3.5.4", + "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.4.tgz", + "integrity": "sha512-yAcIQxtmMiB/jL32dzEp2enBeidsB7xWPLNiw3IIkpVds1P+h7qF9YwJq1yUNzp2OKXgAprs4F61ih66UsoD1A==", + "dev": true, + "requires": { + "acorn": "^5.5.0", + "acorn-jsx": "^3.0.0" + } + }, "esprima": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", @@ -1759,12 +2605,29 @@ "dev": true, "optional": true }, + "esquery": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.1.tgz", + "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==", + "dev": true, + "requires": { + "estraverse": "^4.0.0" + } + }, + "esrecurse": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz", + "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==", + "dev": true, + "requires": { + "estraverse": "^4.1.0" + } + }, "estraverse": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=", - "dev": true, - "optional": true + "dev": true }, "esutils": { "version": "2.0.2", @@ -1824,6 +2687,17 @@ "dev": true, "optional": true }, + "external-editor": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz", + "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==", + "dev": true, + "requires": { + "chardet": "^0.4.0", + "iconv-lite": "^0.4.17", + "tmp": "^0.0.33" + } + }, "extglob": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz", @@ -1840,26 +2714,68 @@ "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=", "dev": true }, + "falafel": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.1.0.tgz", + "integrity": "sha1-lrsXdh2rqU9G0AFzizzt86Z/4Gw=", + "dev": true, + "requires": { + "acorn": "^5.0.0", + "foreach": "^2.0.5", + "isarray": "0.0.1", + "object-keys": "^1.0.6" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + } + } + }, "fast-deep-equal": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=", - "dev": true, - "optional": true + "dev": true + }, + "fast-diff": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz", + "integrity": "sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==", + "dev": true }, "fast-json-stable-stringify": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=", - "dev": true, - "optional": true + "dev": true }, "fast-levenshtein": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "dev": true + }, + "figures": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", + "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", "dev": true, - "optional": true + "requires": { + "escape-string-regexp": "^1.0.5" + } + }, + "file-entry-cache": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz", + "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", + "dev": true, + "requires": { + "flat-cache": "^1.2.1", + "object-assign": "^4.0.1" + } }, "filename-regex": { "version": "2.0.1", @@ -1882,6 +2798,27 @@ "repeat-string": "^1.5.2" } }, + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "dev": true, + "requires": { + "locate-path": "^2.0.0" + } + }, + "flat-cache": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.4.tgz", + "integrity": "sha512-VwyB3Lkgacfik2vhqR4uv2rvebqmDvFu4jlN/C1RzWoJEo8I7z4Q404oiqYCkq41mni8EzQnm95emU9seckwtg==", + "dev": true, + "requires": { + "circular-json": "^0.3.1", + "graceful-fs": "^4.1.2", + "rimraf": "~2.6.2", + "write": "^0.2.1" + } + }, "for-in": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", @@ -1899,6 +2836,12 @@ "for-in": "^1.0.1" } }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", + "dev": true + }, "forever-agent": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", @@ -2476,6 +3419,12 @@ "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", "dev": true }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", + "dev": true + }, "get-assigned-identifiers": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/get-assigned-identifiers/-/get-assigned-identifiers-1.2.0.tgz", @@ -2539,9 +3488,9 @@ "dev": true }, "growl": { - "version": "1.9.2", - "resolved": "https://registry.npmjs.org/growl/-/growl-1.9.2.tgz", - "integrity": "sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=", + "version": "1.10.5", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", + "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", "dev": true }, "har-schema": { @@ -2580,6 +3529,18 @@ "ansi-regex": "^2.0.0" } }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "has-symbols": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz", + "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=", + "dev": true + }, "hash-base": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", @@ -2599,6 +3560,12 @@ "minimalistic-assert": "^1.0.1" } }, + "he": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", + "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=", + "dev": true + }, "hmac-drbg": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", @@ -2620,6 +3587,12 @@ "os-tmpdir": "^1.0.1" } }, + "hosted-git-info": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.7.1.tgz", + "integrity": "sha512-7T/BxH19zbcCTa8XkMlbK5lTo1WtgkFi3GvdWEyNuc4Vex7/9Dqbnpsf4JMydcfj9HCg4zUWFTL3Za6lapg5/w==", + "dev": true + }, "htmlescape": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", @@ -2744,10 +3717,24 @@ } } }, + "iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dev": true, + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, "ieee754": { "version": "1.1.12", "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz", - "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==", + "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==" + }, + "ignore": { + "version": "3.3.10", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.10.tgz", + "integrity": "sha512-Pgs951kaMm5GXP7MOvxERINe3gsaVjUWFm+UZPSq9xYriQAksyhg0csnS0KXSNRD5NmNdapXEpjxG49+AKh/ug==", "dev": true }, "immutable": { @@ -2755,6 +3742,12 @@ "resolved": "https://registry.npmjs.org/immutable/-/immutable-3.8.2.tgz", "integrity": "sha1-wkOZUUVbs5kT2vKBN28VMOEErfM=" }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "dev": true + }, "indexof": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", @@ -2785,6 +3778,74 @@ "source-map": "~0.5.3" } }, + "inquirer": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.3.0.tgz", + "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==", + "dev": true, + "requires": { + "ansi-escapes": "^3.0.0", + "chalk": "^2.0.0", + "cli-cursor": "^2.1.0", + "cli-width": "^2.0.0", + "external-editor": "^2.0.4", + "figures": "^2.0.0", + "lodash": "^4.3.0", + "mute-stream": "0.0.7", + "run-async": "^2.2.0", + "rx-lite": "^4.0.8", + "rx-lite-aggregates": "^4.0.8", + "string-width": "^2.1.0", + "strip-ansi": "^4.0.0", + "through": "^2.3.6" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "^3.0.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, "insert-module-globals": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.0.tgz", @@ -2826,6 +3887,12 @@ "loose-envify": "^1.0.0" } }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true + }, "is-binary-path": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", @@ -2842,6 +3909,27 @@ "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", "dev": true }, + "is-builtin-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", + "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", + "dev": true, + "requires": { + "builtin-modules": "^1.0.0" + } + }, + "is-callable": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz", + "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==", + "dev": true + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=", + "dev": true + }, "is-dotfile": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz", @@ -2881,6 +3969,12 @@ "number-is-nan": "^1.0.0" } }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, "is-glob": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", @@ -2914,6 +4008,36 @@ "dev": true, "optional": true }, + "is-promise": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz", + "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=", + "dev": true + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "dev": true, + "requires": { + "has": "^1.0.1" + } + }, + "is-resolvable": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.1.0.tgz", + "integrity": "sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==", + "dev": true + }, + "is-symbol": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz", + "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==", + "dev": true, + "requires": { + "has-symbols": "^1.0.0" + } + }, "is-typedarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", @@ -2927,6 +4051,12 @@ "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", "dev": true }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", + "dev": true + }, "isobject": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", @@ -2944,36 +4074,36 @@ "dev": true, "optional": true }, - "jade": { - "version": "0.26.3", - "resolved": "https://registry.npmjs.org/jade/-/jade-0.26.3.tgz", - "integrity": "sha1-jxDXl32NefL2/4YqgbBRPMslaGw=", + "jest-docblock": { + "version": "21.2.0", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-21.2.0.tgz", + "integrity": "sha512-5IZ7sY9dBAYSV+YjQ0Ovb540Ku7AO9Z5o2Cg789xj167iQuZ2cG+z0f3Uct6WeYLbU6aQiM2pCs7sZ+4dotydw==", + "dev": true + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", + "dev": true + }, + "js-yaml": { + "version": "3.12.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.1.tgz", + "integrity": "sha512-um46hB9wNOKlwkHgiuyEVAybXBjwFUV0Z/RaHJblRd9DXltue9FTYvzCr9ErQrK9Adz5MU4gHWVaNUfdmrC8qA==", "dev": true, "requires": { - "commander": "0.6.1", - "mkdirp": "0.3.0" + "argparse": "^1.0.7", + "esprima": "^4.0.0" }, "dependencies": { - "commander": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/commander/-/commander-0.6.1.tgz", - "integrity": "sha1-+mihT2qUXVTbvlDYzbMyDp47GgY=", - "dev": true - }, - "mkdirp": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.0.tgz", - "integrity": "sha1-G79asbqCevI1dRQ0kEJkVfSB/h4=", + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", "dev": true } } }, - "js-tokens": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", - "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", - "dev": true - }, "jsbn": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", @@ -3038,8 +4168,7 @@ "version": "0.3.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=", - "dev": true, - "optional": true + "dev": true }, "json-stable-stringify": { "version": "0.0.1", @@ -3050,6 +4179,12 @@ "jsonify": "~0.0.0" } }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", + "dev": true + }, "json-stringify-safe": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", @@ -3097,6 +4232,15 @@ "verror": "1.10.0" } }, + "jsx-ast-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-2.0.1.tgz", + "integrity": "sha1-6AGxs5mF4g//yHtA43SAgOLcrH8=", + "dev": true, + "requires": { + "array-includes": "^3.0.3" + } + }, "kind-of": { "version": "3.2.2", "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", @@ -3130,36 +4274,45 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", "dev": true, - "optional": true, "requires": { "prelude-ls": "~1.1.2", "type-check": "~0.3.2" } }, + "load-json-file": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", + "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "strip-bom": "^3.0.0" + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "dev": true, + "requires": { + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" + } + }, "lodash": { "version": "4.17.10", "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.10.tgz", "integrity": "sha512-UejweD1pDoXu+AD825lWwp4ZGtSwgnpZxb3JDViD7StjQz+Nb/6l093lx4OQ0foGWNRoc19mWy7BzL+UAK2iVg==", "dev": true }, - "lodash.assign": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz", - "integrity": "sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=", - "dev": true - }, "lodash.memoize": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", "dev": true }, - "lodash.pickby": { - "version": "4.6.0", - "resolved": "https://registry.npmjs.org/lodash.pickby/-/lodash.pickby-4.6.0.tgz", - "integrity": "sha1-feoh2MGNdwOifHBMFdO4SmfjOv8=", - "dev": true - }, "long": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/long/-/long-3.2.0.tgz", @@ -3175,10 +4328,14 @@ } }, "lru-cache": { - "version": "2.7.3", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.7.3.tgz", - "integrity": "sha1-bUUk6LlV+V1PW1iFHOId1y+06VI=", - "dev": true + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", + "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==", + "dev": true, + "requires": { + "pseudomap": "^1.0.2", + "yallist": "^2.1.2" + } }, "marked": { "version": "0.3.19", @@ -3249,6 +4406,12 @@ "mime-db": "~1.33.0" } }, + "mimic-fn": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz", + "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==", + "dev": true + }, "minimalistic-assert": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", @@ -3286,75 +4449,47 @@ } }, "mocha": { - "version": "2.5.3", - "resolved": "https://registry.npmjs.org/mocha/-/mocha-2.5.3.tgz", - "integrity": "sha1-FhvlvetJZ3HrmzV0UFC2IrWu/Fg=", - "dev": true, - "requires": { - "commander": "2.3.0", - "debug": "2.2.0", - "diff": "1.4.0", - "escape-string-regexp": "1.0.2", - "glob": "3.2.11", - "growl": "1.9.2", - "jade": "0.26.3", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-5.2.0.tgz", + "integrity": "sha512-2IUgKDhc3J7Uug+FxMXuqIyYzH7gJjXECKe/w43IGgQHTSj3InJi+yAA7T24L9bQMRKiUEHxEX37G5JpVUGLcQ==", + "dev": true, + "requires": { + "browser-stdout": "1.3.1", + "commander": "2.15.1", + "debug": "3.1.0", + "diff": "3.5.0", + "escape-string-regexp": "1.0.5", + "glob": "7.1.2", + "growl": "1.10.5", + "he": "1.1.1", + "minimatch": "3.0.4", "mkdirp": "0.5.1", - "supports-color": "1.2.0", - "to-iso-string": "0.0.2" + "supports-color": "5.4.0" }, "dependencies": { "commander": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.3.0.tgz", - "integrity": "sha1-/UMOiJgy7DU7ms0d4hfBHLPu+HM=", + "version": "2.15.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.15.1.tgz", + "integrity": "sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==", "dev": true }, "debug": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.2.0.tgz", - "integrity": "sha1-+HBX6ZWxofauaklgZkE3vFbwOdo=", - "dev": true, - "requires": { - "ms": "0.7.1" - } - }, - "escape-string-regexp": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.2.tgz", - "integrity": "sha1-Tbwv5nTnGUnK8/smlc5/LcHZqNE=", - "dev": true - }, - "glob": { - "version": "3.2.11", - "resolved": "https://registry.npmjs.org/glob/-/glob-3.2.11.tgz", - "integrity": "sha1-Spc/Y1uRkPcV0QmH1cAP0oFevj0=", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", "dev": true, "requires": { - "inherits": "2", - "minimatch": "0.3" + "ms": "2.0.0" } }, - "minimatch": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-0.3.0.tgz", - "integrity": "sha1-J12O2qxPG7MyZHIInnlJyDlGmd0=", + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "lru-cache": "2", - "sigmund": "~1.0.0" + "has-flag": "^3.0.0" } - }, - "ms": { - "version": "0.7.1", - "resolved": "https://registry.npmjs.org/ms/-/ms-0.7.1.tgz", - "integrity": "sha1-nNE8A62/8ltl7/3nzoZO6VIBcJg=", - "dev": true - }, - "supports-color": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-1.2.0.tgz", - "integrity": "sha1-/x7R5hFp0Gs88tWI4YixjYhH4X4=", - "dev": true } } }, @@ -3387,6 +4522,12 @@ "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", "dev": true }, + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=", + "dev": true + }, "nan": { "version": "2.10.0", "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz", @@ -3394,11 +4535,29 @@ "dev": true, "optional": true }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", + "dev": true + }, "next-tick": { "version": "1.0.0", "resolved": "http://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz", "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=" }, + "normalize-package-data": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.2.tgz", + "integrity": "sha512-YcMnjqeoUckXTPKZSAsPjUPLxH85XotbpqK3w4RyCwdFQSU5FxxBys8buehkSfg0j9fKvV1hn7O0+8reEgkAiw==", + "dev": true, + "requires": { + "hosted-git-info": "^2.1.4", + "is-builtin-module": "^1.0.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" + } + }, "normalize-path": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", @@ -3443,6 +4602,48 @@ "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", "dev": true }, + "object-keys": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz", + "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==", + "dev": true + }, + "object.assign": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", + "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", + "dev": true, + "requires": { + "define-properties": "^1.1.2", + "function-bind": "^1.1.1", + "has-symbols": "^1.0.0", + "object-keys": "^1.0.11" + } + }, + "object.entries": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.0.tgz", + "integrity": "sha512-l+H6EQ8qzGRxbkHOd5I/aHRhHDKoQXQ8g0BYt4uSweQU1/J6dZUOyWh9a2Vky35YCKjzmgxOzta2hH6kf9HuXA==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.12.0", + "function-bind": "^1.1.1", + "has": "^1.0.3" + } + }, + "object.fromentries": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.0.tgz", + "integrity": "sha512-9iLiI6H083uiqUuvzyY6qrlmc/Gz8hLQFOcb/Ri/0xXFkSNS3ctV+CbE6yM2+AnkYfOB3dGjdzC0wrMLIhQICA==", + "dev": true, + "requires": { + "define-properties": "^1.1.2", + "es-abstract": "^1.11.0", + "function-bind": "^1.1.1", + "has": "^1.0.1" + } + }, "object.omit": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz", @@ -3463,12 +4664,20 @@ "wrappy": "1" } }, + "onetime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz", + "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", + "dev": true, + "requires": { + "mimic-fn": "^1.0.0" + } + }, "optionator": { "version": "0.8.2", "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", "dev": true, - "optional": true, "requires": { "deep-is": "~0.1.3", "fast-levenshtein": "~2.0.4", @@ -3478,11 +4687,6 @@ "wordwrap": "~1.0.0" } }, - "options": { - "version": "0.0.6", - "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz", - "integrity": "sha1-7CLTEoBrtT5zF3Pnza788cZDEo8=" - }, "os-browserify": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.1.2.tgz", @@ -3512,6 +4716,30 @@ "object-assign": "^4.1.0" } }, + "p-limit": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", + "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", + "dev": true, + "requires": { + "p-try": "^1.0.0" + } + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "dev": true, + "requires": { + "p-limit": "^1.1.0" + } + }, + "p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", + "dev": true + }, "pako": { "version": "0.2.9", "resolved": "https://registry.npmjs.org/pako/-/pako-0.2.9.tgz", @@ -3553,6 +4781,15 @@ "is-glob": "^2.0.0" } }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, + "requires": { + "error-ex": "^1.2.0" + } + }, "parse5": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/parse5/-/parse5-3.0.3.tgz", @@ -3568,12 +4805,24 @@ "integrity": "sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==", "dev": true }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", + "dev": true + }, "path-is-absolute": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", "dev": true }, + "path-is-inside": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz", + "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=", + "dev": true + }, "path-parse": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", @@ -3586,6 +4835,15 @@ "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=", "dev": true }, + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "dev": true, + "requires": { + "pify": "^2.0.0" + } + }, "pbkdf2": { "version": "3.0.16", "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.16.tgz", @@ -3600,17 +4858,10 @@ } }, "peerplaysjs-ws": { - "version": "0.1.11", - "resolved": "https://registry.npmjs.org/peerplaysjs-ws/-/peerplaysjs-ws-0.1.11.tgz", - "integrity": "sha1-6q6x5yXurfWcpgJ8Zx8yDXAlG+8=", + "version": "git+ssh://git@github.com/PBSA/peerplaysjs-ws.git#a92c3d94297d79e41c75c0c9f63898e59a888a2a", + "from": "git+ssh://git@github.com/PBSA/peerplaysjs-ws.git", "requires": { - "ws": "^1.1.4" - }, - "dependencies": { - "ReconnectingWebSocket": { - "version": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148", - "from": "git+https://github.com/svk31/reconnecting-websocket.git#464ed2e54eb37b90b7f4f8532427ac2753d87148" - } + "ws": "2.3.1" } }, "performance-now": { @@ -3620,6 +4871,27 @@ "dev": true, "optional": true }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "pkg-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-2.0.0.tgz", + "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", + "dev": true, + "requires": { + "find-up": "^2.1.0" + } + }, + "pluralize": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz", + "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==", + "dev": true + }, "prelude-ls": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", @@ -3633,6 +4905,12 @@ "dev": true, "optional": true }, + "prettier": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-1.16.3.tgz", + "integrity": "sha512-kn/GU6SMRYPxUakNXhpP0EedT/KmaPzr0H5lIsDogrykbaxOpOfAFfk5XA7DZrJyMAv1wlMV3CPcZruGXVVUZw==", + "dev": true + }, "private": { "version": "0.1.8", "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", @@ -3651,6 +4929,28 @@ "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==", "dev": true }, + "progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "dev": true + }, + "prop-types": { + "version": "15.6.2", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.6.2.tgz", + "integrity": "sha512-3pboPvLiWD7dkI3qf3KbUe6hKFKa52w+AE0VCqECtf+QHAKgOL37tTaNCnuX1nAAQ4ZhyP+kYVKf8rLmJ/feDQ==", + "dev": true, + "requires": { + "loose-envify": "^1.3.1", + "object-assign": "^4.1.1" + } + }, + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", + "dev": true + }, "psl": { "version": "1.1.28", "resolved": "https://registry.npmjs.org/psl/-/psl-1.1.28.tgz", @@ -3752,6 +5052,27 @@ "readable-stream": "^2.0.2" } }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "dev": true, + "requires": { + "load-json-file": "^2.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^2.0.0" + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "dev": true, + "requires": { + "find-up": "^2.0.0", + "read-pkg": "^2.0.0" + } + }, "readable-stream": { "version": "2.3.6", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", @@ -3813,6 +5134,12 @@ "is-equal-shallow": "^0.1.3" } }, + "regexpp": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-1.1.0.tgz", + "integrity": "sha512-LOPw8FpgdQF9etWMaAfG/WRthIdXJGYp4mJ2Jgn/2lpkbod9jPn0t9UqN7AxBOKNfzRbYyVfgc7Vk4t/MpnXgw==", + "dev": true + }, "regexpu-core": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", @@ -3916,6 +5243,16 @@ } } }, + "require-uncached": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz", + "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", + "dev": true, + "requires": { + "caller-path": "^0.1.0", + "resolve-from": "^1.0.0" + } + }, "resolve": { "version": "1.8.1", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.8.1.tgz", @@ -3925,6 +5262,47 @@ "path-parse": "^1.0.5" } }, + "resolve-from": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz", + "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=", + "dev": true + }, + "restore-cursor": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz", + "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", + "dev": true, + "requires": { + "onetime": "^2.0.0", + "signal-exit": "^3.0.2" + } + }, + "rimraf": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", + "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + }, + "dependencies": { + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + } + } + }, "ripemd160": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", @@ -3934,6 +5312,30 @@ "inherits": "^2.0.1" } }, + "run-async": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", + "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", + "dev": true, + "requires": { + "is-promise": "^2.1.0" + } + }, + "rx-lite": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-4.0.8.tgz", + "integrity": "sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=", + "dev": true + }, + "rx-lite-aggregates": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz", + "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=", + "dev": true, + "requires": { + "rx-lite": "*" + } + }, "safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", @@ -3943,8 +5345,7 @@ "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", - "dev": true, - "optional": true + "dev": true }, "sax": { "version": "1.2.4", @@ -3958,6 +5359,12 @@ "resolved": "https://registry.npmjs.org/secure-random/-/secure-random-1.1.1.tgz", "integrity": "sha1-CIDy2MUYX0vLRoQFjINrTdsHFFo=" }, + "semver": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz", + "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==", + "dev": true + }, "set-immediate-shim": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", @@ -3984,6 +5391,21 @@ "sha.js": "~2.4.4" } }, + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "dev": true, + "requires": { + "shebang-regex": "^1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", + "dev": true + }, "shell-quote": { "version": "1.6.1", "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.6.1.tgz", @@ -3996,10 +5418,10 @@ "jsonify": "~0.0.0" } }, - "sigmund": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz", - "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=", + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", "dev": true }, "simple-concat": { @@ -4014,6 +5436,15 @@ "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=", "dev": true }, + "slice-ansi": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz", + "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "^2.0.0" + } + }, "source-map": { "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", @@ -4029,6 +5460,44 @@ "source-map": "^0.5.6" } }, + "spdx-correct": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz", + "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==", + "dev": true, + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz", + "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==", + "dev": true + }, + "spdx-expression-parse": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", + "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", + "dev": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.3.tgz", + "integrity": "sha512-uBIcIl3Ih6Phe3XHK1NqboJLdGfwr1UN3k6wSD1dZpmPsIkb8AGNbZYJ1fOBk834+Gxy8rpfDxrS6XLEMZMY2g==", + "dev": true + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + }, "sshpk": { "version": "1.14.2", "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.2.tgz", @@ -4090,6 +5559,33 @@ "readable-stream": "^2.0.2" } }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "^3.0.0" + } + } + } + }, "string_decoder": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", @@ -4108,6 +5604,18 @@ "ansi-regex": "^2.0.0" } }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "dev": true + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", + "dev": true + }, "subarg": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", @@ -4147,12 +5655,63 @@ "acorn-node": "^1.2.0" } }, + "table": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/table/-/table-4.0.2.tgz", + "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==", + "dev": true, + "requires": { + "ajv": "^5.2.3", + "ajv-keywords": "^2.1.0", + "chalk": "^2.1.0", + "lodash": "^4.17.4", + "slice-ansi": "1.0.0", + "string-width": "^2.1.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, "taffydb": { "version": "2.7.3", "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.7.3.tgz", "integrity": "sha1-KtNxaWKUmPylvIQkMJbTzeDsOjQ=", "dev": true }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", + "dev": true + }, "through": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", @@ -4178,6 +5737,15 @@ "process": "~0.11.0" } }, + "tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "dev": true, + "requires": { + "os-tmpdir": "~1.0.2" + } + }, "to-arraybuffer": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", @@ -4190,12 +5758,6 @@ "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=", "dev": true }, - "to-iso-string": { - "version": "0.0.2", - "resolved": "https://registry.npmjs.org/to-iso-string/-/to-iso-string-0.0.2.tgz", - "integrity": "sha1-TcGeZk38y+Jb2NtQiwDG2hWCVdE=", - "dev": true - }, "tough-cookie": { "version": "2.4.3", "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz", @@ -4258,16 +5820,34 @@ "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", "dev": true }, - "uglifyjs": { - "version": "2.4.11", - "resolved": "https://registry.npmjs.org/uglifyjs/-/uglifyjs-2.4.11.tgz", - "integrity": "sha1-NEDWTgRXWViVJEGOtkHGi7kNET4=", - "dev": true + "uglify-js": { + "version": "3.4.9", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.4.9.tgz", + "integrity": "sha512-8CJsbKOtEbnJsTyv6LE6m6ZKniqMiFWmm9sRbopbkGs3gMPPfd3Fh8iIA4Ykv5MgaTbqHr4BaoGLJLZNhsrW1Q==", + "dev": true, + "requires": { + "commander": "~2.17.1", + "source-map": "~0.6.1" + }, + "dependencies": { + "commander": { + "version": "2.17.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.17.1.tgz", + "integrity": "sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==", + "dev": true + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } }, "ultron": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.2.tgz", - "integrity": "sha1-rOEWq1V80Zc4ak6I9GhTeMiy5Po=" + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz", + "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==" }, "umd": { "version": "3.0.3", @@ -4321,7 +5901,6 @@ "version": "0.10.3", "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", - "dev": true, "requires": { "inherits": "2.0.1" }, @@ -4329,8 +5908,7 @@ "inherits": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", - "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", - "dev": true + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=" } } }, @@ -4356,6 +5934,16 @@ "user-home": "^1.1.1" } }, + "validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dev": true, + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, "verror": { "version": "1.10.0", "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", @@ -4394,12 +5982,20 @@ "tr46": "~0.0.1" } }, + "which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + }, "wordwrap": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", - "dev": true, - "optional": true + "dev": true }, "wrappy": { "version": "1.0.2", @@ -4407,13 +6003,29 @@ "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", "dev": true }, + "write": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz", + "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", + "dev": true, + "requires": { + "mkdirp": "^0.5.1" + } + }, "ws": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/ws/-/ws-1.1.5.tgz", - "integrity": "sha512-o3KqipXNUdS7wpQzBHSe180lBGO60SoK0yVo3CYJgb2MkobuWuBX6dhkYP5ORCLd55y+SaflMOV5fqAB53ux4w==", + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-2.3.1.tgz", + "integrity": "sha1-a5Sz5EfLajY/eF6vlK9jWejoHIA=", "requires": { - "options": ">=0.0.5", - "ultron": "1.0.x" + "safe-buffer": "~5.0.1", + "ultron": "~1.1.0" + }, + "dependencies": { + "safe-buffer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.0.1.tgz", + "integrity": "sha1-0mPKVGls2KMGtcplUekt5XkY++c=" + } } }, "xml-name-validator": { @@ -4428,6 +6040,12 @@ "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=", "dev": true + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", + "dev": true } } } diff --git a/package.json b/package.json index 8f1dc30..cccf9d9 100644 --- a/package.json +++ b/package.json @@ -1,74 +1,84 @@ { - "name": "peerplaysjs-lib", - "version": "0.4.20", - "description": "Pure JavaScript Peerplays/Graphene library for node.js and browsers.", - "browser": { - "ws": false, - "crypto": false - }, - "scripts": { - "test": "BABEL_ENV=test mocha --compilers js:babel-register --recursive", - "test:chain": "BABEL_ENV=test mocha --compilers js:babel-register ./test/chain --recursive", - "test:ecc": "BABEL_ENV=test mocha --compilers js:babel-register ./test/ecc --recursive", - "test:serializer": "BABEL_ENV=test mocha --compilers js:babel-register ./test/serializer --recursive", - "test:watch": "npm test -- --watch", - "clean": "rm -rf ./dist/* & rm -rf ./build/*", - "prebuild": "npm run clean", - "build": "babel lib -d dist", - "postbuild": "npm run browserify", - "build:watch": "babel lib -d dist --watch", - "prebrowserify": "rm -rf ./build/*", - "browserify": "browserify -t [browserify-package-json --global=true] -p [bundle-collapser/plugin] dist/browser.js --full-path=false --standalone peerplays_js -o build/peerplaysjs-lib.js -d", - "postbrowserify": "uglifyjs --compress --mangle --sequences --drop_console --output build/peerplaysjs-lib.min.js -- build/peerplaysjs-lib.js", - "doc": "esdoc -c esdoc.json", - "example:transfer": "babel-node examples/transfer", - "example:chainStore": "babel-node examples/chainStore", - "example:privKey": "babel-node examples/privKey" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/PBSA/peerplaysjs-lib.git" - }, - "author": "Sigve Kvalsvik (https://github.com/svk31)", - "contributors": [ - "James Calfee (https://github.com/jcalfee/)", - "Daniel Larimer (https://github.com/bytemaster/)", - "Valentine Zavgorodnev (https://github.com/valzav/)" - ], - "license": "BSD-2-Clause-FreeBSD", - "bugs": { - "url": "https://github.com/PBSA/peerplaysjs-lib/issues" - }, - "engines": { - "node": ">= 6.0.0" - }, - "main": "./dist/index.js", - "dependencies": { - "bigi": "^1.4.1", - "bluebird": "^3.5.0", - "bs58": "^3.0.0", - "bytebuffer": "^5.0.0", - "create-hash": "^1.1.2", - "create-hmac": "^1.1.4", - "crypto-js": "^3.1.5", - "deep-equal": "^1.0.1", - "ecurve": "^1.0.2", - "event-emitter": "^0.3.4", - "immutable": "^3.7.6", - "peerplaysjs-ws": "^0.1.11", - "secure-random": "^1.1.1" - }, - "devDependencies": { - "assert": "^1.3.0", - "babel-cli": "^6.9.0", - "babel-core": "^6.10.4", - "babel-eslint": "^6.0.4", - "babel-plugin-transform-async-to-generator": "^6.24.1", - "babel-preset-es2015": "^6.24.1", - "babel-preset-es2015-generators-async": "^6.3.13", - "browserify": "^13.1.0", - "esdoc": "^1.1.0", - "mocha": "^2.5.3", - "uglifyjs": "^2.4.10" - } + "name": "peerplaysjs-lib", + "version": "0.4.24", + "description": "Pure JavaScript Peerplaysjs library for node.js and browsers.", + "browser": { + "ws": false, + "crypto": false + }, + "scripts": { + "test": "BABEL_ENV=test mocha --compilers js:babel-register --recursive", + "test:chain": "BABEL_ENV=test mocha --compilers js:babel-register ./test/chain --recursive", + "test:ecc": "BABEL_ENV=test mocha --compilers js:babel-register ./test/ecc --recursive", + "test:serializer": "BABEL_ENV=test mocha --compilers js:babel-register ./test/serializer --recursive", + "test:watch": "npm test -- --watch", + "clean": "rm -rf ./dist/* & rm -rf ./build/*", + "prebuild": "npm run clean", + "build": "babel lib -d dist", + "postbuild": "npm run browserify", + "build:watch": "babel lib -d dist --watch", + "prebrowserify": "rm -rf ./build/*", + "browserify": "browserify -t [browserify-package-json --global=true] -p [bundle-collapser/plugin] dist/browser.js --full-path=false --standalone peerplays_js -o build/peerplaysjs-lib.js -d", + "postbrowserify": "uglifyjs --compress --mangle --sequences --drop_console --output build/peerplaysjs-lib.min.js -- build/peerplaysjs-lib.js", + "doc": "esdoc -c esdoc.json", + "example:transfer": "babel-node examples/transfer", + "example:chainStore": "babel-node examples/chainStore", + "example:privKey": "babel-node examples/privKey" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/PBSA/peerplaysjs-lib" + }, + "author": "Sigve Kvalsvik (https://github.com/svk31)", + "contributors": [ + "James Calfee (https://github.com/jcalfee/)", + "Daniel Larimer (https://github.com/bytemaster/)", + "Valentine Zavgorodnev (https://github.com/valzav/)" + ], + "license": "MIT", + "bugs": { + "url": "https://github.com/PBSA/peerplaysjs-lib/issues" + }, + "engines": { + "node": ">= 6.0.0" + }, + "main": "dist/index.js", + "jsnext:main": "lib/index.js", + "dependencies": { + "assert": "^1.3.0", + "bigi": "^1.4.1", + "bs58": "^3.0.0", + "buffer": "^5.1.0", + "bytebuffer": "^5.0.0", + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "crypto-js": "^3.1.9-1", + "deep-equal": "^1.0.1", + "ecurve": "^1.0.2", + "event-emitter": "^0.3.4", + "immutable": "^3.7.6", + "peerplaysjs-ws": "git+ssh://git@github.com:PBSA/peerplaysjs-ws.git", + "secure-random": "^1.1.1" + }, + "devDependencies": { + "babel-cli": "^6.18.0", + "babel-core": "^6.21.0", + "babel-eslint": "^7.1.1", + "babel-plugin-add-module-exports": "^0.2.1", + "babel-preset-es2015": "^6.18.0", + "babel-preset-stage-1": "^6.16.0", + "browserify": "^13.1.0", + "browserify-package-json": "^1.0.1", + "bundle-collapser": "^1.3.0", + "esdoc": "^1.1.0", + "eslint": "^4.19.1", + "eslint-config-airbnb": "^17.0.0", + "eslint-plugin-import": "^2.13.0", + "eslint-plugin-jsx-a11y": "^6.1.1", + "eslint-plugin-prettier": "^2.6.2", + "eslint-plugin-react": "^7.10.0", + "mocha": "^5.2.0", + "prettier": "^1.13.7", + "uglify-js": "^3.4.9" + } } From bb01e75e796d18905bdecc8f4c95de03cc2476b6 Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 15:19:18 -0400 Subject: [PATCH 07/15] Modified required modules for building with browserify --- lib/browser.js | 26 +++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/lib/browser.js b/lib/browser.js index 43551b8..65bcb4b 100644 --- a/lib/browser.js +++ b/lib/browser.js @@ -1,9 +1,17 @@ -module.exports = { - PrivateKey: require("./ecc/src/PrivateKey"), - PublicKey: require("./ecc/src/PublicKey"), - Signature: require("./ecc/src/signature"), - key: require("./ecc/src/KeyUtils"), - TransactionBuilder: require("./chain/src/TransactionBuilder"), - Login: require("./chain/src/AccountLogin"), - grapheneWS: require("peerplaysjs-ws") -} +import peerplaysjs_ws from 'peerplaysjs-ws'; +import PrivateKey from './ecc/src/PrivateKey'; +import PublicKey from './ecc/src/PublicKey'; +import Signature from './ecc/src/signature'; +import key from './ecc/src/KeyUtils'; +import TransactionBuilder from './chain/src/TransactionBuilder'; +import Login from './chain/src/AccountLogin'; + +export default { + PrivateKey, + PublicKey, + Signature, + key, + TransactionBuilder, + Login, + peerplaysjs_ws +}; From ce0810bc6fa813475592c24ca842735d13f8c3c3 Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 15:32:12 -0400 Subject: [PATCH 08/15] Update built files --- build/peerplaysjs-lib.js | 10582 ++++++++++++++------------------- build/peerplaysjs-lib.min.js | 2 +- lib/browser.js | 26 +- package-lock.json | 2007 +------ package.json | 151 +- 5 files changed, 4855 insertions(+), 7913 deletions(-) diff --git a/build/peerplaysjs-lib.js b/build/peerplaysjs-lib.js index d42ed5e..7ed675b 100644 --- a/build/peerplaysjs-lib.js +++ b/build/peerplaysjs-lib.js @@ -1,194 +1,161 @@ -(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.peerplays_js = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i} [signer_pubkeys = null] - Optional ["GPHAbc9Def0...", ...]. These are - additional signing keys. Some balance claims require propritary address formats, the - witness node can't tell us which ones are needed so they must be passed in. If the - witness node can figure out a signing key (mostly all other transactions), it should - not be passed in here. - @arg {boolean} [broadcast = false] - */ + /** + This does it all: set fees, finalize, sign, and broadcast (if wanted). + @arg {ConfidentialWallet} cwallet - must be unlocked, used to gather signing keys + @arg {array} [signer_pubkeys = null] - Optional ["GPHAbc9Def0...", ...]. These are additional signing keys. Some balance claims require propritary address formats, the witness node can't tell us which ones are needed so they must be passed in. If the witness node can figure out a signing key (mostly all other transactions), it should not be passed in here. + @arg {boolean} [broadcast = false] + */ + }, { + key: "process_transaction", + value: function process_transaction(cwallet) { + var _this = this; + + var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + + var wallet_object = cwallet.wallet.wallet_object; + if (Apis.instance().chain_id !== wallet_object.get("chain_id")) return Promise.reject("Mismatched chain_id; expecting " + wallet_object.get("chain_id") + ", but got " + Apis.instance().chain_id); + + return this.set_required_fees().then(function () { + var signer_pubkeys_added = {}; + if (signer_pubkeys) { + + // Balance claims are by address, only the private + // key holder can know about these additional + // potential keys. + var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys); + if (!pubkeys.length) throw new Error("Missing signing key"); + + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = pubkeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var pubkey_string = _step.value; + + var private_key = cwallet.getPrivateKey(pubkey_string); + _this.add_signer(private_key, pubkey_string); + signer_pubkeys_added[pubkey_string] = true; + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + + return _this.get_potential_signatures().then(function (_ref) { + var pubkeys = _ref.pubkeys, + addys = _ref.addys; + + var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys); + + //{//Testing only, don't send All public keys! + // var pubkeys_all = PrivateKeyStore.getPubkeys() // All public keys + // this.get_required_signatures(pubkeys_all).then( required_pubkey_strings => + // console.log('get_required_signatures all\t',required_pubkey_strings.sort(), pubkeys_all)) + // this.get_required_signatures(my_pubkeys).then( required_pubkey_strings => + // console.log('get_required_signatures normal\t',required_pubkey_strings.sort(), pubkeys)) + //} + + return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) { + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = required_pubkeys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var _pubkey_string = _step2.value; + + if (signer_pubkeys_added[_pubkey_string]) continue; + var private_key = cwallet.getPrivateKey(_pubkey_string); + if (!private_key) + // This should not happen, get_required_signatures will only + // returned keys from my_pubkeys + throw new Error("Missing signing key for " + _pubkey_string); + _this.add_signer(private_key, _pubkey_string); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + }); + }).then(function () { + return broadcast ? _this.broadcast() : _this.serialize(); + }); + }); + } - TransactionBuilder.prototype.process_transaction = function process_transaction(cwallet) { - var _this = this; + /** Typically this is called automatically just prior to signing. Once finalized this transaction can not be changed. */ + + }, { + key: "finalize", + value: function finalize() { + var _this2 = this; + + return new Promise(function (resolve, reject) { + + if (_this2.tr_buffer) { + throw new Error("already finalized"); + } + + resolve(Apis.instance().db_api().exec("get_objects", [["2.1.0"]]).then(function (r) { + head_block_time_string = r[0].time; + if (_this2.expiration === 0) _this2.expiration = base_expiration_sec() + ChainConfig.expire_in_secs; + _this2.ref_block_num = r[0].head_block_number & 0xFFFF; + _this2.ref_block_prefix = new Buffer(r[0].head_block_id, 'hex').readUInt32LE(4); + //DEBUG console.log("ref_block",@ref_block_num,@ref_block_prefix,r) + + var iterable = _this2.operations; + for (var i = 0, op; i < iterable.length; i++) { + op = iterable[i]; + if (op[1]["finalize"]) { + op[1].finalize(); + } + + var _type = ops.operation.st_operations[op[0]]; + var hexBuffer = _type.toBuffer(op[1]).toString("hex"); + console.log("Operation %s: %O => %s (%d bytes)", _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2); + } + _this2.tr_buffer = ops.transaction.toBuffer(_this2); + })); + }); + } - var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var wallet_object = cwallet.wallet.wallet_object; + /** @return {string} hex transaction ID */ + }, { + key: "id", + value: function id() { + if (!this.tr_buffer) { + throw new Error("not finalized"); + } + return hash.sha256(this.tr_buffer).toString('hex').substring(0, 40); + } - if (_peerplaysjsWs.Apis.instance().chain_id !== wallet_object.get('chain_id')) { - var wallet_chain_id = wallet_object.get('chain_id'); - var api_chain_id = _peerplaysjsWs.Apis.instance().chain_id; + /** + Typically one will use {@link this.add_type_operation} instead. + @arg {array} operation - [operation_id, operation] + */ - var error = new Error('Mismatched chain_id; expecting ' + wallet_chain_id + ', but got ' + api_chain_id); + }, { + key: "add_operation", + value: function add_operation(operation) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + assert(operation, "operation"); + if (!Array.isArray(operation)) { + throw new Error("Expecting array [operation_id, operation]"); + } + this.operations.push(operation); + return; + } + }, { + key: "get_type_operation", + value: function get_type_operation(name, operation) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + assert(name, "name"); + assert(operation, "operation"); + var _type = ops[name]; + assert(_type, "Unknown operation " + name); + var operation_id = ChainTypes.operations[_type.operation_name]; + if (operation_id === undefined) { + throw new Error("unknown operation: " + _type.operation_name); + } + if (!operation.fee) { + operation.fee = { amount: 0, asset_id: 0 }; + } + if (name === 'proposal_create') { + operation.expiration_time || (operation.expiration_time = base_expiration_sec() + ChainConfig.expire_in_secs_proposal); + } + var operation_instance = _type.fromObject(operation); + return [operation_id, operation_instance]; + } - return Promise.reject(error); - } + /** optional: there is a deafult expiration */ - return this.set_required_fees().then(function () { - var signer_pubkeys_added = {}; + }, { + key: "set_expire_seconds", + value: function set_expire_seconds(sec) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + return this.expiration = base_expiration_sec() + sec; + } - if (signer_pubkeys) { - // Balance claims are by address, only the private - // key holder can know about these additional - // potential keys. - var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys); + /* Wraps this transaction in a proposal_create transaction */ - if (!pubkeys.length) { - throw new Error('Missing signing key'); - } + }, { + key: "propose", + value: function propose(proposal_create_options) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + if (!this.operations.length) { + throw new Error("add operation first"); + } - var keys = Object.keys(pubkeys); + assert(proposal_create_options, "proposal_create_options"); + assert(proposal_create_options.fee_paying_account, "proposal_create_options.fee_paying_account"); - for (var i = 0, len = keys.length; i < len; i++) { - var pubkey_string = pubkeys[i]; - var private_key = cwallet.getPrivateKey(pubkey_string); - _this.add_signer(private_key, pubkey_string); - signer_pubkeys_added[pubkey_string] = true; + var proposed_ops = this.operations.map(function (op) { + return { op: op }; + }); + + this.operations = []; + this.signatures = []; + this.signer_private_keys = []; + proposal_create_options.proposed_ops = proposed_ops; + this.add_type_operation("proposal_create", proposal_create_options); + return this; } - } + }, { + key: "has_proposed_operation", + value: function has_proposed_operation() { + var hasProposed = false; + for (var i = 0; i < this.operations.length; i++) { + if ("proposed_ops" in this.operations[i][1]) { + hasProposed = true; + break; + } + } - return _this.get_potential_signatures().then(function (_ref) { - var pubkeys = _ref.pubkeys, - addys = _ref.addys; + return hasProposed; + } - var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys); + /** optional: the fees can be obtained from the witness node */ - return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) { - var keys = Object.keys(required_pubkeys); + }, { + key: "set_required_fees", + value: function set_required_fees(asset_id) { + var _this3 = this; - for (var _i = 0, _len = keys.length; _i < _len; _i++) { - var _pubkey_string = keys[_i]; + var fee_pool; + if (this.tr_buffer) { + throw new Error("already finalized"); + } + if (!this.operations.length) { + throw new Error("add operations first"); + } + var operations = []; + for (var i = 0, op; i < this.operations.length; i++) { + op = this.operations[i]; + operations.push(ops.operation.toObject(op)); + } - if (!signer_pubkeys_added[_pubkey_string]) { - var _private_key = cwallet.getPrivateKey(_pubkey_string); + if (!asset_id) { + var op1_fee = operations[0][1].fee; + if (op1_fee && op1_fee.asset_id !== null) { + asset_id = op1_fee.asset_id; + } else { + asset_id = "1.3.0"; + } + } - // This should not happen, get_required_signatures will only - // returned keys from my_pubkeys - if (!_private_key) { - throw new Error('Missing signing key for ' + _pubkey_string); - } + var promises = [Apis.instance().db_api().exec("get_required_fees", [operations, asset_id])]; - _this.add_signer(_private_key, _pubkey_string); + var feeAssetPromise = null; + if (asset_id !== "1.3.0") { + // This handles the fallback to paying fees in BTS if the fee pool is empty. + promises.push(Apis.instance().db_api().exec("get_required_fees", [operations, "1.3.0"])); + promises.push(Apis.instance().db_api().exec("get_objects", [[asset_id]])); } - } - }); - }).then(function () { - return broadcast ? _this.broadcast() : _this.serialize(); - }); - }); - }; - /** Typically this is called automatically just prior to signing. - * Once finalized this transaction can not be changed. */ + return Promise.all(promises).then(function (results) { + var _results = _slicedToArray(results, 3), + fees = _results[0], + coreFees = _results[1], + asset = _results[2]; + + asset = asset ? asset[0] : null; + + var dynamicPromise = asset_id !== "1.3.0" && asset ? Apis.instance().db_api().exec("get_objects", [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve, reject) { + resolve(); + }); + + return dynamicPromise.then(function (dynamicObject) { + if (asset_id !== "1.3.0") { + fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0; + var totalFees = 0; + for (var j = 0, fee; j < coreFees.length; j++) { + fee = coreFees[j]; + totalFees += fee.amount; + } + + if (totalFees > parseInt(fee_pool, 10)) { + fees = coreFees; + asset_id = "1.3.0"; + } + } + + // Proposed transactions need to be flattened + var flat_assets = []; + var flatten = function flatten(obj) { + if (Array.isArray(obj)) { + for (var k = 0, item; k < obj.length; k++) { + item = obj[k]; + flatten(item); + } + } else { + flat_assets.push(obj); + } + return; + }; + flatten(fees); + + var asset_index = 0; + + var set_fee = function set_fee(operation) { + if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === "0" // Long + ) { + operation.fee = flat_assets[asset_index]; + // console.log("new operation.fee", operation.fee) + } else { + // console.log("old operation.fee", operation.fee) + } + asset_index++; + if (operation.proposed_ops) { + var result = []; + for (var y = 0; y < operation.proposed_ops.length; y++) { + result.push(set_fee(operation.proposed_ops[y].op[1])); + }return result; + } + }; + for (var _i = 0; _i < _this3.operations.length; _i++) { + set_fee(_this3.operations[_i][1]); + } + }); + //DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets) + }); + } + }, { + key: "get_potential_signatures", + value: function get_potential_signatures() { + var tr_object = ops.signed_transaction.toObject(this); + return Promise.all([Apis.instance().db_api().exec("get_potential_signatures", [tr_object]), Apis.instance().db_api().exec("get_potential_address_signatures", [tr_object])]).then(function (results) { + return { pubkeys: results[0], addys: results[1] }; + }); + } + }, { + key: "get_required_signatures", + value: function get_required_signatures(available_keys) { + if (!available_keys.length) { + return Promise.resolve([]); + } + var tr_object = ops.signed_transaction.toObject(this); + //DEBUG console.log('... tr_object',tr_object) + return Apis.instance().db_api().exec("get_required_signatures", [tr_object, available_keys]).then(function (required_public_keys) { + //DEBUG console.log('... get_required_signatures',required_public_keys) + return required_public_keys; + }); + } + }, { + key: "add_signer", + value: function add_signer(private_key) { + var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey(); + + assert(private_key.d, "required PrivateKey object"); - TransactionBuilder.prototype.finalize = function finalize() { - var _this2 = this; + if (this.signed) { + throw new Error("already signed"); + } + if (!public_key.Q) { + public_key = PublicKey.fromPublicKeyString(public_key); + } + // prevent duplicates + var spHex = private_key.toHex(); + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; + + try { + for (var _iterator3 = this.signer_private_keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var sp = _step3.value; + + if (sp[0].toHex() === spHex) return; + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } - return new Promise(function (resolve) { - if (_this2.tr_buffer) { - throw new Error('already finalized'); - } + this.signer_private_keys.push([private_key, public_key]); + } + }, { + key: "sign", + value: function sign() { + var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Apis.instance().chain_id; - resolve(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.1.0']]).then(function (r) { - _this2.head_block_time_string = r[0].time; + if (!this.tr_buffer) { + throw new Error("not finalized"); + } + if (this.signed) { + throw new Error("already signed"); + } + if (!this.signer_private_keys.length) { + throw new Error("Transaction was not signed. Do you have a private key? [no_signers]"); + } + var end = this.signer_private_keys.length; + for (var i = 0; 0 < end ? i < end : i > end; 0 < end ? i++ : i++) { + var _signer_private_keys$ = _slicedToArray(this.signer_private_keys[i], 2), + private_key = _signer_private_keys$[0], + public_key = _signer_private_keys$[1]; + + var sig = Signature.signBuffer(Buffer.concat([new Buffer(chain_id, 'hex'), this.tr_buffer]), private_key, public_key); + this.signatures.push(sig.toBuffer()); + } + this.signer_private_keys = []; + this.signed = true; + return; + } + }, { + key: "serialize", + value: function serialize() { + return ops.signed_transaction.toObject(this); + } + }, { + key: "toObject", + value: function toObject() { + return ops.signed_transaction.toObject(this); + } + }, { + key: "broadcast", + value: function broadcast(was_broadcast_callback) { + var _this4 = this; - if (_this2.expiration === 0) { - _this2.expiration = _this2.base_expiration_sec() + _peerplaysjsWs.ChainConfig.expire_in_secs; + if (this.tr_buffer) { + return this._broadcast(was_broadcast_callback); + } else { + return this.finalize().then(function () { + return _this4._broadcast(was_broadcast_callback); + }); + } } + }]); - _this2.ref_block_num = r[0].head_block_number & 0xffff; // eslint-disable-line - _this2.ref_block_prefix = Buffer.from(r[0].head_block_id, 'hex').readUInt32LE(4); - // DEBUG console.log("ref_block",@ref_block_num,@ref_block_prefix,r) + return TransactionBuilder; +}(); - var iterable = _this2.operations; +var base_expiration_sec = function base_expiration_sec() { + var head_block_sec = Math.ceil(getHeadBlockDate().getTime() / 1000); + var now_sec = Math.ceil(Date.now() / 1000); + // The head block time should be updated every 3 seconds. If it isn't + // then help the transaction to expire (use head_block_sec) + if (now_sec - head_block_sec > 30) { + return head_block_sec; + } + // If the user's clock is very far behind, use the head block time. + return Math.max(now_sec, head_block_sec); +}; - for (var i = 0, len = iterable.length; i < len; i++) { - var op = iterable[i]; +function _broadcast(was_broadcast_callback) { + var _this5 = this; - if (op[1].finalize) { - op[1].finalize(); - } + return new Promise(function (resolve, reject) { - var _type = _serializer.ops.operation.st_operations[op[0]]; - var hexBuffer = _type.toBuffer(op[1]).toString('hex'); - console.log('Operation %s: %O => %s (%d bytes)', _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2); + if (!_this5.signed) { + _this5.sign(); + } + if (!_this5.tr_buffer) { + throw new Error("not finalized"); + } + if (!_this5.signatures.length) { + throw new Error("not signed"); + } + if (!_this5.operations.length) { + throw new Error("no operations"); } - _this2.tr_buffer = _serializer.ops.transaction.toBuffer(_this2); - })); + var tr_object = ops.signed_transaction.toObject(_this5); + // console.log('... broadcast_transaction_with_callback !!!') + Apis.instance().network_api().exec("broadcast_transaction_with_callback", [function (res) { + return resolve(res); + }, tr_object]).then(function () { + //console.log('... broadcast success, waiting for callback') + if (was_broadcast_callback) was_broadcast_callback(); + return; + }).catch(function (error) { + // console.log may be redundant for network errors, other errors could occur + console.log(error); + var message = error.message; + if (!message) { + message = ""; + } + reject(new Error(message + "\n" + 'graphene-crypto ' + ' digest ' + hash.sha256(_this5.tr_buffer).toString('hex') + ' transaction ' + _this5.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object))); + return; + }); + return; }); - }; +} - /** @return {string} hex transaction ID */ +function getHeadBlockDate() { + return timeStringToDate(head_block_time_string); +} +function timeStringToDate(time_string) { + if (!time_string) return new Date("1970-01-01T00:00:00.000Z"); + if (!/Z$/.test(time_string)) //does not end in Z + // https://github.com/cryptonomex/graphene/issues/368 + time_string = time_string + "Z"; + return new Date(time_string); +} - TransactionBuilder.prototype.id = function id() { - if (!this.tr_buffer) { - throw new Error('not finalized'); - } +module.exports = TransactionBuilder; +}).call(this,require("buffer").Buffer) - return _ecc.hash.sha256(this.tr_buffer).toString('hex').substring(0, 40); - }; +},{"../../ecc":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/index.js","../../serializer":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/index.js","./ChainTypes":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/chain/src/ChainTypes.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","peerplaysjs-ws":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/chain/src/state.js":[function(require,module,exports){ +"use strict"; - /** - Typically one will use {@link this.add_type_operation} instead. - @arg {array} operation - [operation_id, operation] - */ +function get(state) { + return function (key) { + return state[key] || ""; + }; +} +function set(state) { + return function (key, value) { + state[key] = value; + return this; + }; +} - TransactionBuilder.prototype.add_operation = function add_operation(operation) { - if (this.tr_buffer) { - throw new Error('already finalized'); - } +module.exports = { + get: get, + set: set +}; +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/index.js":[function(require,module,exports){ +"use strict"; - (0, _assert2.default)(operation, 'operation'); +module.exports = { + Address: require("./src/address"), + Aes: require("./src/aes"), + PrivateKey: require("./src/PrivateKey"), + PublicKey: require("./src/PublicKey"), + Signature: require("./src/signature"), + brainKey: require("./src/BrainKey"), + hash: require("./src/hash"), + key: require("./src/KeyUtils") +}; +},{"./src/BrainKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/BrainKey.js","./src/KeyUtils":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/KeyUtils.js","./src/PrivateKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PrivateKey.js","./src/PublicKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js","./src/address":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/address.js","./src/aes":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/aes.js","./src/hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","./src/signature":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/signature.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/BrainKey.js":[function(require,module,exports){ +'use strict'; - if (!Array.isArray(operation)) { - throw new Error('Expecting array [operation_id, operation]'); +module.exports = function normalize(brainKey) { + if (typeof brainKey !== 'string') { + throw new Error("string required for brainKey"); } + brainKey = brainKey.trim(); + return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); +}; +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/KeyUtils.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; - this.operations.push(operation); - }; - - TransactionBuilder.prototype.get_type_operation = function get_type_operation(name, operation) { - if (this.tr_buffer) { - throw new Error('already finalized'); - } +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); - (0, _assert2.default)(name, 'name'); - (0, _assert2.default)(operation, 'operation'); - var _type = _serializer.ops[name]; - (0, _assert2.default)(_type, 'Unknown operation ' + name); - var operation_id = _ChainTypes2.default.operations[_type.operation_name]; +var key; +var PrivateKey = require('./PrivateKey'); +var PublicKey = require('./PublicKey'); +var Address = require('./address'); +var Aes = require('./aes'); - if (operation_id === undefined) { - throw new Error('unknown operation: ' + _type.operation_name); - } +var hash = require('./hash'); +// var dictionary = require('./dictionary_en'); +var secureRandom = require('secure-random'); - if (!operation.fee) { - operation.fee = { amount: 0, asset_id: 0 }; - } +var _require = require('peerplaysjs-ws'), + ChainConfig = _require.ChainConfig; - if (name === 'proposal_create') { - /* - * Proposals involving the committee account require a review - * period to be set, look for them here - */ - var requiresReview = false; - var extraReview = 0; - - operation.proposed_ops.forEach(function (op) { - var COMMITTE_ACCOUNT = 0; - var key = void 0; - - switch (op.op[0]) { - case 0: - // transfer - key = 'from'; - break; - - case 6: // account_update - case 17: - // asset_settle - key = 'account'; - break; - - case 10: // asset_create - case 11: // asset_update - case 12: // asset_update_bitasset - case 13: // asset_update_feed_producers - case 14: // asset_issue - case 18: // asset_global_settle - case 43: - // asset_claim_fees - key = 'issuer'; - break; - - case 15: - // asset_reserve - key = 'payer'; - break; - - case 16: - // asset_fund_fee_pool - key = 'from_account'; - break; - - case 22: // proposal_create - case 23: // proposal_update - case 24: - // proposal_delete - key = 'fee_paying_account'; - break; - - case 31: - // committee_member_update_global_parameters - requiresReview = true; - extraReview = 60 * 60 * 24 * 13; // Make the review period 2 weeks total - break; - default: - break; - } +// hash for .25 second - if (key in op.op[1] && op.op[1][key] === COMMITTE_ACCOUNT) { - requiresReview = true; - } - }); - if (!operation.expiration_time) { - var experationTime = this.base_expiration_sec(); - operation.expiration_time = experationTime + _peerplaysjsWs.ChainConfig.expire_in_secs_proposal; - } +var HASH_POWER_MILLS = 250; - if (requiresReview) { - var one_day = 24 * 60 * 60; // One day in seconds - var max = Math.max(this.commitee_min_review, one_day, _peerplaysjsWs.ChainConfig.review_in_secs_committee); +module.exports = key = { - operation.review_period_seconds = extraReview + max; - /* - * Expiration time must be at least equal to - * now + review_period_seconds, so we add one hour to make sure - */ - operation.expiration_time += 60 * 60 + extraReview; - } + /** Uses 1 second of hashing power to create a key/password checksum. An + implementation can re-call this method with the same password to re-match + the strength of the CPU (either after moving from a desktop to a mobile, + mobile to desktop, or N years from now when CPUs are presumably stronger). + A salt is used for all the normal reasons... + @return object { + aes_private: Aes, + checksum: "{hash_iteration_count},{salt},{checksum}" } + */ + aes_checksum: function aes_checksum(password) { + if (!(typeof password === "string")) { + throw new "password string required"(); + } + var salt = secureRandom.randomBuffer(4).toString('hex'); + var iterations = 0; + var secret = salt + password; + // hash for .1 second + var start_t = Date.now(); + while (Date.now() - start_t < HASH_POWER_MILLS) { + secret = hash.sha256(secret); + iterations += 1; + } - var operation_instance = _type.fromObject(operation); - return [operation_id, operation_instance]; - }; - - /* optional: fetch the current head block */ - - TransactionBuilder.prototype.update_head_block = function update_head_block() { - var _this3 = this; - - return _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.0.0', '2.1.0']]).then(function (res) { - var g = res[0], - r = res[1]; + var checksum = hash.sha256(secret); + var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(','); - _this3.head_block_time_string = r[0].time; - _this3.committee_min_review = g[0].parameters.committee_proposal_review_period; - }); - }; + return { aes_private: Aes.fromSeed(secret), + checksum: checksum_string + }; + }, - /** optional: there is a deafult expiration */ + /** Provide a matching password and key_checksum. A "wrong password" + error is thrown if the password does not match. If this method takes + much more or less than 1 second to return, one should consider updating + all encyrpted fields using a new key.key_checksum. + */ + aes_private: function aes_private(password, key_checksum) { + var _key_checksum$split = key_checksum.split(','), + _key_checksum$split2 = _slicedToArray(_key_checksum$split, 3), + iterations = _key_checksum$split2[0], + salt = _key_checksum$split2[1], + checksum = _key_checksum$split2[2]; + + var secret = salt + password; + for (var i = 0; 0 < iterations ? i < iterations : i > iterations; 0 < iterations ? i++ : i++) { + secret = hash.sha256(secret); + } + var new_checksum = hash.sha256(secret); + if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) { + throw new Error("wrong password"); + } + return Aes.fromSeed(secret); + }, - TransactionBuilder.prototype.set_expire_seconds = function set_expire_seconds(sec) { - if (this.tr_buffer) { - throw new Error('already finalized'); - } - this.expiration = this.base_expiration_sec() + sec; + /** + A week random number generator can run out of entropy. This should ensure even the worst random number implementation will be reasonably safe. + @param1 string entropy of at least 32 bytes + */ + random32ByteBuffer: function random32ByteBuffer() { + var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy(); - return this.expiration; - }; - /* Wraps this transaction in a proposal_create transaction */ + if (!(typeof entropy === 'string')) { + throw new Error("string required for entropy"); + } + if (entropy.length < 32) { + throw new Error("expecting at least 32 bytes of entropy"); + } - TransactionBuilder.prototype.propose = function propose(proposal_create_options) { - if (this.tr_buffer) { - throw new Error('already finalized'); - } + var start_t = Date.now(); - if (!this.operations.length) { - throw new Error('add operation first'); - } + while (Date.now() - start_t < HASH_POWER_MILLS) { + entropy = hash.sha256(entropy); + }var hash_array = []; + hash_array.push(entropy); - (0, _assert2.default)(proposal_create_options, 'proposal_create_options'); - (0, _assert2.default)(proposal_create_options.fee_paying_account, 'proposal_create_options.fee_paying_account'); + // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back). + hash_array.push(secureRandom.randomBuffer(32)); - var proposed_ops = this.operations.map(function (op) { - return { op: op }; - }); + return hash.sha256(Buffer.concat(hash_array)); + }, - this.operations = []; - this.signatures = []; - this.signer_private_keys = []; - proposal_create_options.proposed_ops = proposed_ops; - this.add_type_operation('proposal_create', proposal_create_options); - return this; - }; - TransactionBuilder.prototype.has_proposed_operation = function has_proposed_operation() { - var hasProposed = false; + suggest_brain_key: function suggest_brain_key() { + var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ","; + var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy(); - for (var i = 0; i < this.operations.length; i++) { - if ('proposed_ops' in this.operations[i][1]) { - hasProposed = true; - break; - } - } - return hasProposed; - }; + var randomBuffer = this.random32ByteBuffer(entropy); + + var word_count = 16; + var dictionary_lines = dictionary.split(','); - /** optional: the fees can be obtained from the witness node */ + if (!(dictionary_lines.length === 49744)) { + throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words'); + } + var brainkey = []; + var end = word_count * 2; - TransactionBuilder.prototype.set_required_fees = function set_required_fees(asset_id) { - var _this4 = this; + for (var i = 0; i < end; i += 2) { - var fee_pool = void 0; + // randomBuffer has 256 bits / 16 bits per word == 16 words + var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; - if (this.tr_buffer) { - throw new Error('already finalized'); - } + // convert into a number between 0 and 1 (inclusive) + var rndMultiplier = num / Math.pow(2, 16); + var wordIndex = Math.round(dictionary_lines.length * rndMultiplier); - if (!this.operations.length) { - throw new Error('add operations first'); - } + brainkey.push(dictionary_lines[wordIndex]); + } + return this.normalize_brainKey(brainkey.join(' ')); + }, - var operations = []; + get_random_key: function get_random_key(entropy) { + return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy)); + }, + get_brainPrivateKey: function get_brainPrivateKey(brainKey) { + var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - for (var i = 0, len = this.operations.length; i < len; i++) { - var op = this.operations[i]; - operations.push(_serializer.ops.operation.toObject(op)); - } + if (sequence < 0) { + throw new Error("invalid sequence"); + } + brainKey = key.normalize_brainKey(brainKey); + return PrivateKey.fromBuffer(hash.sha256(hash.sha512(brainKey + " " + sequence))); + }, - if (!asset_id) { - var op1_fee = operations[0][1].fee; - if (op1_fee && op1_fee.asset_id !== null) { - asset_id = op1_fee.asset_id; - } else { - asset_id = '1.3.0'; - } - } + // Turn invisible space like characters into a single space + normalize_brainKey: function normalize_brainKey(brainKey) { + if (!(typeof brainKey === 'string')) { + throw new Error("string required for brainKey"); + } - var promises = [_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, asset_id])]; + brainKey = brainKey.trim(); + return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); + }, + browserEntropy: function browserEntropy() { - if (asset_id !== '1.3.0') { - // This handles the fallback to paying fees in BTS if the fee pool is empty. - promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, '1.3.0'])); - promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset_id]])); - } + var entropyStr = ""; + try { + entropyStr = new Date().toString() + " " + window.screen.height + " " + window.screen.width + " " + window.screen.colorDepth + " " + " " + window.screen.availHeight + " " + window.screen.availWidth + " " + window.screen.pixelDepth + navigator.language + " " + window.location + " " + window.history.length; - return Promise.all(promises).then(function (results) { - var fees = results[0], - coreFees = results[1], - asset = results[2]; + for (var i = 0, mimeType; i < navigator.mimeTypes.length; i++) { + mimeType = navigator.mimeTypes[i]; + entropyStr += mimeType.description + " " + mimeType.type + " " + mimeType.suffixes + " "; + } + console.log("INFO\tbrowserEntropy gathered"); + } catch (error) { + //nodejs:ReferenceError: window is not defined + entropyStr = hash.sha256(new Date().toString()); + } - asset = asset ? asset[0] : null; + var b = new Buffer(entropyStr); + entropyStr += b.toString('binary') + " " + new Date().toString(); + return entropyStr; + }, - var dynamicPromise = asset_id !== '1.3.0' && asset ? _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve) { - resolve(); - }); - return dynamicPromise.then(function (dynamicObject) { - if (asset_id !== '1.3.0') { - fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0; - var totalFees = 0; + // @return array of 5 legacy addresses for a pubkey string parameter. + addresses: function addresses(pubkey) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; - for (var j = 0, fee; j < coreFees.length; j++) { - fee = coreFees[j]; - totalFees += fee.amount; - } + var public_key = PublicKey.fromPublicKeyString(pubkey, address_prefix); + // S L O W + var address_string = [Address.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed + Address.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed + Address.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed + Address.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed + public_key.toAddressString(address_prefix) // bts_short, most recent format + ]; + return address_string; + } +}; +}).call(this,require("buffer").Buffer) - if (totalFees > parseInt(fee_pool, 10)) { - fees = coreFees; - asset_id = '1.3.0'; - } - } +},{"./PrivateKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PrivateKey.js","./PublicKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js","./address":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/address.js","./aes":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/aes.js","./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","peerplaysjs-ws":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/index.js","secure-random":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/secure-random/lib/secure-random.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PrivateKey.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; - // Proposed transactions need to be flattened - var flat_assets = []; +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - var flatten = function flatten(obj) { - if (Array.isArray(obj)) { - for (var k = 0, _len2 = obj.length; k < _len2; k++) { - var item = obj[k]; - flatten(item); - } - } else { - flat_assets.push(obj); - } - }; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - flatten(fees); +var ecurve = require('ecurve'); - var asset_index = 0; +var _require = require('ecurve'), + Point = _require.Point, + getCurveByName = _require.getCurveByName; - var set_fee = function set_fee(operation) { - if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === '0' // Long - ) { - operation.fee = flat_assets[asset_index]; - // console.log("new operation.fee", operation.fee) - } else { - // console.log("old operation.fee", operation.fee) - } +var secp256k1 = getCurveByName('secp256k1'); +var BigInteger = require('bigi'); - asset_index++; +var _require2 = require('bs58'), + encode = _require2.encode, + decode = _require2.decode; - if (operation.proposed_ops) { - var result = []; +var assert = require('assert'); +var hash = require('./hash'); +var PublicKey = require('./PublicKey'); +var deepEqual = require("deep-equal"); - for (var y = 0; y < operation.proposed_ops.length; y++) { - result.push(set_fee(operation.proposed_ops[y].op[1])); - } +var G = secp256k1.G, + n = secp256k1.n; - return result; - } - }; +var PrivateKey = function () { - for (var _i2 = 0; _i2 < _this4.operations.length; _i2++) { - set_fee(_this4.operations[_i2][1]); + /** + @private see static functions + @param {BigInteger} + */ + function PrivateKey(d) { + _classCallCheck(this, PrivateKey); + + this.d = d; + } + + _createClass(PrivateKey, [{ + key: 'toWif', + value: function toWif() { + var private_key = this.toBuffer(); + // checksum includes the version + private_key = Buffer.concat([new Buffer([0x80]), private_key]); + var checksum = hash.sha256(private_key); + checksum = hash.sha256(checksum); + checksum = checksum.slice(0, 4); + var private_wif = Buffer.concat([private_key, checksum]); + return encode(private_wif); } - }); - // DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets) - }); - }; - TransactionBuilder.prototype.get_potential_signatures = function get_potential_signatures() { - var tr_object = _serializer.ops.signed_transaction.toObject(this); - return Promise.all([_peerplaysjsWs.Apis.instance().db_api().exec('get_potential_signatures', [tr_object]), _peerplaysjsWs.Apis.instance().db_api().exec('get_potential_address_signatures', [tr_object])]).then(function (results) { - return { pubkeys: results[0], addys: results[1] }; - }); - }; + /** + @return {Point} + */ - TransactionBuilder.prototype.get_required_signatures = function get_required_signatures(available_keys) { - if (!available_keys.length) { - return Promise.resolve([]); - } + }, { + key: 'toPublicKeyPoint', + value: function toPublicKeyPoint() { + var Q; + return Q = secp256k1.G.multiply(this.d); + } + }, { + key: 'toPublicKey', + value: function toPublicKey() { + if (this.public_key) { + return this.public_key; + } + return this.public_key = PublicKey.fromPoint(this.toPublicKeyPoint()); + } + }, { + key: 'toBuffer', + value: function toBuffer() { + return this.d.toBuffer(32); + } - var tr_object = _serializer.ops.signed_transaction.toObject(this); - // DEBUG console.log('... tr_object',tr_object) - return _peerplaysjsWs.Apis.instance().db_api().exec('get_required_signatures', [tr_object, available_keys]).then(function (required_public_keys) { - return required_public_keys; - }); - }; + /** ECIES */ + + }, { + key: 'get_shared_secret', + value: function get_shared_secret(public_key) { + var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + public_key = toPublic(public_key); + var KB = public_key.toUncompressed().toBuffer(); + var KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)), // x + BigInteger.fromBuffer(KB.slice(33, 65)) // y + ); + var r = this.toBuffer(); + var P = KBP.multiply(BigInteger.fromBuffer(r)); + var S = P.affineX.toBuffer({ size: 32 }); + /* + the input to sha512 must be exactly 32-bytes, to match the c++ implementation + of get_shared_secret. Right now S will be shorter if the most significant + byte(s) is zero. Pad it back to the full 32-bytes + */ + if (!legacy && S.length < 32) { + pad = new Buffer(32 - S.length).fill(0); + S = Buffer.concat([pad, S]); + } - TransactionBuilder.prototype.add_signer = function add_signer(private_key) { - var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey(); + // SHA512 used in ECIES + return hash.sha512(S); + } - (0, _assert2.default)(private_key.d, 'required PrivateKey object'); + // /** ECIES (does not always match the Point.fromAffine version above) */ + // get_shared_secret(public_key){ + // public_key = toPublic(public_key) + // var P = public_key.Q.multiply( this.d ); + // var S = P.affineX.toBuffer({size: 32}); + // // ECIES, adds an extra sha512 + // return hash.sha512(S); + // } - if (this.signed) { - throw new Error('already signed'); - } + /** @throws {Error} - overflow of the key could not be derived */ - if (!public_key.Q) { - public_key = _ecc.PublicKey.fromPublicKeyString(public_key); - } + }, { + key: 'child', + value: function child(offset) { + offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]); + offset = hash.sha256(offset); + var c = BigInteger.fromBuffer(offset); - // prevent duplicates - var spHex = private_key.toHex(); + if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again"); - var keys = Object.keys(this.signer_private_keys); + var derived = this.d.add(c); //.mod(n) - for (var i = 0, len = keys.length; i < len; i++) { - var sp = this.signer_private_keys[keys[i]]; + if (derived.signum() === 0) throw new Error("Child offset derived to an invalid key, try again"); - if (sp[0].toHex() === spHex) { - return; - } - } + return new PrivateKey(derived); + } - this.signer_private_keys.push([private_key, public_key]); - }; + /* */ - TransactionBuilder.prototype.sign = function sign() { - var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.Apis.instance().chain_id; + }, { + key: 'toByteBuffer', + value: function toByteBuffer() { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + } + }, { + key: 'toHex', + value: function toHex() { + return this.toBuffer().toString('hex'); + } - if (!this.tr_buffer) { - throw new Error('not finalized'); - } + /* */ - if (this.signed) { - throw new Error('already signed'); - } + }], [{ + key: 'fromBuffer', + value: function fromBuffer(buf) { + if (!Buffer.isBuffer(buf)) { + throw new Error("Expecting paramter to be a Buffer type"); + } + if (32 !== buf.length) { + console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack); + } + if (buf.length === 0) { + throw new Error("Empty buffer"); + } + return new PrivateKey(BigInteger.fromBuffer(buf)); + } - if (!this.signer_private_keys.length) { - throw new Error('Transaction was not signed. Do you have a private key? [no_signers]'); - } + /** @arg {string} seed - any length string. This is private, the same seed produces the same private key every time. */ - var end = this.signer_private_keys.length; + }, { + key: 'fromSeed', + value: function fromSeed(seed) { + // generate_private_key + if (!(typeof seed === 'string')) { + throw new Error('seed must be of type string'); + } + return PrivateKey.fromBuffer(hash.sha256(seed)); + } - for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) { - var _signer_private_keys$ = this.signer_private_keys[i], - private_key = _signer_private_keys$[0], - public_key = _signer_private_keys$[1]; + /** @return {string} Wallet Import Format (still a secret, Not encrypted) */ + + }, { + key: 'fromWif', + value: function fromWif(_private_wif) { + var private_wif = new Buffer(decode(_private_wif)); + var version = private_wif.readUInt8(0); + assert.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version); + // checksum includes the version + var private_key = private_wif.slice(0, -4); + var checksum = private_wif.slice(-4); + var new_checksum = hash.sha256(private_key); + new_checksum = hash.sha256(new_checksum); + new_checksum = new_checksum.slice(0, 4); + var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum' + if (!isEqual) { + throw new Error("Checksum did not match"); + } + private_key = private_key.slice(1); + private_key = private_key.slice(0, 32); + return PrivateKey.fromBuffer(private_key); + } + }, { + key: 'fromHex', + value: function fromHex(hex) { + return PrivateKey.fromBuffer(new Buffer(hex, 'hex')); + } + }]); - var sig = _ecc.Signature.signBuffer(Buffer.concat([Buffer.from(chain_id, 'hex'), this.tr_buffer]), private_key, public_key); - this.signatures.push(sig.toBuffer()); - } + return PrivateKey; +}(); - this.signer_private_keys = []; - this.signed = true; - }; +module.exports = PrivateKey; - TransactionBuilder.prototype.serialize = function serialize() { - return _serializer.ops.signed_transaction.toObject(this); - }; +var toPublic = function toPublic(data) { + return data == null ? data : data.Q ? data : PublicKey.fromStringOrThrow(data); +}; +}).call(this,require("buffer").Buffer) - TransactionBuilder.prototype.toObject = function toObject() { - return _serializer.ops.signed_transaction.toObject(this); - }; +},{"./PublicKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js","./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js","bs58":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bs58/index.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","deep-equal":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/index.js","ecurve":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; - TransactionBuilder.prototype.broadcast = function broadcast(was_broadcast_callback) { - var _this5 = this; +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - if (this.tr_buffer) { - return this._broadcast(was_broadcast_callback); - } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - return this.finalize().then(function () { - return _this5._broadcast(was_broadcast_callback); - }); - }; +var BigInteger = require('bigi'); - TransactionBuilder.prototype._broadcast = function _broadcast(was_broadcast_callback) { - var _this6 = this; +var _require = require('ecurve'), + Point = _require.Point, + getCurveByName = _require.getCurveByName; - return new Promise(function (resolve, reject) { - if (!_this6.signed) { - _this6.sign(); - } +var secp256k1 = getCurveByName('secp256k1'); - if (!_this6.tr_buffer) { - throw new Error('not finalized'); - } +var _require2 = require('bs58'), + encode = _require2.encode, + decode = _require2.decode; - if (!_this6.signatures.length) { - throw new Error('not signed'); - } +var hash = require('./hash'); - if (!_this6.operations.length) { - throw new Error('no operations'); - } +var _require3 = require('peerplaysjs-ws'), + ChainConfig = _require3.ChainConfig; - var tr_object = _serializer.ops.signed_transaction.toObject(_this6); - // console.log('... broadcast_transaction_with_callback !!!') - _peerplaysjsWs.Apis.instance().network_api().exec('broadcast_transaction_with_callback', [function (res) { - return resolve(res); - }, tr_object]).then(function () { - // console.log('... broadcast success, waiting for callback') - if (was_broadcast_callback) { - was_broadcast_callback(); - } - }).catch(function (error) { - // console.log may be redundant for network errors, other errors could occur - console.log(error); - var message = error.message; +var assert = require('assert'); +var deepEqual = require("deep-equal"); +var G = secp256k1.G, + n = secp256k1.n; - if (!message) { - message = ''; - } +var PublicKey = function () { - reject(new Error(message + '\n' + 'peerplays-crypto ' + (' digest ' + _ecc.hash.sha256(_this6.tr_buffer).toString('hex') + ' transaction ' + _this6.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object)))); - }); - }); - }; + /** @param {Point} public key */ + function PublicKey(Q) { + _classCallCheck(this, PublicKey); - TransactionBuilder.timeStringToDate = function timeStringToDate(time_string) { - if (!time_string) { - time_string = '1970-01-01T00:00:00.000Z'; + this.Q = Q; } - if (!/Z$/.test(time_string)) { - // does not end in Z - // https://github.com/cryptonomex/graphene/issues/368 - time_string += 'Z'; - } + _createClass(PublicKey, [{ + key: 'toBuffer', + value: function toBuffer() { + var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null; - return new Date(time_string); - }; + if (this.Q === null) return new Buffer('000000000000000000000000000000000000000000000000000000000000000000', 'hex'); + return this.Q.getEncoded(compressed); + } + }, { + key: 'toUncompressed', + value: function toUncompressed() { + var buf = this.Q.getEncoded(false); + var point = Point.decodeFrom(secp256k1, buf); + return PublicKey.fromPoint(point); + } - TransactionBuilder.prototype.getHeadBlockDate = function getHeadBlockDate() { - return TransactionBuilder.timeStringToDate(this.head_block_time_string); - }; + /** bts::blockchain::address (unique but not a full public key) */ - TransactionBuilder.prototype.base_expiration_sec = function base_expiration_sec() { - var head_block_sec = Math.ceil(this.getHeadBlockDate().getTime() / 1000); - var now_sec = Math.ceil(Date.now() / 1000); + }, { + key: 'toBlockchainAddress', + value: function toBlockchainAddress() { + var pub_buf = this.toBuffer(); + var pub_sha = hash.sha512(pub_buf); + return hash.ripemd160(pub_sha); + } - // The head block time should be updated every 3 seconds. If it isn't - // then help the transaction to expire (use head_block_sec) - if (now_sec - head_block_sec > 30) { - return head_block_sec; - } + /** Alias for {@link toPublicKeyString} */ - // If the user's clock is very far behind, use the head block time. - return Math.max(now_sec, head_block_sec); - }; + }, { + key: 'toString', + value: function toString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; - return TransactionBuilder; -}(); + return this.toPublicKeyString(address_prefix); + } -exports.default = TransactionBuilder; -module.exports = exports['default']; -}).call(this,require(35).Buffer) + /** + Full public key + {return} string + */ -},{"19":19,"27":27,"3":3,"35":35,"7":7,"70":70}],6:[function(require,module,exports){ -'use strict'; + }, { + key: 'toPublicKeyString', + value: function toPublicKeyString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; -exports.__esModule = true; -function get(state) { - return function (key) { - return state[key] || ''; - }; -} + var pub_buf = this.toBuffer(); + var checksum = hash.ripemd160(pub_buf); + // Slice from the buffer directly, slicing from the checksum Uint8array will return the entire array each time. + var sliced = new Uint8Array(checksum.buffer.slice(0, 4)); -function set(state) { - var _this = this; + // concat only accepts buffers so initialize the sliced Uint8array as a Buffer. + var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]); + return address_prefix + encode(addy); + } - return function (key, value) { - state[key] = value; - return _this; - }; -} + /** + @arg {string} public_key - like GPHXyz... + @arg {string} address_prefix - like GPH + @return PublicKey or `null` (if the public_key string is invalid) + */ -exports.get = get; -exports.set = set; -},{}],7:[function(require,module,exports){ -'use strict'; + }, { + key: 'toAddressString', + value: function toAddressString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; + + var pub_buf = this.toBuffer(); + var pub_sha = hash.sha512(pub_buf); + var addy = hash.ripemd160(pub_sha); + var checksum = hash.ripemd160(addy); + addy = Buffer.concat([addy, checksum.slice(0, 4)]); + return address_prefix + encode(addy); + } + }, { + key: 'toPtsAddy', + value: function toPtsAddy() { + var pub_buf = this.toBuffer(); + var pub_sha = hash.sha256(pub_buf); + var addy = hash.ripemd160(pub_sha); + addy = Buffer.concat([new Buffer([0x38]), addy]); //version 56(decimal) + + var checksum = hash.sha256(addy); + checksum = hash.sha256(checksum); + + addy = Buffer.concat([addy, checksum.slice(0, 4)]); + return encode(addy); + } + }, { + key: 'child', + value: function child(offset) { -exports.__esModule = true; -exports.key = exports.hash = exports.brainKey = exports.Signature = exports.PublicKey = exports.PrivateKey = exports.Aes = exports.Address = undefined; + assert(Buffer.isBuffer(offset), "Buffer required: offset"); + assert.equal(offset.length, 32, "offset length"); -var _address = require(12); + offset = Buffer.concat([this.toBuffer(), offset]); + offset = hash.sha256(offset); -var _address2 = _interopRequireDefault(_address); + var c = BigInteger.fromBuffer(offset); -var _aes = require(13); + if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again"); -var _aes2 = _interopRequireDefault(_aes); + var cG = G.multiply(c); + var Qprime = this.Q.add(cG); -var _PrivateKey = require(10); + if (secp256k1.isInfinity(Qprime)) throw new Error("Child offset derived to an invalid key, try again"); -var _PrivateKey2 = _interopRequireDefault(_PrivateKey); + return PublicKey.fromPoint(Qprime); + } -var _PublicKey = require(11); + /* */ -var _PublicKey2 = _interopRequireDefault(_PublicKey); + }, { + key: 'toByteBuffer', + value: function toByteBuffer() { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + } + }, { + key: 'toHex', + value: function toHex() { + return this.toBuffer().toString('hex'); + } + }], [{ + key: 'fromBinary', + value: function fromBinary(bin) { + return PublicKey.fromBuffer(new Buffer(bin, 'binary')); + } + }, { + key: 'fromBuffer', + value: function fromBuffer(buffer) { + if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') return new PublicKey(null); + return new PublicKey(Point.decodeFrom(secp256k1, buffer)); + } + }, { + key: 'fromPoint', + value: function fromPoint(point) { + return new PublicKey(point); + } + }, { + key: 'fromPublicKeyString', + value: function fromPublicKeyString(public_key) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + try { + return PublicKey.fromStringOrThrow(public_key, address_prefix); + } catch (e) { + return null; + } + } -var _signature = require(18); + /** + @arg {string} public_key - like GPHXyz... + @arg {string} address_prefix - like GPH + @throws {Error} if public key is invalid + @return PublicKey + */ -var _signature2 = _interopRequireDefault(_signature); + }, { + key: 'fromStringOrThrow', + value: function fromStringOrThrow(public_key) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + var prefix = public_key.slice(0, address_prefix.length); + assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); + public_key = public_key.slice(address_prefix.length); + + public_key = new Buffer(decode(public_key), 'binary'); + var checksum = public_key.slice(-4); + public_key = public_key.slice(0, -4); + var new_checksum = hash.ripemd160(public_key); + new_checksum = new_checksum.slice(0, 4); + var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum' + if (!isEqual) { + throw new Error("Checksum did not match"); + } + return PublicKey.fromBuffer(public_key); + } + }, { + key: 'fromHex', + value: function fromHex(hex) { + return PublicKey.fromBuffer(new Buffer(hex, 'hex')); + } + }, { + key: 'fromPublicKeyStringHex', + value: function fromPublicKeyStringHex(hex) { + return PublicKey.fromPublicKeyString(new Buffer(hex, 'hex')); + } -var _BrainKey = require(8); + /* */ -var _BrainKey2 = _interopRequireDefault(_BrainKey); + }]); -var _hash = require(17); + return PublicKey; +}(); -var hash = _interopRequireWildcard(_hash); +module.exports = PublicKey; +}).call(this,require("buffer").Buffer) -var _KeyUtils = require(9); +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js","bs58":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bs58/index.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","deep-equal":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/index.js","ecurve":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/index.js","peerplaysjs-ws":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/address.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; -var _KeyUtils2 = _interopRequireDefault(_KeyUtils); +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +var assert = require('assert'); -exports.Address = _address2.default; -exports.Aes = _aes2.default; -exports.PrivateKey = _PrivateKey2.default; -exports.PublicKey = _PublicKey2.default; -exports.Signature = _signature2.default; -exports.brainKey = _BrainKey2.default; -exports.hash = hash; -exports.key = _KeyUtils2.default; -},{"10":10,"11":11,"12":12,"13":13,"17":17,"18":18,"8":8,"9":9}],8:[function(require,module,exports){ -'use strict'; +var _require = require('peerplaysjs-ws'), + ChainConfig = _require.ChainConfig; -exports.__esModule = true; -exports.default = normalize; -function normalize(brainKey) { - if (typeof brainKey !== 'string') { - throw new Error('string required for brainKey'); - } +var hash = require('./hash'); - brainKey = brainKey.trim(); - return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); -} -module.exports = exports['default']; -},{}],9:[function(require,module,exports){ -(function (Buffer){ -'use strict'; +var _require2 = require('bs58'), + encode = _require2.encode, + decode = _require2.decode; -exports.__esModule = true; +var deepEqual = require("deep-equal"); -var _secureRandom = require(94); +/** Addresses are shortened non-reversable hashes of a public key. The full PublicKey is preferred. + @deprecated +*/ -var _secureRandom2 = _interopRequireDefault(_secureRandom); +var Address = function () { + function Address(addy) { + _classCallCheck(this, Address); -var _peerplaysjsWs = require(70); + this.addy = addy; + } -var _PrivateKey = require(10); + _createClass(Address, [{ + key: 'toBuffer', + value: function toBuffer() { + return this.addy; + } + }, { + key: 'toString', + value: function toString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; + + var checksum = hash.ripemd160(this.addy); + var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]); + return address_prefix + encode(addy); + } + }], [{ + key: 'fromBuffer', + value: function fromBuffer(buffer) { + var _hash = hash.sha512(buffer); + var addy = hash.ripemd160(_hash); + return new Address(addy); + } + }, { + key: 'fromString', + value: function fromString(string) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + var prefix = string.slice(0, address_prefix.length); + assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); + var addy = string.slice(address_prefix.length); + addy = new Buffer(decode(addy), 'binary'); + var checksum = addy.slice(-4); + addy = addy.slice(0, -4); + var new_checksum = hash.ripemd160(addy); + new_checksum = new_checksum.slice(0, 4); + var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum' + if (!isEqual) { + throw new Error("Checksum did not match"); + } + return new Address(addy); + } + }, { + key: 'fromPublic', + + + /** @return Address - Compressed PTS format (by default) */ + value: function fromPublic(public_key) { + var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56; + + var sha2 = hash.sha256(public_key.toBuffer(compressed)); + var rep = hash.ripemd160(sha2); + var versionBuffer = new Buffer(1); + versionBuffer.writeUInt8(0xFF & version, 0); + var addr = Buffer.concat([versionBuffer, rep]); + var check = hash.sha256(addr); + check = hash.sha256(check); + var buffer = Buffer.concat([addr, check.slice(0, 4)]); + return new Address(hash.ripemd160(buffer)); + } + }]); -var _PrivateKey2 = _interopRequireDefault(_PrivateKey); + return Address; +}(); -var _PublicKey = require(11); +module.exports = Address; +}).call(this,require("buffer").Buffer) -var _PublicKey2 = _interopRequireDefault(_PublicKey); +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bs58":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bs58/index.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","deep-equal":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/index.js","peerplaysjs-ws":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/aes.js":[function(require,module,exports){ +(function (Buffer){ +"use strict"; -var _address = require(12); +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -var _address2 = _interopRequireDefault(_address); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var _aes = require(13); +// https://code.google.com/p/crypto-js +var AES = require("crypto-js/aes"); +var encHex = require("crypto-js/enc-hex"); +var encBase64 = require("crypto-js/enc-base64"); +var assert = require("assert"); -var _aes2 = _interopRequireDefault(_aes); +var _require = require("bytebuffer"), + Long = _require.Long; -var _hash = require(17); +var hash = require('./hash'); -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +/** Provides symetric encrypt and decrypt via AES. */ -// import dictionary from './dictionary_en'; +var Aes = function () { -// hash for .25 second -var HASH_POWER_MILLS = 250; + /** @private */ + function Aes(iv, key) { + _classCallCheck(this, Aes); -var key = { - /** Uses 1 second of hashing power to create a key/password checksum. An - implementation can re-call this method with the same password to re-match - the strength of the CPU (either after moving from a desktop to a mobile, - mobile to desktop, or N years from now when CPUs are presumably stronger). - A salt is used for all the normal reasons... - @return object { - aes_private: Aes, - checksum: "{hash_iteration_count},{salt},{checksum}" - } - */ - aes_checksum: function aes_checksum(password) { - if (!(typeof password === 'string')) { - throw new 'password string required'(); + this.iv = iv, this.key = key; } - var salt = _secureRandom2.default.randomBuffer(4).toString('hex'); - var iterations = 0; - var secret = salt + password; - // hash for .1 second - var start_t = Date.now(); + /** This is an excellent way to ensure that all references to Aes can not operate anymore (example: a wallet becomes locked). An application should ensure there is only one Aes object instance for a given secret `seed`. */ - while (Date.now() - start_t < HASH_POWER_MILLS) { - secret = (0, _hash.sha256)(secret); - iterations += 1; - } - var checksum = (0, _hash.sha256)(secret); - var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(','); + _createClass(Aes, [{ + key: "clear", + value: function clear() { + return this.iv = this.key = undefined; + } - return { - aes_private: _aes2.default.fromSeed(secret), - checksum: checksum_string - }; - }, + /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */ + }, { + key: "_decrypt_word_array", - /** Provide a matching password and key_checksum. A "wrong password" - error is thrown if the password does not match. If this method takes - much more or less than 1 second to return, one should consider updating - all encyrpted fields using a new key.key_checksum. - */ - aes_private: function aes_private(password, key_checksum) { - var _key_checksum$split = key_checksum.split(','), - iterations = _key_checksum$split[0], - salt = _key_checksum$split[1], - checksum = _key_checksum$split[2]; - var secret = salt + password; + /** @private */ + value: function _decrypt_word_array(cipher) { + // https://code.google.com/p/crypto-js/#Custom_Key_and_IV + // see wallet_records.cpp master_key::decrypt_key + return AES.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv }); + } - for (var i = 0; iterations > 0 ? i < iterations : i > iterations; iterations > 0 ? i++ : i++) { - secret = (0, _hash.sha256)(secret); - } + /** @private */ - var new_checksum = (0, _hash.sha256)(secret); + }, { + key: "_encrypt_word_array", + value: function _encrypt_word_array(plaintext) { + //https://code.google.com/p/crypto-js/issues/detail?id=85 + var cipher = AES.encrypt(plaintext, this.key, { iv: this.iv }); + return encBase64.parse(cipher.toString()); + } - if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) { - throw new Error('wrong password'); - } + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} ciphertext + @return {Buffer} binary + */ - return _aes2.default.fromSeed(secret); - }, + }, { + key: "decrypt", + value: function decrypt(ciphertext) { + if (typeof ciphertext === "string") { + ciphertext = new Buffer(ciphertext, 'binary'); + } + if (!Buffer.isBuffer(ciphertext)) { + throw new Error("buffer required"); + } + assert(ciphertext, "Missing cipher text"); + // hex is the only common format + var hex = this.decryptHex(ciphertext.toString('hex')); + return new Buffer(hex, 'hex'); + } + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} plaintext + @return {Buffer} binary + */ - /** - A week random number generator can run out of entropy. - This should ensure even the worst random number implementation will be reasonably safe. - @param1 string entropy of at least 32 bytes - */ - random32ByteBuffer: function random32ByteBuffer() { - var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy(); + }, { + key: "encrypt", + value: function encrypt(plaintext) { + if (typeof plaintext === "string") { + plaintext = new Buffer(plaintext, 'binary'); + } + if (!Buffer.isBuffer(plaintext)) { + throw new Error("buffer required"); + } + //assert plaintext, "Missing plain text" + // hex is the only common format + var hex = this.encryptHex(plaintext.toString('hex')); + return new Buffer(hex, 'hex'); + } - if (!(typeof entropy === 'string')) { - throw new Error('string required for entropy'); - } + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string|Buffer} plaintext + @return {string} hex + */ - if (entropy.length < 32) { - throw new Error('expecting at least 32 bytes of entropy'); - } + }, { + key: "encryptToHex", + value: function encryptToHex(plaintext) { + if (typeof plaintext === "string") { + plaintext = new Buffer(plaintext, 'binary'); + } + if (!Buffer.isBuffer(plaintext)) { + throw new Error("buffer required"); + } + //assert plaintext, "Missing plain text" + // hex is the only common format + return this.encryptHex(plaintext.toString('hex')); + } - var start_t = Date.now(); + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @return {string} binary (could easily be readable text) + */ - while (Date.now() - start_t < HASH_POWER_MILLS) { - entropy = (0, _hash.sha256)(entropy); - } + }, { + key: "decryptHex", + value: function decryptHex(cipher) { + assert(cipher, "Missing cipher text"); + // Convert data into word arrays (used by Crypto) + var cipher_array = encHex.parse(cipher); + var plainwords = this._decrypt_word_array(cipher_array); + return encHex.stringify(plainwords); + } - var hash_array = []; - hash_array.push(entropy); + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @return {Buffer} encoded as specified by the parameter + */ - // Hashing for 1 second may helps the computer is not low on entropy - // (this method may be called back-to-back). - hash_array.push(_secureRandom2.default.randomBuffer(32)); + }, { + key: "decryptHexToBuffer", + value: function decryptHexToBuffer(cipher) { + assert(cipher, "Missing cipher text"); + // Convert data into word arrays (used by Crypto) + var cipher_array = encHex.parse(cipher); + var plainwords = this._decrypt_word_array(cipher_array); + var plainhex = encHex.stringify(plainwords); + return new Buffer(plainhex, 'hex'); + } - return (0, _hash.sha256)(Buffer.concat(hash_array)); - }, - suggest_brain_key: function suggest_brain_key() { - var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ','; - var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy(); + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @arg {string} [encoding = 'binary'] - a valid Buffer encoding + @return {String} encoded as specified by the parameter + */ - var randomBuffer = this.random32ByteBuffer(entropy); + }, { + key: "decryptHexToText", + value: function decryptHexToText(cipher) { + var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary'; - var word_count = 16; - var dictionary_lines = dictionary.split(','); + return this.decryptHexToBuffer(cipher).toString(encoding); + } - if (!(dictionary_lines.length === 49744)) { - throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words'); - } + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} plainhex - hex format + @return {String} hex + */ + + }, { + key: "encryptHex", + value: function encryptHex(plainhex) { + var plain_array = encHex.parse(plainhex); + var cipher_array = this._encrypt_word_array(plain_array); + return encHex.stringify(cipher_array); + } + }], [{ + key: "fromSeed", + value: function fromSeed(seed) { + if (seed === undefined) { + throw new Error("seed is required"); + } + var _hash = hash.sha512(seed); + _hash = _hash.toString('hex'); + // DEBUG console.log('... fromSeed _hash',_hash) + return Aes.fromSha512(_hash); + } + }, { + key: "fromSha512", - var brainkey = []; - var end = word_count * 2; - for (var i = 0; i < end; i += 2) { - // randomBuffer has 256 bits / 16 bits per word == 16 words - var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; // eslint-disable-line + /** @arg {string} hash - A 128 byte hex string, typically one would call {@link fromSeed} instead. */ + value: function fromSha512(hash) { + assert.equal(hash.length, 128, "A Sha512 in HEX should be 128 characters long, instead got " + hash.length); + var iv = encHex.parse(hash.substring(64, 96)); + var key = encHex.parse(hash.substring(0, 64)); + return new Aes(iv, key); + } + }, { + key: "fromBuffer", + value: function fromBuffer(buf) { + assert(Buffer.isBuffer(buf), "Expecting Buffer"); + assert.equal(buf.length, 64, "A Sha512 Buffer should be 64 characters long, instead got " + buf.length); + return Aes.fromSha512(buf.toString("hex")); + } + /** + @throws {Error} - "Invalid Key, ..." + @arg {PrivateKey} private_key - required and used for decryption + @arg {PublicKey} public_key - required and used to calcualte the shared secret + @arg {string} [nonce = ""] optional but should always be provided and be unique when re-using the same private/public keys more than once. This nonce is not a secret. + @arg {string|Buffer} message - Encrypted message containing a checksum + @return {Buffer} + */ - // convert into a number between 0 and 1 (inclusive) - var rndMultiplier = num / Math.pow(2, 16); - var wordIndex = Math.round(dictionary_lines.length * rndMultiplier); + }, { + key: "decrypt_with_checksum", + value: function decrypt_with_checksum(private_key, public_key, nonce, message) { + var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; - brainkey.push(dictionary_lines[wordIndex]); - } - return this.normalize_brainKey(brainkey.join(' ')); - }, - get_random_key: function get_random_key(entropy) { - return _PrivateKey2.default.fromBuffer(this.random32ByteBuffer(entropy)); - }, - get_brainPrivateKey: function get_brainPrivateKey(brainKey) { - var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + // Warning: Do not put `nonce = ""` in the arguments, in es6 this will not convert "null" into an emtpy string + if (nonce == null) // null or undefined + nonce = ""; - if (sequence < 0) { - throw new Error('invalid sequence'); - } + if (!Buffer.isBuffer(message)) { + message = new Buffer(message, 'hex'); + } - brainKey = key.normalize_brainKey(brainKey); - return _PrivateKey2.default.fromBuffer((0, _hash.sha256)((0, _hash.sha512)(brainKey + ' ' + sequence))); - }, + var S = private_key.get_shared_secret(public_key, legacy); + // D E B U G + // console.log('decrypt_with_checksum', { + // priv_to_pub: private_key.toPublicKey().toString(), + // pub: public_key.toPublicKeyString(), + // nonce: nonce, + // message: message.length, + // S: S.toString('hex') + // }) + + var aes = Aes.fromSeed(Buffer.concat([ + // A null or empty string nonce will not effect the hash + new Buffer("" + nonce), new Buffer(S.toString('hex'))])); + + var planebuffer = aes.decrypt(message); + if (!(planebuffer.length >= 4)) { + throw new Error("Invalid key, could not decrypt message(1)"); + } + // DEBUG console.log('... planebuffer',planebuffer) + var checksum = planebuffer.slice(0, 4); + var plaintext = planebuffer.slice(4); - // Turn invisible space like characters into a single space - normalize_brainKey: function normalize_brainKey(brainKey) { - if (!(typeof brainKey === 'string')) { - throw new Error('string required for brainKey'); - } + // console.log('... checksum',checksum.toString('hex')) + // console.log('... plaintext',plaintext.toString()) - brainKey = brainKey.trim(); - return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); - }, - browserEntropy: function browserEntropy() { - var entropyStr = ''; + var new_checksum = hash.sha256(plaintext); + new_checksum = new_checksum.slice(0, 4); + new_checksum = new_checksum.toString('hex'); - try { - entropyStr = new Date().toString() + ' ' + window.screen.height + ' ' + window.screen.width; - entropyStr = entropyStr + ' ' + window.screen.colorDepth + ' ' + window.screen.availHeight; - entropyStr = entropyStr + ' ' + window.screen.availWidth + ' ' + window.screen.pixelDepth; - entropyStr = entropyStr + ' ' + navigator.language + ' ' + window.location; - entropyStr = entropyStr + ' ' + window.history.length; - - for (var i = 0, len = navigator.mimeTypes.length; i < len; i++) { - var mimeType = navigator.mimeTypes[i]; - entropyStr += mimeType.description + ' ' + mimeType.type + ' ' + mimeType.suffixes + ' '; - } + if (!(checksum.toString('hex') === new_checksum)) { + throw new Error("Invalid key, could not decrypt message(2)"); + } - console.log('INFO\tbrowserEntropy gathered'); - } catch (error) { - // nodejs:ReferenceError: window is not defined - entropyStr = (0, _hash.sha256)(new Date().toString()); - } + return plaintext; + } + }, { + key: "encrypt_with_checksum", - var b = Buffer.from(entropyStr); - entropyStr += b.toString('binary') + ' ' + new Date().toString(); - return entropyStr; - }, + /** Identical to {@link decrypt_with_checksum} but used to encrypt. Should not throw an error. + @return {Buffer} message - Encrypted message which includes a checksum + */ + value: function encrypt_with_checksum(private_key, public_key, nonce, message) { - // @return array of 5 legacy addresses for a pubkey string parameter. - addresses: function addresses(pubkey) { - var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; + // Warning: Do not put `nonce = ""` in the arguments, in es6 this will not convert "null" into an emtpy string - var public_key = _PublicKey2.default.fromPublicKeyString(pubkey, address_prefix); - // S L O W - var address_string = [_address2.default.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed - _address2.default.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed - _address2.default.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed - _address2.default.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed - public_key.toAddressString(address_prefix) // bts_short, most recent format - ]; - return address_string; - } -}; + if (nonce == null) // null or undefined + nonce = ""; + + if (!Buffer.isBuffer(message)) { + message = new Buffer(message, 'binary'); + } + + var S = private_key.get_shared_secret(public_key); + + // D E B U G + // console.log('encrypt_with_checksum', { + // priv_to_pub: private_key.toPublicKey().toString() + // pub: public_key.toPublicKeyString() + // nonce: nonce + // message: message.length + // S: S.toString('hex') + // }) + + var aes = Aes.fromSeed(Buffer.concat([ + // A null or empty string nonce will not effect the hash + new Buffer("" + nonce), new Buffer(S.toString('hex'))])); + // DEBUG console.log('... S',S.toString('hex')) + var checksum = hash.sha256(message).slice(0, 4); + var payload = Buffer.concat([checksum, message]); + // DEBUG console.log('... payload',payload.toString()) + return aes.encrypt(payload); + } + }]); + + return Aes; +}(); -exports.default = key; -module.exports = exports['default']; -}).call(this,require(35).Buffer) +module.exports = Aes; +}).call(this,require("buffer").Buffer) -},{"10":10,"11":11,"12":12,"13":13,"17":17,"35":35,"70":70,"94":94}],10:[function(require,module,exports){ +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","bytebuffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bytebuffer/dist/bytebuffer.js","crypto-js/aes":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/aes.js","crypto-js/enc-base64":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-base64.js","crypto-js/enc-hex":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-hex.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/ecdsa.js":[function(require,module,exports){ (function (Buffer){ 'use strict'; -exports.__esModule = true; +var assert = require('assert'); // from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa +var crypto = require('./hash'); +var enforceType = require('./enforce_types'); -var _ecurve = require(59); +var BigInteger = require('bigi'); +var ECSignature = require('./ecsignature'); -var _bigi = require(32); +// https://tools.ietf.org/html/rfc6979#section-3.2 +function deterministicGenerateK(curve, hash, d, checkSig, nonce) { -var _bigi2 = _interopRequireDefault(_bigi); + enforceType('Buffer', hash); + enforceType(BigInteger, d); -var _bs = require(37); + if (nonce) { + hash = crypto.sha256(Buffer.concat([hash, new Buffer(nonce)])); + } -var _deepEqual = require(54); + // sanity check + assert.equal(hash.length, 32, 'Hash must be 256 bit'); -var _deepEqual2 = _interopRequireDefault(_deepEqual); + var x = d.toBuffer(32); + var k = new Buffer(32); + var v = new Buffer(32); -var _assert = require(27); + // Step B + v.fill(1); -var _assert2 = _interopRequireDefault(_assert); + // Step C + k.fill(0); -var _hash = require(17); + // Step D + k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0]), x, hash]), k); -var _PublicKey = require(11); + // Step E + v = crypto.HmacSHA256(v, k); -var _PublicKey2 = _interopRequireDefault(_PublicKey); + // Step F + k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([1]), x, hash]), k); -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + // Step G + v = crypto.HmacSHA256(v, k); -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* global ByteBuffer */ + // Step H1/H2a, ignored as tlen === qlen (256 bit) + // Step H2b + v = crypto.HmacSHA256(v, k); + var T = BigInteger.fromBuffer(v); -var secp256k1 = (0, _ecurve.getCurveByName)('secp256k1'); -var n = secp256k1.n; + // Step H3, repeat until T is within the interval [1, n - 1] + while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) { + k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0])]), k); + v = crypto.HmacSHA256(v, k); + // Step H1/H2a, again, ignored as tlen === qlen (256 bit) + // Step H2b again + v = crypto.HmacSHA256(v, k); -function toPublic(data) { - if (!data || data.Q) { - return data; + T = BigInteger.fromBuffer(v); } - return _PublicKey2.default.fromStringOrThrow(data); + return T; } -var PrivateKey = function () { - /** - @private see static functions - @param {BigInteger} - */ - function PrivateKey(d) { - _classCallCheck(this, PrivateKey); - - this.d = d; - } +function sign(curve, hash, d, nonce) { - PrivateKey.fromBuffer = function fromBuffer(buf) { - if (!Buffer.isBuffer(buf)) { - throw new Error('Expecting paramter to be a Buffer type'); - } + var e = BigInteger.fromBuffer(hash); + var n = curve.n; + var G = curve.G; - if (buf.length !== 32) { - console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack); - } + var r, s; + var k = deterministicGenerateK(curve, hash, d, function (k) { + // find canonically valid signature + var Q = G.multiply(k); - if (buf.length === 0) { - throw new Error('Empty buffer'); - } + if (curve.isInfinity(Q)) return false; - return new PrivateKey(_bigi2.default.fromBuffer(buf)); - }; + r = Q.affineX.mod(n); + if (r.signum() === 0) return false; - /** @arg {string} seed - any length string. This is private, - * the same seed produces the same private key every time. */ + s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n); + if (s.signum() === 0) return false; + return true; + }, nonce); - PrivateKey.fromSeed = function fromSeed(seed) { - // generate_private_key - if (!(typeof seed === 'string')) { - throw new Error('seed must be of type string'); - } + var N_OVER_TWO = n.shiftRight(1); - return PrivateKey.fromBuffer((0, _hash.sha256)(seed)); - }; + // enforce low S values, see bip62: 'low s values in signatures' + if (s.compareTo(N_OVER_TWO) > 0) { + s = n.subtract(s); + } - /** @return {string} Wallet Import Format (still a secret, Not encrypted) */ + return new ECSignature(r, s); +} +function verifyRaw(curve, e, signature, Q) { + var n = curve.n; + var G = curve.G; - PrivateKey.fromWif = function fromWif(_private_wif) { - var private_wif = Buffer.from((0, _bs.decode)(_private_wif)); - var version = private_wif.readUInt8(0); - _assert2.default.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version); - // checksum includes the version - var private_key = private_wif.slice(0, -4); - var checksum = private_wif.slice(-4); - var new_checksum = (0, _hash.sha256)(private_key); - new_checksum = (0, _hash.sha256)(new_checksum); - new_checksum = new_checksum.slice(0, 4); - var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum' + var r = signature.r; + var s = signature.s; - if (!isEqual) { - throw new Error('Checksum did not match'); - } + // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1] + if (r.signum() <= 0 || r.compareTo(n) >= 0) return false; + if (s.signum() <= 0 || s.compareTo(n) >= 0) return false; - private_key = private_key.slice(1); - private_key = private_key.slice(0, 32); - return PrivateKey.fromBuffer(private_key); - }; + // c = s^-1 mod n + var c = s.modInverse(n); - PrivateKey.prototype.toWif = function toWif() { - var private_key = this.toBuffer(); - // checksum includes the version - private_key = Buffer.concat([Buffer.from([0x80]), private_key]); - var checksum = (0, _hash.sha256)(private_key); - checksum = (0, _hash.sha256)(checksum); - checksum = checksum.slice(0, 4); - var private_wif = Buffer.concat([private_key, checksum]); - return (0, _bs.encode)(private_wif); - }; + // 1.4.4 Compute u1 = es^−1 mod n + // u2 = rs^−1 mod n + var u1 = e.multiply(c).mod(n); + var u2 = r.multiply(c).mod(n); - /** - @return {Point} - */ + // 1.4.5 Compute R = (xR, yR) = u1G + u2Q + var R = G.multiplyTwo(u1, Q, u2); + // 1.4.5 (cont.) Enforce R is not at infinity + if (curve.isInfinity(R)) return false; - PrivateKey.prototype.toPublicKeyPoint = function toPublicKeyPoint() { - var Q = secp256k1.G.multiply(this.d); - return Q; - }; + // 1.4.6 Convert the field element R.x to an integer + var xR = R.affineX; - PrivateKey.prototype.toPublicKey = function toPublicKey() { - if (this.public_key) { - return this.public_key; - } + // 1.4.7 Set v = xR mod n + var v = xR.mod(n); - this.public_key = _PublicKey2.default.fromPoint(this.toPublicKeyPoint()); + // 1.4.8 If v = r, output "valid", and if v != r, output "invalid" + return v.equals(r); +} - return this.public_key; - }; +function verify(curve, hash, signature, Q) { + // 1.4.2 H = Hash(M), already done by the user + // 1.4.3 e = H + var e = BigInteger.fromBuffer(hash); + return verifyRaw(curve, e, signature, Q); +} - PrivateKey.prototype.toBuffer = function toBuffer() { - return this.d.toBuffer(32); - }; +/** + * Recover a public key from a signature. + * + * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public + * Key Recovery Operation". + * + * http://www.secg.org/download/aid-780/sec1-v2.pdf + */ +function recoverPubKey(curve, e, signature, i) { + assert.strictEqual(i & 3, i, 'Recovery param is more than two bits'); - /** ECIES */ + var n = curve.n; + var G = curve.G; + var r = signature.r; + var s = signature.s; - PrivateKey.prototype.get_shared_secret = function get_shared_secret(public_key) { - var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + assert(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value'); + assert(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value'); - public_key = toPublic(public_key); - var KB = public_key.toUncompressed().toBuffer(); - var KBP = _ecurve.Point.fromAffine(secp256k1, _bigi2.default.fromBuffer(KB.slice(1, 33)), // x - _bigi2.default.fromBuffer(KB.slice(33, 65)) // y - ); - var r = this.toBuffer(); - var P = KBP.multiply(_bigi2.default.fromBuffer(r)); - var S = P.affineX.toBuffer({ size: 32 }); + // A set LSB signifies that the y-coordinate is odd + var isYOdd = i & 1; - /* - the input to sha512 must be exactly 32-bytes, to match the c++ implementation - of get_shared_secret. Right now S will be shorter if the most significant - byte(s) is zero. Pad it back to the full 32-bytes - */ - if (!legacy && S.length < 32) { - var pad = Buffer.alloc(32 - S.length, 0); - S = Buffer.concat([pad, S]); - } + // The more significant bit specifies whether we should use the + // first or second candidate key. + var isSecondKey = i >> 1; - // SHA512 used in ECIES - return (0, _hash.sha512)(S); - }; + // 1.1 Let x = r + jn + var x = isSecondKey ? r.add(n) : r; + var R = curve.pointFromX(isYOdd, x); - // /** ECIES (does not always match the Point.fromAffine version above) */ - // get_shared_secret(public_key){ - // public_key = toPublic(public_key) - // var P = public_key.Q.multiply( this.d ); - // var S = P.affineX.toBuffer({size: 32}); - // // ECIES, adds an extra sha512 - // return sha512(S); - // } + // 1.4 Check that nR is at infinity + var nR = R.multiply(n); + assert(curve.isInfinity(nR), 'nR is not a valid curve point'); - /** @throws {Error} - overflow of the key could not be derived */ + // Compute -e from e + var eNeg = e.negate().mod(n); + // 1.6.1 Compute Q = r^-1 (sR - eG) + // Q = r^-1 (sR + -eG) + var rInv = r.modInverse(n); - PrivateKey.prototype.child = function child(offset) { - offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]); - offset = (0, _hash.sha256)(offset); - var c = _bigi2.default.fromBuffer(offset); + var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv); + curve.validate(Q); - if (c.compareTo(n) >= 0) { - throw new Error('Child offset went out of bounds, try again'); - } + return Q; +} - var derived = this.d.add(c); // .mod(n) +/** + * Calculate pubkey extraction parameter. + * + * When extracting a pubkey from a signature, we have to + * distinguish four different cases. Rather than putting this + * burden on the verifier, Bitcoin includes a 2-bit value with the + * signature. + * + * This function simply tries all four cases and returns the value + * that resulted in a successful pubkey recovery. + */ +function calcPubKeyRecoveryParam(curve, e, signature, Q) { + for (var i = 0; i < 4; i++) { + var Qprime = recoverPubKey(curve, e, signature, i); - if (derived.signum() === 0) { - throw new Error('Child offset derived to an invalid key, try again'); + // 1.6.2 Verify Q + if (Qprime.equals(Q)) { + return i; } + } - return new PrivateKey(derived); - }; - - /* */ - - PrivateKey.prototype.toByteBuffer = function toByteBuffer() { - var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); - this.appendByteBuffer(b); - return b.copy(0, b.offset); - }; - - PrivateKey.fromHex = function fromHex(hex) { - return PrivateKey.fromBuffer(Buffer.from(hex, 'hex')); - }; - - PrivateKey.prototype.toHex = function toHex() { - return this.toBuffer().toString('hex'); - }; - - /* */ - - - return PrivateKey; -}(); + throw new Error('Unable to find valid recovery factor'); +} -exports.default = PrivateKey; -module.exports = exports['default']; -}).call(this,require(35).Buffer) +module.exports = { + calcPubKeyRecoveryParam: calcPubKeyRecoveryParam, + deterministicGenerateK: deterministicGenerateK, + recoverPubKey: recoverPubKey, + sign: sign, + verify: verify, + verifyRaw: verifyRaw +}; +}).call(this,require("buffer").Buffer) -},{"11":11,"17":17,"27":27,"32":32,"35":35,"37":37,"54":54,"59":59}],11:[function(require,module,exports){ +},{"./ecsignature":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/ecsignature.js","./enforce_types":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/enforce_types.js","./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/ecsignature.js":[function(require,module,exports){ (function (Buffer){ 'use strict'; -exports.__esModule = true; - -var _bigi = require(32); - -var _bigi2 = _interopRequireDefault(_bigi); +var assert = require('assert'); // from https://github.com/bitcoinjs/bitcoinjs-lib +var enforceType = require('./enforce_types'); -var _ecurve = require(59); +var BigInteger = require('bigi'); -var _bs = require(37); - -var _peerplaysjsWs = require(70); +function ECSignature(r, s) { + enforceType(BigInteger, r); + enforceType(BigInteger, s); -var _assert = require(27); + this.r = r; + this.s = s; +} -var _assert2 = _interopRequireDefault(_assert); +// Import operations +ECSignature.parseCompact = function (buffer) { + assert.equal(buffer.length, 65, 'Invalid signature length'); + var i = buffer.readUInt8(0) - 27; -var _deepEqual = require(54); + // At most 3 bits + assert.equal(i, i & 7, 'Invalid signature parameter'); + var compressed = !!(i & 4); -var _deepEqual2 = _interopRequireDefault(_deepEqual); + // Recovery param only + i = i & 3; -var _hash = require(17); + var r = BigInteger.fromBuffer(buffer.slice(1, 33)); + var s = BigInteger.fromBuffer(buffer.slice(33)); -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + return { + compressed: compressed, + i: i, + signature: new ECSignature(r, s) + }; +}; -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* global ByteBuffer */ +ECSignature.fromDER = function (buffer) { + assert.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence'); + assert.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length'); + assert.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer'); + var rLen = buffer.readUInt8(3); + assert(rLen > 0, 'R length is zero'); -var secp256k1 = (0, _ecurve.getCurveByName)('secp256k1'); + var offset = 4 + rLen; + assert.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)'); -var G = secp256k1.G, - n = secp256k1.n; + var sLen = buffer.readUInt8(offset + 1); + assert(sLen > 0, 'S length is zero'); -var PublicKey = function () { - /** @param {Point} public key */ - function PublicKey(Q) { - _classCallCheck(this, PublicKey); + var rB = buffer.slice(4, offset); + var sB = buffer.slice(offset + 2); + offset += 2 + sLen; - this.Q = Q; + if (rLen > 1 && rB.readUInt8(0) === 0x00) { + assert(rB.readUInt8(1) & 0x80, 'R value excessively padded'); } - PublicKey.fromBinary = function fromBinary(bin) { - return PublicKey.fromBuffer(Buffer.from(bin, 'binary')); - }; - - PublicKey.fromBuffer = function fromBuffer(buffer) { - if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') { - return new PublicKey(null); - } + if (sLen > 1 && sB.readUInt8(0) === 0x00) { + assert(sB.readUInt8(1) & 0x80, 'S value excessively padded'); + } - return new PublicKey(_ecurve.Point.decodeFrom(secp256k1, buffer)); - }; + assert.equal(offset, buffer.length, 'Invalid DER encoding'); + var r = BigInteger.fromDERInteger(rB); + var s = BigInteger.fromDERInteger(sB); - PublicKey.prototype.toBuffer = function toBuffer() { - var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null; + assert(r.signum() >= 0, 'R value is negative'); + assert(s.signum() >= 0, 'S value is negative'); - if (this.Q === null) { - return Buffer.from('000000000000000000000000000000000000000000000000000000000000000000', 'hex'); - } + return new ECSignature(r, s); +}; - return this.Q.getEncoded(compressed); - }; +// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, importing Transaction causes a circular dependency +ECSignature.parseScriptSignature = function (buffer) { + var hashType = buffer.readUInt8(buffer.length - 1); + var hashTypeMod = hashType & ~0x80; - PublicKey.fromPoint = function fromPoint(point) { - return new PublicKey(point); - }; + assert(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType'); - PublicKey.prototype.toUncompressed = function toUncompressed() { - var buf = this.Q.getEncoded(false); - var point = _ecurve.Point.decodeFrom(secp256k1, buf); - return PublicKey.fromPoint(point); + return { + signature: ECSignature.fromDER(buffer.slice(0, -1)), + hashType: hashType }; +}; - /** bts::blockchain::address (unique but not a full public key) */ +// Export operations +ECSignature.prototype.toCompact = function (i, compressed) { + if (compressed) i += 4; + i += 27; + var buffer = new Buffer(65); + buffer.writeUInt8(i, 0); - PublicKey.prototype.toBlockchainAddress = function toBlockchainAddress() { - var pub_buf = this.toBuffer(); - var pub_sha = (0, _hash.sha512)(pub_buf); - return (0, _hash.ripemd160)(pub_sha); - }; + this.r.toBuffer(32).copy(buffer, 1); + this.s.toBuffer(32).copy(buffer, 33); - /** Alias for {@link toPublicKeyString} */ + return buffer; +}; +ECSignature.prototype.toDER = function () { + var rBa = this.r.toDERInteger(); + var sBa = this.s.toDERInteger(); - PublicKey.prototype.toString = function toString() { - var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + var sequence = []; - return this.toPublicKeyString(address_prefix); - }; + // INTEGER + sequence.push(0x02, rBa.length); + sequence = sequence.concat(rBa); - /** - Full public key - {return} string - */ + // INTEGER + sequence.push(0x02, sBa.length); + sequence = sequence.concat(sBa); + // SEQUENCE + sequence.unshift(0x30, sequence.length); - PublicKey.prototype.toPublicKeyString = function toPublicKeyString() { - var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + return new Buffer(sequence); +}; - var pub_buf = this.toBuffer(); - var checksum = (0, _hash.ripemd160)(pub_buf); - // Slice from the buffer directly, slicing from the checksum - // Uint8array will return the entire array each time. - var sliced = new Uint8Array(checksum.buffer.slice(0, 4)); +ECSignature.prototype.toScriptSignature = function (hashType) { + var hashTypeBuffer = new Buffer(1); + hashTypeBuffer.writeUInt8(hashType, 0); - // concat only accepts buffers so initialize the sliced Uint8array as a Buffer. - var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]); - return address_prefix + (0, _bs.encode)(addy); - }; + return Buffer.concat([this.toDER(), hashTypeBuffer]); +}; - /** - @arg {string} public_key - like GPHXyz... - @arg {string} address_prefix - like GPH - @return PublicKey or `null` (if the public_key string is invalid) - */ +module.exports = ECSignature; +}).call(this,require("buffer").Buffer) +},{"./enforce_types":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/enforce_types.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/enforce_types.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; - PublicKey.fromPublicKeyString = function fromPublicKeyString(public_key) { - var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; - - try { - return PublicKey.fromStringOrThrow(public_key, address_prefix); - } catch (e) { - return null; - } - }; - - /** - @arg {string} public_key - like GPHXyz... - @arg {string} address_prefix - like GPH - @throws {Error} if public key is invalid - @return PublicKey - */ - +module.exports = function enforce(type, value) { + // Copied from https://github.com/bitcoinjs/bitcoinjs-lib + switch (type) { + case 'Array': + { + if (Array.isArray(value)) return; + break; + } - PublicKey.fromStringOrThrow = function fromStringOrThrow(public_key) { - var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; + case 'Boolean': + { + if (typeof value === 'boolean') return; + break; + } - var prefix = public_key.slice(0, address_prefix.length); - _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); - public_key = public_key.slice(address_prefix.length); + case 'Buffer': + { + if (Buffer.isBuffer(value)) return; + break; + } - public_key = Buffer.from((0, _bs.decode)(public_key), 'binary'); - var checksum = public_key.slice(-4); - public_key = public_key.slice(0, -4); - var new_checksum = (0, _hash.ripemd160)(public_key); - new_checksum = new_checksum.slice(0, 4); - var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum' + case 'Number': + { + if (typeof value === 'number') return; + break; + } - if (!isEqual) { - throw new Error('Checksum did not match'); - } + case 'String': + { + if (typeof value === 'string') return; + break; + } - return PublicKey.fromBuffer(public_key); - }; + default: + { + if (getName(value.constructor) === getName(type)) return; + } + } - PublicKey.prototype.toAddressString = function toAddressString() { - var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; + throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value); +}; - var pub_buf = this.toBuffer(); - var pub_sha = (0, _hash.sha512)(pub_buf); - var addy = (0, _hash.ripemd160)(pub_sha); - var checksum = (0, _hash.ripemd160)(addy); - addy = Buffer.concat([addy, checksum.slice(0, 4)]); - return address_prefix + (0, _bs.encode)(addy); - }; +function getName(fn) { + // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property + var match = fn.toString().match(/function (.*?)\(/); + return match ? match[1] : null; +} +}).call(this,{"isBuffer":require("../../../node_modules/is-buffer/index.js")}) - PublicKey.prototype.toPtsAddy = function toPtsAddy() { - var pub_buf = this.toBuffer(); - var pub_sha = (0, _hash.sha256)(pub_buf); - var addy = (0, _hash.ripemd160)(pub_sha); - addy = Buffer.concat([Buffer.from([0x38]), addy]); // version 56(decimal) +},{"../../../node_modules/is-buffer/index.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/is-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js":[function(require,module,exports){ +"use strict"; - var checksum = (0, _hash.sha256)(addy); - checksum = (0, _hash.sha256)(checksum); +var createHash = require("create-hash"); +var createHmac = require("create-hmac"); - addy = Buffer.concat([addy, checksum.slice(0, 4)]); - return (0, _bs.encode)(addy); - }; +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha1(data, encoding) { + return createHash('sha1').update(data).digest(encoding); +} - PublicKey.prototype.child = function child(offset) { - (0, _assert2.default)(Buffer.isBuffer(offset), 'Buffer required: offset'); - _assert2.default.equal(offset.length, 32, 'offset length'); +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha256(data, encoding) { + return createHash('sha256').update(data).digest(encoding); +} - offset = Buffer.concat([this.toBuffer(), offset]); - offset = (0, _hash.sha256)(offset); +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha512(data, encoding) { + return createHash('sha512').update(data).digest(encoding); +} - var c = _bigi2.default.fromBuffer(offset); +function HmacSHA256(buffer, secret) { + return createHmac('sha256', secret).update(buffer).digest(); +} - if (c.compareTo(n) >= 0) { - throw new Error('Child offset went out of bounds, try again'); - } +function ripemd160(data) { + return createHash('rmd160').update(data).digest(); +} - var cG = G.multiply(c); - var Qprime = this.Q.add(cG); +// function hash160(buffer) { +// return ripemd160(sha256(buffer)) +// } +// +// function hash256(buffer) { +// return sha256(sha256(buffer)) +// } - if (secp256k1.isInfinity(Qprime)) { - throw new Error('Child offset derived to an invalid key, try again'); - } +// +// function HmacSHA512(buffer, secret) { +// return crypto.createHmac('sha512', secret).update(buffer).digest() +// } - return PublicKey.fromPoint(Qprime); - }; +module.exports = { + sha1: sha1, + sha256: sha256, + sha512: sha512, + HmacSHA256: HmacSHA256, + ripemd160: ripemd160 + // hash160: hash160, + // hash256: hash256, + // HmacSHA512: HmacSHA512 +}; +},{"create-hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hash/browser.js","create-hmac":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hmac/browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/signature.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; - /* */ +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - PublicKey.prototype.toByteBuffer = function toByteBuffer() { - var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); - this.appendByteBuffer(b); - return b.copy(0, b.offset); - }; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - PublicKey.fromHex = function fromHex(hex) { - return PublicKey.fromBuffer(Buffer.from(hex, 'hex')); - }; +var ecdsa = require('./ecdsa'); +var hash = require('./hash'); - PublicKey.prototype.toHex = function toHex() { - return this.toBuffer().toString('hex'); - }; +var _require = require('ecurve'), + getCurveByName = _require.getCurveByName; - PublicKey.fromPublicKeyStringHex = function fromPublicKeyStringHex(hex) { - return PublicKey.fromPublicKeyString(Buffer.from(hex, 'hex')); - }; +var secp256k1 = getCurveByName('secp256k1'); +var assert = require('assert'); +var BigInteger = require('bigi'); +var PublicKey = require('./PublicKey'); - /* */ +var Signature = function () { + function Signature(r1, s1, i1) { + _classCallCheck(this, Signature); + + this.r = r1; + this.s = s1; + this.i = i1; + assert.equal(this.r != null, true, 'Missing parameter'); + assert.equal(this.s != null, true, 'Missing parameter'); + assert.equal(this.i != null, true, 'Missing parameter'); + } + + _createClass(Signature, [{ + key: 'toBuffer', + value: function toBuffer() { + var buf; + buf = new Buffer(65); + buf.writeUInt8(this.i, 0); + this.r.toBuffer(32).copy(buf, 1); + this.s.toBuffer(32).copy(buf, 33); + return buf; + } + }, { + key: 'recoverPublicKeyFromBuffer', + value: function recoverPublicKeyFromBuffer(buffer) { + return this.recoverPublicKey(hash.sha256(buffer)); + } + }, { + key: 'recoverPublicKey', - return PublicKey; -}(); + /** + @return {PublicKey} + */ + value: function recoverPublicKey(sha256_buffer) { + var Q = void 0, + e = void 0, + i = void 0; + e = BigInteger.fromBuffer(sha256_buffer); + i = this.i; + i -= 27; + i = i & 3; + Q = ecdsa.recoverPubKey(secp256k1, e, this, i); + return PublicKey.fromPoint(Q); + } + }, { + key: 'verifyBuffer', -exports.default = PublicKey; -module.exports = exports['default']; -}).call(this,require(35).Buffer) -},{"17":17,"27":27,"32":32,"35":35,"37":37,"54":54,"59":59,"70":70}],12:[function(require,module,exports){ -(function (Buffer){ -'use strict'; + /** + @param {Buffer} un-hashed + @param {./PublicKey} + @return {boolean} + */ + value: function verifyBuffer(buf, public_key) { + var _hash = hash.sha256(buf); + return this.verifyHash(_hash, public_key); + } + }, { + key: 'verifyHash', + value: function verifyHash(hash, public_key) { + assert.equal(hash.length, 32, "A SHA 256 should be 32 bytes long, instead got " + hash.length); + return ecdsa.verify(secp256k1, hash, { + r: this.r, + s: this.s + }, public_key.Q); + } + }, { + key: 'toByteBuffer', -exports.__esModule = true; -var _assert = require(27); + /* */ -var _assert2 = _interopRequireDefault(_assert); + value: function toByteBuffer() { + var b; + b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + } + }, { + key: 'toHex', + value: function toHex() { + return this.toBuffer().toString("hex"); + } + }, { + key: 'verifyHex', + value: function verifyHex(hex, public_key) { + var buf; + buf = new Buffer(hex, 'hex'); + return this.verifyBuffer(buf, public_key); + } + }], [{ + key: 'fromBuffer', + value: function fromBuffer(buf) { + var i, r, s; + assert.equal(buf.length, 65, 'Invalid signature length'); + i = buf.readUInt8(0); + assert.equal(i - 27, i - 27 & 7, 'Invalid signature parameter'); + r = BigInteger.fromBuffer(buf.slice(1, 33)); + s = BigInteger.fromBuffer(buf.slice(33)); + return new Signature(r, s, i); + } + }, { + key: 'signBuffer', -var _peerplaysjsWs = require(70); -var _bs = require(37); + /** + @param {Buffer} buf + @param {PrivateKey} private_key + @return {Signature} + */ + value: function signBuffer(buf, private_key) { + var _hash = hash.sha256(buf); + return Signature.signBufferSha256(_hash, private_key); + } -var _deepEqual = require(54); + /** Sign a buffer of exactally 32 bytes in size (sha256(text)) + @param {Buffer} buf - 32 bytes binary + @param {PrivateKey} private_key + @return {Signature} + */ -var _deepEqual2 = _interopRequireDefault(_deepEqual); + }, { + key: 'signBufferSha256', + value: function signBufferSha256(buf_sha256, private_key) { + if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error("buf_sha256: 32 byte buffer requred"); + var der, e, ecsignature, i, lenR, lenS, nonce; + i = null; + nonce = 0; + e = BigInteger.fromBuffer(buf_sha256); + while (true) { + ecsignature = ecdsa.sign(secp256k1, buf_sha256, private_key.d, nonce++); + der = ecsignature.toDER(); + lenR = der[3]; + lenS = der[5 + lenR]; + if (lenR === 32 && lenS === 32) { + i = ecdsa.calcPubKeyRecoveryParam(secp256k1, e, ecsignature, private_key.toPublicKey().Q); + i += 4; // compressed + i += 27; // compact // 24 or 27 :( forcing odd-y 2nd key candidate) + break; + } + if (nonce % 10 === 0) { + console.log("WARN: " + nonce + " attempts to find canonical signature"); + } + } + return new Signature(ecsignature.r, ecsignature.s, i); + } + }, { + key: 'sign', + value: function sign(string, private_key) { + return Signature.signBuffer(new Buffer(string), private_key); + } + }, { + key: 'fromHex', + value: function fromHex(hex) { + return Signature.fromBuffer(new Buffer(hex, "hex")); + } + }, { + key: 'signHex', + value: function signHex(hex, private_key) { + var buf; + buf = new Buffer(hex, 'hex'); + return Signature.signBuffer(buf, private_key); + } + }]); -var _hash2 = require(17); + return Signature; +}(); -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +module.exports = Signature; +}).call(this,require("buffer").Buffer) -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +},{"./PublicKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js","./ecdsa":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/ecdsa.js","./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/hash.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","ecurve":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/index.js":[function(require,module,exports){ +'use strict'; -/** Addresses are shortened non-reversable hashes of a public key. The full PublicKey is preferred. - @deprecated -*/ -var Address = function () { - function Address(addy) { - _classCallCheck(this, Address); +module.exports = { - this.addy = addy; - } + // Primary class for creating operations + Serializer: require('./src/serializer'), - Address.fromBuffer = function fromBuffer(buffer) { - var _hash = (0, _hash2.sha512)(buffer); - var addy = (0, _hash2.ripemd160)(_hash); - return new Address(addy); - }; + // helper functions for creating operations + fp: require('./src/FastParser'), - Address.fromString = function fromString(string) { - var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix; - - var prefix = string.slice(0, address_prefix.length); - _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); - var addy = string.slice(address_prefix.length); - addy = Buffer.from((0, _bs.decode)(addy), 'binary'); - var checksum = addy.slice(-4); - addy = addy.slice(0, -4); - var new_checksum = (0, _hash2.ripemd160)(addy); - new_checksum = new_checksum.slice(0, 4); - var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum' - - if (!isEqual) { - throw new Error('Checksum did not match'); - } + // Low level types + types: require('./src/types'), - return new Address(addy); - }; + // Higher level operations (made out of generic types) + ops: require('./src/operations'), - /** @return Address - Compressed PTS format (by default) */ + // Utility that generates JSON examples + template: require('./src/template'), + // Serializer validation + SerializerValidation: require('./src/SerializerValidation') +}; +},{"./src/FastParser":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/FastParser.js","./src/SerializerValidation":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/SerializerValidation.js","./src/operations":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/operations.js","./src/serializer":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/serializer.js","./src/template":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/template.js","./src/types":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/types.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/FastParser.js":[function(require,module,exports){ +(function (Buffer){ +'use strict'; - Address.fromPublic = function fromPublic(public_key) { - var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; - var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56; +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - var sha2 = (0, _hash2.sha256)(public_key.toBuffer(compressed)); - var rep = (0, _hash2.ripemd160)(sha2); - var versionBuffer = Buffer.alloc(1); - versionBuffer.writeUInt8(0xff & version, 0); // eslint-disable-line - var addr = Buffer.concat([versionBuffer, rep]); - var check = (0, _hash2.sha256)(addr); - check = (0, _hash2.sha256)(check); - var buffer = Buffer.concat([addr, check.slice(0, 4)]); - return new Address((0, _hash2.ripemd160)(buffer)); - }; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - Address.prototype.toBuffer = function toBuffer() { - return this.addy; - }; +var PublicKey = require("../../ecc/src/PublicKey"); - Address.prototype.toString = function toString() { - var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix; +var FastParser = function () { + function FastParser() { + _classCallCheck(this, FastParser); + } - var checksum = (0, _hash2.ripemd160)(this.addy); - var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]); - return address_prefix + (0, _bs.encode)(addy); - }; + _createClass(FastParser, null, [{ + key: 'fixed_data', + value: function fixed_data(b, len, buffer) { + if (!b) { + return; + } + if (buffer) { + var data = buffer.slice(0, len).toString('binary'); + b.append(data, 'binary'); + while (len-- > data.length) { + b.writeUint8(0); + } + } else { + var b_copy = b.copy(b.offset, b.offset + len); + b.skip(len); + return new Buffer(b_copy.toBinary(), 'binary'); + } + } + }, { + key: 'public_key', + value: function public_key(b, _public_key) { + if (!b) { + return; + } + if (_public_key) { + var buffer = _public_key.toBuffer(); + b.append(buffer.toString('binary'), 'binary'); + return; + } else { + buffer = FastParser.fixed_data(b, 33); + return PublicKey.fromBuffer(buffer); + } + } + }, { + key: 'ripemd160', + value: function ripemd160(b, _ripemd) { + if (!b) { + return; + } + if (_ripemd) { + FastParser.fixed_data(b, 20, _ripemd); + return; + } else { + return FastParser.fixed_data(b, 20); + } + } + }, { + key: 'sha256', + value: function sha256(b, _sha) { + if (!b) { + return; + } + if (_sha) { + FastParser.fixed_data(b, 32, _sha); + return; + } else { + return FastParser.fixed_data(b, 32); + } + } + }, { + key: 'time_point_sec', + value: function time_point_sec(b, epoch) { + if (epoch) { + epoch = Math.ceil(epoch / 1000); + b.writeInt32(epoch); + return; + } else { + epoch = b.readInt32(); // fc::time_point_sec + return new Date(epoch * 1000); + } + } + }]); - return Address; + return FastParser; }(); -exports.default = Address; -module.exports = exports['default']; -}).call(this,require(35).Buffer) +module.exports = FastParser; +}).call(this,require("buffer").Buffer) -},{"17":17,"27":27,"35":35,"37":37,"54":54,"70":70}],13:[function(require,module,exports){ -(function (Buffer){ +},{"../../ecc/src/PublicKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/SerializerValidation.js":[function(require,module,exports){ 'use strict'; -exports.__esModule = true; +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; -var _aes = require(45); +var _require = require('bytebuffer'), + Long = _require.Long; -var _aes2 = _interopRequireDefault(_aes); +var ChainTypes = require('../../chain/src/ChainTypes'); -var _encHex = require(49); +var MAX_SAFE_INT = 9007199254740991; +var MIN_SAFE_INT = -9007199254740991; -var _encHex2 = _interopRequireDefault(_encHex); +/** + Most validations are skipped and the value returned unchanged when an empty string, null, or undefined is encountered (except "required"). -var _encBase = require(48); + Validations support a string format for dealing with large numbers. +*/ +var _my = { -var _encBase2 = _interopRequireDefault(_encBase); + is_empty: function is_empty(value) { + return value === null || value === undefined; + }, -var _assert = require(27); + required: function required(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; -var _assert2 = _interopRequireDefault(_assert); + if (this.is_empty(value)) { + throw new Error('value required ' + field_name + ' ' + value); + } + return value; + }, + require_long: function require_long(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; -var _hash2 = require(17); + if (!Long.isLong(value)) { + throw new Error('Long value required ' + field_name + ' ' + value); + } + return value; + }, + string: function string(value) { + if (this.is_empty(value)) { + return value; + } + if (typeof value !== "string") { + throw new Error('string required: ' + value); + } + return value; + }, + number: function number(value) { + if (this.is_empty(value)) { + return value; + } + if (typeof value !== "number") { + throw new Error('number required: ' + value); + } + return value; + }, + whole_number: function whole_number(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + if (this.is_empty(value)) { + return value; + } + if (/\./.test(value)) { + throw new Error('whole number required ' + field_name + ' ' + value); + } + return value; + }, + unsigned: function unsigned(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // https://code.google.com/p/crypto-js + if (this.is_empty(value)) { + return value; + } + if (/-/.test(value)) { + throw new Error('unsigned required ' + field_name + ' ' + value); + } + return value; + }, -/** Provides symetric encrypt and decrypt via AES. */ -var Aes = function () { - /** @private */ - function Aes(iv, key) { - _classCallCheck(this, Aes); + is_digits: function is_digits(value) { + if (typeof value === "numeric") { + return true; + } + return (/^[0-9]+$/.test(value) + ); + }, - this.iv = iv; - this.key = key; - } + to_number: function to_number(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; - /** This is an excellent way to ensure that all references to Aes can not operate anymore - * (example: a wallet becomes locked). An application should ensure there is only one - * Aes object instance for a given secret `seed`. */ + if (this.is_empty(value)) { + return value; + } + this.no_overflow53(value, field_name); + var int_value = function () { + if (typeof value === "number") { + return value; + } else { + return parseInt(value); + } + }(); + return int_value; + }, + to_long: function to_long(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; - Aes.prototype.clear = function clear() { - this.iv = undefined; - this.key = undefined; - return undefined; - }; + if (this.is_empty(value)) { + return value; + } + if (Long.isLong(value)) { + return value; + } - /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */ + this.no_overflow64(value, field_name); + if (typeof value === "number") { + value = "" + value; + } + return Long.fromString(value); + }, + to_ulong: function to_ulong(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + if (this.is_empty(value)) { + return value; + } + if (Long.isLong(value)) { + return value; + } - Aes.fromSeed = function fromSeed(seed) { - if (seed === undefined) { - throw new Error('seed is required'); - } + this.no_overflow64(value, field_name, true); + if (typeof value === "number") { + value = "" + value; + } + return Long.fromString(value, true); + }, + to_string: function to_string(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; - var _hash = (0, _hash2.sha512)(seed); - _hash = _hash.toString('hex'); - // DEBUG console.log('... fromSeed _hash',_hash) - return Aes.fromSha512(_hash); - }; + if (this.is_empty(value)) { + return value; + } + if (typeof value === "string") { + return value; + } + if (typeof value === "number") { + this.no_overflow53(value, field_name); + return "" + value; + } + if (Long.isLong(value)) { + return value.toString(); + } + throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value; + }, + require_test: function require_test(regex, value) { + var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; - /** @arg {string} hash - A 128 byte hex string, typically one - * would call {@link fromSeed} instead. */ + if (this.is_empty(value)) { + return value; + } + if (!regex.test(value)) { + throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); + } + return value; + }, - Aes.fromSha512 = function fromSha512(hash) { - _assert2.default.equal(hash.length, 128, 'A Sha512 in HEX should be 128 characters long, instead got ' + hash.length); - var iv = _encHex2.default.parse(hash.substring(64, 96)); - var key = _encHex2.default.parse(hash.substring(0, 64)); - return new Aes(iv, key); - }; + require_match: function require_match(regex, value) { + var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; - Aes.fromBuffer = function fromBuffer(buf) { - (0, _assert2.default)(Buffer.isBuffer(buf), 'Expecting Buffer'); - _assert2.default.equal(buf.length, 64, 'A Sha512 Buffer should be 64 characters long, instead got ' + buf.length); - return Aes.fromSha512(buf.toString('hex')); - }; + if (this.is_empty(value)) { + return value; + } + var match = value.match(regex); + if (match === null) { + throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); + } + return match; + }, - /** - @throws {Error} - "Invalid Key, ..." - @arg {PrivateKey} private_key - required and used for decryption - @arg {PublicKey} public_key - required and used to calcualte the shared secret - @arg {string} [nonce = ""] optional but should always be provided and be unique - when re-using the same private/public keys more than once. This nonce is not a secret. - @arg {string|Buffer} message - Encrypted message containing a checksum - @return {Buffer} - */ + require_object_id: function require_object_id(value, field_name) { + return require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, value, field_name); + }, + // Does not support over 53 bits + require_range: function require_range(min, max, value) { + var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ""; - Aes.decrypt_with_checksum = function decrypt_with_checksum(private_key, public_key, nonce, message) { - var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + if (this.is_empty(value)) { + return value; + } + var number = this.to_number(value); + if (value < min || value > max) { + throw new Error('out of range ' + value + ' ' + field_name + ' ' + value); + } + return value; + }, - // Warning: Do not put `nonce = ""` in the arguments, in es6 this will - // not convert "null" into an emtpy string - if (nonce == null) { - nonce = ''; - } - if (!Buffer.isBuffer(message)) { - message = Buffer.from(message, 'hex'); - } + require_object_type: function require_object_type() { + var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var type = arguments[1]; + var value = arguments[2]; + var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ""; - var S = private_key.get_shared_secret(public_key, legacy); - // D E B U G - // console.log('decrypt_with_checksum', { - // priv_to_pub: private_key.toPublicKey().toString(), - // pub: public_key.toPublicKeyString(), - // nonce: nonce, - // message: message.length, - // S: S.toString('hex') - // }) + if (this.is_empty(value)) { + return value; + } + var object_type = ChainTypes.object_type[type]; + if (!object_type) { + throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value); + } + var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$'); + if (!re.test(value)) { + throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value)); + } + return value; + }, - var aes = Aes.fromSeed(Buffer.concat([ - // A null or empty string nonce will not effect the hash - Buffer.from('' + nonce), Buffer.from(S.toString('hex'))])); + get_instance: function get_instance(reserve_spaces, type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(reserve_spaces, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, - var planebuffer = aes.decrypt(message); + require_relative_type: function require_relative_type(type, value, field_name) { + this.require_object_type(0, type, value, field_name); + return value; + }, - if (!(planebuffer.length >= 4)) { - throw new Error('Invalid key, could not decrypt message(1)'); - } + get_relative_instance: function get_relative_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(0, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, - // DEBUG console.log('... planebuffer',planebuffer) - var checksum = planebuffer.slice(0, 4); - var plaintext = planebuffer.slice(4); + require_protocol_type: function require_protocol_type(type, value, field_name) { + this.require_object_type(1, type, value, field_name); + return value; + }, - // console.log('... checksum',checksum.toString('hex')) - // console.log('... plaintext',plaintext.toString()) + get_protocol_instance: function get_protocol_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(1, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, - var new_checksum = (0, _hash2.sha256)(plaintext); - new_checksum = new_checksum.slice(0, 4); - new_checksum = new_checksum.toString('hex'); + get_protocol_type: function get_protocol_type(value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_id(value, field_name); + var values = value.split('.'); + return this.to_number(values[1]); + }, - if (!(checksum.toString('hex') === new_checksum)) { - throw new Error('Invalid key, could not decrypt message(2)'); - } + get_protocol_type_name: function get_protocol_type_name(value, field_name) { + if (this.is_empty(value)) { + return value; + } + var type_id = this.get_protocol_type(value, field_name); + return Object.keys(ChainTypes.object_type)[type_id]; + }, - return plaintext; - }; - /** Identical to {@link decrypt_with_checksum} but used to encrypt. Should not throw an error. - @return {Buffer} message - Encrypted message which includes a checksum - */ + require_implementation_type: function require_implementation_type(type, value, field_name) { + this.require_object_type(2, type, value, field_name); + return value; + }, + get_implementation_instance: function get_implementation_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(2, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, - Aes.encrypt_with_checksum = function encrypt_with_checksum(private_key, public_key, nonce, message) { - // Warning: Do not put `nonce = ""` in the arguments, in es6 this will - // not convert "null" into an emtpy string + // signed / unsigned decimal + no_overflow53: function no_overflow53(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; - if (nonce == null) { - nonce = ''; - } + if (typeof value === "number") { + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + if (typeof value === "string") { + var int = parseInt(value); + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + if (Long.isLong(value)) { + // typeof value.toInt() is 'number' + this.no_overflow53(value.toInt(), field_name); + return; + } + throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value; + }, - if (!Buffer.isBuffer(message)) { - message = Buffer.from(message, 'binary'); - } - var S = private_key.get_shared_secret(public_key); - - // D E B U G - // console.log('encrypt_with_checksum', { - // priv_to_pub: private_key.toPublicKey().toString() - // pub: public_key.toPublicKeyString() - // nonce: nonce - // message: message.length - // S: S.toString('hex') - // }) - - var aes = Aes.fromSeed(Buffer.concat([ - // A null or empty string nonce will not effect the hash - Buffer.from('' + nonce), Buffer.from(S.toString('hex'))])); - // DEBUG console.log('... S',S.toString('hex')) - var checksum = (0, _hash2.sha256)(message).slice(0, 4); - var payload = Buffer.concat([checksum, message]); - // DEBUG console.log('... payload',payload.toString()) - return aes.encrypt(payload); - }; + // signed / unsigned whole numbers only + no_overflow64: function no_overflow64(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - /** @private */ + // https://github.com/dcodeIO/Long.js/issues/20 + if (Long.isLong(value)) { + return; + } + // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20 + if (value.t !== undefined && value.s !== undefined) { + this.no_overflow64(value.toString(), field_name, unsigned); - Aes.prototype._decrypt_word_array = function _decrypt_word_array(cipher) { - // https://code.google.com/p/crypto-js/#Custom_Key_and_IV - // see wallet_records.cpp master_key::decrypt_key - return _aes2.default.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv }); - }; + return; + } - /** @private */ + if (typeof value === "string") { + // remove leading zeros, will cause a false positive + value = value.replace(/^0+/, ''); + // remove trailing zeros + while (/0$/.test(value)) { + value = value.substring(0, value.length - 1); + } + if (/\.$/.test(value)) { + // remove trailing dot + value = value.substring(0, value.length - 1); + } + if (value === "") { + value = "0"; + } + var long_string = Long.fromString(value, unsigned).toString(); - Aes.prototype._encrypt_word_array = function _encrypt_word_array(plaintext) { - // https://code.google.com/p/crypto-js/issues/detail?id=85 - var cipher = _aes2.default.encrypt(plaintext, this.key, { iv: this.iv }); - return _encBase2.default.parse(cipher.toString()); - }; + if (long_string !== value.trim()) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + if (typeof value === "number") { + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string} ciphertext - @return {Buffer} binary - */ + throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value; + } +}; +module.exports = _my; +},{"../../chain/src/ChainTypes":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/chain/src/ChainTypes.js","bytebuffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bytebuffer/dist/bytebuffer.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/error_with_cause.js":[function(require,module,exports){ +"use strict"; - Aes.prototype.decrypt = function decrypt(ciphertext) { - if (typeof ciphertext === 'string') { - ciphertext = Buffer.from(ciphertext, 'binary'); - } +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - if (!Buffer.isBuffer(ciphertext)) { - throw new Error('buffer required'); - } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - (0, _assert2.default)(ciphertext, 'Missing cipher text'); - // hex is the only common format - var hex = this.decryptHex(ciphertext.toString('hex')); - return Buffer.from(hex, 'hex'); - }; +/** Exception nesting. */ +var ErrorWithCause = function () { + function ErrorWithCause(message, cause) { + _classCallCheck(this, ErrorWithCause); - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string} plaintext - @return {Buffer} binary - */ + this.message = message; + if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) { + this.message = "cause\t" + cause.message + "\t" + this.message; + } + var stack = ""; //(new Error).stack + if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) { + stack = "caused by\n\t" + cause.stack + "\t" + stack; + } - Aes.prototype.encrypt = function encrypt(plaintext) { - if (typeof plaintext === 'string') { - plaintext = Buffer.from(plaintext, 'binary'); + this.stack = this.message + "\n" + stack; } - if (!Buffer.isBuffer(plaintext)) { - throw new Error('buffer required'); - } + _createClass(ErrorWithCause, null, [{ + key: "throw", + value: function _throw(message, cause) { + var msg = message; + if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) { + msg += "\t cause: " + cause.message + " "; + } + if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) { + msg += "\n stack: " + cause.stack + " "; + } + throw new Error(msg); + } + }]); - // assert plaintext, "Missing plain text" - // hex is the only common format - var hex = this.encryptHex(plaintext.toString('hex')); - return Buffer.from(hex, 'hex'); - }; + return ErrorWithCause; +}(); - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string|Buffer} plaintext - @return {string} hex - */ +module.exports = ErrorWithCause; +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/operations.js":[function(require,module,exports){ +"use strict"; +var types = require("./types"); +var SerializerImpl = require("./serializer"); + +var uint8 = types.uint8, + uint16 = types.uint16, + uint32 = types.uint32, + int64 = types.int64, + uint64 = types.uint64, + string = types.string, + bytes = types.bytes, + bool = types.bool, + array = types.array, + fixed_array = types.fixed_array, + protocol_id_type = types.protocol_id_type, + object_id_type = types.object_id_type, + vote_id = types.vote_id, + future_extensions = types.future_extensions, + static_variant = types.static_variant, + map = types.map, + set = types.set, + public_key = types.public_key, + address = types.address, + time_point_sec = types.time_point_sec, + optional = types.optional, + variant = types.variant, + variant_object = types.variant_object, + enumeration = types.enumeration, + sha256 = types.sha256; + + +future_extensions = types.void; - Aes.prototype.encryptToHex = function encryptToHex(plaintext) { - if (typeof plaintext === 'string') { - plaintext = Buffer.from(plaintext, 'binary'); - } +/* +When updating generated code +Replace: operation = static_variant [ +with: operation.st_operations = [ - if (!Buffer.isBuffer(plaintext)) { - throw new Error('buffer required'); - } +Delete: +public_key = new Serializer( + "public_key" + key_data: bytes 33 +) - // assert plaintext, "Missing plain text" - // hex is the only common format - return this.encryptHex(plaintext.toString('hex')); - }; +*/ +// Place-holder, their are dependencies on "operation" .. The final list of +// operations is not avialble until the very end of the generated code. +// See: operation.st_operations = ... +var operation = static_variant(); +module.exports["operation"] = operation; - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string} cipher - hex - @return {string} binary (could easily be readable text) - */ +// For module.exports +var Serializer = function Serializer(operation_name, serilization_types_object) { + var s = new SerializerImpl(operation_name, serilization_types_object); + return module.exports[operation_name] = s; +}; +// Custom-types follow Generated code: - Aes.prototype.decryptHex = function decryptHex(cipher) { - (0, _assert2.default)(cipher, 'Missing cipher text'); - // Convert data into word arrays (used by Crypto) - var cipher_array = _encHex2.default.parse(cipher); - var plainwords = this._decrypt_word_array(cipher_array); - return _encHex2.default.stringify(plainwords); - }; +// ## Generated code follows +// # programs/js_operation_serializer > npm i -g decaffeinate +// ## ------------------------------- +var transfer_operation_fee_parameters = new Serializer("transfer_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string} cipher - hex - @return {Buffer} encoded as specified by the parameter - */ +var limit_order_create_operation_fee_parameters = new Serializer("limit_order_create_operation_fee_parameters", { fee: uint64 }); +var limit_order_cancel_operation_fee_parameters = new Serializer("limit_order_cancel_operation_fee_parameters", { fee: uint64 }); - Aes.prototype.decryptHexToBuffer = function decryptHexToBuffer(cipher) { - (0, _assert2.default)(cipher, 'Missing cipher text'); - // Convert data into word arrays (used by Crypto) - var cipher_array = _encHex2.default.parse(cipher); - var plainwords = this._decrypt_word_array(cipher_array); - var plainhex = _encHex2.default.stringify(plainwords); - return Buffer.from(plainhex, 'hex'); - }; +var call_order_update_operation_fee_parameters = new Serializer("call_order_update_operation_fee_parameters", { fee: uint64 }); - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string} cipher - hex - @arg {string} [encoding = 'binary'] - a valid Buffer encoding - @return {String} encoded as specified by the parameter - */ +var fill_order_operation_fee_parameters = new Serializer("fill_order_operation_fee_parameters"); +var account_create_operation_fee_parameters = new Serializer("account_create_operation_fee_parameters", { basic_fee: uint64, + premium_fee: uint64, + price_per_kbyte: uint32 }); - Aes.prototype.decryptHexToText = function decryptHexToText(cipher) { - var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary'; +var account_update_operation_fee_parameters = new Serializer("account_update_operation_fee_parameters", { fee: int64, + price_per_kbyte: uint32 }); - return this.decryptHexToBuffer(cipher).toString(encoding); - }; +var account_whitelist_operation_fee_parameters = new Serializer("account_whitelist_operation_fee_parameters", { fee: int64 }); - /** This method does not use a checksum, the returned data must be validated some other way. - @arg {string} plainhex - hex format - @return {String} hex - */ +var account_upgrade_operation_fee_parameters = new Serializer("account_upgrade_operation_fee_parameters", { membership_annual_fee: uint64, + membership_lifetime_fee: uint64 }); +var account_transfer_operation_fee_parameters = new Serializer("account_transfer_operation_fee_parameters", { fee: uint64 }); - Aes.prototype.encryptHex = function encryptHex(plainhex) { - var plain_array = _encHex2.default.parse(plainhex); - var cipher_array = this._encrypt_word_array(plain_array); - return _encHex2.default.stringify(cipher_array); - }; +var asset_create_operation_fee_parameters = new Serializer("asset_create_operation_fee_parameters", { symbol3: uint64, + symbol4: uint64, + long_symbol: uint64, + price_per_kbyte: uint32 }); - return Aes; -}(); +var asset_update_operation_fee_parameters = new Serializer("asset_update_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); -exports.default = Aes; -module.exports = exports['default']; -}).call(this,require(35).Buffer) +var asset_update_bitasset_operation_fee_parameters = new Serializer("asset_update_bitasset_operation_fee_parameters", { fee: uint64 }); -},{"17":17,"27":27,"35":35,"45":45,"48":48,"49":49}],14:[function(require,module,exports){ -(function (Buffer){ -'use strict'; +var asset_update_feed_producers_operation_fee_parameters = new Serializer("asset_update_feed_producers_operation_fee_parameters", { fee: uint64 }); -exports.__esModule = true; -exports.verifyRaw = exports.verify = exports.sign = exports.recoverPubKey = exports.deterministicGenerateK = exports.calcPubKeyRecoveryParam = undefined; +var asset_issue_operation_fee_parameters = new Serializer("asset_issue_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); -var _assert = require(27); +var asset_reserve_operation_fee_parameters = new Serializer("asset_reserve_operation_fee_parameters", { fee: uint64 }); -var _assert2 = _interopRequireDefault(_assert); +var asset_fund_fee_pool_operation_fee_parameters = new Serializer("asset_fund_fee_pool_operation_fee_parameters", { fee: uint64 }); -var _bigi = require(32); +var asset_settle_operation_fee_parameters = new Serializer("asset_settle_operation_fee_parameters", { fee: uint64 }); -var _bigi2 = _interopRequireDefault(_bigi); +var asset_global_settle_operation_fee_parameters = new Serializer("asset_global_settle_operation_fee_parameters", { fee: uint64 }); -var _hash = require(17); +var asset_publish_feed_operation_fee_parameters = new Serializer("asset_publish_feed_operation_fee_parameters", { fee: uint64 }); -var _enforce_types = require(16); +var witness_create_operation_fee_parameters = new Serializer("witness_create_operation_fee_parameters", { fee: uint64 }); -var _enforce_types2 = _interopRequireDefault(_enforce_types); +var witness_update_operation_fee_parameters = new Serializer("witness_update_operation_fee_parameters", { fee: int64 }); -var _ecsignature = require(15); +var proposal_create_operation_fee_parameters = new Serializer("proposal_create_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); -var _ecsignature2 = _interopRequireDefault(_ecsignature); +var proposal_update_operation_fee_parameters = new Serializer("proposal_update_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +var proposal_delete_operation_fee_parameters = new Serializer("proposal_delete_operation_fee_parameters", { fee: uint64 }); -// https://tools.ietf.org/html/rfc6979#section-3.2 +var withdraw_permission_create_operation_fee_parameters = new Serializer("withdraw_permission_create_operation_fee_parameters", { fee: uint64 }); -// from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa -function deterministicGenerateK(curve, hash, d, checkSig, nonce) { - (0, _enforce_types2.default)('Buffer', hash); - (0, _enforce_types2.default)(_bigi2.default, d); +var withdraw_permission_update_operation_fee_parameters = new Serializer("withdraw_permission_update_operation_fee_parameters", { fee: uint64 }); - if (nonce) { - hash = (0, _hash.sha256)(Buffer.concat([hash, Buffer.alloc(nonce)])); - } +var withdraw_permission_claim_operation_fee_parameters = new Serializer("withdraw_permission_claim_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); - // sanity check - _assert2.default.equal(hash.length, 32, 'Hash must be 256 bit'); +var withdraw_permission_delete_operation_fee_parameters = new Serializer("withdraw_permission_delete_operation_fee_parameters", { fee: uint64 }); - var x = d.toBuffer(32); - var k = Buffer.alloc(32); - var v = Buffer.alloc(32); +var committee_member_create_operation_fee_parameters = new Serializer("committee_member_create_operation_fee_parameters", { fee: uint64 }); - // Step B - v.fill(1); +var committee_member_update_operation_fee_parameters = new Serializer("committee_member_update_operation_fee_parameters", { fee: uint64 }); - // Step C - k.fill(0); +var committee_member_update_global_parameters_operation_fee_parameters = new Serializer("committee_member_update_global_parameters_operation_fee_parameters", { fee: uint64 }); - // Step D - k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0]), x, hash]), k); +var vesting_balance_create_operation_fee_parameters = new Serializer("vesting_balance_create_operation_fee_parameters", { fee: uint64 }); - // Step E - v = (0, _hash.HmacSHA256)(v, k); +var vesting_balance_withdraw_operation_fee_parameters = new Serializer("vesting_balance_withdraw_operation_fee_parameters", { fee: uint64 }); - // Step F - k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([1]), x, hash]), k); +var worker_create_operation_fee_parameters = new Serializer("worker_create_operation_fee_parameters", { fee: uint64 }); - // Step G - v = (0, _hash.HmacSHA256)(v, k); +var custom_operation_fee_parameters = new Serializer("custom_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); - // Step H1/H2a, ignored as tlen === qlen (256 bit) - // Step H2b - v = (0, _hash.HmacSHA256)(v, k); +var assert_operation_fee_parameters = new Serializer("assert_operation_fee_parameters", { fee: uint64 }); - var T = _bigi2.default.fromBuffer(v); +var balance_claim_operation_fee_parameters = new Serializer("balance_claim_operation_fee_parameters"); - // Step H3, repeat until T is within the interval [1, n - 1] - while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) { - k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0])]), k); - v = (0, _hash.HmacSHA256)(v, k); +var override_transfer_operation_fee_parameters = new Serializer("override_transfer_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); - // Step H1/H2a, again, ignored as tlen === qlen (256 bit) - // Step H2b again - v = (0, _hash.HmacSHA256)(v, k); +var transfer_to_blind_operation_fee_parameters = new Serializer("transfer_to_blind_operation_fee_parameters", { fee: uint64, + price_per_output: uint32 }); - T = _bigi2.default.fromBuffer(v); - } +var blind_transfer_operation_fee_parameters = new Serializer("blind_transfer_operation_fee_parameters", { fee: uint64, + price_per_output: uint32 }); - return T; -} +var transfer_from_blind_operation_fee_parameters = new Serializer("transfer_from_blind_operation_fee_parameters", { fee: uint64 }); -function sign(curve, hash, d, nonce) { - var e = _bigi2.default.fromBuffer(hash); - var n = curve.n; - var G = curve.G; +var asset_settle_cancel_operation_fee_parameters = new Serializer("asset_settle_cancel_operation_fee_parameters"); - var r = void 0; - var s = void 0; +var asset_claim_fees_operation_fee_parameters = new Serializer("asset_claim_fees_operation_fee_parameters", { fee: uint64 }); - deterministicGenerateK(curve, hash, d, function (key) { - // find canonically valid signature - var Q = G.multiply(key); +var fba_distribute_operation_fee_parameters = new Serializer("fba_distribute_operation_fee_parameters", {}); - if (curve.isInfinity(Q)) { - return false; - } +var tournament_create_operation_fee_parameters = new Serializer("tournament_create_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); - r = Q.affineX.mod(n); +var tournament_join_operation_fee_parameters = new Serializer("tournament_join_operation_fee_parameters", { fee: uint64 }); - if (r.signum() === 0) { - return false; - } +var fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters]); - s = key.modInverse(n).multiply(e.add(d.multiply(r))).mod(n); +var fee_schedule = new Serializer("fee_schedule", { parameters: set(fee_parameters), + scale: uint32 }); - if (s.signum() === 0) { - return false; - } +var void_result = new Serializer("void_result"); - return true; - }, nonce); +var asset = new Serializer("asset", { amount: int64, + asset_id: protocol_id_type("asset") }); - var N_OVER_TWO = n.shiftRight(1); +var operation_result = static_variant([void_result, object_id_type, asset]); - // enforce low S values, see bip62: 'low s values in signatures' - if (s.compareTo(N_OVER_TWO) > 0) { - s = n.subtract(s); - } +var processed_transaction = new Serializer("processed_transaction", { ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions), + signatures: array(bytes(65)), + operation_results: array(operation_result) }); + +var signed_block = new Serializer("signed_block", { previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type("witness"), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions), + witness_signature: bytes(65), + transactions: array(processed_transaction) }); + +var block_header = new Serializer("block_header", { previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type("witness"), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions) }); + +var signed_block_header = new Serializer("signed_block_header", { previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type("witness"), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions), + witness_signature: bytes(65) }); + +var memo_data = new Serializer("memo_data", { from: public_key, + to: public_key, + nonce: uint64, + message: bytes() }); + +var transfer = new Serializer("transfer", { fee: asset, + from: protocol_id_type("account"), + to: protocol_id_type("account"), + amount: asset, + memo: optional(memo_data), + extensions: set(future_extensions) }); + +var limit_order_create = new Serializer("limit_order_create", { fee: asset, + seller: protocol_id_type("account"), + amount_to_sell: asset, + min_to_receive: asset, + expiration: time_point_sec, + fill_or_kill: bool, + extensions: set(future_extensions) }); + +var limit_order_cancel = new Serializer("limit_order_cancel", { fee: asset, + fee_paying_account: protocol_id_type("account"), + order: protocol_id_type("limit_order"), + extensions: set(future_extensions) }); + +var call_order_update = new Serializer("call_order_update", { fee: asset, + funding_account: protocol_id_type("account"), + delta_collateral: asset, + delta_debt: asset, + extensions: set(future_extensions) }); + +var fill_order = new Serializer("fill_order", { fee: asset, + order_id: object_id_type, + account_id: protocol_id_type("account"), + pays: asset, + receives: asset }); + +var authority = new Serializer("authority", { weight_threshold: uint32, + account_auths: map(protocol_id_type("account"), uint16), + key_auths: map(public_key, uint16), + address_auths: map(address, uint16) }); + +var account_options = new Serializer("account_options", { memo_key: public_key, + voting_account: protocol_id_type("account"), + num_witness: uint16, + num_committee: uint16, + votes: set(vote_id), + extensions: set(future_extensions) }); + +var account_create = new Serializer("account_create", { fee: asset, + registrar: protocol_id_type("account"), + referrer: protocol_id_type("account"), + referrer_percent: uint16, + name: string, + owner: authority, + active: authority, + options: account_options, + extensions: set(future_extensions) }); + +var account_update = new Serializer("account_update", { fee: asset, + account: protocol_id_type("account"), + owner: optional(authority), + active: optional(authority), + new_options: optional(account_options), + extensions: set(future_extensions) }); + +var account_whitelist = new Serializer("account_whitelist", { fee: asset, + authorizing_account: protocol_id_type("account"), + account_to_list: protocol_id_type("account"), + new_listing: uint8, + extensions: set(future_extensions) }); + +var account_upgrade = new Serializer("account_upgrade", { fee: asset, + account_to_upgrade: protocol_id_type("account"), + upgrade_to_lifetime_member: bool, + extensions: set(future_extensions) }); + +var account_transfer = new Serializer("account_transfer", { fee: asset, + account_id: protocol_id_type("account"), + new_owner: protocol_id_type("account"), + extensions: set(future_extensions) }); + +var price = new Serializer("price", { base: asset, + quote: asset }); + +var asset_options = new Serializer("asset_options", { max_supply: int64, + market_fee_percent: uint16, + max_market_fee: int64, + issuer_permissions: uint16, + flags: uint16, + core_exchange_rate: price, + whitelist_authorities: set(protocol_id_type("account")), + blacklist_authorities: set(protocol_id_type("account")), + whitelist_markets: set(protocol_id_type("asset")), + blacklist_markets: set(protocol_id_type("asset")), + description: string, + extensions: set(future_extensions) }); + +var bitasset_options = new Serializer("bitasset_options", { feed_lifetime_sec: uint32, + minimum_feeds: uint8, + force_settlement_delay_sec: uint32, + force_settlement_offset_percent: uint16, + maximum_force_settlement_volume: uint16, + short_backing_asset: protocol_id_type("asset"), + extensions: set(future_extensions) }); + +var asset_create = new Serializer("asset_create", { fee: asset, + issuer: protocol_id_type("account"), + symbol: string, + precision: uint8, + common_options: asset_options, + bitasset_opts: optional(bitasset_options), + is_prediction_market: bool, + extensions: set(future_extensions) }); + +var asset_update = new Serializer("asset_update", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_issuer: optional(protocol_id_type("account")), + new_options: asset_options, + extensions: set(future_extensions) }); + +var asset_update_bitasset = new Serializer("asset_update_bitasset", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_options: bitasset_options, + extensions: set(future_extensions) }); + +var asset_update_feed_producers = new Serializer("asset_update_feed_producers", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_feed_producers: set(protocol_id_type("account")), + extensions: set(future_extensions) }); + +var asset_issue = new Serializer("asset_issue", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_issue: asset, + issue_to_account: protocol_id_type("account"), + memo: optional(memo_data), + extensions: set(future_extensions) }); + +var asset_reserve = new Serializer("asset_reserve", { fee: asset, + payer: protocol_id_type("account"), + amount_to_reserve: asset, + extensions: set(future_extensions) }); + +var asset_fund_fee_pool = new Serializer("asset_fund_fee_pool", { fee: asset, + from_account: protocol_id_type("account"), + asset_id: protocol_id_type("asset"), + amount: int64, + extensions: set(future_extensions) }); + +var asset_settle = new Serializer("asset_settle", { fee: asset, + account: protocol_id_type("account"), + amount: asset, + extensions: set(future_extensions) }); + +var asset_global_settle = new Serializer("asset_global_settle", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_settle: protocol_id_type("asset"), + settle_price: price, + extensions: set(future_extensions) }); + +var price_feed = new Serializer("price_feed", { settlement_price: price, + maintenance_collateral_ratio: uint16, + maximum_short_squeeze_ratio: uint16, + core_exchange_rate: price }); + +var asset_publish_feed = new Serializer("asset_publish_feed", { fee: asset, + publisher: protocol_id_type("account"), + asset_id: protocol_id_type("asset"), + feed: price_feed, + extensions: set(future_extensions) }); + +var witness_create = new Serializer("witness_create", { fee: asset, + witness_account: protocol_id_type("account"), + url: string, + block_signing_key: public_key }); + +var witness_update = new Serializer("witness_update", { fee: asset, + witness: protocol_id_type("witness"), + witness_account: protocol_id_type("account"), + new_url: optional(string), + new_signing_key: optional(public_key) }); + +var op_wrapper = new Serializer("op_wrapper", { op: operation }); + +var proposal_create = new Serializer("proposal_create", { fee: asset, + fee_paying_account: protocol_id_type("account"), + expiration_time: time_point_sec, + proposed_ops: array(op_wrapper), + review_period_seconds: optional(uint32), + extensions: set(future_extensions) }); + +var proposal_update = new Serializer("proposal_update", { fee: asset, + fee_paying_account: protocol_id_type("account"), + proposal: protocol_id_type("proposal"), + active_approvals_to_add: set(protocol_id_type("account")), + active_approvals_to_remove: set(protocol_id_type("account")), + owner_approvals_to_add: set(protocol_id_type("account")), + owner_approvals_to_remove: set(protocol_id_type("account")), + key_approvals_to_add: set(public_key), + key_approvals_to_remove: set(public_key), + extensions: set(future_extensions) }); + +var proposal_delete = new Serializer("proposal_delete", { fee: asset, + fee_paying_account: protocol_id_type("account"), + using_owner_authority: bool, + proposal: protocol_id_type("proposal"), + extensions: set(future_extensions) }); + +var withdraw_permission_create = new Serializer("withdraw_permission_create", { fee: asset, + withdraw_from_account: protocol_id_type("account"), + authorized_account: protocol_id_type("account"), + withdrawal_limit: asset, + withdrawal_period_sec: uint32, + periods_until_expiration: uint32, + period_start_time: time_point_sec }); + +var withdraw_permission_update = new Serializer("withdraw_permission_update", { fee: asset, + withdraw_from_account: protocol_id_type("account"), + authorized_account: protocol_id_type("account"), + permission_to_update: protocol_id_type("withdraw_permission"), + withdrawal_limit: asset, + withdrawal_period_sec: uint32, + period_start_time: time_point_sec, + periods_until_expiration: uint32 }); + +var withdraw_permission_claim = new Serializer("withdraw_permission_claim", { fee: asset, + withdraw_permission: protocol_id_type("withdraw_permission"), + withdraw_from_account: protocol_id_type("account"), + withdraw_to_account: protocol_id_type("account"), + amount_to_withdraw: asset, + memo: optional(memo_data) }); + +var withdraw_permission_delete = new Serializer("withdraw_permission_delete", { fee: asset, + withdraw_from_account: protocol_id_type("account"), + authorized_account: protocol_id_type("account"), + withdrawal_permission: protocol_id_type("withdraw_permission") }); + +var committee_member_create = new Serializer("committee_member_create", { fee: asset, + committee_member_account: protocol_id_type("account"), + url: string }); + +var committee_member_update = new Serializer("committee_member_update", { fee: asset, + committee_member: protocol_id_type("committee_member"), + committee_member_account: protocol_id_type("account"), + new_url: optional(string) }); + +var chain_parameters = new Serializer("chain_parameters", { current_fees: fee_schedule, + block_interval: uint8, + maintenance_interval: uint32, + maintenance_skip_slots: uint8, + committee_proposal_review_period: uint32, + maximum_transaction_size: uint32, + maximum_block_size: uint32, + maximum_time_until_expiration: uint32, + maximum_proposal_lifetime: uint32, + maximum_asset_whitelist_authorities: uint8, + maximum_asset_feed_publishers: uint8, + maximum_witness_count: uint16, + maximum_committee_count: uint16, + maximum_authority_membership: uint16, + reserve_percent_of_fee: uint16, + network_percent_of_fee: uint16, + lifetime_referrer_percent_of_fee: uint16, + cashback_vesting_period_seconds: uint32, + cashback_vesting_threshold: int64, + count_non_member_votes: bool, + allow_non_member_whitelists: bool, + witness_pay_per_block: int64, + worker_budget_per_day: int64, + max_predicate_opcode: uint16, + fee_liquidation_threshold: int64, + accounts_per_fee_scale: uint16, + account_fee_scale_bitshifts: uint8, + max_authority_depth: uint8, + extensions: set(future_extensions) }); + +var committee_member_update_global_parameters = new Serializer("committee_member_update_global_parameters", { fee: asset, + new_parameters: chain_parameters }); + +var linear_vesting_policy_initializer = new Serializer("linear_vesting_policy_initializer", { begin_timestamp: time_point_sec, + vesting_cliff_seconds: uint32, + vesting_duration_seconds: uint32 }); + +var cdd_vesting_policy_initializer = new Serializer("cdd_vesting_policy_initializer", { start_claim: time_point_sec, + vesting_seconds: uint32 }); - return new _ecsignature2.default(r, s); -} +var vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]); -function verifyRaw(curve, e, signature, Q) { - var n = curve.n; - var G = curve.G; +var vesting_balance_create = new Serializer("vesting_balance_create", { fee: asset, + creator: protocol_id_type("account"), + owner: protocol_id_type("account"), + amount: asset, + policy: vesting_policy_initializer }); - var r = signature.r; - var s = signature.s; +var vesting_balance_withdraw = new Serializer("vesting_balance_withdraw", { fee: asset, + vesting_balance: protocol_id_type("vesting_balance"), + owner: protocol_id_type("account"), + amount: asset }); - // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1] - if (r.signum() <= 0 || r.compareTo(n) >= 0) { - return false; - } +var refund_worker_initializer = new Serializer("refund_worker_initializer"); - if (s.signum() <= 0 || s.compareTo(n) >= 0) { - return false; - } +var vesting_balance_worker_initializer = new Serializer("vesting_balance_worker_initializer", { pay_vesting_period_days: uint16 }); - // c = s^-1 mod n - var c = s.modInverse(n); +var burn_worker_initializer = new Serializer("burn_worker_initializer"); - // 1.4.4 Compute u1 = es^−1 mod n - // u2 = rs^−1 mod n - var u1 = e.multiply(c).mod(n); - var u2 = r.multiply(c).mod(n); +var worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]); - // 1.4.5 Compute R = (xR, yR) = u1G + u2Q - var R = G.multiplyTwo(u1, Q, u2); +var worker_create = new Serializer("worker_create", { fee: asset, + owner: protocol_id_type("account"), + work_begin_date: time_point_sec, + work_end_date: time_point_sec, + daily_pay: int64, + name: string, + url: string, + initializer: worker_initializer }); - // 1.4.5 (cont.) Enforce R is not at infinity - if (curve.isInfinity(R)) { - return false; - } +var custom = new Serializer("custom", { fee: asset, + payer: protocol_id_type("account"), + required_auths: set(protocol_id_type("account")), + id: uint16, + data: bytes() }); - // 1.4.6 Convert the field element R.x to an integer - var xR = R.affineX; +var account_name_eq_lit_predicate = new Serializer("account_name_eq_lit_predicate", { account_id: protocol_id_type("account"), + name: string }); - // 1.4.7 Set v = xR mod n - var v = xR.mod(n); +var asset_symbol_eq_lit_predicate = new Serializer("asset_symbol_eq_lit_predicate", { asset_id: protocol_id_type("asset"), + symbol: string }); - // 1.4.8 If v = r, output "valid", and if v != r, output "invalid" - return v.equals(r); -} +var block_id_predicate = new Serializer("block_id_predicate", { id: bytes(20) }); -function verify(curve, hash, signature, Q) { - // 1.4.2 H = Hash(M), already done by the user - // 1.4.3 e = H - var e = _bigi2.default.fromBuffer(hash); - return verifyRaw(curve, e, signature, Q); -} +var predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]); -/** - * Recover a public key from a signature. - * - * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public - * Key Recovery Operation". - * - * http://www.secg.org/download/aid-780/sec1-v2.pdf - */ -function recoverPubKey(curve, e, signature, i) { - _assert2.default.strictEqual(i & 3, i, 'Recovery param is more than two bits'); // eslint-disable-line +var assert = new Serializer("assert", { fee: asset, + fee_paying_account: protocol_id_type("account"), + predicates: array(predicate), + required_auths: set(protocol_id_type("account")), + extensions: set(future_extensions) }); + +var balance_claim = new Serializer("balance_claim", { fee: asset, + deposit_to_account: protocol_id_type("account"), + balance_to_claim: protocol_id_type("balance"), + balance_owner_key: public_key, + total_claimed: asset }); + +var override_transfer = new Serializer("override_transfer", { fee: asset, + issuer: protocol_id_type("account"), + from: protocol_id_type("account"), + to: protocol_id_type("account"), + amount: asset, + memo: optional(memo_data), + extensions: set(future_extensions) }); + +var stealth_confirmation = new Serializer("stealth_confirmation", { one_time_key: public_key, + to: optional(public_key), + encrypted_memo: bytes() }); + +var blind_output = new Serializer("blind_output", { commitment: bytes(33), + range_proof: bytes(), + owner: authority, + stealth_memo: optional(stealth_confirmation) }); + +var transfer_to_blind = new Serializer("transfer_to_blind", { fee: asset, + amount: asset, + from: protocol_id_type("account"), + blinding_factor: bytes(32), + outputs: array(blind_output) }); + +var blind_input = new Serializer("blind_input", { commitment: bytes(33), + owner: authority }); + +var blind_transfer = new Serializer("blind_transfer", { fee: asset, + inputs: array(blind_input), + outputs: array(blind_output) }); + +var transfer_from_blind = new Serializer("transfer_from_blind", { fee: asset, + amount: asset, + to: protocol_id_type("account"), + blinding_factor: bytes(32), + inputs: array(blind_input) }); + +var asset_settle_cancel = new Serializer("asset_settle_cancel", { fee: asset, + settlement: protocol_id_type("force_settlement"), + account: protocol_id_type("account"), + amount: asset, + extensions: set(future_extensions) }); + +var asset_claim_fees = new Serializer("asset_claim_fees", { fee: asset, + issuer: protocol_id_type("account"), + amount_to_claim: asset, + extensions: set(future_extensions) }); + +var fba_distribute = new Serializer("fba_distribute", { fee: asset, + account_id: protocol_id_type("account"), + fba_id: protocol_id_type("fba_accumulator"), + amount: int64 }); + +var dividend_asset_options = new Serializer("dividend_asset_options", { next_payout_time: optional(time_point_sec), + payout_interval: optional(uint32), + minimum_fee_percentage: uint64, + minimum_distribution_interval: optional(uint32), + extensions: set(future_extensions) }); + +var asset_update_dividend = new Serializer("asset_update_dividend", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_options: dividend_asset_options, + extensions: set(future_extensions) }); + +var rock_paper_scissors_game_options = new Serializer("rock_paper_scissors_game_options", { insurance_enabled: bool, + time_per_commit_move: uint32, + time_per_reveal_move: uint32, + number_of_gestures: uint8 }); - var n = curve.n; - var G = curve.G; +var game_specific_details = static_variant([rock_paper_scissors_game_options]); - var r = signature.r; - var s = signature.s; +var tournament_options = new Serializer("tournament_options", { + type_of_game: uint16, + registration_deadline: time_point_sec, + number_of_players: uint32, + buy_in: asset, + whitelist: set(protocol_id_type("account")), + start_time: optional(time_point_sec), + start_delay: optional(uint32), + round_delay: uint32, + number_of_wins: uint32, + meta: variant_object, + game_options: game_specific_details +}); - (0, _assert2.default)(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value'); - (0, _assert2.default)(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value'); +var tournament_create = new Serializer("tournament_create", { fee: asset, + creator: protocol_id_type("account"), + options: tournament_options, + extensions: set(future_extensions) }); - // A set LSB signifies that the y-coordinate is odd - var isYOdd = i & 1; // eslint-disable-line +var tournament_join = new Serializer("tournament_join", { fee: asset, + payer_account_id: protocol_id_type("account"), + player_account_id: protocol_id_type("account"), + tournament_id: protocol_id_type("tournament"), + buy_in: asset, + extensions: set(future_extensions) }); - // The more significant bit specifies whether we should use the - // first or second candidate key. - var isSecondKey = i >> 1; // eslint-disable-line +var rock_paper_scissors_gesture = enumeration(["rock", "paper", "scissors", "spock", "lizard"]); - // 1.1 Let x = r + jn - var x = isSecondKey ? r.add(n) : r; - var R = curve.pointFromX(isYOdd, x); +var rock_paper_scissors_throw_commit = new Serializer("rock_paper_scissors_throw_commit", { nonce1: uint64, + throw_hash: sha256 }); - // 1.4 Check that nR is at infinity - var nR = R.multiply(n); - (0, _assert2.default)(curve.isInfinity(nR), 'nR is not a valid curve point'); +var rock_paper_scissors_throw_reveal = new Serializer("rock_paper_scissors_throw_reveal", { nonce2: uint64, + gesture: rock_paper_scissors_gesture }); - // Compute -e from e - var eNeg = e.negate().mod(n); +var game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]); - // 1.6.1 Compute Q = r^-1 (sR - eG) - // Q = r^-1 (sR + -eG) - var rInv = r.modInverse(n); +var game_move = new Serializer("game_move", { fee: asset, + game_id: protocol_id_type("game"), + player_account_id: protocol_id_type("account"), + move: game_specific_moves, + extensions: set(future_extensions) }); + +operation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend]; + +var transaction = new Serializer("transaction", { ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions) }); + +var signed_transaction = new Serializer("signed_transaction", { ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions), + signatures: array(bytes(65)) }); +//# ------------------------------- +//# Generated code end +//# ------------------------------- - var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv); - curve.validate(Q); +// Custom Types - return Q; -} +var stealth_memo_data = new Serializer("stealth_memo_data", { + from: optional(public_key), + amount: asset, + blinding_factor: bytes(32), + commitment: bytes(33), + check: uint32 +}); +// var stealth_confirmation = new Serializer( +// "stealth_confirmation", { +// one_time_key: public_key, +// to: optional( public_key ), +// encrypted_memo: stealth_memo_data +// }) +},{"./serializer":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/serializer.js","./types":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/types.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/serializer.js":[function(require,module,exports){ +(function (process,Buffer){ +'use strict'; -/** - * Calculate pubkey extraction parameter. - * - * When extracting a pubkey from a signature, we have to - * distinguish four different cases. Rather than putting this - * burden on the verifier, Bitcoin includes a 2-bit value with the - * signature. - * - * This function simply tries all four cases and returns the value - * that resulted in a successful pubkey recovery. - */ -function calcPubKeyRecoveryParam(curve, e, signature, Q) { - for (var i = 0; i < 4; i++) { - var Qprime = recoverPubKey(curve, e, signature, i); +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - // 1.6.2 Verify Q - if (Qprime.equals(Q)) { - return i; - } - } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - throw new Error('Unable to find valid recovery factor'); -} +var ByteBuffer = require('bytebuffer'); +var EC = require('./error_with_cause'); -exports.calcPubKeyRecoveryParam = calcPubKeyRecoveryParam; -exports.deterministicGenerateK = deterministicGenerateK; -exports.recoverPubKey = recoverPubKey; -exports.sign = sign; -exports.verify = verify; -exports.verifyRaw = verifyRaw; -}).call(this,require(35).Buffer) +var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; -},{"15":15,"16":16,"17":17,"27":27,"32":32,"35":35}],15:[function(require,module,exports){ -(function (Buffer){ -'use strict'; +var Serializer = function () { + function Serializer(operation_name, types) { + _classCallCheck(this, Serializer); + + this.operation_name = operation_name; + this.types = types; + if (this.types) this.keys = Object.keys(this.types); + + Serializer.printDebug = true; + } + + _createClass(Serializer, [{ + key: 'fromByteBuffer', + value: function fromByteBuffer(b) { + var object = {}; + var field = null; + try { + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + try { + if (HEX_DUMP) { + if (type.operation_name) { + console.error(type.operation_name); + } else { + var o1 = b.offset; + type.fromByteBuffer(b); + var o2 = b.offset; + b.offset = o1; + //b.reset() + var _b = b.copy(o1, o2); + console.error(this.operation_name + '.' + field + '\t', _b.toHex()); + } + } + object[field] = type.fromByteBuffer(b); + } catch (e) { + if (Serializer.printDebug) { + console.error('Error reading ' + this.operation_name + '.' + field + ' in data:'); + b.printDebug(); + } + throw e; + } + } + } catch (error) { + EC.throw(this.operation_name + '.' + field, error); + } -exports.__esModule = true; + return object; + } + }, { + key: 'appendByteBuffer', + value: function appendByteBuffer(b, object) { + var field = null; + try { + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + type.appendByteBuffer(b, object[field]); + } + } catch (error) { + try { + EC.throw(this.operation_name + '.' + field + " = " + JSON.stringify(object[field]), error); + } catch (e) { + // circular ref + EC.throw(this.operation_name + '.' + field + " = " + object[field], error); + } + } + return; + } + }, { + key: 'fromObject', + value: function fromObject(serialized_object) { + var result = {}; + var field = null; + try { + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + var value = serialized_object[field]; + //DEBUG value = value.resolve if value.resolve + //DEBUG console.log('... value',field,value) + var object = type.fromObject(value); + result[field] = object; + } + } catch (error) { + EC.throw(this.operation_name + '.' + field, error); + } -var _assert = require(27); + return result; + } -var _assert2 = _interopRequireDefault(_assert); + /** + @arg {boolean} [debug.use_default = false] - more template friendly + @arg {boolean} [debug.annotate = false] - add user-friendly information + */ -var _bigi = require(32); + }, { + key: 'toObject', + value: function toObject() { + var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false }; + + var result = {}; + var field = null; + try { + if (!this.types) return result; + + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + var object = type.toObject(typeof serialized_object !== "undefined" && serialized_object !== null ? serialized_object[field] : undefined, debug); + result[field] = object; + if (HEX_DUMP) { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + type.appendByteBuffer(b, typeof serialized_object !== "undefined" && serialized_object !== null ? serialized_object[field] : undefined); + b = b.copy(0, b.offset); + console.error(this.operation_name + '.' + field, b.toHex()); + } + } + } catch (error) { + EC.throw(this.operation_name + '.' + field, error); + } -var _bigi2 = _interopRequireDefault(_bigi); + return result; + } -var _enforce_types = require(16); + /** Sort by the first element in a operation */ -var _enforce_types2 = _interopRequireDefault(_enforce_types); + }, { + key: 'compare', + value: function compare(a, b) { -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + var first_key = this.keys[0]; + var first_type = this.types[first_key]; -// from https://github.com/bitcoinjs/bitcoinjs-lib -function ECSignature(r, s) { - (0, _enforce_types2.default)(_bigi2.default, r); - (0, _enforce_types2.default)(_bigi2.default, s); + var valA = a[first_key]; + var valB = b[first_key]; - this.r = r; - this.s = s; -} + if (first_type.compare) return first_type.compare(valA, valB); -// Import operations -/* eslint no-bitwise: "off" */ -ECSignature.parseCompact = function (buffer) { - _assert2.default.equal(buffer.length, 65, 'Invalid signature length'); - var i = buffer.readUInt8(0) - 27; + if (typeof valA === "number" && typeof valB === "number") return valA - valB; - // At most 3 bits - _assert2.default.equal(i, i & 7, 'Invalid signature parameter'); - var compressed = !!(i & 4); + var encoding = void 0; + if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) { + // A binary string compare does not work. If localeCompare is well supported that could replace HEX. Performanance is very good so comparing HEX works. + encoding = "hex"; + } - // Recovery param only - i &= 3; + var strA = valA.toString(encoding); + var strB = valB.toString(encoding); + return strA > strB ? 1 : strA < strB ? -1 : 0; + } - var r = _bigi2.default.fromBuffer(buffer.slice(1, 33)); - var s = _bigi2.default.fromBuffer(buffer.slice(33)); + // - return { - compressed: compressed, - i: i, - signature: new ECSignature(r, s) - }; -}; + }, { + key: 'fromHex', + value: function fromHex(hex) { + var b = ByteBuffer.fromHex(hex, ByteBuffer.LITTLE_ENDIAN); + return this.fromByteBuffer(b); + } + }, { + key: 'fromBuffer', + value: function fromBuffer(buffer) { + var b = ByteBuffer.fromBinary(buffer.toString("binary"), ByteBuffer.LITTLE_ENDIAN); + return this.fromByteBuffer(b); + } + }, { + key: 'toHex', + value: function toHex(object) { + // return this.toBuffer(object).toString("hex") + var b = this.toByteBuffer(object); + return b.toHex(); + } + }, { + key: 'toByteBuffer', + value: function toByteBuffer(object) { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b, object); + return b.copy(0, b.offset); + } + }, { + key: 'toBuffer', + value: function toBuffer(object) { + return new Buffer(this.toByteBuffer(object).toBinary(), 'binary'); + } + }]); -ECSignature.fromDER = function (buffer) { - _assert2.default.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence'); - _assert2.default.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length'); - _assert2.default.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer'); + return Serializer; +}(); - var rLen = buffer.readUInt8(3); - (0, _assert2.default)(rLen > 0, 'R length is zero'); +module.exports = Serializer; +}).call(this,require('_process'),require("buffer").Buffer) - var offset = 4 + rLen; - _assert2.default.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)'); +},{"./error_with_cause":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/error_with_cause.js","_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","bytebuffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bytebuffer/dist/bytebuffer.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/template.js":[function(require,module,exports){ +"use strict"; - var sLen = buffer.readUInt8(offset + 1); - (0, _assert2.default)(sLen > 0, 'S length is zero'); - - var rB = buffer.slice(4, offset); - var sB = buffer.slice(offset + 2); - offset += 2 + sLen; - - if (rLen > 1 && rB.readUInt8(0) === 0x00) { - (0, _assert2.default)(rB.readUInt8(1) & 0x80, 'R value excessively padded'); - } - - if (sLen > 1 && sB.readUInt8(0) === 0x00) { - (0, _assert2.default)(sB.readUInt8(1) & 0x80, 'S value excessively padded'); - } - - _assert2.default.equal(offset, buffer.length, 'Invalid DER encoding'); - var r = _bigi2.default.fromDERInteger(rB); - var s = _bigi2.default.fromDERInteger(sB); - - (0, _assert2.default)(r.signum() >= 0, 'R value is negative'); - (0, _assert2.default)(s.signum() >= 0, 'S value is negative'); - - return new ECSignature(r, s); -}; - -// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, -// importing Transaction causes a circular dependency -ECSignature.parseScriptSignature = function (buffer) { - var hashType = buffer.readUInt8(buffer.length - 1); - var hashTypeMod = hashType & ~0x80; - - (0, _assert2.default)(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType'); - - return { - signature: ECSignature.fromDER(buffer.slice(0, -1)), - hashType: hashType - }; -}; - -// Export operations -ECSignature.prototype.toCompact = function toCompact(i, compressed) { - if (compressed) { - i += 4; - } - - i += 27; - - var buffer = Buffer.alloc(65); - buffer.writeUInt8(i, 0); - - this.r.toBuffer(32).copy(buffer, 1); - this.s.toBuffer(32).copy(buffer, 33); - - return buffer; -}; - -ECSignature.prototype.toDER = function toDER() { - var rBa = this.r.toDERInteger(); - var sBa = this.s.toDERInteger(); - - var sequence = []; - - // INTEGER - sequence.push(0x02, rBa.length); - sequence = sequence.concat(rBa); - - // INTEGER - sequence.push(0x02, sBa.length); - sequence = sequence.concat(sBa); - - // SEQUENCE - sequence.unshift(0x30, sequence.length); - - return Buffer.from(sequence); -}; - -ECSignature.prototype.toScriptSignature = function toScriptSignature(hashType) { - var hashTypeBuffer = Buffer.alloc(1); - hashTypeBuffer.writeUInt8(hashType, 0); - - return Buffer.concat([this.toDER(), hashTypeBuffer]); -}; - -exports.default = ECSignature; -module.exports = exports['default']; -}).call(this,require(35).Buffer) - -},{"16":16,"27":27,"32":32,"35":35}],16:[function(require,module,exports){ -(function (Buffer){ -'use strict'; - -exports.__esModule = true; -exports.default = enforce; - -function getName(fn) { - // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property - var match = fn.toString().match(/function (.*?)\(/); - return match ? match[1] : null; -} - -function enforce(type, value) { - // Copied from https://github.com/bitcoinjs/bitcoinjs-lib - switch (type) { - case 'Array': - { - if (Array.isArray(value)) { - return; - } - - break; - } - - case 'Boolean': - { - if (typeof value === 'boolean') { - return; - } - - break; - } - - case 'Buffer': - { - if (Buffer.isBuffer(value)) { - return; - } - - break; - } - - case 'Number': - { - if (typeof value === 'number') { - return; - } - - break; - } - - case 'String': - { - if (typeof value === 'string') { - return; - } - - break; - } - - default: - { - if (getName(value.constructor) === getName(type)) { - return; - } - } - } - - throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value); -} -module.exports = exports['default']; -}).call(this,{"isBuffer":require(66)}) - -},{"66":66}],17:[function(require,module,exports){ -'use strict'; - -exports.__esModule = true; -exports.ripemd160 = exports.HmacSHA256 = exports.sha512 = exports.sha256 = exports.sha1 = undefined; - -var _createHash = require(41); - -var _createHash2 = _interopRequireDefault(_createHash); - -var _createHmac = require(43); - -var _createHmac2 = _interopRequireDefault(_createHmac); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/** @arg {string|Buffer} data - @arg {string} [digest = null] - 'hex', 'binary' or 'base64' - @return {string|Buffer} - Buffer when digest is null, or string -*/ -function sha1(data, encoding) { - return (0, _createHash2.default)('sha1').update(data).digest(encoding); -} - -/** @arg {string|Buffer} data - @arg {string} [digest = null] - 'hex', 'binary' or 'base64' - @return {string|Buffer} - Buffer when digest is null, or string -*/ -function sha256(data, encoding) { - return (0, _createHash2.default)('sha256').update(data).digest(encoding); -} - -/** @arg {string|Buffer} data - @arg {string} [digest = null] - 'hex', 'binary' or 'base64' - @return {string|Buffer} - Buffer when digest is null, or string -*/ -function sha512(data, encoding) { - return (0, _createHash2.default)('sha512').update(data).digest(encoding); -} - -function HmacSHA256(buffer, secret) { - return (0, _createHmac2.default)('sha256', secret).update(buffer).digest(); -} - -function ripemd160(data) { - return (0, _createHash2.default)('rmd160').update(data).digest(); -} - -// function hash160(buffer) { -// return ripemd160(sha256(buffer)) -// } -// -// function hash256(buffer) { -// return sha256(sha256(buffer)) -// } - -// -// function HmacSHA512(buffer, secret) { -// return crypto.createHmac('sha512', secret).update(buffer).digest() -// } - -exports.sha1 = sha1; -exports.sha256 = sha256; -exports.sha512 = sha512; -exports.HmacSHA256 = HmacSHA256; -exports.ripemd160 = ripemd160; -},{"41":41,"43":43}],18:[function(require,module,exports){ -(function (Buffer){ -'use strict'; - -exports.__esModule = true; - -var _ecurve = require(59); - -var _assert = require(27); - -var _assert2 = _interopRequireDefault(_assert); - -var _bigi = require(32); - -var _bigi2 = _interopRequireDefault(_bigi); - -var _hash2 = require(17); - -var _ecdsa = require(14); - -var _PublicKey = require(11); - -var _PublicKey2 = _interopRequireDefault(_PublicKey); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* global ByteBuffer */ - - -var secp256k1 = (0, _ecurve.getCurveByName)('secp256k1'); - -var Signature = function () { - function Signature(r1, s1, i1) { - _classCallCheck(this, Signature); - - this.r = r1; - this.s = s1; - this.i = i1; - _assert2.default.equal(this.r != null, true, 'Missing parameter'); - _assert2.default.equal(this.s != null, true, 'Missing parameter'); - _assert2.default.equal(this.i != null, true, 'Missing parameter'); - } - - Signature.fromBuffer = function fromBuffer(buf) { - var i = void 0; - var r = void 0; - var s = void 0; - _assert2.default.equal(buf.length, 65, 'Invalid signature length'); - i = buf.readUInt8(0); - _assert2.default.equal(i - 27, i - 27 & 7, 'Invalid signature parameter'); // eslint-disable-line - r = _bigi2.default.fromBuffer(buf.slice(1, 33)); - s = _bigi2.default.fromBuffer(buf.slice(33)); - return new Signature(r, s, i); - }; - - Signature.prototype.toBuffer = function toBuffer() { - var buf = void 0; - buf = Buffer.alloc(65); - buf.writeUInt8(this.i, 0); - this.r.toBuffer(32).copy(buf, 1); - this.s.toBuffer(32).copy(buf, 33); - return buf; - }; - - Signature.prototype.recoverPublicKeyFromBuffer = function recoverPublicKeyFromBuffer(buffer) { - return this.recoverPublicKey((0, _hash2.sha256)(buffer)); - }; - - /** - @return {PublicKey} - */ - - - Signature.prototype.recoverPublicKey = function recoverPublicKey(sha256_buffer) { - var Q = void 0; - var e = void 0; - var i = void 0; - e = _bigi2.default.fromBuffer(sha256_buffer); - i = this.i; - i -= 27; - i &= 3; // eslint-disable-line - Q = (0, _ecdsa.recoverPubKey)(secp256k1, e, this, i); - return _PublicKey2.default.fromPoint(Q); - }; - - /** - @param {Buffer} buf - @param {PrivateKey} private_key - @return {Signature} - */ - - - Signature.signBuffer = function signBuffer(buf, private_key) { - var _hash = (0, _hash2.sha256)(buf); - return Signature.signBufferSha256(_hash, private_key); - }; - - /** Sign a buffer of exactally 32 bytes in size (sha256(text)) - @param {Buffer} buf - 32 bytes binary - @param {PrivateKey} private_key - @return {Signature} - */ - - - Signature.signBufferSha256 = function signBufferSha256(buf_sha256, private_key) { - if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) { - throw new Error('buf_sha256: 32 byte buffer requred'); - } - - var der = void 0; - var e = void 0; - var ecsignature = void 0; - var i = void 0; - var lenR = void 0; - var lenS = void 0; - var nonce = void 0; - i = null; - nonce = 0; - e = _bigi2.default.fromBuffer(buf_sha256); - - var loop = true; - - while (loop) { - ecsignature = (0, _ecdsa.sign)(secp256k1, buf_sha256, private_key.d, nonce++); - der = ecsignature.toDER(); - lenR = der[3]; - lenS = der[5 + lenR]; - - if (lenR === 32 && lenS === 32) { - i = (0, _ecdsa.calcPubKeyRecoveryParam)(secp256k1, e, ecsignature, private_key.toPublicKey().Q); - i += 4; // compressed - i += 27; // compact // 24 or 27 :( forcing odd-y 2nd key candidate) - loop = false; - break; - } - - if (nonce % 10 === 0) { - console.log('WARN: ' + nonce + ' attempts to find canonical signature'); - } - } - - return new Signature(ecsignature.r, ecsignature.s, i); - }; - - Signature.sign = function sign(string, private_key) { - return Signature.signBuffer(Buffer.from(string), private_key); - }; - - /** - @param {Buffer} un-hashed - @param {./PublicKey} - @return {boolean} - */ - - - Signature.prototype.verifyBuffer = function verifyBuffer(buf, public_key) { - var _hash = (0, _hash2.sha256)(buf); - return this.verifyHash(_hash, public_key); - }; - - Signature.prototype.verifyHash = function verifyHash(hash, public_key) { - _assert2.default.equal(hash.length, 32, 'A SHA 256 should be 32 bytes long, instead got ' + hash.length); - return (0, _ecdsa.verify)(secp256k1, hash, { - r: this.r, - s: this.s - }, public_key.Q); - }; - - /* */ - - Signature.prototype.toByteBuffer = function toByteBuffer() { - var b = void 0; - b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); - this.appendByteBuffer(b); - return b.copy(0, b.offset); - }; - - Signature.fromHex = function fromHex(hex) { - return Signature.fromBuffer(Buffer.from(hex, 'hex')); - }; - - Signature.prototype.toHex = function toHex() { - return this.toBuffer().toString('hex'); - }; - - Signature.signHex = function signHex(hex, private_key) { - var buf = void 0; - buf = Buffer.from(hex, 'hex'); - return Signature.signBuffer(buf, private_key); - }; - - Signature.prototype.verifyHex = function verifyHex(hex, public_key) { - var buf = void 0; - buf = Buffer.from(hex, 'hex'); - return this.verifyBuffer(buf, public_key); - }; - - return Signature; -}(); - -exports.default = Signature; -module.exports = exports['default']; -}).call(this,require(35).Buffer) - -},{"11":11,"14":14,"17":17,"27":27,"32":32,"35":35,"59":59}],19:[function(require,module,exports){ -'use strict'; - -exports.__esModule = true; -exports.SerializerValidation = exports.template = exports.ops = exports.types = exports.fp = exports.Serializer = undefined; - -var _serializer = require(24); - -var _serializer2 = _interopRequireDefault(_serializer); - -var _FastParser = require(20); - -var _FastParser2 = _interopRequireDefault(_FastParser); - -var _types = require(26); - -var _types2 = _interopRequireDefault(_types); - -var _operations = require(23); - -var ops = _interopRequireWildcard(_operations); - -var _template = require(25); - -var _template2 = _interopRequireDefault(_template); - -var _SerializerValidation = require(21); - -var _SerializerValidation2 = _interopRequireDefault(_SerializerValidation); - -function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -exports.Serializer = _serializer2.default; -exports.fp = _FastParser2.default; -exports.types = _types2.default; -exports.ops = ops; -exports.template = _template2.default; -exports.SerializerValidation = _SerializerValidation2.default; -},{"20":20,"21":21,"23":23,"24":24,"25":25,"26":26}],20:[function(require,module,exports){ -(function (Buffer){ -'use strict'; - -exports.__esModule = true; - -var _PublicKey = require(11); - -var _PublicKey2 = _interopRequireDefault(_PublicKey); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var FastParser = function () { - function FastParser() { - _classCallCheck(this, FastParser); - } - - FastParser.fixed_data = function fixed_data(b, len, buffer) { - if (!b) { - return; - } - if (buffer) { - var data = buffer.slice(0, len).toString('binary'); - b.append(data, 'binary'); - while (len-- > data.length) { - b.writeUint8(0); - } - } else { - var b_copy = b.copy(b.offset, b.offset + len); - b.skip(len); - return Buffer.from(b_copy.toBinary(), 'binary'); - } - }; - - FastParser.public_key = function public_key(b, _public_key) { - var buffer = void 0; - if (!b) { - return; - } - if (_public_key) { - buffer = _public_key.toBuffer(); - b.append(buffer.toString('binary'), 'binary'); - } else { - buffer = FastParser.fixed_data(b, 33); - return _PublicKey2.default.fromBuffer(buffer); - } - }; - - FastParser.ripemd160 = function ripemd160(b, _ripemd) { - if (!b) { - return; - } - if (_ripemd) { - FastParser.fixed_data(b, 20, _ripemd); - } else { - return FastParser.fixed_data(b, 20); - } - }; - - FastParser.sha256 = function sha256(b, _sha) { - if (!b) { - return; - } - if (_sha) { - FastParser.fixed_data(b, 32, _sha); - } else { - return FastParser.fixed_data(b, 32); - } - }; - - FastParser.time_point_sec = function time_point_sec(b, epoch) { - if (epoch) { - epoch = Math.ceil(epoch / 1000); - b.writeInt32(epoch); - } else { - epoch = b.readInt32(); // fc::time_point_sec - return new Date(epoch * 1000); - } - }; - - return FastParser; -}(); - -exports.default = FastParser; -module.exports = exports['default']; -}).call(this,require(35).Buffer) - -},{"11":11,"35":35}],21:[function(require,module,exports){ -'use strict'; - -exports.__esModule = true; - -var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - -var _bytebuffer = require(38); - -var _ChainTypes = require(3); - -var _ChainTypes2 = _interopRequireDefault(_ChainTypes); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -var MAX_SAFE_INT = 9007199254740991; -var MIN_SAFE_INT = -9007199254740991; - -/** - Most validations are skipped and the value returned unchanged when an empty string, - null, or undefined is encountered (except "required"). - Validations support a string format for dealing with large numbers. -*/ -var _my = { - is_empty: function is_empty(value) { - return value === null || value === undefined; - }, - required: function required(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - throw new Error('value required ' + field_name + ' | ' + value); - } - - return value; - }, - require_long: function require_long(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (!_bytebuffer.Long.isLong(value)) { - throw new Error('Long value required ' + field_name + ' | ' + value); - } - - return value; - }, - string: function string(value) { - if (this.is_empty(value)) { - return value; - } - - if (typeof value !== 'string') { - throw new Error('string required: ' + value); - } - - return value; - }, - number: function number(value) { - if (this.is_empty(value)) { - return value; - } - - if (typeof value !== 'number') { - throw new Error('number required: ' + value); - } - - return value; - }, - whole_number: function whole_number(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - return value; - } - - if (/\./.test(value)) { - throw new Error('whole number required ' + field_name + ' ' + value); - } - - return value; - }, - unsigned: function unsigned(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - return value; - } - - if (/-/.test(value)) { - throw new Error('unsigned required ' + field_name + ' ' + value); - } - - return value; - }, - is_digits: function is_digits(value) { - if (typeof value === 'number') { - return true; - } - - return (/^[0-9]+$/.test(value) - ); - }, - to_number: function to_number(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - return value; - } - - this.no_overflow53(value, field_name); - var int_value = function () { - if (typeof value === 'number') { - return value; - } - - return parseInt(value, 10); - }(); - return int_value; - }, - to_long: function to_long(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - return value; - } - - if (_bytebuffer.Long.isLong(value)) { - return value; - } - - this.no_overflow64(value, field_name); - - if (typeof value === 'number') { - value = '' + value; - } - - return _bytebuffer.Long.fromString(value); - }, - to_ulong: function to_ulong(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - return value; - } - - if (_bytebuffer.Long.isLong(value)) { - return value; - } - - this.no_overflow64(value, field_name, true); - - if (typeof value === 'number') { - value = '' + value; - } - - return _bytebuffer.Long.fromString(value, true); - }, - to_string: function to_string(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (this.is_empty(value)) { - return value; - } - - if (typeof value === 'string') { - return value; - } - - if (typeof value === 'number') { - this.no_overflow53(value, field_name); - return '' + value; - } - - if (_bytebuffer.Long.isLong(value)) { - return value.toString(); - } - - throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value); - }, - require_test: function require_test(regex, value) { - var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; - - if (this.is_empty(value)) { - return value; - } - - if (!regex.test(value)) { - throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); - } - - return value; - }, - require_match: function require_match(regex, value) { - var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; - - if (this.is_empty(value)) { - return value; - } - - var match = value.match(regex); - - if (match === null) { - throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); - } - - return match; - }, - require_object_id: function require_object_id(value, field_name) { - return this.require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, value, field_name); - }, - - - // Does not support over 53 bits - require_range: function require_range(min, max, value) { - var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ''; - - if (this.is_empty(value)) { - return value; - } - - var num = this.to_number(value); - - if (num < min || num > max) { - throw new Error('out of range ' + value + ' ' + field_name + ' ' + value); - } - - return value; - }, - require_object_type: function require_object_type() { - var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; - var type = arguments[1]; - var value = arguments[2]; - var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ''; - - if (this.is_empty(value)) { - return value; - } - - var object_type = _ChainTypes2.default.object_type[type]; - - if (!object_type) { - throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value); - } - - var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$'); - - if (!re.test(value)) { - throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value)); - } - - return value; - }, - get_instance: function get_instance(reserve_spaces, type, value, field_name) { - if (this.is_empty(value)) { - return value; - } - - this.require_object_type(reserve_spaces, type, value, field_name); - return this.to_number(value.split('.')[2]); - }, - require_relative_type: function require_relative_type(type, value, field_name) { - this.require_object_type(0, type, value, field_name); - return value; - }, - get_relative_instance: function get_relative_instance(type, value, field_name) { - if (this.is_empty(value)) { - return value; - } - - this.require_object_type(0, type, value, field_name); - return this.to_number(value.split('.')[2]); - }, - require_protocol_type: function require_protocol_type(type, value, field_name) { - this.require_object_type(1, type, value, field_name); - return value; - }, - get_protocol_instance: function get_protocol_instance(type, value, field_name) { - if (this.is_empty(value)) { - return value; - } - - this.require_object_type(1, type, value, field_name); - return this.to_number(value.split('.')[2]); - }, - get_protocol_type: function get_protocol_type(value, field_name) { - if (this.is_empty(value)) { - return value; - } - - this.require_object_id(value, field_name); - var values = value.split('.'); - return this.to_number(values[1]); - }, - get_protocol_type_name: function get_protocol_type_name(value, field_name) { - if (this.is_empty(value)) { - return value; - } - - var type_id = this.get_protocol_type(value, field_name); - return Object.keys(_ChainTypes2.default.object_type)[type_id]; - }, - require_implementation_type: function require_implementation_type(type, value, field_name) { - this.require_object_type(2, type, value, field_name); - return value; - }, - get_implementation_instance: function get_implementation_instance(type, value, field_name) { - if (this.is_empty(value)) { - return value; - } - - this.require_object_type(2, type, value, field_name); - return this.to_number(value.split('.')[2]); - }, - - - // signed / unsigned decimal - no_overflow53: function no_overflow53(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - - if (typeof value === 'number') { - if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { - throw new Error('overflow ' + field_name + ' ' + value); - } - - return; - } - - if (typeof value === 'string') { - var int = parseInt(value, 10); - - if (int > MAX_SAFE_INT || int < MIN_SAFE_INT) { - throw new Error('overflow ' + field_name + ' ' + int); - } - - return; - } - - if (_bytebuffer.Long.isLong(value)) { - // typeof value.toInt() is 'number' - this.no_overflow53(value.toInt(), field_name); - return; - } - - throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value); - }, - - - // signed / unsigned whole numbers only - no_overflow64: function no_overflow64(value) { - var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; - var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - - // https://github.com/dcodeIO/Long.js/issues/20 - if (_bytebuffer.Long.isLong(value)) { - return; - } - - // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20 - if (value.t !== undefined && value.s !== undefined) { - this.no_overflow64(value.toString(), field_name, unsigned); - - return; - } - - if (typeof value === 'string') { - // remove leading zeros, will cause a false positive - value = value.replace(/^0+/, ''); - - // remove trailing zeros - while (/0$/.test(value)) { - value = value.substring(0, value.length - 1); - } - - if (/\.$/.test(value)) { - // remove trailing dot - value = value.substring(0, value.length - 1); - } - - if (value === '') { - value = '0'; - } - - var long_string = _bytebuffer.Long.fromString(value, unsigned).toString(); - - if (long_string !== value.trim()) { - throw new Error('overflow ' + field_name + ' ' + value); - } - - return; - } - - if (typeof value === 'number') { - if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { - throw new Error('overflow ' + field_name + ' ' + value); - } - - return; - } - - throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value); - } -}; - -exports.default = _my; -module.exports = exports['default']; -},{"3":3,"38":38}],22:[function(require,module,exports){ -'use strict'; - -exports.__esModule = true; - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -/** Exception nesting. */ -var ErrorWithCause = function () { - function ErrorWithCause(message, cause) { - _classCallCheck(this, ErrorWithCause); - - this.message = message; - - if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) { - this.message = 'cause\t' + cause.message + '\t' + this.message; - } - - var stack = ''; // (new Error).stack - - if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) { - stack = 'caused by\n\t' + cause.stack + '\t' + stack; - } - - this.stack = this.message + '\n' + stack; - } - - ErrorWithCause.throw = function _throw(message, cause) { - var msg = message; - - if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) { - msg += '\t cause: ' + cause.message + ' '; - } - - if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) { - msg += '\n stack: ' + cause.stack + ' '; - } - - throw new Error(msg); - }; - - return ErrorWithCause; -}(); - -exports.default = ErrorWithCause; -module.exports = exports['default']; -},{}],23:[function(require,module,exports){ -'use strict'; - -exports.__esModule = true; -exports.stealth_memo_data = exports.global_betting_statistics = exports.betting_market_position = exports.bet = exports.betting_market = exports.betting_market_group = exports.betting_market_rules = exports.event = exports.event_group = exports.sport = exports.signed_transaction = exports.transaction = exports.bet_adjusted = exports.betting_market_update = exports.betting_market_group_update = exports.tournament_leave = exports.tournament_payout = exports.payout_type = exports.bet_canceled = exports.bet_cancel = exports.bet_matched = exports.betting_market_group_cancel_unmatched_bets = exports.betting_market_group_resolved = exports.betting_market_group_resolve = exports.betting_market_resolution_type = exports.bet_place = exports.bet_type = exports.betting_market_create = exports.betting_market_group_create = exports.betting_market_rules_update = exports.betting_market_rules_create = exports.event_update = exports.event_create = exports.event_group_update = exports.event_group_create = exports.sport_update = exports.sport_create = exports.asset_dividend_distribution = exports.asset_update_dividend = exports.dividend_asset_options = exports.game_move = exports.rock_paper_scissors_throw_reveal = exports.rock_paper_scissors_throw_commit = exports.rock_paper_scissors_gesture = exports.tournament_join = exports.tournament_create = exports.tournament_options = exports.rock_paper_scissors_game_options = exports.fba_distribute = exports.asset_claim_fees = exports.asset_settle_cancel = exports.transfer_from_blind = exports.blind_transfer = exports.blind_input = exports.transfer_to_blind = exports.blind_output = exports.stealth_confirmation = exports.override_transfer = exports.balance_claim = exports.assert = exports.block_id_predicate = exports.asset_symbol_eq_lit_predicate = exports.account_name_eq_lit_predicate = exports.custom = exports.worker_create = exports.burn_worker_initializer = exports.vesting_balance_worker_initializer = exports.refund_worker_initializer = exports.vesting_balance_withdraw = exports.vesting_balance_create = exports.cdd_vesting_policy_initializer = exports.linear_vesting_policy_initializer = exports.committee_member_update_global_parameters = exports.chain_parameters = exports.committee_member_update = exports.committee_member_create = exports.withdraw_permission_delete = exports.withdraw_permission_claim = exports.withdraw_permission_update = exports.withdraw_permission_create = exports.proposal_delete = exports.proposal_update = exports.proposal_create = exports.op_wrapper = exports.witness_update = exports.witness_create = exports.asset_publish_feed = exports.price_feed = exports.asset_global_settle = exports.asset_settle = exports.asset_fund_fee_pool = exports.asset_reserve = exports.asset_issue = undefined; -exports.asset_update_feed_producers = exports.asset_update_bitasset = exports.asset_update = exports.asset_create = exports.bitasset_options = exports.asset_options = exports.price = exports.account_transfer = exports.account_upgrade = exports.account_whitelist = exports.account_update = exports.account_create = exports.account_options = exports.authority = exports.fill_order = exports.call_order_update = exports.limit_order_cancel = exports.limit_order_create = exports.transfer = exports.memo_data = exports.signed_block_header = exports.block_header = exports.signed_block = exports.processed_transaction = exports.asset = exports.void_result = exports.fee_schedule = exports.bet_adjusted_operation_fee_parameters = exports.betting_market_update_operation_fee_parameters = exports.betting_market_group_update_operation_fee_parameters = exports.tournament_leave_operation_fee_parameters = exports.tournament_payout_operation_fee_parameters = exports.game_move_operation_fee_parameters = exports.tournament_join_operation_fee_parameters = exports.tournament_create_operation_fee_parameters = exports.bet_canceled_operation_fee_parameters = exports.bet_cancel_operation_fee_parameters = exports.bet_matched_operation_fee_parameters = exports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = exports.betting_market_group_resolved_operation_fee_parameters = exports.betting_market_group_resolve_operation_fee_parameters = exports.bet_place_operation_fee_parameters = exports.betting_market_create_operation_fee_parameters = exports.betting_market_group_create_operation_fee_parameters = exports.betting_market_rules_update_operation_fee_parameters = exports.betting_market_rules_create_operation_fee_parameters = exports.event_update_operation_fee_parameters = exports.event_create_operation_fee_parameters = exports.event_group_update_operation_fee_parameters = exports.event_group_create_operation_fee_parameters = exports.sport_update_operation_fee_parameters = exports.sport_create_operation_fee_parameters = exports.asset_dividend_distribution_operation_fee_parameters = exports.asset_update_dividend_operation_fee_parameters = exports.fba_distribute_operation_fee_parameters = exports.asset_claim_fees_operation_fee_parameters = exports.asset_settle_cancel_operation_fee_parameters = exports.transfer_from_blind_operation_fee_parameters = exports.blind_transfer_operation_fee_parameters = exports.transfer_to_blind_operation_fee_parameters = exports.override_transfer_operation_fee_parameters = exports.balance_claim_operation_fee_parameters = exports.assert_operation_fee_parameters = exports.custom_operation_fee_parameters = exports.worker_create_operation_fee_parameters = exports.vesting_balance_withdraw_operation_fee_parameters = exports.vesting_balance_create_operation_fee_parameters = exports.committee_member_update_global_parameters_operation_fee_parameters = exports.committee_member_update_operation_fee_parameters = exports.committee_member_create_operation_fee_parameters = exports.withdraw_permission_delete_operation_fee_parameters = exports.withdraw_permission_claim_operation_fee_parameters = exports.withdraw_permission_update_operation_fee_parameters = exports.withdraw_permission_create_operation_fee_parameters = exports.proposal_delete_operation_fee_parameters = exports.proposal_update_operation_fee_parameters = exports.proposal_create_operation_fee_parameters = exports.witness_update_operation_fee_parameters = exports.witness_create_operation_fee_parameters = exports.asset_publish_feed_operation_fee_parameters = exports.asset_global_settle_operation_fee_parameters = exports.asset_settle_operation_fee_parameters = exports.asset_fund_fee_pool_operation_fee_parameters = exports.asset_reserve_operation_fee_parameters = exports.asset_issue_operation_fee_parameters = exports.asset_update_feed_producers_operation_fee_parameters = exports.asset_update_bitasset_operation_fee_parameters = exports.asset_update_operation_fee_parameters = exports.asset_create_operation_fee_parameters = exports.account_transfer_operation_fee_parameters = exports.account_upgrade_operation_fee_parameters = exports.account_whitelist_operation_fee_parameters = exports.account_update_operation_fee_parameters = exports.account_create_operation_fee_parameters = exports.fill_order_operation_fee_parameters = exports.call_order_update_operation_fee_parameters = exports.limit_order_cancel_operation_fee_parameters = exports.limit_order_create_operation_fee_parameters = exports.transfer_operation_fee_parameters = exports.operation = undefined; - -var _types = require(26); - -var _types2 = _interopRequireDefault(_types); - -var _serializer = require(24); - -var _serializer2 = _interopRequireDefault(_serializer); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -var uint8 = _types2.default.uint8, - uint16 = _types2.default.uint16, - uint32 = _types2.default.uint32, - int64 = _types2.default.int64, - uint64 = _types2.default.uint64, - string = _types2.default.string, - bytes = _types2.default.bytes, - bool = _types2.default.bool, - array = _types2.default.array, - protocol_id_type = _types2.default.protocol_id_type, - object_id_type = _types2.default.object_id_type, - vote_id = _types2.default.vote_id, - implementation_id_type = _types2.default.implementation_id_type, - static_variant = _types2.default.static_variant, - map = _types2.default.map, - set = _types2.default.set, - public_key = _types2.default.public_key, - address = _types2.default.address, - time_point_sec = _types2.default.time_point_sec, - optional = _types2.default.optional, - variant_object = _types2.default.variant_object, - enumeration = _types2.default.enumeration, - sha256 = _types2.default.sha256; - - -var future_extensions = _types2.default.void; - -/* -When updating generated code -Replace: operation = static_variant [ -with: operation.st_operations = [ - -Delete: -public_key = new Serializer( - "public_key" - key_data: bytes 33 -); -*/ - -function Serializer(operation_name, serilization_types_object) { - return new _serializer2.default(operation_name, serilization_types_object); -} -// Place-holder, their are dependencies on "operation" .. The final list of -// operations is not avialble until the very end of the generated code. -// See: operation.st_operations = ... -// module.exports["operation"] = operation; - -var operation = static_variant(); - -// Custom-types follow Generated code: - -// ## Generated code follows -// # programs/js_operation_serializer > npm i -g decaffeinate -// ## ------------------------------- -var transfer_operation_fee_parameters = new Serializer('transfer_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var limit_order_create_operation_fee_parameters = new Serializer('limit_order_create_operation_fee_parameters', { - fee: uint64 -}); - -var limit_order_cancel_operation_fee_parameters = new Serializer('limit_order_cancel_operation_fee_parameters', { - fee: uint64 -}); - -var call_order_update_operation_fee_parameters = new Serializer('call_order_update_operation_fee_parameters', { - fee: uint64 -}); - -var fill_order_operation_fee_parameters = new Serializer('fill_order_operation_fee_parameters'); - -var account_create_operation_fee_parameters = new Serializer('account_create_operation_fee_parameters', { - basic_fee: uint64, - premium_fee: uint64, - price_per_kbyte: uint32 -}); - -var account_update_operation_fee_parameters = new Serializer('account_update_operation_fee_parameters', { - fee: int64, - price_per_kbyte: uint32 -}); - -var account_whitelist_operation_fee_parameters = new Serializer('account_whitelist_operation_fee_parameters', { - fee: int64 -}); - -var account_upgrade_operation_fee_parameters = new Serializer('account_upgrade_operation_fee_parameters', { - membership_annual_fee: uint64, - membership_lifetime_fee: uint64 -}); - -var account_transfer_operation_fee_parameters = new Serializer('account_transfer_operation_fee_parameters', { - fee: uint64 -}); - -var asset_create_operation_fee_parameters = new Serializer('asset_create_operation_fee_parameters', { - symbol3: uint64, - symbol4: uint64, - long_symbol: uint64, - price_per_kbyte: uint32 -}); - -var asset_update_operation_fee_parameters = new Serializer('asset_update_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var asset_update_bitasset_operation_fee_parameters = new Serializer('asset_update_bitasset_operation_fee_parameters', { - fee: uint64 -}); - -var asset_update_feed_producers_operation_fee_parameters = new Serializer('asset_update_feed_producers_operation_fee_parameters', { - fee: uint64 -}); - -var asset_issue_operation_fee_parameters = new Serializer('asset_issue_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var asset_reserve_operation_fee_parameters = new Serializer('asset_reserve_operation_fee_parameters', { - fee: uint64 -}); - -var asset_fund_fee_pool_operation_fee_parameters = new Serializer('asset_fund_fee_pool_operation_fee_parameters', { - fee: uint64 -}); - -var asset_settle_operation_fee_parameters = new Serializer('asset_settle_operation_fee_parameters', { - fee: uint64 -}); - -var asset_global_settle_operation_fee_parameters = new Serializer('asset_global_settle_operation_fee_parameters', { - fee: uint64 -}); - -var asset_publish_feed_operation_fee_parameters = new Serializer('asset_publish_feed_operation_fee_parameters', { - fee: uint64 -}); - -var witness_create_operation_fee_parameters = new Serializer('witness_create_operation_fee_parameters', { - fee: uint64 -}); - -var witness_update_operation_fee_parameters = new Serializer('witness_update_operation_fee_parameters', { - fee: int64 -}); - -var proposal_create_operation_fee_parameters = new Serializer('proposal_create_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var proposal_update_operation_fee_parameters = new Serializer('proposal_update_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var proposal_delete_operation_fee_parameters = new Serializer('proposal_delete_operation_fee_parameters', { - fee: uint64 -}); - -var withdraw_permission_create_operation_fee_parameters = new Serializer('withdraw_permission_create_operation_fee_parameters', { - fee: uint64 -}); - -var withdraw_permission_update_operation_fee_parameters = new Serializer('withdraw_permission_update_operation_fee_parameters', { - fee: uint64 -}); - -var withdraw_permission_claim_operation_fee_parameters = new Serializer('withdraw_permission_claim_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var withdraw_permission_delete_operation_fee_parameters = new Serializer('withdraw_permission_delete_operation_fee_parameters', { - fee: uint64 -}); - -var committee_member_create_operation_fee_parameters = new Serializer('committee_member_create_operation_fee_parameters', { - fee: uint64 -}); - -var committee_member_update_operation_fee_parameters = new Serializer('committee_member_update_operation_fee_parameters', { - fee: uint64 -}); - -var committee_member_update_global_parameters_operation_fee_parameters = new Serializer('committee_member_update_global_parameters_operation_fee_parameters', { - fee: uint64 -}); - -var vesting_balance_create_operation_fee_parameters = new Serializer('vesting_balance_create_operation_fee_parameters', { - fee: uint64 -}); - -var vesting_balance_withdraw_operation_fee_parameters = new Serializer('vesting_balance_withdraw_operation_fee_parameters', { - fee: uint64 -}); - -var worker_create_operation_fee_parameters = new Serializer('worker_create_operation_fee_parameters', { - fee: uint64 -}); - -var custom_operation_fee_parameters = new Serializer('custom_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var assert_operation_fee_parameters = new Serializer('assert_operation_fee_parameters', { - fee: uint64 -}); - -var balance_claim_operation_fee_parameters = new Serializer('balance_claim_operation_fee_parameters'); - -var override_transfer_operation_fee_parameters = new Serializer('override_transfer_operation_fee_parameters', { - fee: uint64, - price_per_kbyte: uint32 -}); - -var transfer_to_blind_operation_fee_parameters = new Serializer('transfer_to_blind_operation_fee_parameters', { - fee: uint64, - price_per_output: uint32 -}); - -var blind_transfer_operation_fee_parameters = new Serializer('blind_transfer_operation_fee_parameters', { - fee: uint64, - price_per_output: uint32 -}); - -var transfer_from_blind_operation_fee_parameters = new Serializer('transfer_from_blind_operation_fee_parameters', { - fee: uint64 -}); - -var asset_settle_cancel_operation_fee_parameters = new Serializer('asset_settle_cancel_operation_fee_parameters'); - -var asset_claim_fees_operation_fee_parameters = new Serializer('asset_claim_fees_operation_fee_parameters', { - fee: uint64 -}); - -var fba_distribute_operation_fee_parameters = new Serializer('fba_distribute_operation_fee_parameters', {}); - -var asset_update_dividend_operation_fee_parameters = new Serializer('asset_update_dividend_operation_fee_parameters', { - fee: uint64 -}); - -var asset_dividend_distribution_operation_fee_parameters = new Serializer('asset_dividend_distribution_operation_fee_parameters', { - distribution_base_fee: uint64, - distribution_fee_per_holder: uint32 -}); - -var sport_create_operation_fee_parameters = new Serializer('sport_create_operation_fee_parameters', { - fee: uint64 -}); - -var sport_update_operation_fee_parameters = new Serializer('sport_update_operation_fee_parameters', { - fee: uint64 -}); - -var event_group_create_operation_fee_parameters = new Serializer('event_group_create_operation_fee_parameters', { - fee: uint64 -}); - -var event_group_update_operation_fee_parameters = new Serializer('event_group_update_operation_fee_parameters', { - fee: uint64 -}); - -var event_create_operation_fee_parameters = new Serializer('event_create_operation_fee_parameters', { - fee: uint64 -}); - -var event_update_operation_fee_parameters = new Serializer('event_update_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_rules_create_operation_fee_parameters = new Serializer('betting_market_rules_create_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_rules_update_operation_fee_parameters = new Serializer('betting_market_rules_update_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_group_create_operation_fee_parameters = new Serializer('betting_market_group_create_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_create_operation_fee_parameters = new Serializer('betting_market_create_operation_fee_parameters', { - fee: uint64 -}); - -var bet_place_operation_fee_parameters = new Serializer('bet_place_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_group_resolve_operation_fee_parameters = new Serializer('betting_market_group_resolve_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_group_resolved_operation_fee_parameters = new Serializer('betting_market_group_resolved_operation_fee_parameters'); - -var betting_market_group_cancel_unmatched_bets_operation_fee_parameters = new Serializer('betting_market_group_cancel_unmatched_bets_operation_fee_parameters', { - fee: uint64 -}); - -var bet_matched_operation_fee_parameters = new Serializer('bet_matched_operation_fee_parameters'); - -var bet_cancel_operation_fee_parameters = new Serializer('bet_cancel_operation_fee_parameters', { - fee: uint64 -}); - -var bet_canceled_operation_fee_parameters = new Serializer('bet_canceled_operation_fee_parameters'); - -var tournament_create_operation_fee_parameters = new Serializer('tournament_create_operation_fee_parameters', { - fee: int64 -}); - -var tournament_join_operation_fee_parameters = new Serializer('tournament_join_operation_fee_parameters', { - fee: int64 -}); - -var game_move_operation_fee_parameters = new Serializer('game_move_operation_fee_parameters', { - fee: int64 -}); - -var tournament_payout_operation_fee_parameters = new Serializer('tournament_payout_operation_fee_parameters'); - -var tournament_leave_operation_fee_parameters = new Serializer('tournament_leave_operation_fee_parameters', { - fee: int64 -}); - -var betting_market_group_update_operation_fee_parameters = new Serializer('betting_market_group_update_operation_fee_parameters', { - fee: uint64 -}); - -var betting_market_update_operation_fee_parameters = new Serializer('betting_market_update_operation_fee_parameters', { - fee: uint64 -}); - -var bet_adjusted_operation_fee_parameters = new Serializer('bet_adjusted_operation_fee_parameters'); - -var fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters, game_move_operation_fee_parameters, asset_update_dividend_operation_fee_parameters, asset_dividend_distribution_operation_fee_parameters, tournament_payout_operation_fee_parameters, tournament_leave_operation_fee_parameters, sport_create_operation_fee_parameters, sport_update_operation_fee_parameters, event_group_create_operation_fee_parameters, event_group_update_operation_fee_parameters, event_create_operation_fee_parameters, event_update_operation_fee_parameters, betting_market_rules_create_operation_fee_parameters, betting_market_rules_update_operation_fee_parameters, betting_market_group_create_operation_fee_parameters, betting_market_create_operation_fee_parameters, bet_place_operation_fee_parameters, betting_market_group_resolve_operation_fee_parameters, betting_market_group_resolved_operation_fee_parameters, bet_adjusted_operation_fee_parameters, betting_market_group_cancel_unmatched_bets_operation_fee_parameters, bet_matched_operation_fee_parameters, bet_cancel_operation_fee_parameters, bet_canceled_operation_fee_parameters, betting_market_group_update_operation_fee_parameters, betting_market_update_operation_fee_parameters -// Missing event_update_status -]); - -var fee_schedule = new Serializer('fee_schedule', { - parameters: set(fee_parameters), - scale: uint32 -}); - -var void_result = new Serializer('void_result'); - -var asset = new Serializer('asset', { - amount: int64, - asset_id: protocol_id_type('asset') -}); - -var operation_result = static_variant([void_result, object_id_type, asset]); - -var processed_transaction = new Serializer('processed_transaction', { - ref_block_num: uint16, - ref_block_prefix: uint32, - expiration: time_point_sec, - operations: array(operation), - extensions: set(future_extensions), - signatures: array(bytes(65)), - operation_results: array(operation_result) -}); - -var signed_block = new Serializer('signed_block', { - previous: bytes(20), - timestamp: time_point_sec, - witness: protocol_id_type('witness'), - next_secret_hash: bytes(20), - previous_secret: bytes(20), - transaction_merkle_root: bytes(20), - extensions: set(future_extensions), - witness_signature: bytes(65), - transactions: array(processed_transaction) -}); - -var block_header = new Serializer('block_header', { - previous: bytes(20), - timestamp: time_point_sec, - witness: protocol_id_type('witness'), - next_secret_hash: bytes(20), - previous_secret: bytes(20), - transaction_merkle_root: bytes(20), - extensions: set(future_extensions) -}); - -var signed_block_header = new Serializer('signed_block_header', { - previous: bytes(20), - timestamp: time_point_sec, - witness: protocol_id_type('witness'), - next_secret_hash: bytes(20), - previous_secret: bytes(20), - transaction_merkle_root: bytes(20), - extensions: set(future_extensions), - witness_signature: bytes(65) -}); - -var memo_data = new Serializer('memo_data', { - from: public_key, - to: public_key, - nonce: uint64, - message: bytes() -}); - -var transfer = new Serializer('transfer', { - fee: asset, - from: protocol_id_type('account'), - to: protocol_id_type('account'), - amount: asset, - memo: optional(memo_data), - extensions: set(future_extensions) -}); - -var limit_order_create = new Serializer('limit_order_create', { - fee: asset, - seller: protocol_id_type('account'), - amount_to_sell: asset, - min_to_receive: asset, - expiration: time_point_sec, - fill_or_kill: bool, - extensions: set(future_extensions) -}); - -var limit_order_cancel = new Serializer('limit_order_cancel', { - fee: asset, - fee_paying_account: protocol_id_type('account'), - order: protocol_id_type('limit_order'), - extensions: set(future_extensions) -}); - -var call_order_update = new Serializer('call_order_update', { - fee: asset, - funding_account: protocol_id_type('account'), - delta_collateral: asset, - delta_debt: asset, - extensions: set(future_extensions) -}); - -var fill_order = new Serializer('fill_order', { - fee: asset, - order_id: object_id_type, - account_id: protocol_id_type('account'), - pays: asset, - receives: asset -}); - -var authority = new Serializer('authority', { - weight_threshold: uint32, - account_auths: map(protocol_id_type('account'), uint16), - key_auths: map(public_key, uint16), - address_auths: map(address, uint16) -}); - -var account_options = new Serializer('account_options', { - memo_key: public_key, - voting_account: protocol_id_type('account'), - num_witness: uint16, - num_committee: uint16, - votes: set(vote_id), - extensions: set(future_extensions) -}); - -var account_create = new Serializer('account_create', { - fee: asset, - registrar: protocol_id_type('account'), - referrer: protocol_id_type('account'), - referrer_percent: uint16, - name: string, - owner: authority, - active: authority, - options: account_options, - extensions: set(future_extensions) -}); - -var account_update = new Serializer('account_update', { - fee: asset, - account: protocol_id_type('account'), - owner: optional(authority), - active: optional(authority), - new_options: optional(account_options), - extensions: set(future_extensions) -}); - -var account_whitelist = new Serializer('account_whitelist', { - fee: asset, - authorizing_account: protocol_id_type('account'), - account_to_list: protocol_id_type('account'), - new_listing: uint8, - extensions: set(future_extensions) -}); - -var account_upgrade = new Serializer('account_upgrade', { - fee: asset, - account_to_upgrade: protocol_id_type('account'), - upgrade_to_lifetime_member: bool, - extensions: set(future_extensions) -}); - -var account_transfer = new Serializer('account_transfer', { - fee: asset, - account_id: protocol_id_type('account'), - new_owner: protocol_id_type('account'), - extensions: set(future_extensions) -}); - -var price = new Serializer('price', { - base: asset, - quote: asset -}); - -var asset_options = new Serializer('asset_options', { - max_supply: int64, - market_fee_percent: uint16, - max_market_fee: int64, - issuer_permissions: uint16, - flags: uint16, - core_exchange_rate: price, - whitelist_authorities: set(protocol_id_type('account')), - blacklist_authorities: set(protocol_id_type('account')), - whitelist_markets: set(protocol_id_type('asset')), - blacklist_markets: set(protocol_id_type('asset')), - description: string, - extensions: set(future_extensions) -}); - -var bitasset_options = new Serializer('bitasset_options', { - feed_lifetime_sec: uint32, - minimum_feeds: uint8, - force_settlement_delay_sec: uint32, - force_settlement_offset_percent: uint16, - maximum_force_settlement_volume: uint16, - short_backing_asset: protocol_id_type('asset'), - extensions: set(future_extensions) -}); - -var asset_create = new Serializer('asset_create', { - fee: asset, - issuer: protocol_id_type('account'), - symbol: string, - precision: uint8, - common_options: asset_options, - bitasset_opts: optional(bitasset_options), - is_prediction_market: bool, - extensions: set(future_extensions) -}); - -var asset_update = new Serializer('asset_update', { - fee: asset, - issuer: protocol_id_type('account'), - asset_to_update: protocol_id_type('asset'), - new_issuer: optional(protocol_id_type('account')), - new_options: asset_options, - extensions: set(future_extensions) -}); - -var asset_update_bitasset = new Serializer('asset_update_bitasset', { - fee: asset, - issuer: protocol_id_type('account'), - asset_to_update: protocol_id_type('asset'), - new_options: bitasset_options, - extensions: set(future_extensions) -}); - -var asset_update_feed_producers = new Serializer('asset_update_feed_producers', { - fee: asset, - issuer: protocol_id_type('account'), - asset_to_update: protocol_id_type('asset'), - new_feed_producers: set(protocol_id_type('account')), - extensions: set(future_extensions) -}); - -var asset_issue = new Serializer('asset_issue', { - fee: asset, - issuer: protocol_id_type('account'), - asset_to_issue: asset, - issue_to_account: protocol_id_type('account'), - memo: optional(memo_data), - extensions: set(future_extensions) -}); - -var asset_reserve = new Serializer('asset_reserve', { - fee: asset, - payer: protocol_id_type('account'), - amount_to_reserve: asset, - extensions: set(future_extensions) -}); - -var asset_fund_fee_pool = new Serializer('asset_fund_fee_pool', { - fee: asset, - from_account: protocol_id_type('account'), - asset_id: protocol_id_type('asset'), - amount: int64, - extensions: set(future_extensions) -}); - -var asset_settle = new Serializer('asset_settle', { - fee: asset, - account: protocol_id_type('account'), - amount: asset, - extensions: set(future_extensions) -}); - -var asset_global_settle = new Serializer('asset_global_settle', { - fee: asset, - issuer: protocol_id_type('account'), - asset_to_settle: protocol_id_type('asset'), - settle_price: price, - extensions: set(future_extensions) -}); - -var price_feed = new Serializer('price_feed', { - settlement_price: price, - maintenance_collateral_ratio: uint16, - maximum_short_squeeze_ratio: uint16, - core_exchange_rate: price -}); - -var asset_publish_feed = new Serializer('asset_publish_feed', { - fee: asset, - publisher: protocol_id_type('account'), - asset_id: protocol_id_type('asset'), - feed: price_feed, - extensions: set(future_extensions) -}); - -var witness_create = new Serializer('witness_create', { - fee: asset, - witness_account: protocol_id_type('account'), - url: string, - block_signing_key: public_key, - initial_secret: bytes(20) -}); - -var witness_update = new Serializer('witness_update', { - fee: asset, - witness: protocol_id_type('witness'), - witness_account: protocol_id_type('account'), - new_url: optional(string), - new_signing_key: optional(public_key), - new_initial_secret: optional(bytes(20)) -}); - -var op_wrapper = new Serializer('op_wrapper', { - op: operation -}); - -var proposal_create = new Serializer('proposal_create', { - fee: asset, - fee_paying_account: protocol_id_type('account'), - expiration_time: time_point_sec, - proposed_ops: array(op_wrapper), - review_period_seconds: optional(uint32), - extensions: set(future_extensions) -}); - -var proposal_update = new Serializer('proposal_update', { - fee: asset, - fee_paying_account: protocol_id_type('account'), - proposal: protocol_id_type('proposal'), - active_approvals_to_add: set(protocol_id_type('account')), - active_approvals_to_remove: set(protocol_id_type('account')), - owner_approvals_to_add: set(protocol_id_type('account')), - owner_approvals_to_remove: set(protocol_id_type('account')), - key_approvals_to_add: set(public_key), - key_approvals_to_remove: set(public_key), - extensions: set(future_extensions) -}); - -var proposal_delete = new Serializer('proposal_delete', { - fee: asset, - fee_paying_account: protocol_id_type('account'), - using_owner_authority: bool, - proposal: protocol_id_type('proposal'), - extensions: set(future_extensions) -}); - -var withdraw_permission_create = new Serializer('withdraw_permission_create', { - fee: asset, - withdraw_from_account: protocol_id_type('account'), - authorized_account: protocol_id_type('account'), - withdrawal_limit: asset, - withdrawal_period_sec: uint32, - periods_until_expiration: uint32, - period_start_time: time_point_sec -}); - -var withdraw_permission_update = new Serializer('withdraw_permission_update', { - fee: asset, - withdraw_from_account: protocol_id_type('account'), - authorized_account: protocol_id_type('account'), - permission_to_update: protocol_id_type('withdraw_permission'), - withdrawal_limit: asset, - withdrawal_period_sec: uint32, - period_start_time: time_point_sec, - periods_until_expiration: uint32 -}); - -var withdraw_permission_claim = new Serializer('withdraw_permission_claim', { - fee: asset, - withdraw_permission: protocol_id_type('withdraw_permission'), - withdraw_from_account: protocol_id_type('account'), - withdraw_to_account: protocol_id_type('account'), - amount_to_withdraw: asset, - memo: optional(memo_data) -}); - -var withdraw_permission_delete = new Serializer('withdraw_permission_delete', { - fee: asset, - withdraw_from_account: protocol_id_type('account'), - authorized_account: protocol_id_type('account'), - withdrawal_permission: protocol_id_type('withdraw_permission') -}); - -var committee_member_create = new Serializer('committee_member_create', { - fee: asset, - committee_member_account: protocol_id_type('account'), - url: string -}); - -var committee_member_update = new Serializer('committee_member_update', { - fee: asset, - committee_member: protocol_id_type('committee_member'), - committee_member_account: protocol_id_type('account'), - new_url: optional(string) -}); - -var chain_parameters = new Serializer('chain_parameters', { - current_fees: fee_schedule, - block_interval: uint8, - maintenance_interval: uint32, - maintenance_skip_slots: uint8, - committee_proposal_review_period: uint32, - maximum_transaction_size: uint32, - maximum_block_size: uint32, - maximum_time_until_expiration: uint32, - maximum_proposal_lifetime: uint32, - maximum_asset_whitelist_authorities: uint8, - maximum_asset_feed_publishers: uint8, - maximum_witness_count: uint16, - maximum_committee_count: uint16, - maximum_authority_membership: uint16, - reserve_percent_of_fee: uint16, - network_percent_of_fee: uint16, - lifetime_referrer_percent_of_fee: uint16, - cashback_vesting_period_seconds: uint32, - cashback_vesting_threshold: int64, - count_non_member_votes: bool, - allow_non_member_whitelists: bool, - witness_pay_per_block: int64, - worker_budget_per_day: int64, - max_predicate_opcode: uint16, - fee_liquidation_threshold: int64, - accounts_per_fee_scale: uint16, - account_fee_scale_bitshifts: uint8, - max_authority_depth: uint8, - min_bet_multiplier: uint32, - max_bet_multiplier: uint32, - betting_rake_fee_percentage: uint16, - permitted_betting_odds_increments: map(uint32, uint32), - witness_schedule_algorithm: uint8, - live_betting_delay_time: uint16, - min_round_delay: uint32, - max_round_delay: uint32, - min_time_per_commit_move: uint32, - max_time_per_commit_move: uint32, - min_time_per_reveal_move: uint32, - max_time_per_reveal_move: uint32, - rake_fee_percentage: uint16, - maximum_registration_deadline: uint32, - maximum_players_in_tournament: uint16, - maximum_tournament_whitelist_length: uint16, - maximum_tournament_start_time_in_future: uint32, - maximum_tournament_start_delay: uint32, - maximum_tournament_number_of_wins: uint16, - extensions: set(future_extensions) -}); - -var committee_member_update_global_parameters = new Serializer('committee_member_update_global_parameters', { - fee: asset, - new_parameters: chain_parameters -}); - -var linear_vesting_policy_initializer = new Serializer('linear_vesting_policy_initializer', { - begin_timestamp: time_point_sec, - vesting_cliff_seconds: uint32, - vesting_duration_seconds: uint32 -}); - -var cdd_vesting_policy_initializer = new Serializer('cdd_vesting_policy_initializer', { - start_claim: time_point_sec, - vesting_seconds: uint32 -}); - -var vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]); - -var vesting_balance_create = new Serializer('vesting_balance_create', { - fee: asset, - creator: protocol_id_type('account'), - owner: protocol_id_type('account'), - amount: asset, - policy: vesting_policy_initializer -}); - -var vesting_balance_withdraw = new Serializer('vesting_balance_withdraw', { - fee: asset, - vesting_balance: protocol_id_type('vesting_balance'), - owner: protocol_id_type('account'), - amount: asset -}); - -var refund_worker_initializer = new Serializer('refund_worker_initializer'); - -var vesting_balance_worker_initializer = new Serializer('vesting_balance_worker_initializer', { - pay_vesting_period_days: uint16 -}); - -var burn_worker_initializer = new Serializer('burn_worker_initializer'); - -var worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]); - -var worker_create = new Serializer('worker_create', { - fee: asset, - owner: protocol_id_type('account'), - work_begin_date: time_point_sec, - work_end_date: time_point_sec, - daily_pay: int64, - name: string, - url: string, - initializer: worker_initializer -}); - -var custom = new Serializer('custom', { - fee: asset, - payer: protocol_id_type('account'), - required_auths: set(protocol_id_type('account')), - id: uint16, - data: bytes() -}); - -var account_name_eq_lit_predicate = new Serializer('account_name_eq_lit_predicate', { - account_id: protocol_id_type('account'), - name: string -}); - -var asset_symbol_eq_lit_predicate = new Serializer('asset_symbol_eq_lit_predicate', { - asset_id: protocol_id_type('asset'), - symbol: string -}); - -var block_id_predicate = new Serializer('block_id_predicate', { - id: bytes(20) -}); - -var predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]); - -var assert = new Serializer('assert', { - fee: asset, - fee_paying_account: protocol_id_type('account'), - predicates: array(predicate), - required_auths: set(protocol_id_type('account')), - extensions: set(future_extensions) -}); - -var balance_claim = new Serializer('balance_claim', { - fee: asset, - deposit_to_account: protocol_id_type('account'), - balance_to_claim: protocol_id_type('balance'), - balance_owner_key: public_key, - total_claimed: asset -}); - -var override_transfer = new Serializer('override_transfer', { - fee: asset, - issuer: protocol_id_type('account'), - from: protocol_id_type('account'), - to: protocol_id_type('account'), - amount: asset, - memo: optional(memo_data), - extensions: set(future_extensions) -}); - -var stealth_confirmation = new Serializer('stealth_confirmation', { - one_time_key: public_key, - to: optional(public_key), - encrypted_memo: bytes() -}); - -var blind_output = new Serializer('blind_output', { - commitment: bytes(33), - range_proof: bytes(), - owner: authority, - stealth_memo: optional(stealth_confirmation) -}); - -var transfer_to_blind = new Serializer('transfer_to_blind', { - fee: asset, - amount: asset, - from: protocol_id_type('account'), - blinding_factor: bytes(32), - outputs: array(blind_output) -}); - -var blind_input = new Serializer('blind_input', { - commitment: bytes(33), - owner: authority -}); - -var blind_transfer = new Serializer('blind_transfer', { - fee: asset, - inputs: array(blind_input), - outputs: array(blind_output) -}); - -var transfer_from_blind = new Serializer('transfer_from_blind', { - fee: asset, - amount: asset, - to: protocol_id_type('account'), - blinding_factor: bytes(32), - inputs: array(blind_input) -}); - -var asset_settle_cancel = new Serializer('asset_settle_cancel', { - fee: asset, - settlement: protocol_id_type('force_settlement'), - account: protocol_id_type('account'), - amount: asset, - extensions: set(future_extensions) -}); - -var asset_claim_fees = new Serializer('asset_claim_fees', { - fee: asset, - issuer: protocol_id_type('account'), - amount_to_claim: asset, - extensions: set(future_extensions) -}); - -var fba_distribute = new Serializer('fba_distribute', { - fee: asset, - account_id: protocol_id_type('account'), - fba_id: protocol_id_type('fba_accumulator'), - amount: int64 -}); - -var rock_paper_scissors_game_options = new Serializer('rock_paper_scissors_game_options', { - insurance_enabled: bool, - time_per_commit_move: uint32, - time_per_reveal_move: uint32, - number_of_gestures: uint8 -}); - -var game_specific_details = static_variant([rock_paper_scissors_game_options]); - -var tournament_options = new Serializer('tournament_options', { - type_of_game: uint16, - registration_deadline: time_point_sec, - number_of_players: uint32, - buy_in: asset, - whitelist: set(protocol_id_type('account')), - start_time: optional(time_point_sec), - start_delay: optional(uint32), - round_delay: uint32, - number_of_wins: uint32, - meta: variant_object, - game_options: game_specific_details -}); - -var tournament_create = new Serializer('tournament_create', { - fee: asset, - creator: protocol_id_type('account'), - options: tournament_options, - extensions: set(future_extensions) -}); - -var tournament_join = new Serializer('tournament_join', { - fee: asset, - payer_account_id: protocol_id_type('account'), - player_account_id: protocol_id_type('account'), - tournament_id: protocol_id_type('tournament'), - buy_in: asset, - extensions: set(future_extensions) -}); - -var rock_paper_scissors_gesture = enumeration(['rock', 'paper', 'scissors', 'spock', 'lizard']); - -var rock_paper_scissors_throw_commit = new Serializer('rock_paper_scissors_throw_commit', { - nonce1: uint64, - throw_hash: sha256 -}); - -var rock_paper_scissors_throw_reveal = new Serializer('rock_paper_scissors_throw_reveal', { - nonce2: uint64, - gesture: rock_paper_scissors_gesture -}); - -var game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]); - -var game_move = new Serializer('game_move', { - fee: asset, - game_id: protocol_id_type('game'), - player_account_id: protocol_id_type('account'), - move: game_specific_moves, - extensions: set(future_extensions) -}); - -var dividend_asset_options = new Serializer('dividend_asset_options', { - next_payout_time: optional(time_point_sec), - payout_interval: optional(uint32), - minimum_fee_percentage: uint64, - minimum_distribution_interval: optional(uint32), - extensions: set(future_extensions) -}); - -var asset_update_dividend = new Serializer('asset_update_dividend', { - fee: asset, - issuer: protocol_id_type('account'), - asset_to_update: protocol_id_type('asset'), - new_options: dividend_asset_options, - extensions: set(future_extensions) -}); - -var asset_dividend_distribution = new Serializer('asset_dividend_distribution', { - fee: asset, - dividend_asset_id: protocol_id_type('asset'), - account_id: protocol_id_type('account'), - amounts: set(asset), - extensions: set(future_extensions) -}); - -var sport_create = new Serializer('sport_create', { - fee: asset, - name: map(string, string), - extensions: set(future_extensions) -}); - -var sport_update = new Serializer('sport_update', { - fee: asset, - sport_id: protocol_id_type('sport'), - new_name: optional(map(string, string)), - extensions: set(future_extensions) -}); - -var event_group_create = new Serializer('event_group_create', { - fee: asset, - name: map(string, string), - sport_id: object_id_type, - extensions: set(future_extensions) -}); - -var event_group_update = new Serializer('event_group_update', { - fee: asset, - new_sport_id: optional(protocol_id_type('sport')), - new_name: optional(map(string, string)), - event_group_id: protocol_id_type('event_group'), - extensions: set(future_extensions) -}); - -var event_create = new Serializer('event_create', { - fee: asset, - name: map(string, string), - season: map(string, string), - start_time: optional(time_point_sec), - event_group_id: object_id_type, - extensions: set(future_extensions) -}); - -var event_update = new Serializer('event_update', { - fee: asset, - event_id: protocol_id_type('event'), - new_event_group_id: optional(protocol_id_type('event_group')), - new_name: optional(map(string, string)), - new_season: optional(map(string, string)), - new_start_time: optional(time_point_sec), - is_live_market: optional(bool), - extensions: set(future_extensions) -}); - -var betting_market_rules_create = new Serializer('betting_market_rules_create', { - fee: asset, - name: map(string, string), - description: map(string, string), - extensions: set(future_extensions) -}); - -var betting_market_rules_update = new Serializer('betting_market_rules_update', { - fee: asset, - new_name: optional(map(string, string)), - new_description: optional(map(string, string)), - extensions: set(future_extensions), - betting_market_rules_id: protocol_id_type('betting_market_rules') -}); - -var betting_market_group_create = new Serializer('betting_market_group_create', { - fee: asset, - description: map(string, string), - event_id: object_id_type, - rules_id: object_id_type, - asset_id: protocol_id_type('asset'), - extensions: set(future_extensions) -}); - -var betting_market_create = new Serializer('betting_market_create', { - fee: asset, - group_id: object_id_type, - description: map(string, string), - payout_condition: map(string, string), - extensions: set(future_extensions) -}); - -var bet_type = enumeration(['back', 'lay']); - -var bet_place = new Serializer('bet_place', { - fee: asset, - bettor_id: protocol_id_type('account'), - betting_market_id: protocol_id_type('betting_market'), - amount_to_bet: asset, - backer_multiplier: uint32, - back_or_lay: bet_type, - extensions: set(future_extensions) -}); - -var betting_market_resolution_type = enumeration(['win', 'not_win', 'cancel', 'BETTING_MARKET_RESOLUTION_COUNT']); - -var betting_market_group_resolve = new Serializer('betting_market_group_resolve', { - fee: asset, - betting_market_group_id: protocol_id_type('betting_market_group'), - resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type), - extensions: set(future_extensions) -}); - -var betting_market_group_resolved = new Serializer('betting_market_group_resolved', { - bettor_id: protocol_id_type('account'), - betting_market_group_id: protocol_id_type('betting_market_group'), - resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type), - winnings: int64, - fees_paid: int64, - fee: asset -}); - -var betting_market_group_cancel_unmatched_bets = new Serializer('betting_market_group_cancel_unmatched_bets', { - fee: asset, - betting_market_group_id: protocol_id_type('betting_market_group'), - extensions: set(future_extensions) -}); - -var bet_matched = new Serializer('bet_matched', { - bettor_id: protocol_id_type('account'), - bet_id: protocol_id_type('bet'), - betting_market_id: protocol_id_type('betting_market'), - amount_bet: asset, - fees_paid: int64, - backer_multiplier: uint32, - guaranteed_winnings_returned: int64 -}); - -var bet_cancel = new Serializer('bet_cancel', { - fee: asset, - bettor_id: protocol_id_type('account'), - bet_to_cancel: protocol_id_type('bet'), - extensions: set(future_extensions) -}); - -var bet_canceled = new Serializer('bet_canceled', { - bettor_id: protocol_id_type('account'), - bet_id: protocol_id_type('bet'), - stake_returned: asset, - unused_fees_returned: asset -}); - -var payout_type = enumeration(['prize_award', 'buyin_refund', 'rake_fee']); - -var tournament_payout = new Serializer('tournament_payout', { - fee: asset, - payout_account_id: protocol_id_type('account'), - tournament_id: protocol_id_type('tournament'), - payout_amount: asset, - type: payout_type, - extensions: set(future_extensions) -}); - -var tournament_leave = new Serializer('tournament_leave', { - fee: asset, - canceling_account_id: protocol_id_type('account'), - player_account_id: protocol_id_type('account'), - tournament_id: protocol_id_type('tournament'), - extensions: set(future_extensions) -}); - -var betting_market_group_update = new Serializer('betting_market_group_update', { - fee: asset, - betting_market_group_id: protocol_id_type('betting_market_group'), - new_description: optional(map(string, string)), - new_rules_id: optional(protocol_id_type('betting_market_rules')), - freeze: optional(bool), - delay_bets: optional(bool), - extensions: set(future_extensions) -}); - -var betting_market_update = new Serializer('betting_market_update', { - fee: asset, - betting_market_id: protocol_id_type('betting_market'), - new_group_id: optional(protocol_id_type('betting_market_group')), - new_description: optional(map(string, string)), - new_payout_condition: optional(map(string, string)), - extensions: set(future_extensions) -}); - -var bet_adjusted = new Serializer('bet_adjusted', { - bettor_id: protocol_id_type('account'), - bet_id: protocol_id_type('bet'), - stake_returned: asset -}); - -operation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend, asset_dividend_distribution, tournament_payout, tournament_leave, sport_create, sport_update, event_group_create, event_group_update, event_create, event_update, betting_market_rules_create, betting_market_rules_update, betting_market_group_create, betting_market_create, bet_place, betting_market_group_resolve, betting_market_group_resolved, bet_adjusted, betting_market_group_cancel_unmatched_bets, bet_matched, bet_cancel, bet_canceled, betting_market_group_update, betting_market_update]; - -var transaction = new Serializer('transaction', { - ref_block_num: uint16, - ref_block_prefix: uint32, - expiration: time_point_sec, - operations: array(operation), - extensions: set(future_extensions) -}); - -var signed_transaction = new Serializer('signed_transaction', { - ref_block_num: uint16, - ref_block_prefix: uint32, - expiration: time_point_sec, - operations: array(operation), - extensions: set(future_extensions), - signatures: array(bytes(65)) -}); -// # ------------------------------- -// # Generated code end -// # ------------------------------- - -// Betting Objects - -var sport = new Serializer('sport', { - id: protocol_id_type('sport'), - name: map(string, string) -}); - -var event_group = new Serializer('event_group', { - id: protocol_id_type('event_group'), - name: map(string, string), - sport_id: protocol_id_type('sport') -}); - -var event_status = enumeration(['upcoming', 'in_progress', 'frozen', 'finished', 'completed', 'canceled', 'STATUS_COUNT']); - -var betting_market_status = enumeration(['unresolved', 'frozen', 'graded', 'canceled', 'settled']); - -var betting_market_group_status = enumeration(['upcoming', 'in_play', 'closed', 'graded', 're-grading', 'settled', 'frozen', 'canceled']); - -var event = new Serializer('event', { - id: protocol_id_type('event'), - name: map(string, string), - season: map(string, string), - start_time: optional(time_point_sec), - event_group_id: protocol_id_type('event_group'), - is_live_market: bool, - status: event_status, - scores: array(string) -}); - -var betting_market_rules = new Serializer('betting_market_rules', { - id: protocol_id_type('betting_market_rules'), - name: map(string, string), - description: map(string, string) -}); - -var betting_market_group = new Serializer('betting_market_group', { - id: protocol_id_type('betting_market_group'), - description: map(string, string), - event_id: protocol_id_type('event'), - rules_id: protocol_id_type('betting_market_rules'), - asset_id: protocol_id_type('asset'), - total_matched_bets_amount: uint64, - frozen: bool, - delay_bets: bool, - status: betting_market_group_status -}); - -var betting_market = new Serializer('betting_market', { - id: protocol_id_type('betting_market'), - group_id: protocol_id_type('betting_market_group'), - description: map(string, string), - payout_condition: map(string, string), - status: betting_market_status -}); - -var bet = new Serializer('bet', { - id: protocol_id_type('bet'), - bettor_id: protocol_id_type('account'), - betting_market_id: protocol_id_type('betting_market'), - amount_to_bet: asset, - backer_multiplier: uint32, - back_or_lay: bet_type -}); - -var betting_market_position = new Serializer('betting_market_position', { - id: implementation_id_type('betting_market_position'), - bettor_id: protocol_id_type('account'), - betting_market_id: protocol_id_type('betting_market'), - pay_if_payout_condition: int64, - pay_if_not_payout_condition: int64, - pay_if_canceled: int64, - pay_if_not_canceled: int64, - fees_collected: int64 -}); - -var global_betting_statistics = new Serializer('global_betting_statistics', { - id: implementation_id_type('global_betting_statistics'), - number_of_active_events: uint32, - total_amount_staked: map(protocol_id_type('asset'), int64) -}); - -// eof Betting Objects - -// Custom Types - -var stealth_memo_data = new Serializer('stealth_memo_data', { - from: optional(public_key), - amount: asset, - blinding_factor: bytes(32), - commitment: bytes(33), - check: uint32 -}); -// var stealth_confirmation = new Serializer( -// "stealth_confirmation", { -// one_time_key: public_key, -// to: optional( public_key ), -// encrypted_memo: stealth_memo_data -// }) - -exports.operation = operation; -exports.transfer_operation_fee_parameters = transfer_operation_fee_parameters; -exports.limit_order_create_operation_fee_parameters = limit_order_create_operation_fee_parameters; -exports.limit_order_cancel_operation_fee_parameters = limit_order_cancel_operation_fee_parameters; -exports.call_order_update_operation_fee_parameters = call_order_update_operation_fee_parameters; -exports.fill_order_operation_fee_parameters = fill_order_operation_fee_parameters; -exports.account_create_operation_fee_parameters = account_create_operation_fee_parameters; -exports.account_update_operation_fee_parameters = account_update_operation_fee_parameters; -exports.account_whitelist_operation_fee_parameters = account_whitelist_operation_fee_parameters; -exports.account_upgrade_operation_fee_parameters = account_upgrade_operation_fee_parameters; -exports.account_transfer_operation_fee_parameters = account_transfer_operation_fee_parameters; -exports.asset_create_operation_fee_parameters = asset_create_operation_fee_parameters; -exports.asset_update_operation_fee_parameters = asset_update_operation_fee_parameters; -exports.asset_update_bitasset_operation_fee_parameters = asset_update_bitasset_operation_fee_parameters; -exports.asset_update_feed_producers_operation_fee_parameters = asset_update_feed_producers_operation_fee_parameters; -exports.asset_issue_operation_fee_parameters = asset_issue_operation_fee_parameters; -exports.asset_reserve_operation_fee_parameters = asset_reserve_operation_fee_parameters; -exports.asset_fund_fee_pool_operation_fee_parameters = asset_fund_fee_pool_operation_fee_parameters; -exports.asset_settle_operation_fee_parameters = asset_settle_operation_fee_parameters; -exports.asset_global_settle_operation_fee_parameters = asset_global_settle_operation_fee_parameters; -exports.asset_publish_feed_operation_fee_parameters = asset_publish_feed_operation_fee_parameters; -exports.witness_create_operation_fee_parameters = witness_create_operation_fee_parameters; -exports.witness_update_operation_fee_parameters = witness_update_operation_fee_parameters; -exports.proposal_create_operation_fee_parameters = proposal_create_operation_fee_parameters; -exports.proposal_update_operation_fee_parameters = proposal_update_operation_fee_parameters; -exports.proposal_delete_operation_fee_parameters = proposal_delete_operation_fee_parameters; -exports.withdraw_permission_create_operation_fee_parameters = withdraw_permission_create_operation_fee_parameters; -exports.withdraw_permission_update_operation_fee_parameters = withdraw_permission_update_operation_fee_parameters; -exports.withdraw_permission_claim_operation_fee_parameters = withdraw_permission_claim_operation_fee_parameters; -exports.withdraw_permission_delete_operation_fee_parameters = withdraw_permission_delete_operation_fee_parameters; -exports.committee_member_create_operation_fee_parameters = committee_member_create_operation_fee_parameters; -exports.committee_member_update_operation_fee_parameters = committee_member_update_operation_fee_parameters; -exports.committee_member_update_global_parameters_operation_fee_parameters = committee_member_update_global_parameters_operation_fee_parameters; -exports.vesting_balance_create_operation_fee_parameters = vesting_balance_create_operation_fee_parameters; -exports.vesting_balance_withdraw_operation_fee_parameters = vesting_balance_withdraw_operation_fee_parameters; -exports.worker_create_operation_fee_parameters = worker_create_operation_fee_parameters; -exports.custom_operation_fee_parameters = custom_operation_fee_parameters; -exports.assert_operation_fee_parameters = assert_operation_fee_parameters; -exports.balance_claim_operation_fee_parameters = balance_claim_operation_fee_parameters; -exports.override_transfer_operation_fee_parameters = override_transfer_operation_fee_parameters; -exports.transfer_to_blind_operation_fee_parameters = transfer_to_blind_operation_fee_parameters; -exports.blind_transfer_operation_fee_parameters = blind_transfer_operation_fee_parameters; -exports.transfer_from_blind_operation_fee_parameters = transfer_from_blind_operation_fee_parameters; -exports.asset_settle_cancel_operation_fee_parameters = asset_settle_cancel_operation_fee_parameters; -exports.asset_claim_fees_operation_fee_parameters = asset_claim_fees_operation_fee_parameters; -exports.fba_distribute_operation_fee_parameters = fba_distribute_operation_fee_parameters; -exports.asset_update_dividend_operation_fee_parameters = asset_update_dividend_operation_fee_parameters; -exports.asset_dividend_distribution_operation_fee_parameters = asset_dividend_distribution_operation_fee_parameters; -exports.sport_create_operation_fee_parameters = sport_create_operation_fee_parameters; -exports.sport_update_operation_fee_parameters = sport_update_operation_fee_parameters; -exports.event_group_create_operation_fee_parameters = event_group_create_operation_fee_parameters; -exports.event_group_update_operation_fee_parameters = event_group_update_operation_fee_parameters; -exports.event_create_operation_fee_parameters = event_create_operation_fee_parameters; -exports.event_update_operation_fee_parameters = event_update_operation_fee_parameters; -exports.betting_market_rules_create_operation_fee_parameters = betting_market_rules_create_operation_fee_parameters; -exports.betting_market_rules_update_operation_fee_parameters = betting_market_rules_update_operation_fee_parameters; -exports.betting_market_group_create_operation_fee_parameters = betting_market_group_create_operation_fee_parameters; -exports.betting_market_create_operation_fee_parameters = betting_market_create_operation_fee_parameters; -exports.bet_place_operation_fee_parameters = bet_place_operation_fee_parameters; -exports.betting_market_group_resolve_operation_fee_parameters = betting_market_group_resolve_operation_fee_parameters; -exports.betting_market_group_resolved_operation_fee_parameters = betting_market_group_resolved_operation_fee_parameters; -exports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = betting_market_group_cancel_unmatched_bets_operation_fee_parameters; -exports.bet_matched_operation_fee_parameters = bet_matched_operation_fee_parameters; -exports.bet_cancel_operation_fee_parameters = bet_cancel_operation_fee_parameters; -exports.bet_canceled_operation_fee_parameters = bet_canceled_operation_fee_parameters; -exports.tournament_create_operation_fee_parameters = tournament_create_operation_fee_parameters; -exports.tournament_join_operation_fee_parameters = tournament_join_operation_fee_parameters; -exports.game_move_operation_fee_parameters = game_move_operation_fee_parameters; -exports.tournament_payout_operation_fee_parameters = tournament_payout_operation_fee_parameters; -exports.tournament_leave_operation_fee_parameters = tournament_leave_operation_fee_parameters; -exports.betting_market_group_update_operation_fee_parameters = betting_market_group_update_operation_fee_parameters; -exports.betting_market_update_operation_fee_parameters = betting_market_update_operation_fee_parameters; -exports.bet_adjusted_operation_fee_parameters = bet_adjusted_operation_fee_parameters; -exports.fee_schedule = fee_schedule; -exports.void_result = void_result; -exports.asset = asset; -exports.processed_transaction = processed_transaction; -exports.signed_block = signed_block; -exports.block_header = block_header; -exports.signed_block_header = signed_block_header; -exports.memo_data = memo_data; -exports.transfer = transfer; -exports.limit_order_create = limit_order_create; -exports.limit_order_cancel = limit_order_cancel; -exports.call_order_update = call_order_update; -exports.fill_order = fill_order; -exports.authority = authority; -exports.account_options = account_options; -exports.account_create = account_create; -exports.account_update = account_update; -exports.account_whitelist = account_whitelist; -exports.account_upgrade = account_upgrade; -exports.account_transfer = account_transfer; -exports.price = price; -exports.asset_options = asset_options; -exports.bitasset_options = bitasset_options; -exports.asset_create = asset_create; -exports.asset_update = asset_update; -exports.asset_update_bitasset = asset_update_bitasset; -exports.asset_update_feed_producers = asset_update_feed_producers; -exports.asset_issue = asset_issue; -exports.asset_reserve = asset_reserve; -exports.asset_fund_fee_pool = asset_fund_fee_pool; -exports.asset_settle = asset_settle; -exports.asset_global_settle = asset_global_settle; -exports.price_feed = price_feed; -exports.asset_publish_feed = asset_publish_feed; -exports.witness_create = witness_create; -exports.witness_update = witness_update; -exports.op_wrapper = op_wrapper; -exports.proposal_create = proposal_create; -exports.proposal_update = proposal_update; -exports.proposal_delete = proposal_delete; -exports.withdraw_permission_create = withdraw_permission_create; -exports.withdraw_permission_update = withdraw_permission_update; -exports.withdraw_permission_claim = withdraw_permission_claim; -exports.withdraw_permission_delete = withdraw_permission_delete; -exports.committee_member_create = committee_member_create; -exports.committee_member_update = committee_member_update; -exports.chain_parameters = chain_parameters; -exports.committee_member_update_global_parameters = committee_member_update_global_parameters; -exports.linear_vesting_policy_initializer = linear_vesting_policy_initializer; -exports.cdd_vesting_policy_initializer = cdd_vesting_policy_initializer; -exports.vesting_balance_create = vesting_balance_create; -exports.vesting_balance_withdraw = vesting_balance_withdraw; -exports.refund_worker_initializer = refund_worker_initializer; -exports.vesting_balance_worker_initializer = vesting_balance_worker_initializer; -exports.burn_worker_initializer = burn_worker_initializer; -exports.worker_create = worker_create; -exports.custom = custom; -exports.account_name_eq_lit_predicate = account_name_eq_lit_predicate; -exports.asset_symbol_eq_lit_predicate = asset_symbol_eq_lit_predicate; -exports.block_id_predicate = block_id_predicate; -exports.assert = assert; -exports.balance_claim = balance_claim; -exports.override_transfer = override_transfer; -exports.stealth_confirmation = stealth_confirmation; -exports.blind_output = blind_output; -exports.transfer_to_blind = transfer_to_blind; -exports.blind_input = blind_input; -exports.blind_transfer = blind_transfer; -exports.transfer_from_blind = transfer_from_blind; -exports.asset_settle_cancel = asset_settle_cancel; -exports.asset_claim_fees = asset_claim_fees; -exports.fba_distribute = fba_distribute; -exports.rock_paper_scissors_game_options = rock_paper_scissors_game_options; -exports.tournament_options = tournament_options; -exports.tournament_create = tournament_create; -exports.tournament_join = tournament_join; -exports.rock_paper_scissors_gesture = rock_paper_scissors_gesture; -exports.rock_paper_scissors_throw_commit = rock_paper_scissors_throw_commit; -exports.rock_paper_scissors_throw_reveal = rock_paper_scissors_throw_reveal; -exports.game_move = game_move; -exports.dividend_asset_options = dividend_asset_options; -exports.asset_update_dividend = asset_update_dividend; -exports.asset_dividend_distribution = asset_dividend_distribution; -exports.sport_create = sport_create; -exports.sport_update = sport_update; -exports.event_group_create = event_group_create; -exports.event_group_update = event_group_update; -exports.event_create = event_create; -exports.event_update = event_update; -exports.betting_market_rules_create = betting_market_rules_create; -exports.betting_market_rules_update = betting_market_rules_update; -exports.betting_market_group_create = betting_market_group_create; -exports.betting_market_create = betting_market_create; -exports.bet_type = bet_type; -exports.bet_place = bet_place; -exports.betting_market_resolution_type = betting_market_resolution_type; -exports.betting_market_group_resolve = betting_market_group_resolve; -exports.betting_market_group_resolved = betting_market_group_resolved; -exports.betting_market_group_cancel_unmatched_bets = betting_market_group_cancel_unmatched_bets; -exports.bet_matched = bet_matched; -exports.bet_cancel = bet_cancel; -exports.bet_canceled = bet_canceled; -exports.payout_type = payout_type; -exports.tournament_payout = tournament_payout; -exports.tournament_leave = tournament_leave; -exports.betting_market_group_update = betting_market_group_update; -exports.betting_market_update = betting_market_update; -exports.bet_adjusted = bet_adjusted; -exports.transaction = transaction; -exports.signed_transaction = signed_transaction; -exports.sport = sport; -exports.event_group = event_group; -exports.event = event; -exports.betting_market_rules = betting_market_rules; -exports.betting_market_group = betting_market_group; -exports.betting_market = betting_market; -exports.bet = bet; -exports.betting_market_position = betting_market_position; -exports.global_betting_statistics = global_betting_statistics; -exports.stealth_memo_data = stealth_memo_data; -},{"24":24,"26":26}],24:[function(require,module,exports){ -(function (process,Buffer){ -'use strict'; - -exports.__esModule = true; - -var _bytebuffer = require(38); - -var _bytebuffer2 = _interopRequireDefault(_bytebuffer); - -var _error_with_cause = require(22); - -var _error_with_cause2 = _interopRequireDefault(_error_with_cause); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; - -var Serializer = function () { - function Serializer(operation_name, types) { - _classCallCheck(this, Serializer); - - this.operation_name = operation_name; - this.types = types; - - if (this.types) { - this.keys = Object.keys(this.types); - } - - Serializer.printDebug = true; - } - - Serializer.prototype.fromByteBuffer = function fromByteBuffer(b) { - var object = {}; - var field = null; - - try { - var iterable = this.keys; - - for (var i = 0; i < iterable.length; i++) { - field = iterable[i]; - var type = this.types[field]; - - try { - if (HEX_DUMP) { - if (type.operation_name) { - console.error(type.operation_name); - } else { - var o1 = b.offset; - type.fromByteBuffer(b); - var o2 = b.offset; - b.offset = o1; - // b.reset() - var _b = b.copy(o1, o2); - console.error(this.operation_name + '.' + field + '\t', _b.toHex()); - } - } - - object[field] = type.fromByteBuffer(b); - } catch (e) { - if (Serializer.printDebug) { - console.error('Error reading ' + this.operation_name + '.' + field + ' in data:'); - b.printDebug(); - } - - throw e; - } - } - } catch (error) { - _error_with_cause2.default.throw(this.operation_name + '.' + field, error); - } - - return object; - }; - - Serializer.prototype.appendByteBuffer = function appendByteBuffer(b, object) { - var field = null; - - try { - var iterable = this.keys; - - for (var i = 0; i < iterable.length; i++) { - field = iterable[i]; - var type = this.types[field]; - type.appendByteBuffer(b, object[field]); - } - } catch (error) { - try { - _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + JSON.stringify(object[field]), error); - } catch (e) { - // circular ref - _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + object[field], error); - } - } - }; - - Serializer.prototype.fromObject = function fromObject(serialized_object) { - var result = {}; - var field = null; - - try { - var iterable = this.keys; - - for (var i = 0; i < iterable.length; i++) { - field = iterable[i]; - var type = this.types[field]; - var value = serialized_object[field]; - // DEBUG value = value.resolve if value.resolve - // DEBUG console.log('... value',field,value) - var object = type.fromObject(value); - result[field] = object; - } - } catch (error) { - _error_with_cause2.default.throw(this.operation_name + '.' + field, error); - } - - return result; - }; - - /** - @arg {boolean} [debug.use_default = false] - more template friendly - @arg {boolean} [debug.annotate = false] - add user-friendly information - */ - - - Serializer.prototype.toObject = function toObject() { - var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false }; - - var result = {}; - var field = null; - - try { - if (!this.types) { - return result; - } - - var iterable = this.keys; - - for (var i = 0; i < iterable.length; i++) { - field = iterable[i]; - var type = this.types[field]; - var object = type.toObject(typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined, debug); - result[field] = object; - - if (HEX_DUMP) { - var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN); - type.appendByteBuffer(b, typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined); - b = b.copy(0, b.offset); - console.error(this.operation_name + '.' + field, b.toHex()); - } - } - } catch (error) { - _error_with_cause2.default.throw(this.operation_name + '.' + field, error); - } - - return result; - }; - - /** Sort by the first element in a operation */ - - - Serializer.prototype.compare = function compare(a, b) { - var first_key = this.keys[0]; - var first_type = this.types[first_key]; - - var valA = a[first_key]; - var valB = b[first_key]; - - if (first_type.compare) { - return first_type.compare(valA, valB); - } - - if (typeof valA === 'number' && typeof valB === 'number') { - return valA - valB; - } - - var encoding = void 0; - - if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) { - // A binary string compare does not work. If localeCompare is well supported that could - // replace HEX. Performanance is very good so comparing HEX works. - encoding = 'hex'; - } - - var strA = valA.toString(encoding); - var strB = valB.toString(encoding); - - var result = 0; - - if (strA > strB) { - result = 1; - } - - if (strA < strB) { - result = -1; - } - - return result; - }; - - // - - Serializer.prototype.fromHex = function fromHex(hex) { - var b = _bytebuffer2.default.fromHex(hex, _bytebuffer2.default.LITTLE_ENDIAN); - return this.fromByteBuffer(b); - }; - - Serializer.prototype.fromBuffer = function fromBuffer(buffer) { - var b = _bytebuffer2.default.fromBinary(buffer.toString('binary'), _bytebuffer2.default.LITTLE_ENDIAN); - return this.fromByteBuffer(b); - }; - - Serializer.prototype.toHex = function toHex(object) { - // return this.toBuffer(object).toString("hex") - var b = this.toByteBuffer(object); - return b.toHex(); - }; - - Serializer.prototype.toByteBuffer = function toByteBuffer(object) { - var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN); - this.appendByteBuffer(b, object); - return b.copy(0, b.offset); - }; - - Serializer.prototype.toBuffer = function toBuffer(object) { - return Buffer.from(this.toByteBuffer(object).toBinary(), 'binary'); - }; - - return Serializer; -}(); - -exports.default = Serializer; -module.exports = exports['default']; -}).call(this,require(77),require(35).Buffer) - -},{"22":22,"35":35,"38":38,"77":77}],25:[function(require,module,exports){ -"use strict"; - -exports.__esModule = true; -exports.default = template; /** Console print any transaction object with zero default values. */ -function template(op) { - var object = op.toObject(undefined, { use_default: true, annotate: true }); - - // visual (with descriptions) - console.error(JSON.stringify(object, null, 4)); - - // usable in a copy-paste - - object = op.toObject(undefined, { use_default: true, annotate: false }); - - // copy-paste one-lineer - console.error(JSON.stringify(object)); -} -module.exports = exports["default"]; -},{}],26:[function(require,module,exports){ -(function (process,Buffer){ -'use strict'; - -exports.__esModule = true; - -var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; // Low-level types that make up operations - -var _peerplaysjsWs = require(70); - -var _SerializerValidation = require(21); - -var _SerializerValidation2 = _interopRequireDefault(_SerializerValidation); - -var _FastParser = require(20); - -var _FastParser2 = _interopRequireDefault(_FastParser); - -var _ChainTypes = require(3); - -var _ChainTypes2 = _interopRequireDefault(_ChainTypes); - -var _ObjectId = require(4); - -var _ObjectId2 = _interopRequireDefault(_ObjectId); - -var _ecc = require(7); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -var MIN_SIGNED_32 = -1 * Math.pow(2, 31); -var MAX_SIGNED_32 = Math.pow(2, 31) - 1; - -var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; - -var strCmp = function strCmp(a, b) { - var result = 0; - - if (a > b) { - result = 1; - } +module.exports = function template(op) { - if (a < b) { - result = -1; - } - - return result; -}; - -var firstEl = function firstEl(el) { - return Array.isArray(el) ? el[0] : el; -}; - -var sortOperation = function sortOperation(array, st_operation) { - if (!st_operation.nosort) { - // If the operation has its own compare function. - if (st_operation.compare) { - return array.sort(function (a, b) { - return st_operation.compare(firstEl(a), firstEl(b)); - }); - } - - return array.sort(function (a, b) { - var aFirst = firstEl(a); - var bFirst = firstEl(b); - - // If both of the first elements are numbers. - if (typeof aFirst === 'number' && typeof bFirst === 'number') { - return aFirst - bFirst; - } - - // If they are both buffers. - if (Buffer.isBuffer(aFirst) && Buffer.isBuffer(bFirst)) { - return strCmp(aFirst.toString('hex'), bFirst.toString('hex')); - } - - // Otherwise - return strCmp(aFirst.toString(), bFirst.toString()); - }); - } - - return array; -}; - -var Types = {}; - -Types.uint8 = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readUint8(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object); - b.writeUint8(object); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object); - return object; - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return 0; - } - - _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object); - return parseInt(object, 10); - } -}; - -Types.uint16 = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readUint16(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object); - b.writeUint16(object); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object); - return object; - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return 0; - } - - _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object); - return parseInt(object, 10); - } -}; - -Types.uint32 = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readUint32(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object); - b.writeUint32(object); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object); - return object; - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return 0; - } - - _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object); - return parseInt(object, 10); - } -}; - -Types.varint32 = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readVarint32(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); - b.writeVarint32(object); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); - return object; - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return 0; - } - - _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); - return parseInt(object, 10); - } -}; - -Types.int64 = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readInt64(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - b.writeInt64(_SerializerValidation2.default.to_long(object)); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - return _SerializerValidation2.default.to_long(object); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return '0'; - } - - _SerializerValidation2.default.required(object); - return _SerializerValidation2.default.to_long(object).toString(); - } -}; - -Types.uint64 = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readUint64(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - b.writeUint64(_SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object))); - }, - fromObject: function fromObject(object) { - return _SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object)); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return '0'; - } - - return _SerializerValidation2.default.to_ulong(object).toString(); - } -}; - -Types.string = { - fromByteBuffer: function fromByteBuffer(b) { - var b_copy = void 0; - var len = b.readVarint32(); - b_copy = b.copy(b.offset, b.offset + len); - b.skip(len); - return Buffer.from(b_copy.toBinary(), 'binary'); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - b.writeVarint32(object.length); - b.append(object.toString('binary'), 'binary'); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - return Buffer.from(object); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return ''; - } - - return object.toString(); - } -}; - -Types.bytes = function (size) { - var bytes = { - fromByteBuffer: function fromByteBuffer(b) { - if (size === undefined) { - var _b_copy = void 0; - var len = b.readVarint32(); - _b_copy = b.copy(b.offset, b.offset + len); - b.skip(len); - return Buffer.from(_b_copy.toBinary(), 'binary'); - } - - var b_copy = b.copy(b.offset, b.offset + size); - b.skip(size); - return Buffer.from(b_copy.toBinary(), 'binary'); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - - if (typeof object === 'string') { - object = Buffer.from(object, 'hex'); - } - - if (size === undefined) { - b.writeVarint32(object.length); - } - - b.append(object.toString('binary'), 'binary'); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - - if (Buffer.isBuffer(object)) { - return object; - } - - return Buffer.from(object, 'hex'); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return new Array(size).join('00'); - } - - _SerializerValidation2.default.required(object); - return object.toString('hex'); - } - }; + var object = op.toObject(void 0, { use_default: true, annotate: true }); - return bytes; -}; + // visual (with descriptions) + console.error(JSON.stringify(object, null, 4)); -Types.bool = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readUint8() === 1; - }, - appendByteBuffer: function appendByteBuffer(b, object) { - // supports boolean or integer - b.writeUint8(JSON.parse(object) ? 1 : 0); - }, - fromObject: function fromObject(object) { - return !!JSON.parse(object); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + // usable in a copy-paste - if (debug.use_default && object === undefined) { - return false; - } + object = op.toObject(void 0, { use_default: true, annotate: false }); - return !!JSON.parse(object); - } + // copy-paste one-lineer + console.error(JSON.stringify(object)); }; +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/types.js":[function(require,module,exports){ +(function (process,Buffer){ +'use strict'; -Types.void = { - fromByteBuffer: function fromByteBuffer() { - throw new Error('(void) undefined type'); - }, - appendByteBuffer: function appendByteBuffer() { - throw new Error('(void) undefined type'); - }, - fromObject: function fromObject() { - throw new Error('(void) undefined type'); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); - if (debug.use_default && object === undefined) { - return undefined; - } +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - throw new Error('(void) undefined type'); - } -}; +// Low-level types that make up operations -Types.array = function (st_operation) { - var array = { - fromByteBuffer: function fromByteBuffer(b) { - var size = b.readVarint32(); +var v = require('./SerializerValidation'); +var fp = require('./FastParser'); - if (HEX_DUMP) { - console.log('varint32 size = ' + size.toString(16)); - } +var ChainTypes = require("../../chain/src/ChainTypes"); +var ObjectId = require("../../chain/src/ObjectId"); - var result = []; +var _require = require("../../ecc"), + PublicKey = _require.PublicKey, + Address = _require.Address; - for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) { - result.push(st_operation.fromByteBuffer(b)); - } +var _require2 = require("peerplaysjs-ws"), + ChainConfig = _require2.ChainConfig; + +var Types = {}; +module.exports = Types; + +var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; - return sortOperation(result, st_operation); +Types.uint8 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint8(); }, appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - object = sortOperation(object, st_operation); - b.writeVarint32(object.length); - - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - st_operation.appendByteBuffer(b, o); - } + v.require_range(0, 0xFF, object, 'uint8 ' + object); + b.writeUint8(object); + return; }, fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - object = sortOperation(object, st_operation); - var result = []; - - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - result.push(st_operation.fromObject(o)); - } - - return result; + v.require_range(0, 0xFF, object, 'uint8 ' + object); + return object; }, toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return [st_operation.toObject(object, debug)]; - } - - _SerializerValidation2.default.required(object); - object = sortOperation(object, st_operation); - - var result = []; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - result.push(st_operation.toObject(o, debug)); - } - - return result; + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(0, 0xFF, object, 'uint8 ' + object); + return parseInt(object); } - }; - - return array; }; -Types.time_point_sec = { - fromByteBuffer: function fromByteBuffer(b) { - return b.readUint32(); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - if (typeof object !== 'number') { - object = Types.time_point_sec.fromObject(object); - } - - b.writeUint32(object); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); +Types.uint16 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint16(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(0, 0xFFFF, object, 'uint16 ' + object); + b.writeUint16(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(0, 0xFFFF, object, 'uint16 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (typeof object === 'number') { - return object; + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(0, 0xFFFF, object, 'uint16 ' + object); + return parseInt(object); } +}; - if (object.getTime) { - return Math.floor(object.getTime() / 1000); - } +Types.uint32 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object); + b.writeUint32(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (typeof object !== 'string') { - throw new Error('Unknown date type: ' + object); + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object); + return parseInt(object); } +}; - // if(typeof object === "string" && !/Z$/.test(object)) - // object = object + "Z" +var MIN_SIGNED_32 = -1 * Math.pow(2, 31); +var MAX_SIGNED_32 = Math.pow(2, 31) - 1; - return Math.floor(new Date(object).getTime() / 1000); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; +Types.varint32 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readVarint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + b.writeVarint32(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (debug.use_default && object === undefined) { - return new Date(0).toISOString().split('.')[0]; + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + return parseInt(object); } +}; - _SerializerValidation2.default.required(object); - - if (typeof object === 'string') { - return object; - } +Types.int64 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readInt64(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + b.writeInt64(v.to_long(object)); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + return v.to_long(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (object.getTime) { - return object.toISOString().split('.')[0]; + if (debug.use_default && object === undefined) { + return "0"; + } + v.required(object); + return v.to_long(object).toString(); } - - var int = parseInt(object, 10); - _SerializerValidation2.default.require_range(0, 0xffffffff, int, 'uint32 ' + object); - return new Date(int * 1000).toISOString().split('.')[0]; - } }; -Types.set = function (st_operation) { - var set_object = { - validate: function validate(array) { - var dup_map = {}; - - for (var i = 0, len = array.length; i < len; i++) { - var o = array[i]; - var ref = typeof o === 'undefined' ? 'undefined' : _typeof(o); - - if (['string', 'number'].indexOf(ref) >= 0) { - if (dup_map[o] !== undefined) { - throw new Error('duplicate (set)'); - } +Types.uint64 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint64(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + b.writeUint64(v.to_ulong(v.unsigned(object))); + return; + }, + fromObject: function fromObject(object) { + return v.to_ulong(v.unsigned(object)); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - dup_map[o] = true; + if (debug.use_default && object === undefined) { + return "0"; } - } + return v.to_ulong(object).toString(); + } +}; - return sortOperation(array, st_operation); - }, +Types.string = { fromByteBuffer: function fromByteBuffer(b) { - var size = b.readVarint32(); + var b_copy; + var len = b.readVarint32(); + b_copy = b.copy(b.offset, b.offset + len), b.skip(len); + return new Buffer(b_copy.toBinary(), 'binary'); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + b.writeVarint32(object.length); + b.append(object.toString('binary'), 'binary'); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + return new Buffer(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (HEX_DUMP) { - console.log('varint32 size = ' + size.toString(16)); - } + if (debug.use_default && object === undefined) { + return ""; + } + return object.toString(); + } +}; - return this.validate(function () { - var result = []; +Types.bytes = function (size) { + return { + fromByteBuffer: function fromByteBuffer(b) { + if (size === undefined) { + var b_copy; + var len = b.readVarint32(); + b_copy = b.copy(b.offset, b.offset + len), b.skip(len); + return new Buffer(b_copy.toBinary(), 'binary'); + } else { + b_copy = b.copy(b.offset, b.offset + size), b.skip(size); + return new Buffer(b_copy.toBinary(), 'binary'); + } + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + if (typeof object === "string") object = new Buffer(object, "hex"); - for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) { - result.push(st_operation.fromByteBuffer(b)); + if (size === undefined) { + b.writeVarint32(object.length); + } + b.append(object.toString('binary'), 'binary'); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + if (Buffer.isBuffer(object)) return object; + + return new Buffer(object, 'hex'); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + var zeros = function zeros(num) { + return new Array(num).join("00"); + }; + return zeros(size); + } + v.required(object); + return object.toString('hex'); } + }; +}; - return result; - }()); +Types.bool = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint8() === 1; }, appendByteBuffer: function appendByteBuffer(b, object) { - if (!object) { - object = []; - } - - b.writeVarint32(object.length); - var iterable = this.validate(object); - - for (var i = 0, len = iterable.length; i < len; i++) { - var o = iterable[i]; - st_operation.appendByteBuffer(b, o); - } + // supports boolean or integer + b.writeUint8(JSON.parse(object) ? 1 : 0); + return; }, fromObject: function fromObject(object) { - if (!object) { - object = []; - } - - return this.validate(function () { - var result = []; - - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - result.push(st_operation.fromObject(o)); - } - - return result; - }()); + return JSON.parse(object) ? true : false; }, toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return [st_operation.toObject(object, debug)]; - } - - if (!object) { - object = []; - } - - var result = []; - - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - result.push(st_operation.toObject(o, debug)); - } + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - return this.validate(result); + if (debug.use_default && object === undefined) { + return false; + } + return JSON.parse(object) ? true : false; } - }; - - return set_object; }; -Types.fixed_array = function (count, st_operation) { - var fixed_array = { +Types.void = { fromByteBuffer: function fromByteBuffer(b) { - var results = []; - - for (var i = 0, ref = count; i < ref; i++) { - results.push(st_operation.fromByteBuffer(b)); - } - - return sortOperation(results, st_operation); + throw new Error("(void) undefined type"); }, appendByteBuffer: function appendByteBuffer(b, object) { - if (count !== 0) { - _SerializerValidation2.default.required(object); - object = sortOperation(object, st_operation); - } - - for (var i = 0, ref = count; i < ref; i++) { - st_operation.appendByteBuffer(b, object[i]); - } + throw new Error("(void) undefined type"); }, fromObject: function fromObject(object) { - if (count !== 0) { - _SerializerValidation2.default.required(object); - } - - var results = []; - - for (var i = 0, ref = count; i < ref; i++) { - results.push(st_operation.fromObject(object[i])); - } - - return results; + throw new Error("(void) undefined type"); }, - toObject: function toObject(object, debug) { - if (debug == null) { - debug = {}; - } - - var results = void 0; - - if (debug.use_default && object === undefined) { - results = []; + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - for (var i = 0, ref = count; i < ref; i++) { - results.push(st_operation.toObject(undefined, debug)); + if (debug.use_default && object === undefined) { + return undefined; } + throw new Error("(void) undefined type"); + } +}; - return results; - } - - if (count !== 0) { - _SerializerValidation2.default.required(object); - } - - results = []; - - for (var _i = 0, _ref = count; _i < _ref; _i++) { - results.push(st_operation.toObject(object[_i], debug)); - } +Types.array = function (st_operation) { + return { + fromByteBuffer: function fromByteBuffer(b) { + var size = b.readVarint32(); + if (HEX_DUMP) { + console.log("varint32 size = " + size.toString(16)); + } + var result = []; + for (var i = 0; 0 < size ? i < size : i > size; 0 < size ? i++ : i++) { + result.push(st_operation.fromByteBuffer(b)); + } + return sortOperation(result, st_operation); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + object = sortOperation(object, st_operation); + b.writeVarint32(object.length); + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + st_operation.appendByteBuffer(b, o); + } + }, + fromObject: function fromObject(object) { + v.required(object); + object = sortOperation(object, st_operation); + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.fromObject(o)); + } + return result; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - return results; - } - }; + if (debug.use_default && object === undefined) { + return [st_operation.toObject(object, debug)]; + } + v.required(object); + object = sortOperation(object, st_operation); - return fixed_array; + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.toObject(o, debug)); + } + return result; + } + }; }; -/* Supports instance numbers (11) or object types (1.2.11). Object type -Validation is enforced when an object type is used. */ -Types.id_type = function (reserved_spaces, object_type) { - _SerializerValidation2.default.required(reserved_spaces, 'reserved_spaces'); - _SerializerValidation2.default.required(object_type, 'object_type'); - - var id_type_object = { +Types.time_point_sec = { fromByteBuffer: function fromByteBuffer(b) { - return b.readVarint32(); + return b.readUint32(); }, appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - - if (object.resolve !== undefined) { - object = object.resolve; - } - - // convert 1.2.n into just n - if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { - object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object); - } + if (typeof object !== "number") object = Types.time_point_sec.fromObject(object); - b.writeVarint32(_SerializerValidation2.default.to_number(object)); + b.writeUint32(object); + return; }, fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); + v.required(object); - if (object.resolve !== undefined) { - object = object.resolve; - } + if (typeof object === "number") return object; - if (_SerializerValidation2.default.is_digits(object)) { - return _SerializerValidation2.default.to_number(object); - } + if (object.getTime) return Math.floor(object.getTime() / 1000); - return _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object); + if (typeof object !== "string") throw new Error("Unknown date type: " + object); + + // if(typeof object === "string" && !/Z$/.test(object)) + // object = object + "Z" + + return Math.floor(new Date(object).getTime() / 1000); }, toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - var object_type_id = _ChainTypes2.default.object_type[object_type]; - - if (debug.use_default && object === undefined) { - return reserved_spaces + '.' + object_type_id + '.0'; - } + if (debug.use_default && object === undefined) return new Date(0).toISOString().split('.')[0]; - _SerializerValidation2.default.required(object); + v.required(object); - if (object.resolve !== undefined) { - object = object.resolve; - } + if (typeof object === "string") return object; - if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { - object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object); - } + if (object.getTime) return object.toISOString().split('.')[0]; - return reserved_spaces + '.' + object_type_id + '.' + object; + var int = parseInt(object); + v.require_range(0, 0xFFFFFFFF, int, 'uint32 ' + object); + return new Date(int * 1000).toISOString().split('.')[0]; } - }; - - return id_type_object; }; -Types.protocol_id_type = function (name) { - _SerializerValidation2.default.required(name, 'name'); - return Types.id_type(_ChainTypes2.default.reserved_spaces.protocol_ids, name); -}; - -Types.implementation_id_type = function (name) { - var result = Types.id_type(_ChainTypes2.default.reserved_spaces.implementation_ids, name); - return result; +Types.set = function (st_operation) { + return { + validate: function validate(array) { + var dup_map = {}; + for (var i = 0, o; i < array.length; i++) { + o = array[i]; + var ref; + if (ref = typeof o === 'undefined' ? 'undefined' : _typeof(o), ['string', 'number'].indexOf(ref) >= 0) { + if (dup_map[o] !== undefined) { + throw new Error("duplicate (set)"); + } + dup_map[o] = true; + } + } + return sortOperation(array, st_operation); + }, + fromByteBuffer: function fromByteBuffer(b) { + var size = b.readVarint32(); + if (HEX_DUMP) { + console.log("varint32 size = " + size.toString(16)); + } + return this.validate(function () { + var result = []; + for (var i = 0; 0 < size ? i < size : i > size; 0 < size ? i++ : i++) { + result.push(st_operation.fromByteBuffer(b)); + } + return result; + }()); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (!object) { + object = []; + } + b.writeVarint32(object.length); + var iterable = this.validate(object); + for (var i = 0, o; i < iterable.length; i++) { + o = iterable[i]; + st_operation.appendByteBuffer(b, o); + } + return; + }, + fromObject: function fromObject(object) { + if (!object) { + object = []; + } + return this.validate(function () { + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.fromObject(o)); + } + return result; + }()); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [st_operation.toObject(object, debug)]; + } + if (!object) { + object = []; + } + return this.validate(function () { + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.toObject(o, debug)); + } + return result; + }()); + } + }; }; -Types.object_id_type = { - fromByteBuffer: function fromByteBuffer(b) { - return _ObjectId2.default.fromByteBuffer(b); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - - if (object.resolve !== undefined) { - object = object.resolve; - } - - object = _ObjectId2.default.fromString(object); - object.appendByteBuffer(b); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - - if (object.resolve !== undefined) { - object = object.resolve; - } - - return _ObjectId2.default.fromString(object); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return '0.0.0'; - } - - _SerializerValidation2.default.required(object); - - if (object.resolve !== undefined) { - object = object.resolve; - } - - object = _ObjectId2.default.fromString(object); - return object.toString(); - } +// global_parameters_update_operation current_fees +Types.fixed_array = function (count, st_operation) { + return { + fromByteBuffer: function fromByteBuffer(b) { + var i, j, ref, results; + results = []; + for (i = j = 0, ref = count; j < ref; i = j += 1) { + results.push(st_operation.fromByteBuffer(b)); + } + return sortOperation(results, st_operation); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + var i, j, ref; + if (count !== 0) { + v.required(object); + object = sortOperation(object, st_operation); + } + for (i = j = 0, ref = count; j < ref; i = j += 1) { + st_operation.appendByteBuffer(b, object[i]); + } + }, + fromObject: function fromObject(object) { + var i, j, ref, results; + if (count !== 0) { + v.required(object); + } + results = []; + for (i = j = 0, ref = count; j < ref; i = j += 1) { + results.push(st_operation.fromObject(object[i])); + } + return results; + }, + toObject: function toObject(object, debug) { + var i, j, k, ref, ref1, results, results1; + if (debug == null) { + debug = {}; + } + if (debug.use_default && object === void 0) { + results = []; + for (i = j = 0, ref = count; j < ref; i = j += 1) { + results.push(st_operation.toObject(void 0, debug)); + } + return results; + } + if (count !== 0) { + v.required(object); + } + results1 = []; + for (i = k = 0, ref1 = count; k < ref1; i = k += 1) { + results1.push(st_operation.toObject(object[i], debug)); + } + return results1; + } + }; }; -Types.vote_id = { - TYPE: 0x000000ff, - ID: 0xffffff00, - fromByteBuffer: function fromByteBuffer(b) { - var value = b.readUint32(); +/* Supports instance numbers (11) or object types (1.2.11). Object type +Validation is enforced when an object type is used. */ +var id_type = function id_type(reserved_spaces, object_type) { + v.required(reserved_spaces, "reserved_spaces"); + v.required(object_type, "object_type"); return { - type: value & this.TYPE, // eslint-disable-line - id: value & this.ID // eslint-disable-line - }; - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - - if (object === 'string') { - object = Types.vote_id.fromObject(object); - } - - var value = object.id << 8 | object.type; // eslint-disable-line - b.writeUint32(value); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object, '(type vote_id)'); - - if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object') { - _SerializerValidation2.default.required(object.type, 'type'); - _SerializerValidation2.default.required(object.id, 'id'); - return object; - } - - _SerializerValidation2.default.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object); - - var _object$split = object.split(':'), - type = _object$split[0], - id = _object$split[1]; - - _SerializerValidation2.default.require_range(0, 0xff, type, 'vote type ' + object); - _SerializerValidation2.default.require_range(0, 0xffffff, id, 'vote id ' + object); - return { type: type, id: id }; - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return '0:0'; - } - - _SerializerValidation2.default.required(object); - - if (typeof object === 'string') { - object = Types.vote_id.fromObject(object); - } - - return object.type + ':' + object.id; - }, - compare: function compare(a, b) { - if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== 'object') { - a = Types.vote_id.fromObject(a); - } + fromByteBuffer: function fromByteBuffer(b) { + return b.readVarint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + // convert 1.2.n into just n + if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { + object = v.get_instance(reserved_spaces, object_type, object); + } + b.writeVarint32(v.to_number(object)); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + if (v.is_digits(object)) { + return v.to_number(object); + } + return v.get_instance(reserved_spaces, object_type, object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var object_type_id = ChainTypes.object_type[object_type]; + if (debug.use_default && object === undefined) { + return reserved_spaces + '.' + object_type_id + '.0'; + } + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { + object = v.get_instance(reserved_spaces, object_type, object); + } - if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== 'object') { - b = Types.vote_id.fromObject(b); - } + return reserved_spaces + '.' + object_type_id + '.' + object; + } + }; +}; - return parseInt(a.id, 10) - parseInt(b.id, 10); - } +Types.protocol_id_type = function (name) { + v.required(name, "name"); + return id_type(ChainTypes.reserved_spaces.protocol_ids, name); }; -Types.optional = function (st_operation) { - _SerializerValidation2.default.required(st_operation, 'st_operation'); - return { +Types.object_id_type = { fromByteBuffer: function fromByteBuffer(b) { - if (!(b.readUint8() === 1)) { - return undefined; - } - - return st_operation.fromByteBuffer(b); + return ObjectId.fromByteBuffer(b); }, appendByteBuffer: function appendByteBuffer(b, object) { - if (object !== null && object !== undefined) { - b.writeUint8(1); - st_operation.appendByteBuffer(b, object); - } else { - b.writeUint8(0); - } + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + object = ObjectId.fromString(object); + object.appendByteBuffer(b); + return; }, fromObject: function fromObject(object) { - if (object === undefined) { - return undefined; - } - - return st_operation.fromObject(object); + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + return ObjectId.fromString(object); }, toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - // toObject is only null save if use_default is true - var result_object = function () { - if (!debug.use_default && object === undefined) { - return undefined; + if (debug.use_default && object === undefined) { + return "0.0.0"; } - - return st_operation.toObject(object, debug); - }(); - - if (debug.annotate) { - if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === 'object') { - result_object.__optional = 'parent is optional'; - } else { - result_object = { __optional: result_object }; + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; } - } - - return result_object; + object = ObjectId.fromString(object); + return object.toString(); } - }; }; -Types.static_variant = function (_st_operations) { - var static_variant = { - nosort: true, - st_operations: _st_operations, +Types.vote_id = { TYPE: 0x000000FF, + ID: 0xFFFFFF00, fromByteBuffer: function fromByteBuffer(b) { - var type_id = b.readVarint32(); - var st_operation = this.st_operations[type_id]; - - if (HEX_DUMP) { - console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')'); - } - - _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); - return [type_id, st_operation.fromByteBuffer(b)]; + var value = b.readUint32(); + return { + type: value & this.TYPE, + id: value & this.ID + }; }, appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - var type_id = object[0]; - var st_operation = this.st_operations[type_id]; - _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); - b.writeVarint32(type_id); - st_operation.appendByteBuffer(b, object[1]); + v.required(object); + if (object === "string") object = Types.vote_id.fromObject(object); + + var value = object.id << 8 | object.type; + b.writeUint32(value); + return; }, fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - var type_id = object[0]; - var st_operation = this.st_operations[type_id]; + v.required(object, "(type vote_id)"); + if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === "object") { + v.required(object.type, "type"); + v.required(object.id, "id"); + return object; + } + v.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object); - _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); - return [type_id, st_operation.fromObject(object[1])]; + var _object$split = object.split(':'), + _object$split2 = _slicedToArray(_object$split, 2), + type = _object$split2[0], + id = _object$split2[1]; + + v.require_range(0, 0xff, type, 'vote type ' + object); + v.require_range(0, 0xffffff, id, 'vote id ' + object); + return { type: type, id: id }; }, toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (debug.use_default && object === undefined) { - return [0, this.st_operations[0].toObject(undefined, debug)]; - } + if (debug.use_default && object === undefined) { + return "0:0"; + } + v.required(object); + if (typeof object === "string") object = Types.vote_id.fromObject(object); - _SerializerValidation2.default.required(object); - var type_id = object[0]; - var st_operation = this.st_operations[type_id]; - _SerializerValidation2.default.required(st_operation, 'operation ' + type_id); - return [type_id, st_operation.toObject(object[1], debug)]; + return object.type + ":" + object.id; + }, + compare: function compare(a, b) { + if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== "object") a = Types.vote_id.fromObject(a); + if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== "object") b = Types.vote_id.fromObject(b); + return parseInt(a.id) - parseInt(b.id); } - }; - - return static_variant; }; -Types.map = function (key_st_operation, value_st_operation) { - var map_object = { - validate: function validate(array) { - if (!Array.isArray(array)) { - throw new Error('expecting array'); - } +Types.optional = function (st_operation) { + v.required(st_operation, "st_operation"); + return { + fromByteBuffer: function fromByteBuffer(b) { + if (!(b.readUint8() === 1)) { + return undefined; + } + return st_operation.fromByteBuffer(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (object !== null && object !== undefined) { + b.writeUint8(1); + st_operation.appendByteBuffer(b, object); + } else { + b.writeUint8(0); + } + return; + }, + fromObject: function fromObject(object) { + if (object === undefined) { + return undefined; + } + return st_operation.fromObject(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + // toObject is only null save if use_default is true + var result_object = function () { + if (!debug.use_default && object === undefined) { + return undefined; + } else { + return st_operation.toObject(object, debug); + } + }(); + + if (debug.annotate) { + if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === "object") { + result_object.__optional = "parent is optional"; + } else { + result_object = { __optional: result_object }; + } + } + return result_object; + } + }; +}; - var dup_map = {}; +Types.static_variant = function (_st_operations) { + return { + nosort: true, + st_operations: _st_operations, + fromByteBuffer: function fromByteBuffer(b) { + var type_id = b.readVarint32(); + var st_operation = this.st_operations[type_id]; + if (HEX_DUMP) { + console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')'); + } + v.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.fromByteBuffer(b)]; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + v.required(st_operation, 'operation ' + type_id); + b.writeVarint32(type_id); + st_operation.appendByteBuffer(b, object[1]); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + v.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.fromObject(object[1])]; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [0, this.st_operations[0].toObject(undefined, debug)]; + } + v.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + v.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.toObject(object[1], debug)]; + } + }; +}; - for (var i = 0, len = array.length; i < len; i++) { - var o = array[i]; - var ref = void 0; +Types.map = function (key_st_operation, value_st_operation) { + return { + validate: function validate(array) { + if (!Array.isArray(array)) { + throw new Error("expecting array"); + } + var dup_map = {}; + for (var i = 0, o; i < array.length; i++) { + o = array[i]; + var ref; + if (!(o.length === 2)) { + throw new Error("expecting two elements"); + } + if (ref = _typeof(o[0]), ['number', 'string'].indexOf(ref) >= 0) { + if (dup_map[o[0]] !== undefined) { + throw new Error("duplicate (map)"); + } + dup_map[o[0]] = true; + } + } + return sortOperation(array, key_st_operation); + }, + fromByteBuffer: function fromByteBuffer(b) { + var result = []; + var end = b.readVarint32(); + for (var i = 0; 0 < end ? i < end : i > end; 0 < end ? i++ : i++) { + result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]); + } + return this.validate(result); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + this.validate(object); + b.writeVarint32(object.length); + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + key_st_operation.appendByteBuffer(b, o[0]); + value_st_operation.appendByteBuffer(b, o[1]); + } + return; + }, + fromObject: function fromObject(object) { + v.required(object); + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]); + } + return this.validate(result); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (!(o.length === 2)) { - throw new Error('expecting two elements'); + if (debug.use_default && object === undefined) { + return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]]; + } + v.required(object); + object = this.validate(object); + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]); + } + return result; } + }; +}; - ref = _typeof(o[0]); - - if (ref && ['number', 'string'].indexOf(ref) >= 0) { - if (dup_map[o[0]] !== undefined) { - throw new Error('duplicate (map)'); - } +Types.public_key = { + toPublic: function toPublic(object) { + if (object.resolve !== undefined) { + object = object.resolve; + } - dup_map[o[0]] = true; + if (object instanceof PublicKey) { + return object; } - } - return sortOperation(array, key_st_operation); + return object == null ? object : object.Q ? object : PublicKey.fromStringOrThrow(object); }, fromByteBuffer: function fromByteBuffer(b) { - var result = []; - var end = b.readVarint32(); - - for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) { - result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]); - } - - return this.validate(result); + return fp.public_key(b); }, appendByteBuffer: function appendByteBuffer(b, object) { - this.validate(object); - b.writeVarint32(object.length); - - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - key_st_operation.appendByteBuffer(b, o[0]); - value_st_operation.appendByteBuffer(b, o[1]); - } + v.required(object); + fp.public_key(b, Types.public_key.toPublic(object)); + return; }, fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - var result = []; - - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]); - } - - return this.validate(result); + v.required(object); + if (object.Q) { + return object; + } + return Types.public_key.toPublic(object); }, toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]]; - } - - _SerializerValidation2.default.required(object); - object = this.validate(object); - var result = []; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - for (var i = 0, len = object.length; i < len; i++) { - var o = object[i]; - result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]); - } - - return result; - } - }; - - return map_object; -}; - -Types.public_key = { - toPublic: function toPublic(object) { - if (object.resolve !== undefined) { - object = object.resolve; - } - - if (object instanceof _ecc.PublicKey) { - return object; - } - - var result = object; - - if (!object) { - return null; - } - - if (!object.Q) { - result = _ecc.PublicKey.fromStringOrThrow(object); - } - - return result; - }, - fromByteBuffer: function fromByteBuffer(b) { - return _FastParser2.default.public_key(b); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _SerializerValidation2.default.required(object); - _FastParser2.default.public_key(b, Types.public_key.toPublic(object)); - }, - fromObject: function fromObject(object) { - _SerializerValidation2.default.required(object); - - if (object.Q) { - return object; - } - - return Types.public_key.toPublic(object); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - if (debug.use_default && object === undefined) { - return _peerplaysjsWs.ChainConfig.address_prefix + '859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM'; + if (debug.use_default && object === undefined) { + return ChainConfig.address_prefix + "859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM"; + } + v.required(object); + return object.toString(); + }, + compare: function compare(a, b) { + return strCmp(a.toAddressString(), b.toAddressString()); } - - _SerializerValidation2.default.required(object); - return object.toString(); - }, - compare: function compare(a, b) { - return strCmp(a.toAddressString(), b.toAddressString()); - } }; Types.address = { - _to_address: function _to_address(object) { - _SerializerValidation2.default.required(object); - - if (object.addy) { - return object; - } - - return _ecc.Address.fromString(object); - }, - fromByteBuffer: function fromByteBuffer(b) { - return new _ecc.Address(_FastParser2.default.ripemd160(b)); - }, - appendByteBuffer: function appendByteBuffer(b, object) { - _FastParser2.default.ripemd160(b, Types.address._to_address(object).toBuffer()); - }, - fromObject: function fromObject(object) { - return Types.address._to_address(object); - }, - toObject: function toObject(object) { - var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + _to_address: function _to_address(object) { + v.required(object); + if (object.addy) { + return object; + } + return Address.fromString(object); + }, + fromByteBuffer: function fromByteBuffer(b) { + return new Address(fp.ripemd160(b)); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + fp.ripemd160(b, Types.address._to_address(object).toBuffer()); + return; + }, + fromObject: function fromObject(object) { + return Types.address._to_address(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - if (debug.use_default && object === undefined) { - return _peerplaysjsWs.ChainConfig.address_prefix + '664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S'; + if (debug.use_default && object === undefined) { + return ChainConfig.address_prefix + "664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S"; + } + return Types.address._to_address(object).toString(); + }, + compare: function compare(a, b) { + return strCmp(a.toString(), b.toString()); } - - return Types.address._to_address(object).toString(); - }, - compare: function compare(a, b) { - return strCmp(a.toString(), b.toString()); - } }; Types.variant = { - fromByteBuffer: function fromByteBuffer(b) { - var type = b.readUint8(); - - switch (type) { - case 0: - return null; - case 1: - return Types.int64.fromByteBuffer(b); - case 2: - return Types.uint64.fromByteBuffer(b); - case 3: - return b.readDouble(); - case 4: - return Types.bool.fromByteBuffer(b); - case 5: - return Types.string.fromByteBuffer(b); - case 6: - return Types.array(Types.variant).fromByteBuffer(b); - case 7: - default: - return Types.variant_object.fromByteBuffer(b); - } - }, - appendByteBuffer: function appendByteBuffer(b, object) { - if (typeof object === 'number') { - if (Number.isInteger(object)) { - if (object >= 0) { - b.writeUint8(2); - Types.uint64.appendByteBuffer(b, object); + fromByteBuffer: function fromByteBuffer(b) { + var type = b.readUint8(); + switch (type) { + case 0: + return null; + case 1: + return Types.int64.fromByteBuffer(b); + case 2: + return Types.uint64.fromByteBuffer(b); + case 3: + return b.readDouble(); + case 4: + return Types.bool.fromByteBuffer(b); + case 5: + return Types.string.fromByteBuffer(b); + case 6: + return Types.array(Types.variant).fromByteBuffer(b); + case 7: + default: + return Types.variant_object.fromByteBuffer(b); + }; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (typeof object == 'number') { + if (Number.isInteger(object)) { + if (object >= 0) { + b.writeUint8(2); + Types.uint64.appendByteBuffer(b, object); + } else { + b.writeUint8(1); + Types.int64.appendByteBuffer(b, object); + } + } else { + b.writeUint8(3); + b.writeDouble(Number.parseFloat(object)); + } + } else if (typeof object == 'boolean') { + b.writeUint8(4); + Types.bool.appendByteBuffer(b, object); + } else if (typeof object == 'string') { + b.writeUint8(5); + Types.string.appendByteBuffer(b, object); + } else if (typeof object == 'array') { + b.writeUint8(6); + Types.array(Types.variant).appendByteBuffer(b, object); } else { - b.writeUint8(1); - Types.int64.appendByteBuffer(b, object); + b.writeUint8(7); + Types.variant_object.appendByteBuffer(b, object); } - } else { - b.writeUint8(3); - b.writeDouble(Number.parseFloat(object)); - } - } else if (typeof object === 'boolean') { - b.writeUint8(4); - Types.bool.appendByteBuffer(b, object); - } else if (typeof object === 'string') { - b.writeUint8(5); - Types.string.appendByteBuffer(b, object); - } else if (Array.isArray(object)) { - b.writeUint8(6); - Types.array(Types.variant).appendByteBuffer(b, object); - } else { - b.writeUint8(7); - Types.variant_object.appendByteBuffer(b, object); - } - }, - fromObject: function fromObject(object) { - return JSON.parse(object); - }, - toObject: function toObject(object) { - return JSON.parse(object); - } -}; - -Types.variant_object = { - fromByteBuffer: function fromByteBuffer(b) { - var count = b.readVarint32(); - var result = {}; - - for (var i = 0; i < count; ++i) { - var key = Types.string.fromByteBuffer(b); - result[key] = Types.variant.fromByteBuffer(b); - } - - return result; - }, - appendByteBuffer: function appendByteBuffer(b, object) { - var keys = Object.keys(object); - - b.writeVarint32(keys.length); // number of key/value pairs - - for (var i = 0, len = keys.length; i < len; i++) { - var key = keys[i]; - Types.string.appendByteBuffer(b, key); - Types.variant.appendByteBuffer(b, object[key]); - } - }, - fromObject: function fromObject(object) { - var newObject = {}; - - var keys = Object.keys(object); - - for (var i = 0, len = keys.length; i < len; i++) { - var key = keys[i]; - newObject[key] = object[key]; - } - - return newObject; - }, - toObject: function toObject(object) { - var newObject = {}; - - var keys = Object.keys(object); + }, + fromObject: function fromObject(object) { + return JSON.parse(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - for (var i = 0, len = keys.length; i < len; i++) { - var key = keys[i]; - newObject[key] = object[key]; + if (debug.use_default && object === undefined) { + return null; + } + return JSON.parse(object); } - - return newObject; - } }; -Types.enumeration = function (values) { - var enumeration = { +Types.variant_object = { fromByteBuffer: function fromByteBuffer(b) { - return values[b.readVarint32ZigZag()]; + var count = b.readVarint32(); + var result = {}; + for (var i = 0; i < count; ++i) { + var key = Types.string.fromByteBuffer(b); + result[key] = Types.variant.fromByteBuffer(b); + } + return result; }, appendByteBuffer: function appendByteBuffer(b, object) { - b.writeVarint32ZigZag(values.indexOf(object)); + var count = 0; + for (var key in object) { + if (object.hasOwnProperty(key)) ++count; + }b.writeVarint32(count); // number of key/value pairs + for (var key in object) { + if (object.hasOwnProperty(key)) { + Types.string.appendByteBuffer(b, key); + Types.variant.appendByteBuffer(b, object[key]); + } + }return; }, fromObject: function fromObject(object) { - return object; + var newObject = {}; + for (var key in object) { + if (object.hasOwnProperty(key)) newObject[key] = object[key]; + }return newObject; }, toObject: function toObject(object) { - return object; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var newObject = {}; + for (var key in object) { + if (object.hasOwnProperty(key)) newObject[key] = object[key]; + }return newObject; } - }; +}; - return enumeration; +Types.enumeration = function (values) { + return { + fromByteBuffer: function fromByteBuffer(b) { + return values[b.readVarint32ZigZag()]; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + b.writeVarint32ZigZag(values.indexOf(object)); + return; + }, + fromObject: function fromObject(object) { + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + values[0]; + } + return object; + } + }; }; Types.sha256 = Types.bytes(32); -exports.default = Types; -module.exports = exports['default']; -}).call(this,require(77),require(35).Buffer) +var strCmp = function strCmp(a, b) { + return a > b ? 1 : a < b ? -1 : 0; +}; +var firstEl = function firstEl(el) { + return Array.isArray(el) ? el[0] : el; +}; +var sortOperation = function sortOperation(array, st_operation) { + return st_operation.nosort ? array : st_operation.compare ? array.sort(function (a, b) { + return st_operation.compare(firstEl(a), firstEl(b)); + }) : // custom compare operation + array.sort(function (a, b) { + return typeof firstEl(a) === "number" && typeof firstEl(b) === "number" ? firstEl(a) - firstEl(b) : + // A binary string compare does not work. Performanance is very good so HEX is used.. localeCompare is another option. + Buffer.isBuffer(firstEl(a)) && Buffer.isBuffer(firstEl(b)) ? strCmp(firstEl(a).toString("hex"), firstEl(b).toString("hex")) : strCmp(firstEl(a).toString(), firstEl(b).toString()); + }); +}; +}).call(this,require('_process'),require("buffer").Buffer) -},{"20":20,"21":21,"3":3,"35":35,"4":4,"7":7,"70":70,"77":77}],27:[function(require,module,exports){ +},{"../../chain/src/ChainTypes":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/chain/src/ChainTypes.js","../../chain/src/ObjectId":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/chain/src/ObjectId.js","../../ecc":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/index.js","./FastParser":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/FastParser.js","./SerializerValidation":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/SerializerValidation.js","_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","peerplaysjs-ws":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js":[function(require,module,exports){ (function (global){ 'use strict'; @@ -6699,7 +5265,7 @@ function isBuffer(b) { // 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. -var util = require(108); +var util = require('util/'); var hasOwn = Object.prototype.hasOwnProperty; var pSlice = Array.prototype.slice; var functionsHaveNames = (function () { @@ -7124,7 +5690,7 @@ var objectKeys = Object.keys || function (obj) { }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"108":108}],28:[function(require,module,exports){ +},{"util/":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util/util.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/base-x/index.js":[function(require,module,exports){ // base-x encoding // Forked from https://github.com/cryptocoinjs/bs58 // Originally written by Mike Hearn for BitcoinJ @@ -7212,7 +5778,7 @@ module.exports = function base (ALPHABET) { } } -},{}],29:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/base64-js/index.js":[function(require,module,exports){ 'use strict' exports.byteLength = byteLength @@ -7365,7 +5931,7 @@ function fromByteArray (uint8) { return parts.join('') } -},{}],30:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/bigi.js":[function(require,module,exports){ // (public) Constructor function BigInteger(a, b, c) { if (!(this instanceof BigInteger)) @@ -7381,7 +5947,7 @@ function BigInteger(a, b, c) { var proto = BigInteger.prototype // duck-typed isBigInteger -proto.__bigi = require(33).version +proto.__bigi = require('../package.json').version BigInteger.isBigInteger = function (obj, check_ver) { return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi) } @@ -8876,11 +7442,11 @@ BigInteger.valueOf = nbv module.exports = BigInteger -},{"33":33}],31:[function(require,module,exports){ +},{"../package.json":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/package.json"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/convert.js":[function(require,module,exports){ (function (Buffer){ // FIXME: Kind of a weird way to throw exceptions, consider removing -var assert = require(27) -var BigInteger = require(30) +var assert = require('assert') +var BigInteger = require('./bigi') /** * Turns a byte array into a big integer. @@ -8970,17 +7536,41 @@ BigInteger.prototype.toHex = function(size) { return this.toBuffer(size).toString('hex') } -}).call(this,require(35).Buffer) +}).call(this,require("buffer").Buffer) -},{"27":27,"30":30,"35":35}],32:[function(require,module,exports){ -var BigInteger = require(30) +},{"./bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/bigi.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js":[function(require,module,exports){ +var BigInteger = require('./bigi') //addons -require(31) +require('./convert') module.exports = BigInteger -},{"30":30,"31":31}],33:[function(require,module,exports){ +},{"./bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/bigi.js","./convert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/convert.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/package.json":[function(require,module,exports){ module.exports={ + "_from": "bigi@^1.4.1", + "_id": "bigi@1.4.2", + "_inBundle": false, + "_integrity": "sha1-nGZalfiLiwj8Bc/XMfVhhZ1yWCU=", + "_location": "/peerplaysjs-lib/bigi", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "bigi@^1.4.1", + "name": "bigi", + "escapedName": "bigi", + "rawSpec": "^1.4.1", + "saveSpec": null, + "fetchSpec": "^1.4.1" + }, + "_requiredBy": [ + "/peerplaysjs-lib", + "/peerplaysjs-lib/ecurve" + ], + "_resolved": "https://registry.npmjs.org/bigi/-/bigi-1.4.2.tgz", + "_shasum": "9c665a95f88b8b08fc05cfd731f561859d725825", + "_spec": "bigi@^1.4.1", + "_where": "/Users/mseaward/Documents/code/peerplaysjs-lib", "bugs": { "url": "https://github.com/cryptocoinjs/bigi/issues" }, @@ -9041,9 +7631,10 @@ module.exports={ }, "version": "1.4.2" } -},{}],34:[function(require,module,exports){ -},{}],35:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browser-resolve/empty.js":[function(require,module,exports){ + +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js":[function(require,module,exports){ (function (global){ /*! * The buffer module from node.js, for the browser. @@ -9055,9 +7646,9 @@ module.exports={ 'use strict' -var base64 = require(29) -var ieee754 = require(64) -var isArray = require(67) +var base64 = require('base64-js') +var ieee754 = require('ieee754') +var isArray = require('isarray') exports.Buffer = Buffer exports.SlowBuffer = SlowBuffer @@ -10837,7 +9428,7 @@ function isnan (val) { }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"29":29,"64":64,"67":67}],36:[function(require,module,exports){ +},{"base64-js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/base64-js/index.js","ieee754":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ieee754/index.js","isarray":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/isarray/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/string_decoder/index.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -10859,7 +9450,7 @@ function isnan (val) { // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. -var Buffer = require(35).Buffer; +var Buffer = require('buffer').Buffer; var isBufferEncoding = Buffer.isEncoding || function(encoding) { @@ -11060,13 +9651,13 @@ function base64DetectIncompleteChar(buffer) { this.charLength = this.charReceived ? 3 : 0; } -},{"35":35}],37:[function(require,module,exports){ -var basex = require(28) +},{"buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bs58/index.js":[function(require,module,exports){ +var basex = require('base-x') var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' module.exports = basex(ALPHABET) -},{"28":28}],38:[function(require,module,exports){ +},{"base-x":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/base-x/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bytebuffer/dist/bytebuffer.js":[function(require,module,exports){ /* Copyright 2013-2014 Daniel Wirtz @@ -11095,7 +9686,7 @@ module.exports = basex(ALPHABET) define(["long"], factory); /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"]) module['exports'] = (function() { - var Long; try { Long = require(68); } catch (e) {} + var Long; try { Long = require("long"); } catch (e) {} return factory(Long); })(); /* Global */ else @@ -14814,11 +13405,11 @@ module.exports = basex(ALPHABET) return ByteBuffer; }); -},{"68":68}],39:[function(require,module,exports){ -var Buffer = require(93).Buffer -var Transform = require(103).Transform -var StringDecoder = require(36).StringDecoder -var inherits = require(65) +},{"long":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/long/dist/long.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/cipher-base/index.js":[function(require,module,exports){ +var Buffer = require('safe-buffer').Buffer +var Transform = require('stream').Transform +var StringDecoder = require('string_decoder').StringDecoder +var inherits = require('inherits') function CipherBase (hashMode) { Transform.call(this) @@ -14915,7 +13506,7 @@ CipherBase.prototype._toString = function (value, enc, fin) { module.exports = CipherBase -},{"103":103,"36":36,"65":65,"93":93}],40:[function(require,module,exports){ +},{"inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js","stream":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/stream-browserify/index.js","string_decoder":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/string_decoder/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/core-util-is/lib/util.js":[function(require,module,exports){ (function (Buffer){ // Copyright Joyent, Inc. and other Node contributors. // @@ -15025,15 +13616,15 @@ function objectToString(o) { return Object.prototype.toString.call(o); } -}).call(this,{"isBuffer":require(66)}) +}).call(this,{"isBuffer":require("../../is-buffer/index.js")}) -},{"66":66}],41:[function(require,module,exports){ +},{"../../is-buffer/index.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/is-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hash/browser.js":[function(require,module,exports){ 'use strict' -var inherits = require(65) -var MD5 = require(69) -var RIPEMD160 = require(92) -var sha = require(96) -var Base = require(39) +var inherits = require('inherits') +var MD5 = require('md5.js') +var RIPEMD160 = require('ripemd160') +var sha = require('sha.js') +var Base = require('cipher-base') function Hash (hash) { Base.call(this, 'digest') @@ -15059,23 +13650,23 @@ module.exports = function createHash (alg) { return new Hash(sha(alg)) } -},{"39":39,"65":65,"69":69,"92":92,"96":96}],42:[function(require,module,exports){ -var MD5 = require(69) +},{"cipher-base":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/cipher-base/index.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","md5.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/md5.js/index.js","ripemd160":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ripemd160/index.js","sha.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hash/md5.js":[function(require,module,exports){ +var MD5 = require('md5.js') module.exports = function (buffer) { return new MD5().update(buffer).digest() } -},{"69":69}],43:[function(require,module,exports){ +},{"md5.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/md5.js/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hmac/browser.js":[function(require,module,exports){ 'use strict' -var inherits = require(65) -var Legacy = require(44) -var Base = require(39) -var Buffer = require(93).Buffer -var md5 = require(42) -var RIPEMD160 = require(92) +var inherits = require('inherits') +var Legacy = require('./legacy') +var Base = require('cipher-base') +var Buffer = require('safe-buffer').Buffer +var md5 = require('create-hash/md5') +var RIPEMD160 = require('ripemd160') -var sha = require(96) +var sha = require('sha.js') var ZEROS = Buffer.alloc(128) @@ -15130,12 +13721,12 @@ module.exports = function createHmac (alg, key) { return new Hmac(alg, key) } -},{"39":39,"42":42,"44":44,"65":65,"92":92,"93":93,"96":96}],44:[function(require,module,exports){ +},{"./legacy":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hmac/legacy.js","cipher-base":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/cipher-base/index.js","create-hash/md5":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hash/md5.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","ripemd160":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ripemd160/index.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js","sha.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/create-hmac/legacy.js":[function(require,module,exports){ 'use strict' -var inherits = require(65) -var Buffer = require(93).Buffer +var inherits = require('inherits') +var Buffer = require('safe-buffer').Buffer -var Base = require(39) +var Base = require('cipher-base') var ZEROS = Buffer.alloc(128) var blocksize = 64 @@ -15178,11 +13769,11 @@ Hmac.prototype._final = function () { } module.exports = Hmac -},{"39":39,"65":65,"93":93}],45:[function(require,module,exports){ +},{"cipher-base":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/cipher-base/index.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/aes.js":[function(require,module,exports){ ;(function (root, factory, undef) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47), require(48), require(52), require(50), require(46)); + module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); } else if (typeof define === "function" && define.amd) { // AMD @@ -15411,15 +14002,15 @@ module.exports = Hmac return CryptoJS.AES; })); -},{"46":46,"47":47,"48":48,"50":50,"52":52}],46:[function(require,module,exports){ -;(function (root, factory, undef) { +},{"./cipher-core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/cipher-core.js","./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js","./enc-base64":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-base64.js","./evpkdf":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/evpkdf.js","./md5":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/md5.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/cipher-core.js":[function(require,module,exports){ +;(function (root, factory) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47), require(50)); + module.exports = exports = factory(require("./core")); } else if (typeof define === "function" && define.amd) { // AMD - define(["./core", "./evpkdf"], factory); + define(["./core"], factory); } else { // Global (browser) @@ -15880,16 +14471,11 @@ module.exports = Hmac var modeCreator = mode.createEncryptor; } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { var modeCreator = mode.createDecryptor; + // Keep at least one block in the buffer for unpadding this._minBufferSize = 1; } - - if (this._mode && this._mode.__creator == modeCreator) { - this._mode.init(this, iv && iv.words); - } else { - this._mode = modeCreator.call(mode, this, iv && iv.words); - this._mode.__creator = modeCreator; - } + this._mode = modeCreator.call(mode, this, iv && iv.words); }, _doProcessBlock: function (words, offset) { @@ -16292,7 +14878,7 @@ module.exports = Hmac })); -},{"47":47,"50":50}],47:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js":[function(require,module,exports){ ;(function (root, factory) { if (typeof exports === "object") { // CommonJS @@ -17053,11 +15639,11 @@ module.exports = Hmac return CryptoJS; })); -},{}],48:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-base64.js":[function(require,module,exports){ ;(function (root, factory) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47)); + module.exports = exports = factory(require("./core")); } else if (typeof define === "function" && define.amd) { // AMD @@ -17189,11 +15775,11 @@ module.exports = Hmac return CryptoJS.enc.Base64; })); -},{"47":47}],49:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-hex.js":[function(require,module,exports){ ;(function (root, factory) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47)); + module.exports = exports = factory(require("./core")); } else if (typeof define === "function" && define.amd) { // AMD @@ -17208,11 +15794,11 @@ module.exports = Hmac return CryptoJS.enc.Hex; })); -},{"47":47}],50:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/evpkdf.js":[function(require,module,exports){ ;(function (root, factory, undef) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47), require(53), require(51)); + module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac")); } else if (typeof define === "function" && define.amd) { // AMD @@ -17341,11 +15927,11 @@ module.exports = Hmac return CryptoJS.EvpKDF; })); -},{"47":47,"51":51,"53":53}],51:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js","./hmac":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/hmac.js","./sha1":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/sha1.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/hmac.js":[function(require,module,exports){ ;(function (root, factory) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47)); + module.exports = exports = factory(require("./core")); } else if (typeof define === "function" && define.amd) { // AMD @@ -17485,11 +16071,11 @@ module.exports = Hmac })); -},{"47":47}],52:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/md5.js":[function(require,module,exports){ ;(function (root, factory) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47)); + module.exports = exports = factory(require("./core")); } else if (typeof define === "function" && define.amd) { // AMD @@ -17754,11 +16340,11 @@ module.exports = Hmac return CryptoJS.MD5; })); -},{"47":47}],53:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/sha1.js":[function(require,module,exports){ ;(function (root, factory) { if (typeof exports === "object") { // CommonJS - module.exports = exports = factory(require(47)); + module.exports = exports = factory(require("./core")); } else if (typeof define === "function" && define.amd) { // AMD @@ -17905,10 +16491,10 @@ module.exports = Hmac return CryptoJS.SHA1; })); -},{"47":47}],54:[function(require,module,exports){ +},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/index.js":[function(require,module,exports){ var pSlice = Array.prototype.slice; -var objectKeys = require(56); -var isArguments = require(55); +var objectKeys = require('./lib/keys.js'); +var isArguments = require('./lib/is_arguments.js'); var deepEqual = module.exports = function (actual, expected, opts) { if (!opts) opts = {}; @@ -18001,7 +16587,7 @@ function objEquiv(a, b, opts) { return typeof a === typeof b; } -},{"55":55,"56":56}],55:[function(require,module,exports){ +},{"./lib/is_arguments.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/lib/is_arguments.js","./lib/keys.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/lib/keys.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/lib/is_arguments.js":[function(require,module,exports){ var supportsArgumentsClass = (function(){ return Object.prototype.toString.call(arguments) })() == '[object Arguments]'; @@ -18023,7 +16609,7 @@ function unsupported(object){ false; }; -},{}],56:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/lib/keys.js":[function(require,module,exports){ exports = module.exports = typeof Object.keys === 'function' ? Object.keys : shim; @@ -18034,11 +16620,11 @@ function shim (obj) { return keys; } -},{}],57:[function(require,module,exports){ -var assert = require(27) -var BigInteger = require(32) +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/curve.js":[function(require,module,exports){ +var assert = require('assert') +var BigInteger = require('bigi') -var Point = require(61) +var Point = require('./point') function Curve (p, a, b, Gx, Gy, n, h) { this.p = p @@ -18113,7 +16699,7 @@ Curve.prototype.validate = function (Q) { module.exports = Curve -},{"27":27,"32":32,"61":61}],58:[function(require,module,exports){ +},{"./point":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/point.js","assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/curves.json":[function(require,module,exports){ module.exports={ "secp128r1": { "p": "fffffffdffffffffffffffffffffffff", @@ -18180,11 +16766,11 @@ module.exports={ } } -},{}],59:[function(require,module,exports){ -var Point = require(61) -var Curve = require(57) +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/index.js":[function(require,module,exports){ +var Point = require('./point') +var Curve = require('./curve') -var getCurveByName = require(60) +var getCurveByName = require('./names') module.exports = { Curve: Curve, @@ -18192,11 +16778,11 @@ module.exports = { getCurveByName: getCurveByName } -},{"57":57,"60":60,"61":61}],60:[function(require,module,exports){ -var BigInteger = require(32) +},{"./curve":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/curve.js","./names":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/names.js","./point":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/point.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/names.js":[function(require,module,exports){ +var BigInteger = require('bigi') -var curves = require(58) -var Curve = require(57) +var curves = require('./curves.json') +var Curve = require('./curve') function getCurveByName (name) { var curve = curves[name] @@ -18215,10 +16801,10 @@ function getCurveByName (name) { module.exports = getCurveByName -},{"32":32,"57":57,"58":58}],61:[function(require,module,exports){ -var assert = require(27) -var Buffer = require(93).Buffer -var BigInteger = require(32) +},{"./curve":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/curve.js","./curves.json":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/curves.json","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ecurve/lib/point.js":[function(require,module,exports){ +var assert = require('assert') +var Buffer = require('safe-buffer').Buffer +var BigInteger = require('bigi') var THREE = BigInteger.valueOf(3) @@ -18461,7 +17047,7 @@ Point.prototype.toString = function () { module.exports = Point -},{"27":27,"32":32,"93":93}],62:[function(require,module,exports){ +},{"assert":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/assert/assert.js","bigi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/index.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/events/events.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -18765,11 +17351,11 @@ function isUndefined(arg) { return arg === void 0; } -},{}],63:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/hash-base/index.js":[function(require,module,exports){ 'use strict' -var Buffer = require(93).Buffer -var Transform = require(103).Transform -var inherits = require(65) +var Buffer = require('safe-buffer').Buffer +var Transform = require('stream').Transform +var inherits = require('inherits') function throwIfNotStringOrBuffer (val, prefix) { if (!Buffer.isBuffer(val) && typeof val !== 'string') { @@ -18862,7 +17448,7 @@ HashBase.prototype._digest = function () { module.exports = HashBase -},{"103":103,"65":65,"93":93}],64:[function(require,module,exports){ +},{"inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js","stream":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/stream-browserify/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ieee754/index.js":[function(require,module,exports){ exports.read = function (buffer, offset, isLE, mLen, nBytes) { var e, m var eLen = (nBytes * 8) - mLen - 1 @@ -18948,7 +17534,7 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { buffer[offset + i - d] |= s * 128 } -},{}],65:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js":[function(require,module,exports){ if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { @@ -18973,7 +17559,7 @@ if (typeof Object.create === 'function') { } } -},{}],66:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/is-buffer/index.js":[function(require,module,exports){ /*! * Determine if an object is a Buffer * @@ -18996,14 +17582,14 @@ function isSlowBuffer (obj) { return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) } -},{}],67:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/isarray/index.js":[function(require,module,exports){ var toString = {}.toString; module.exports = Array.isArray || function (arr) { return toString.call(arr) == '[object Array]'; }; -},{}],68:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/long/dist/long.js":[function(require,module,exports){ /* Copyright 2013 Daniel Wirtz Copyright 2009 The Closure Library Authors. All Rights Reserved. @@ -20214,11 +18800,11 @@ module.exports = Array.isArray || function (arr) { return Long; }); -},{}],69:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/md5.js/index.js":[function(require,module,exports){ (function (Buffer){ 'use strict' -var inherits = require(65) -var HashBase = require(63) +var inherits = require('inherits') +var HashBase = require('hash-base') var ARRAY16 = new Array(16) @@ -20362,23 +18948,23 @@ function fnI (a, b, c, d, m, k, s) { module.exports = MD5 -}).call(this,require(35).Buffer) +}).call(this,require("buffer").Buffer) -},{"35":35,"63":63,"65":65}],70:[function(require,module,exports){ +},{"buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","hash-base":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/hash-base/index.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/index.js":[function(require,module,exports){ 'use strict'; exports.__esModule = true; exports.Manager = exports.ChainConfig = exports.Apis = undefined; -var _ApiInstances = require(71); +var _ApiInstances = require('./src/ApiInstances'); var _ApiInstances2 = _interopRequireDefault(_ApiInstances); -var _ConnectionManager = require(74); +var _ConnectionManager = require('./src/ConnectionManager'); var _ConnectionManager2 = _interopRequireDefault(_ConnectionManager); -var _ChainConfig = require(72); +var _ChainConfig = require('./src/ChainConfig'); var _ChainConfig2 = _interopRequireDefault(_ChainConfig); @@ -20387,20 +18973,20 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de exports.Apis = _ApiInstances2.default; exports.ChainConfig = _ChainConfig2.default; exports.Manager = _ConnectionManager2.default; -},{"71":71,"72":72,"74":74}],71:[function(require,module,exports){ +},{"./src/ApiInstances":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ApiInstances.js","./src/ChainConfig":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ChainConfig.js","./src/ConnectionManager":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ConnectionManager.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ApiInstances.js":[function(require,module,exports){ 'use strict'; exports.__esModule = true; -var _ChainWebSocket = require(73); +var _ChainWebSocket = require('./ChainWebSocket'); var _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket); -var _GrapheneApi = require(75); +var _GrapheneApi = require('./GrapheneApi'); var _GrapheneApi2 = _interopRequireDefault(_GrapheneApi); -var _ChainConfig = require(72); +var _ChainConfig = require('./ChainConfig'); var _ChainConfig2 = _interopRequireDefault(_ChainConfig); @@ -20575,7 +19161,7 @@ exports.default = { // crypto: (method, ...args) => Apis.instance().crypto_api().exec(method, toStrings(args)) }; -},{"72":72,"73":73,"75":75}],72:[function(require,module,exports){ +},{"./ChainConfig":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ChainConfig.js","./ChainWebSocket":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ChainWebSocket.js","./GrapheneApi":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/GrapheneApi.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ChainConfig.js":[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -20652,7 +19238,7 @@ var ChainConfig = function () { }(); exports.default = new ChainConfig(); -},{}],73:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ChainWebSocket.js":[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -20665,7 +19251,7 @@ var WebSocketClient = null; if (typeof WebSocket !== 'undefined') { WebSocketClient = WebSocket; } else { - WebSocketClient = require(34); // eslint-disable-line global-require + WebSocketClient = require('ws'); // eslint-disable-line global-require } var SUBSCRIBE_OPERATIONS = ['set_subscribe_callback', 'subscribe_to_market', 'broadcast_transaction_with_callback', 'set_pending_transaction_callback']; @@ -21136,16 +19722,16 @@ ChainWebSocket.status = { }; exports.default = ChainWebSocket; -},{"34":34}],74:[function(require,module,exports){ +},{"ws":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browser-resolve/empty.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ConnectionManager.js":[function(require,module,exports){ 'use strict'; exports.__esModule = true; -var _ApiInstances = require(71); +var _ApiInstances = require('./ApiInstances'); var _ApiInstances2 = _interopRequireDefault(_ApiInstances); -var _ChainWebSocket = require(73); +var _ChainWebSocket = require('./ChainWebSocket'); var _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket); @@ -21280,7 +19866,7 @@ var Manager = function () { }(); exports.default = Manager; -},{"71":71,"73":73}],75:[function(require,module,exports){ +},{"./ApiInstances":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ApiInstances.js","./ChainWebSocket":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/ChainWebSocket.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/peerplaysjs-ws/dist/src/GrapheneApi.js":[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -21315,7 +19901,7 @@ var GrapheneApi = function () { }(); exports.default = GrapheneApi; -},{}],76:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process-nextick-args/index.js":[function(require,module,exports){ (function (process){ 'use strict'; @@ -21362,9 +19948,9 @@ function nextTick(fn, arg1, arg2, arg3) { } -}).call(this,require(77)) +}).call(this,require('_process')) -},{"77":77}],77:[function(require,module,exports){ +},{"_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js":[function(require,module,exports){ // shim for using process in browser var process = module.exports = {}; @@ -21550,10 +20136,10 @@ process.chdir = function (dir) { }; process.umask = function() { return 0; }; -},{}],78:[function(require,module,exports){ -module.exports = require(79); +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/duplex-browser.js":[function(require,module,exports){ +module.exports = require('./lib/_stream_duplex.js'); -},{"79":79}],79:[function(require,module,exports){ +},{"./lib/_stream_duplex.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -21584,7 +20170,7 @@ module.exports = require(79); /**/ -var pna = require(76); +var pna = require('process-nextick-args'); /**/ /**/ @@ -21599,12 +20185,12 @@ var objectKeys = Object.keys || function (obj) { module.exports = Duplex; /**/ -var util = require(40); -util.inherits = require(87); +var util = require('core-util-is'); +util.inherits = require('inherits'); /**/ -var Readable = require(81); -var Writable = require(83); +var Readable = require('./_stream_readable'); +var Writable = require('./_stream_writable'); util.inherits(Duplex, Readable); @@ -21685,7 +20271,7 @@ Duplex.prototype._destroy = function (err, cb) { pna.nextTick(cb, err); }; -},{"40":40,"76":76,"81":81,"83":83,"87":87}],80:[function(require,module,exports){ +},{"./_stream_readable":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_readable.js","./_stream_writable":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_writable.js","core-util-is":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/core-util-is/lib/util.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","process-nextick-args":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process-nextick-args/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_passthrough.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -21715,11 +20301,11 @@ Duplex.prototype._destroy = function (err, cb) { module.exports = PassThrough; -var Transform = require(82); +var Transform = require('./_stream_transform'); /**/ -var util = require(40); -util.inherits = require(87); +var util = require('core-util-is'); +util.inherits = require('inherits'); /**/ util.inherits(PassThrough, Transform); @@ -21733,7 +20319,7 @@ function PassThrough(options) { PassThrough.prototype._transform = function (chunk, encoding, cb) { cb(null, chunk); }; -},{"40":40,"82":82,"87":87}],81:[function(require,module,exports){ +},{"./_stream_transform":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_transform.js","core-util-is":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/core-util-is/lib/util.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_readable.js":[function(require,module,exports){ (function (process,global){ // Copyright Joyent, Inc. and other Node contributors. // @@ -21760,13 +20346,13 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /**/ -var pna = require(76); +var pna = require('process-nextick-args'); /**/ module.exports = Readable; /**/ -var isArray = require(67); +var isArray = require('isarray'); /**/ /**/ @@ -21776,7 +20362,7 @@ var Duplex; Readable.ReadableState = ReadableState; /**/ -var EE = require(62).EventEmitter; +var EE = require('events').EventEmitter; var EElistenerCount = function (emitter, type) { return emitter.listeners(type).length; @@ -21784,12 +20370,12 @@ var EElistenerCount = function (emitter, type) { /**/ /**/ -var Stream = require(86); +var Stream = require('./internal/streams/stream'); /**/ /**/ -var Buffer = require(93).Buffer; +var Buffer = require('safe-buffer').Buffer; var OurUint8Array = global.Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -21801,12 +20387,12 @@ function _isUint8Array(obj) { /**/ /**/ -var util = require(40); -util.inherits = require(87); +var util = require('core-util-is'); +util.inherits = require('inherits'); /**/ /**/ -var debugUtil = require(34); +var debugUtil = require('util'); var debug = void 0; if (debugUtil && debugUtil.debuglog) { debug = debugUtil.debuglog('stream'); @@ -21815,8 +20401,8 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = require(84); -var destroyImpl = require(85); +var BufferList = require('./internal/streams/BufferList'); +var destroyImpl = require('./internal/streams/destroy'); var StringDecoder; util.inherits(Readable, Stream); @@ -21836,7 +20422,7 @@ function prependListener(emitter, event, fn) { } function ReadableState(options, stream) { - Duplex = Duplex || require(79); + Duplex = Duplex || require('./_stream_duplex'); options = options || {}; @@ -21906,14 +20492,14 @@ function ReadableState(options, stream) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = require(104).StringDecoder; + if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || require(79); + Duplex = Duplex || require('./_stream_duplex'); if (!(this instanceof Readable)) return new Readable(options); @@ -22062,7 +20648,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = require(104).StringDecoder; + if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; @@ -22754,9 +21340,9 @@ function indexOf(xs, x) { } return -1; } -}).call(this,require(77),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"104":104,"34":34,"40":40,"62":62,"67":67,"76":76,"77":77,"79":79,"84":84,"85":85,"86":86,"87":87,"93":93}],82:[function(require,module,exports){ +},{"./_stream_duplex":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js","./internal/streams/BufferList":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/BufferList.js","./internal/streams/destroy":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/destroy.js","./internal/streams/stream":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/stream-browser.js","_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","core-util-is":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/core-util-is/lib/util.js","events":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/events/events.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","isarray":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/isarray/index.js","process-nextick-args":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process-nextick-args/index.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js","string_decoder/":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/string_decoder/lib/string_decoder.js","util":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browser-resolve/empty.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_transform.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -22824,11 +21410,11 @@ function indexOf(xs, x) { module.exports = Transform; -var Duplex = require(79); +var Duplex = require('./_stream_duplex'); /**/ -var util = require(40); -util.inherits = require(87); +var util = require('core-util-is'); +util.inherits = require('inherits'); /**/ util.inherits(Transform, Duplex); @@ -22971,7 +21557,7 @@ function done(stream, er, data) { return stream.push(null); } -},{"40":40,"79":79,"87":87}],83:[function(require,module,exports){ +},{"./_stream_duplex":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js","core-util-is":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/core-util-is/lib/util.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_writable.js":[function(require,module,exports){ (function (process,global,setImmediate){ // Copyright Joyent, Inc. and other Node contributors. // @@ -23002,7 +21588,7 @@ function done(stream, er, data) { /**/ -var pna = require(76); +var pna = require('process-nextick-args'); /**/ module.exports = Writable; @@ -23039,23 +21625,23 @@ var Duplex; Writable.WritableState = WritableState; /**/ -var util = require(40); -util.inherits = require(87); +var util = require('core-util-is'); +util.inherits = require('inherits'); /**/ /**/ var internalUtil = { - deprecate: require(106) + deprecate: require('util-deprecate') }; /**/ /**/ -var Stream = require(86); +var Stream = require('./internal/streams/stream'); /**/ /**/ -var Buffer = require(93).Buffer; +var Buffer = require('safe-buffer').Buffer; var OurUint8Array = global.Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -23066,14 +21652,14 @@ function _isUint8Array(obj) { /**/ -var destroyImpl = require(85); +var destroyImpl = require('./internal/streams/destroy'); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { - Duplex = Duplex || require(79); + Duplex = Duplex || require('./_stream_duplex'); options = options || {}; @@ -23223,7 +21809,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot } function Writable(options) { - Duplex = Duplex || require(79); + Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -23660,15 +22246,15 @@ Writable.prototype._destroy = function (err, cb) { this.end(); cb(err); }; -}).call(this,require(77),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require(105).setImmediate) +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate) -},{"105":105,"106":106,"40":40,"76":76,"77":77,"79":79,"85":85,"86":86,"87":87,"93":93}],84:[function(require,module,exports){ +},{"./_stream_duplex":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js","./internal/streams/destroy":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/destroy.js","./internal/streams/stream":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/stream-browser.js","_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","core-util-is":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/core-util-is/lib/util.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","process-nextick-args":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process-nextick-args/index.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js","timers":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/timers-browserify/main.js","util-deprecate":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util-deprecate/browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/BufferList.js":[function(require,module,exports){ 'use strict'; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var Buffer = require(93).Buffer; -var util = require(34); +var Buffer = require('safe-buffer').Buffer; +var util = require('util'); function copyBuffer(src, target, offset) { src.copy(target, offset); @@ -23742,12 +22328,12 @@ if (util && util.inspect && util.inspect.custom) { return this.constructor.name + ' ' + obj; }; } -},{"34":34,"93":93}],85:[function(require,module,exports){ +},{"safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js","util":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browser-resolve/empty.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/destroy.js":[function(require,module,exports){ 'use strict'; /**/ -var pna = require(76); +var pna = require('process-nextick-args'); /**/ // undocumented cb() API, needed for core, not for public API @@ -23817,34 +22403,32 @@ module.exports = { destroy: destroy, undestroy: undestroy }; -},{"76":76}],86:[function(require,module,exports){ -module.exports = require(62).EventEmitter; +},{"process-nextick-args":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process-nextick-args/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/stream-browser.js":[function(require,module,exports){ +module.exports = require('events').EventEmitter; -},{"62":62}],87:[function(require,module,exports){ -arguments[4][65][0].apply(exports,arguments) -},{"65":65}],88:[function(require,module,exports){ -module.exports = require(89).PassThrough +},{"events":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/events/events.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/passthrough.js":[function(require,module,exports){ +module.exports = require('./readable').PassThrough -},{"89":89}],89:[function(require,module,exports){ -exports = module.exports = require(81); +},{"./readable":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js":[function(require,module,exports){ +exports = module.exports = require('./lib/_stream_readable.js'); exports.Stream = exports; exports.Readable = exports; -exports.Writable = require(83); -exports.Duplex = require(79); -exports.Transform = require(82); -exports.PassThrough = require(80); +exports.Writable = require('./lib/_stream_writable.js'); +exports.Duplex = require('./lib/_stream_duplex.js'); +exports.Transform = require('./lib/_stream_transform.js'); +exports.PassThrough = require('./lib/_stream_passthrough.js'); -},{"79":79,"80":80,"81":81,"82":82,"83":83}],90:[function(require,module,exports){ -module.exports = require(89).Transform +},{"./lib/_stream_duplex.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js","./lib/_stream_passthrough.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_passthrough.js","./lib/_stream_readable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_readable.js","./lib/_stream_transform.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_transform.js","./lib/_stream_writable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_writable.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/transform.js":[function(require,module,exports){ +module.exports = require('./readable').Transform -},{"89":89}],91:[function(require,module,exports){ -module.exports = require(83); +},{"./readable":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/writable-browser.js":[function(require,module,exports){ +module.exports = require('./lib/_stream_writable.js'); -},{"83":83}],92:[function(require,module,exports){ +},{"./lib/_stream_writable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_writable.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ripemd160/index.js":[function(require,module,exports){ 'use strict' -var Buffer = require(35).Buffer -var inherits = require(65) -var HashBase = require(63) +var Buffer = require('buffer').Buffer +var inherits = require('inherits') +var HashBase = require('hash-base') var ARRAY16 = new Array(16) @@ -24005,9 +22589,9 @@ function fn5 (a, b, c, d, e, m, k, s) { module.exports = RIPEMD160 -},{"35":35,"63":63,"65":65}],93:[function(require,module,exports){ +},{"buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","hash-base":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/hash-base/index.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js":[function(require,module,exports){ /* eslint-disable node/no-deprecated-api */ -var buffer = require(35) +var buffer = require('buffer') var Buffer = buffer.Buffer // alternative to using Object.keys for old browsers @@ -24069,7 +22653,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { return buffer.SlowBuffer(size) } -},{"35":35}],94:[function(require,module,exports){ +},{"buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/secure-random/lib/secure-random.js":[function(require,module,exports){ (function (process,Buffer){ !function(globals){ 'use strict' @@ -24100,7 +22684,7 @@ function secureRandom(count, options) { } function nodeRandom(count, options) { - var crypto = require(34) + var crypto = require('crypto') var buf = crypto.randomBytes(count) switch (options.type) { @@ -24150,10 +22734,10 @@ secureRandom.randomBuffer = function(byteCount) { }(this); -}).call(this,require(77),require(35).Buffer) +}).call(this,require('_process'),require("buffer").Buffer) -},{"34":34,"35":35,"77":77}],95:[function(require,module,exports){ -var Buffer = require(93).Buffer +},{"_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js","crypto":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browser-resolve/empty.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js":[function(require,module,exports){ +var Buffer = require('safe-buffer').Buffer // prototype class for hash functions function Hash (blockSize, finalSize) { @@ -24235,7 +22819,7 @@ Hash.prototype._update = function () { module.exports = Hash -},{"93":93}],96:[function(require,module,exports){ +},{"safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/index.js":[function(require,module,exports){ var exports = module.exports = function SHA (algorithm) { algorithm = algorithm.toLowerCase() @@ -24245,14 +22829,14 @@ var exports = module.exports = function SHA (algorithm) { return new Algorithm() } -exports.sha = require(97) -exports.sha1 = require(98) -exports.sha224 = require(99) -exports.sha256 = require(100) -exports.sha384 = require(101) -exports.sha512 = require(102) +exports.sha = require('./sha') +exports.sha1 = require('./sha1') +exports.sha224 = require('./sha224') +exports.sha256 = require('./sha256') +exports.sha384 = require('./sha384') +exports.sha512 = require('./sha512') -},{"100":100,"101":101,"102":102,"97":97,"98":98,"99":99}],97:[function(require,module,exports){ +},{"./sha":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha.js","./sha1":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha1.js","./sha224":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha224.js","./sha256":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha256.js","./sha384":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha384.js","./sha512":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha512.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha.js":[function(require,module,exports){ /* * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined * in FIPS PUB 180-1 @@ -24261,9 +22845,9 @@ exports.sha512 = require(102) * operation was added. */ -var inherits = require(65) -var Hash = require(95) -var Buffer = require(93).Buffer +var inherits = require('inherits') +var Hash = require('./hash') +var Buffer = require('safe-buffer').Buffer var K = [ 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 @@ -24348,7 +22932,7 @@ Sha.prototype._hash = function () { module.exports = Sha -},{"65":65,"93":93,"95":95}],98:[function(require,module,exports){ +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha1.js":[function(require,module,exports){ /* * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined * in FIPS PUB 180-1 @@ -24358,9 +22942,9 @@ module.exports = Sha * See http://pajhome.org.uk/crypt/md5 for details. */ -var inherits = require(65) -var Hash = require(95) -var Buffer = require(93).Buffer +var inherits = require('inherits') +var Hash = require('./hash') +var Buffer = require('safe-buffer').Buffer var K = [ 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 @@ -24449,7 +23033,7 @@ Sha1.prototype._hash = function () { module.exports = Sha1 -},{"65":65,"93":93,"95":95}],99:[function(require,module,exports){ +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha224.js":[function(require,module,exports){ /** * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined * in FIPS 180-2 @@ -24458,10 +23042,10 @@ module.exports = Sha1 * */ -var inherits = require(65) -var Sha256 = require(100) -var Hash = require(95) -var Buffer = require(93).Buffer +var inherits = require('inherits') +var Sha256 = require('./sha256') +var Hash = require('./hash') +var Buffer = require('safe-buffer').Buffer var W = new Array(64) @@ -24504,7 +23088,7 @@ Sha224.prototype._hash = function () { module.exports = Sha224 -},{"100":100,"65":65,"93":93,"95":95}],100:[function(require,module,exports){ +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","./sha256":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha256.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha256.js":[function(require,module,exports){ /** * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined * in FIPS 180-2 @@ -24513,9 +23097,9 @@ module.exports = Sha224 * */ -var inherits = require(65) -var Hash = require(95) -var Buffer = require(93).Buffer +var inherits = require('inherits') +var Hash = require('./hash') +var Buffer = require('safe-buffer').Buffer var K = [ 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, @@ -24641,11 +23225,11 @@ Sha256.prototype._hash = function () { module.exports = Sha256 -},{"65":65,"93":93,"95":95}],101:[function(require,module,exports){ -var inherits = require(65) -var SHA512 = require(102) -var Hash = require(95) -var Buffer = require(93).Buffer +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha384.js":[function(require,module,exports){ +var inherits = require('inherits') +var SHA512 = require('./sha512') +var Hash = require('./hash') +var Buffer = require('safe-buffer').Buffer var W = new Array(160) @@ -24700,10 +23284,10 @@ Sha384.prototype._hash = function () { module.exports = Sha384 -},{"102":102,"65":65,"93":93,"95":95}],102:[function(require,module,exports){ -var inherits = require(65) -var Hash = require(95) -var Buffer = require(93).Buffer +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","./sha512":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha512.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha512.js":[function(require,module,exports){ +var inherits = require('inherits') +var Hash = require('./hash') +var Buffer = require('safe-buffer').Buffer var K = [ 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, @@ -24962,7 +23546,7 @@ Sha512.prototype._hash = function () { module.exports = Sha512 -},{"65":65,"93":93,"95":95}],103:[function(require,module,exports){ +},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/stream-browserify/index.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -24986,15 +23570,15 @@ module.exports = Sha512 module.exports = Stream; -var EE = require(62).EventEmitter; -var inherits = require(65); +var EE = require('events').EventEmitter; +var inherits = require('inherits'); inherits(Stream, EE); -Stream.Readable = require(89); -Stream.Writable = require(91); -Stream.Duplex = require(78); -Stream.Transform = require(90); -Stream.PassThrough = require(88); +Stream.Readable = require('readable-stream/readable.js'); +Stream.Writable = require('readable-stream/writable.js'); +Stream.Duplex = require('readable-stream/duplex.js'); +Stream.Transform = require('readable-stream/transform.js'); +Stream.PassThrough = require('readable-stream/passthrough.js'); // Backwards-compat with node 0.4.x Stream.Stream = Stream; @@ -25091,7 +23675,7 @@ Stream.prototype.pipe = function(dest, options) { return dest; }; -},{"62":62,"65":65,"78":78,"88":88,"89":89,"90":90,"91":91}],104:[function(require,module,exports){ +},{"events":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/events/events.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","readable-stream/duplex.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/duplex-browser.js","readable-stream/passthrough.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/passthrough.js","readable-stream/readable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js","readable-stream/transform.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/transform.js","readable-stream/writable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/writable-browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/string_decoder/lib/string_decoder.js":[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -25117,7 +23701,7 @@ Stream.prototype.pipe = function(dest, options) { /**/ -var Buffer = require(93).Buffer; +var Buffer = require('safe-buffer').Buffer; /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -25388,9 +23972,9 @@ function simpleWrite(buf) { function simpleEnd(buf) { return buf && buf.length ? this.write(buf) : ''; } -},{"93":93}],105:[function(require,module,exports){ +},{"safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/timers-browserify/main.js":[function(require,module,exports){ (function (setImmediate,clearImmediate){ -var nextTick = require(77).nextTick; +var nextTick = require('process/browser.js').nextTick; var apply = Function.prototype.apply; var slice = Array.prototype.slice; var immediateIds = {}; @@ -25466,9 +24050,9 @@ exports.setImmediate = typeof setImmediate === "function" ? setImmediate : funct exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { delete immediateIds[id]; }; -}).call(this,require(105).setImmediate,require(105).clearImmediate) +}).call(this,require("timers").setImmediate,require("timers").clearImmediate) -},{"105":105,"77":77}],106:[function(require,module,exports){ +},{"process/browser.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","timers":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/timers-browserify/main.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util-deprecate/browser.js":[function(require,module,exports){ (function (global){ /** @@ -25540,14 +24124,16 @@ function config (name) { }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{}],107:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util/node_modules/inherits/inherits_browser.js":[function(require,module,exports){ +arguments[4]["/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js"][0].apply(exports,arguments) +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util/support/isBufferBrowser.js":[function(require,module,exports){ module.exports = function isBuffer(arg) { return arg && typeof arg === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function'; } -},{}],108:[function(require,module,exports){ +},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util/util.js":[function(require,module,exports){ (function (process,global){ // Copyright Joyent, Inc. and other Node contributors. // @@ -26074,7 +24660,7 @@ function isPrimitive(arg) { } exports.isPrimitive = isPrimitive; -exports.isBuffer = require(107); +exports.isBuffer = require('./support/isBuffer'); function objectToString(o) { return Object.prototype.toString.call(o); @@ -26118,7 +24704,7 @@ exports.log = function() { * prototype. * @param {function} superCtor Constructor function to inherit prototype from. */ -exports.inherits = require(65); +exports.inherits = require('inherits'); exports._extend = function(origin, add) { // Don't do anything if add isn't an object @@ -26136,9 +24722,9 @@ function hasOwnProperty(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } -}).call(this,require(77),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"107":107,"65":65,"77":77}]},{},[1])(1) +},{"./support/isBuffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util/support/isBufferBrowser.js","_process":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process/browser.js","inherits":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/util/node_modules/inherits/inherits_browser.js"}]},{},["/Users/mseaward/Documents/code/peerplaysjs-lib/dist/browser.js"])("/Users/mseaward/Documents/code/peerplaysjs-lib/dist/browser.js") }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","dist/browser.js","dist/chain/src/AccountLogin.js","dist/chain/src/ChainTypes.js","dist/chain/src/ObjectId.js","dist/chain/src/TransactionBuilder.js","dist/chain/src/state.js","dist/ecc/index.js","dist/ecc/src/BrainKey.js","dist/ecc/src/KeyUtils.js","dist/ecc/src/PrivateKey.js","dist/ecc/src/PublicKey.js","dist/ecc/src/address.js","dist/ecc/src/aes.js","dist/ecc/src/ecdsa.js","dist/ecc/src/ecsignature.js","dist/ecc/src/enforce_types.js","dist/ecc/src/hash.js","dist/ecc/src/signature.js","dist/serializer/index.js","dist/serializer/src/FastParser.js","dist/serializer/src/SerializerValidation.js","dist/serializer/src/error_with_cause.js","dist/serializer/src/operations.js","dist/serializer/src/serializer.js","dist/serializer/src/template.js","dist/serializer/src/types.js","node_modules/assert/assert.js","node_modules/base-x/index.js","node_modules/base64-js/index.js","node_modules/bigi/lib/bigi.js","node_modules/bigi/lib/convert.js","node_modules/bigi/lib/index.js","node_modules/bigi/package.json","node_modules/browser-resolve/empty.js","node_modules/browserify/node_modules/buffer/index.js","node_modules/browserify/node_modules/string_decoder/index.js","node_modules/bs58/index.js","node_modules/bytebuffer/dist/bytebuffer.js","node_modules/cipher-base/index.js","node_modules/core-util-is/lib/util.js","node_modules/create-hash/browser.js","node_modules/create-hash/md5.js","node_modules/create-hmac/browser.js","node_modules/create-hmac/legacy.js","node_modules/crypto-js/aes.js","node_modules/crypto-js/cipher-core.js","node_modules/crypto-js/core.js","node_modules/crypto-js/enc-base64.js","node_modules/crypto-js/enc-hex.js","node_modules/crypto-js/evpkdf.js","node_modules/crypto-js/hmac.js","node_modules/crypto-js/md5.js","node_modules/crypto-js/sha1.js","node_modules/deep-equal/index.js","node_modules/deep-equal/lib/is_arguments.js","node_modules/deep-equal/lib/keys.js","node_modules/ecurve/lib/curve.js","node_modules/ecurve/lib/curves.json","node_modules/ecurve/lib/index.js","node_modules/ecurve/lib/names.js","node_modules/ecurve/lib/point.js","node_modules/events/events.js","node_modules/hash-base/index.js","node_modules/ieee754/index.js","node_modules/inherits/inherits_browser.js","node_modules/is-buffer/index.js","node_modules/isarray/index.js","node_modules/long/dist/long.js","node_modules/md5.js/index.js","node_modules/peerplaysjs-ws/dist/index.js","node_modules/peerplaysjs-ws/dist/src/ApiInstances.js","node_modules/peerplaysjs-ws/dist/src/ChainConfig.js","node_modules/peerplaysjs-ws/dist/src/ChainWebSocket.js","node_modules/peerplaysjs-ws/dist/src/ConnectionManager.js","node_modules/peerplaysjs-ws/dist/src/GrapheneApi.js","node_modules/process-nextick-args/index.js","node_modules/process/browser.js","node_modules/readable-stream/duplex-browser.js","node_modules/readable-stream/lib/_stream_duplex.js","node_modules/readable-stream/lib/_stream_passthrough.js","node_modules/readable-stream/lib/_stream_readable.js","node_modules/readable-stream/lib/_stream_transform.js","node_modules/readable-stream/lib/_stream_writable.js","node_modules/readable-stream/lib/internal/streams/BufferList.js","node_modules/readable-stream/lib/internal/streams/destroy.js","node_modules/readable-stream/lib/internal/streams/stream-browser.js","node_modules/readable-stream/passthrough.js","node_modules/readable-stream/readable-browser.js","node_modules/readable-stream/transform.js","node_modules/readable-stream/writable-browser.js","node_modules/ripemd160/index.js","node_modules/safe-buffer/index.js","node_modules/secure-random/lib/secure-random.js","node_modules/sha.js/hash.js","node_modules/sha.js/index.js","node_modules/sha.js/sha.js","node_modules/sha.js/sha1.js","node_modules/sha.js/sha224.js","node_modules/sha.js/sha256.js","node_modules/sha.js/sha384.js","node_modules/sha.js/sha512.js","node_modules/stream-browserify/index.js","node_modules/string_decoder/lib/string_decoder.js","node_modules/timers-browserify/main.js","node_modules/util-deprecate/browser.js","node_modules/util/support/isBufferBrowser.js","node_modules/util/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AClqBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACnOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AChOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACx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zPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACjJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACrEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC5gDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACrrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1eA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACr+CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3FA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5DA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7NA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClqHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/2BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3QA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9SA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACleA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxLA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACrNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9qBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;;;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACvSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACn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file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","'use strict';\n\nexports.__esModule = true;\n\nvar _peerplaysjsWs = require(70);\n\nvar _peerplaysjsWs2 = _interopRequireDefault(_peerplaysjsWs);\n\nvar _PrivateKey = require(10);\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _PublicKey = require(11);\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nvar _signature = require(18);\n\nvar _signature2 = _interopRequireDefault(_signature);\n\nvar _KeyUtils = require(9);\n\nvar _KeyUtils2 = _interopRequireDefault(_KeyUtils);\n\nvar _TransactionBuilder = require(5);\n\nvar _TransactionBuilder2 = _interopRequireDefault(_TransactionBuilder);\n\nvar _AccountLogin = require(2);\n\nvar _AccountLogin2 = _interopRequireDefault(_AccountLogin);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  PrivateKey: _PrivateKey2.default,\n  PublicKey: _PublicKey2.default,\n  Signature: _signature2.default,\n  key: _KeyUtils2.default,\n  TransactionBuilder: _TransactionBuilder2.default,\n  Login: _AccountLogin2.default,\n  peerplaysjs_ws: _peerplaysjsWs2.default\n};\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _PrivateKey = require(10);\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _KeyUtils = require(9);\n\nvar _KeyUtils2 = _interopRequireDefault(_KeyUtils);\n\nvar _state = require(6);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _keyCachePriv = {};\nvar _keyCachePub = {};\n\nvar AccountLogin = function () {\n  function AccountLogin() {\n    _classCallCheck(this, AccountLogin);\n\n    var state = { loggedIn: false, roles: ['active', 'owner', 'memo'] };\n    this.get = (0, _state.get)(state);\n    this.set = (0, _state.set)(state);\n\n    this.subs = {};\n  }\n\n  AccountLogin.prototype.addSubscription = function addSubscription(cb) {\n    this.subs[cb] = cb;\n  };\n\n  AccountLogin.prototype.setRoles = function setRoles(roles) {\n    this.set('roles', roles);\n  };\n\n  AccountLogin.prototype.generateKeys = function generateKeys(accountName, password, roles, prefix) {\n    if (!accountName || !password) {\n      throw new Error('Account name or password required');\n    }\n\n    if (password.length < 12) {\n      throw new Error('Password must have at least 12 characters');\n    }\n\n    var privKeys = {};\n    var pubKeys = {};\n\n    (roles || this.get('roles')).forEach(function (role) {\n      var seed = password + accountName + role;\n      var pkey = _keyCachePriv[seed] ? _keyCachePriv[seed] : _PrivateKey2.default.fromSeed(_KeyUtils2.default.normalize_brainKey(seed));\n      _keyCachePriv[seed] = pkey;\n\n      privKeys[role] = pkey;\n      pubKeys[role] = _keyCachePub[seed] ? _keyCachePub[seed] : pkey.toPublicKey().toString(prefix);\n\n      _keyCachePub[seed] = pubKeys[role];\n    });\n\n    return { privKeys: privKeys, pubKeys: pubKeys };\n  };\n\n  AccountLogin.prototype.checkKeys = function checkKeys(_ref) {\n    var _this = this;\n\n    var accountName = _ref.accountName,\n        password = _ref.password,\n        auths = _ref.auths;\n\n    if (!accountName || !password || !auths) {\n      throw new Error('checkKeys: Missing inputs');\n    }\n\n    var hasKey = false;\n    var roles = Object.keys(auths);\n\n    var _loop = function _loop(i, len) {\n      var role = roles[i];\n\n      var _generateKeys = _this.generateKeys(accountName, password, [role]),\n          privKeys = _generateKeys.privKeys,\n          pubKeys = _generateKeys.pubKeys;\n\n      auths[role].forEach(function (roleKey) {\n        if (roleKey[0] === pubKeys[role]) {\n          hasKey = true;\n          _this.set(role, { priv: privKeys[role], pub: pubKeys[role] });\n        }\n      });\n    };\n\n    for (var i = 0, len = roles.length; i < len; i++) {\n      _loop(i, len);\n    }\n\n    if (hasKey) {\n      this.set('name', accountName);\n    }\n\n    this.set('loggedIn', hasKey);\n\n    return hasKey;\n  };\n\n  AccountLogin.prototype.signTransaction = function signTransaction(tr) {\n    var _this2 = this;\n\n    var hasKey = false;\n\n    this.get('roles').forEach(function (role) {\n      var myKey = _this2.get(role);\n\n      if (myKey) {\n        hasKey = true;\n        console.log('adding signer:', myKey.pub);\n        tr.add_signer(myKey.priv, myKey.pub);\n      }\n    });\n\n    if (!hasKey) {\n      throw new Error('You do not have any private keys to sign this transaction');\n    }\n  };\n\n  return AccountLogin;\n}();\n\nexports.default = new AccountLogin();\nmodule.exports = exports['default'];","\"use strict\";\n\nexports.__esModule = true;\nvar reserved_spaces = {\n  relative_protocol_ids: 0,\n  protocol_ids: 1,\n  implementation_ids: 2\n};\n\nvar object_type = {\n  null: 0,\n  base: 1,\n  account: 2,\n  asset: 3,\n  force_settlement: 4,\n  committee_member: 5,\n  witness: 6,\n  limit_order: 7,\n  call_order: 8,\n  custom: 9,\n  proposal: 10,\n  operation_history: 11,\n  withdraw_permission: 12,\n  vesting_balance: 13,\n  worker: 14,\n  balance: 15,\n  tournament: 16,\n  tournament_details: 17,\n  match: 18,\n  game: 19,\n  sport: 20,\n  event_group: 21,\n  event: 22,\n  betting_market_rules: 23,\n  betting_market_group: 24,\n  betting_market: 25,\n  bet: 26\n};\n\nvar impl_object_type = {\n  global_property: 0,\n  dynamic_global_property: 1,\n  reserved0: 2,\n  asset_dynamic_data: 3,\n  asset_bitasset_data: 4,\n  account_balance: 5,\n  account_statistics: 6,\n  transaction: 7,\n  block_summary: 8,\n  account_transaction_history: 9,\n  blinded_balance: 10,\n  chain_property: 11,\n  witness_schedule: 12,\n  budget_record: 13,\n  special_authority: 14,\n  buyback: 15,\n  fba_accumulator: 16,\n  betting_market_position: 17,\n  global_betting_statistics: 18,\n  asset_dividend_data: 19,\n  pending_dividend_payout_balance_for_holder: 20,\n  distributed_dividend_balance_data: 21\n};\n\nvar vote_type = {\n  committee: 0,\n  witness: 1,\n  worker: 2\n};\n\nvar operations = {\n  transfer: 0,\n  limit_order_create: 1,\n  limit_order_cancel: 2,\n  call_order_update: 3,\n  fill_order: 4,\n  account_create: 5,\n  account_update: 6,\n  account_whitelist: 7,\n  account_upgrade: 8,\n  account_transfer: 9,\n  asset_create: 10,\n  asset_update: 11,\n  asset_update_bitasset: 12,\n  asset_update_feed_producers: 13,\n  asset_issue: 14,\n  asset_reserve: 15,\n  asset_fund_fee_pool: 16,\n  asset_settle: 17,\n  asset_global_settle: 18,\n  asset_publish_feed: 19,\n  witness_create: 20,\n  witness_update: 21,\n  proposal_create: 22,\n  proposal_update: 23,\n  proposal_delete: 24,\n  withdraw_permission_create: 25,\n  withdraw_permission_update: 26,\n  withdraw_permission_claim: 27,\n  withdraw_permission_delete: 28,\n  committee_member_create: 29,\n  committee_member_update: 30,\n  committee_member_update_global_parameters: 31,\n  vesting_balance_create: 32,\n  vesting_balance_withdraw: 33,\n  worker_create: 34,\n  custom: 35,\n  assert: 36,\n  balance_claim: 37,\n  override_transfer: 38,\n  transfer_to_blind: 39,\n  blind_transfer: 40,\n  transfer_from_blind: 41,\n  asset_settle_cancel: 42,\n  asset_claim_fees: 43,\n  fba_distribute_operation: 44,\n  tournament_create: 45,\n  tournament_join: 46,\n  game_move: 47,\n  asset_update_dividend: 48,\n  asset_dividend_distribution: 49,\n  tournament_payout: 50,\n  tournament_leave: 51,\n  sport_create: 52,\n  sport_update: 53,\n  event_group_create: 54,\n  event_group_update: 55,\n  event_create: 56,\n  event_update: 57,\n  betting_market_rules_create: 58,\n  betting_market_rules_update: 59,\n  betting_market_group_create: 60,\n  betting_market_create: 61,\n  bet_place: 62,\n  betting_market_group_resolve: 63,\n  betting_market_group_resolved: 64,\n  bet_adjusted: 65,\n  betting_market_group_cancel: 66,\n  bet_matched: 67,\n  bet_cancel: 68,\n  bet_canceled: 69,\n  betting_market_group_update: 70,\n  betting_market_update: 71,\n  event_update_status: 72\n};\n\nvar ChainTypes = {\n  reserved_spaces: reserved_spaces,\n  object_type: object_type,\n  impl_object_type: impl_object_type,\n  vote_type: vote_type,\n  operations: operations\n};\n\nexports.default = ChainTypes;\nmodule.exports = exports[\"default\"];","'use strict';\n\nexports.__esModule = true;\n\nvar _bytebuffer = require(38);\n\nvar _SerializerValidation = require(21);\n\nvar _SerializerValidation2 = _interopRequireDefault(_SerializerValidation);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar DB_MAX_INSTANCE_ID = _bytebuffer.Long.fromNumber(Math.pow(2, 48) - 1);\n\nvar ObjectId = function () {\n  function ObjectId(space, type, instance) {\n    _classCallCheck(this, ObjectId);\n\n    this.space = space;\n    this.type = type;\n    this.instance = instance;\n    var instance_string = this.instance.toString();\n    var id = this.space + '.' + this.type + '.' + instance_string;\n\n    if (!_SerializerValidation2.default.is_digits(instance_string)) {\n      throw new ('Invalid object id ' + id)();\n    }\n  }\n\n  ObjectId.fromString = function fromString(value) {\n    if (value.space !== undefined && value.type !== undefined && value.instance !== undefined) {\n      return value;\n    }\n\n    var params = _SerializerValidation2.default.require_match(/^([0-9]+)\\.([0-9]+)\\.([0-9]+)$/, _SerializerValidation2.default.required(value, 'ObjectId'), 'ObjectId');\n    return new ObjectId(parseInt(params[1], 10), parseInt(params[2], 10), _bytebuffer.Long.fromString(params[3]));\n  };\n\n  ObjectId.fromLong = function fromLong(long) {\n    var space = long.shiftRight(56).toInt();\n    var type = long.shiftRight(48).toInt() & 0x00ff; // eslint-disable-line\n    var instance = long.and(DB_MAX_INSTANCE_ID);\n    return new ObjectId(space, type, instance);\n  };\n\n  ObjectId.fromByteBuffer = function fromByteBuffer(b) {\n    return ObjectId.fromLong(b.readUint64());\n  };\n\n  ObjectId.prototype.toLong = function toLong() {\n    return _bytebuffer.Long.fromNumber(this.space).shiftLeft(56).or(_bytebuffer.Long.fromNumber(this.type).shiftLeft(48).or(this.instance));\n  };\n\n  ObjectId.prototype.appendByteBuffer = function appendByteBuffer(b) {\n    return b.writeUint64(this.toLong());\n  };\n\n  ObjectId.prototype.toString = function toString() {\n    return this.space + '.' + this.type + '.' + this.instance.toString();\n  };\n\n  return ObjectId;\n}();\n\nexports.default = ObjectId;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _ecc = require('../../ecc');\n\nvar _serializer = require('../../serializer');\n\nvar _ChainTypes = require('./ChainTypes');\n\nvar _ChainTypes2 = _interopRequireDefault(_ChainTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar TransactionBuilder = function () {\n  function TransactionBuilder() {\n    _classCallCheck(this, TransactionBuilder);\n\n    this.ref_block_num = 0;\n    this.ref_block_prefix = 0;\n    this.expiration = 0;\n    this.operations = [];\n    this.signatures = [];\n    this.signer_private_keys = [];\n\n    this.head_block_time_string = null;\n    this.committee_min_review = null;\n\n    // semi-private method bindings\n    this._broadcast = this._broadcast.bind(this);\n  }\n\n  /**\n        @arg {string} name - like \"transfer\"\n        @arg {object} operation - JSON matchching the operation's format\n    */\n\n\n  TransactionBuilder.prototype.add_type_operation = function add_type_operation(name, operation) {\n    this.add_operation(this.get_type_operation(name, operation));\n  };\n\n  /**\n        This does it all: set fees, finalize, sign, and broadcast (if wanted).\n         @arg {ConfidentialWallet} cwallet - must be unlocked, used to gather signing keys\n         @arg {array<string>} [signer_pubkeys = null] - Optional [\"GPHAbc9Def0...\", ...].  These are\n        additional signing keys.  Some balance claims require propritary address formats, the\n        witness node can't tell us which ones are needed so they must be passed in.  If the\n        witness node can figure out a signing key (mostly all other transactions), it should\n        not be passed in here.\n         @arg {boolean} [broadcast = false]\n    */\n\n\n  TransactionBuilder.prototype.process_transaction = function process_transaction(cwallet) {\n    var _this = this;\n\n    var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n    var wallet_object = cwallet.wallet.wallet_object;\n\n\n    if (_peerplaysjsWs.Apis.instance().chain_id !== wallet_object.get('chain_id')) {\n      var wallet_chain_id = wallet_object.get('chain_id');\n      var api_chain_id = _peerplaysjsWs.Apis.instance().chain_id;\n\n      var error = new Error('Mismatched chain_id; expecting ' + wallet_chain_id + ', but got ' + api_chain_id);\n\n      return Promise.reject(error);\n    }\n\n    return this.set_required_fees().then(function () {\n      var signer_pubkeys_added = {};\n\n      if (signer_pubkeys) {\n        // Balance claims are by address, only the private\n        // key holder can know about these additional\n        // potential keys.\n        var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys);\n\n        if (!pubkeys.length) {\n          throw new Error('Missing signing key');\n        }\n\n        var keys = Object.keys(pubkeys);\n\n        for (var i = 0, len = keys.length; i < len; i++) {\n          var pubkey_string = pubkeys[i];\n          var private_key = cwallet.getPrivateKey(pubkey_string);\n          _this.add_signer(private_key, pubkey_string);\n          signer_pubkeys_added[pubkey_string] = true;\n        }\n      }\n\n      return _this.get_potential_signatures().then(function (_ref) {\n        var pubkeys = _ref.pubkeys,\n            addys = _ref.addys;\n\n        var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys);\n\n        return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) {\n          var keys = Object.keys(required_pubkeys);\n\n          for (var _i = 0, _len = keys.length; _i < _len; _i++) {\n            var _pubkey_string = keys[_i];\n\n            if (!signer_pubkeys_added[_pubkey_string]) {\n              var _private_key = cwallet.getPrivateKey(_pubkey_string);\n\n              // This should not happen, get_required_signatures will only\n              // returned keys from my_pubkeys\n              if (!_private_key) {\n                throw new Error('Missing signing key for ' + _pubkey_string);\n              }\n\n              _this.add_signer(_private_key, _pubkey_string);\n            }\n          }\n        });\n      }).then(function () {\n        return broadcast ? _this.broadcast() : _this.serialize();\n      });\n    });\n  };\n\n  /** Typically this is called automatically just prior to signing.\n   * Once finalized this transaction can not be changed. */\n\n\n  TransactionBuilder.prototype.finalize = function finalize() {\n    var _this2 = this;\n\n    return new Promise(function (resolve) {\n      if (_this2.tr_buffer) {\n        throw new Error('already finalized');\n      }\n\n      resolve(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.1.0']]).then(function (r) {\n        _this2.head_block_time_string = r[0].time;\n\n        if (_this2.expiration === 0) {\n          _this2.expiration = _this2.base_expiration_sec() + _peerplaysjsWs.ChainConfig.expire_in_secs;\n        }\n\n        _this2.ref_block_num = r[0].head_block_number & 0xffff; // eslint-disable-line\n        _this2.ref_block_prefix = Buffer.from(r[0].head_block_id, 'hex').readUInt32LE(4);\n        // DEBUG console.log(\"ref_block\",@ref_block_num,@ref_block_prefix,r)\n\n        var iterable = _this2.operations;\n\n        for (var i = 0, len = iterable.length; i < len; i++) {\n          var op = iterable[i];\n\n          if (op[1].finalize) {\n            op[1].finalize();\n          }\n\n          var _type = _serializer.ops.operation.st_operations[op[0]];\n          var hexBuffer = _type.toBuffer(op[1]).toString('hex');\n          console.log('Operation %s: %O => %s (%d bytes)', _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2);\n        }\n\n        _this2.tr_buffer = _serializer.ops.transaction.toBuffer(_this2);\n      }));\n    });\n  };\n\n  /** @return {string} hex transaction ID */\n\n\n  TransactionBuilder.prototype.id = function id() {\n    if (!this.tr_buffer) {\n      throw new Error('not finalized');\n    }\n\n    return _ecc.hash.sha256(this.tr_buffer).toString('hex').substring(0, 40);\n  };\n\n  /**\n        Typically one will use {@link this.add_type_operation} instead.\n        @arg {array} operation - [operation_id, operation]\n    */\n\n\n  TransactionBuilder.prototype.add_operation = function add_operation(operation) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    (0, _assert2.default)(operation, 'operation');\n\n    if (!Array.isArray(operation)) {\n      throw new Error('Expecting array [operation_id, operation]');\n    }\n\n    this.operations.push(operation);\n  };\n\n  TransactionBuilder.prototype.get_type_operation = function get_type_operation(name, operation) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    (0, _assert2.default)(name, 'name');\n    (0, _assert2.default)(operation, 'operation');\n    var _type = _serializer.ops[name];\n    (0, _assert2.default)(_type, 'Unknown operation ' + name);\n    var operation_id = _ChainTypes2.default.operations[_type.operation_name];\n\n    if (operation_id === undefined) {\n      throw new Error('unknown operation: ' + _type.operation_name);\n    }\n\n    if (!operation.fee) {\n      operation.fee = { amount: 0, asset_id: 0 };\n    }\n\n    if (name === 'proposal_create') {\n      /*\n            * Proposals involving the committee account require a review\n            * period to be set, look for them here\n            */\n      var requiresReview = false;\n      var extraReview = 0;\n\n      operation.proposed_ops.forEach(function (op) {\n        var COMMITTE_ACCOUNT = 0;\n        var key = void 0;\n\n        switch (op.op[0]) {\n          case 0:\n            // transfer\n            key = 'from';\n            break;\n\n          case 6: // account_update\n          case 17:\n            // asset_settle\n            key = 'account';\n            break;\n\n          case 10: // asset_create\n          case 11: // asset_update\n          case 12: // asset_update_bitasset\n          case 13: // asset_update_feed_producers\n          case 14: // asset_issue\n          case 18: // asset_global_settle\n          case 43:\n            // asset_claim_fees\n            key = 'issuer';\n            break;\n\n          case 15:\n            // asset_reserve\n            key = 'payer';\n            break;\n\n          case 16:\n            // asset_fund_fee_pool\n            key = 'from_account';\n            break;\n\n          case 22: // proposal_create\n          case 23: // proposal_update\n          case 24:\n            // proposal_delete\n            key = 'fee_paying_account';\n            break;\n\n          case 31:\n            // committee_member_update_global_parameters\n            requiresReview = true;\n            extraReview = 60 * 60 * 24 * 13; // Make the review period 2 weeks total\n            break;\n          default:\n            break;\n        }\n\n        if (key in op.op[1] && op.op[1][key] === COMMITTE_ACCOUNT) {\n          requiresReview = true;\n        }\n      });\n\n      if (!operation.expiration_time) {\n        var experationTime = this.base_expiration_sec();\n        operation.expiration_time = experationTime + _peerplaysjsWs.ChainConfig.expire_in_secs_proposal;\n      }\n\n      if (requiresReview) {\n        var one_day = 24 * 60 * 60; // One day in seconds\n        var max = Math.max(this.commitee_min_review, one_day, _peerplaysjsWs.ChainConfig.review_in_secs_committee);\n\n        operation.review_period_seconds = extraReview + max;\n        /*\n                * Expiration time must be at least equal to\n                * now + review_period_seconds, so we add one hour to make sure\n                */\n        operation.expiration_time += 60 * 60 + extraReview;\n      }\n    }\n\n    var operation_instance = _type.fromObject(operation);\n    return [operation_id, operation_instance];\n  };\n\n  /* optional: fetch the current head block */\n\n  TransactionBuilder.prototype.update_head_block = function update_head_block() {\n    var _this3 = this;\n\n    return _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [['2.0.0', '2.1.0']]).then(function (res) {\n      var g = res[0],\n          r = res[1];\n\n      _this3.head_block_time_string = r[0].time;\n      _this3.committee_min_review = g[0].parameters.committee_proposal_review_period;\n    });\n  };\n\n  /** optional: there is a deafult expiration */\n\n\n  TransactionBuilder.prototype.set_expire_seconds = function set_expire_seconds(sec) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    this.expiration = this.base_expiration_sec() + sec;\n\n    return this.expiration;\n  };\n\n  /* Wraps this transaction in a proposal_create transaction */\n\n\n  TransactionBuilder.prototype.propose = function propose(proposal_create_options) {\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    if (!this.operations.length) {\n      throw new Error('add operation first');\n    }\n\n    (0, _assert2.default)(proposal_create_options, 'proposal_create_options');\n    (0, _assert2.default)(proposal_create_options.fee_paying_account, 'proposal_create_options.fee_paying_account');\n\n    var proposed_ops = this.operations.map(function (op) {\n      return { op: op };\n    });\n\n    this.operations = [];\n    this.signatures = [];\n    this.signer_private_keys = [];\n    proposal_create_options.proposed_ops = proposed_ops;\n    this.add_type_operation('proposal_create', proposal_create_options);\n    return this;\n  };\n\n  TransactionBuilder.prototype.has_proposed_operation = function has_proposed_operation() {\n    var hasProposed = false;\n\n    for (var i = 0; i < this.operations.length; i++) {\n      if ('proposed_ops' in this.operations[i][1]) {\n        hasProposed = true;\n        break;\n      }\n    }\n\n    return hasProposed;\n  };\n\n  /** optional: the fees can be obtained from the witness node */\n\n\n  TransactionBuilder.prototype.set_required_fees = function set_required_fees(asset_id) {\n    var _this4 = this;\n\n    var fee_pool = void 0;\n\n    if (this.tr_buffer) {\n      throw new Error('already finalized');\n    }\n\n    if (!this.operations.length) {\n      throw new Error('add operations first');\n    }\n\n    var operations = [];\n\n    for (var i = 0, len = this.operations.length; i < len; i++) {\n      var op = this.operations[i];\n      operations.push(_serializer.ops.operation.toObject(op));\n    }\n\n    if (!asset_id) {\n      var op1_fee = operations[0][1].fee;\n\n      if (op1_fee && op1_fee.asset_id !== null) {\n        asset_id = op1_fee.asset_id;\n      } else {\n        asset_id = '1.3.0';\n      }\n    }\n\n    var promises = [_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, asset_id])];\n\n    if (asset_id !== '1.3.0') {\n      // This handles the fallback to paying fees in BTS if the fee pool is empty.\n      promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_required_fees', [operations, '1.3.0']));\n      promises.push(_peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset_id]]));\n    }\n\n    return Promise.all(promises).then(function (results) {\n      var fees = results[0],\n          coreFees = results[1],\n          asset = results[2];\n\n      asset = asset ? asset[0] : null;\n\n      var dynamicPromise = asset_id !== '1.3.0' && asset ? _peerplaysjsWs.Apis.instance().db_api().exec('get_objects', [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve) {\n        resolve();\n      });\n\n      return dynamicPromise.then(function (dynamicObject) {\n        if (asset_id !== '1.3.0') {\n          fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0;\n          var totalFees = 0;\n\n          for (var j = 0, fee; j < coreFees.length; j++) {\n            fee = coreFees[j];\n            totalFees += fee.amount;\n          }\n\n          if (totalFees > parseInt(fee_pool, 10)) {\n            fees = coreFees;\n            asset_id = '1.3.0';\n          }\n        }\n\n        // Proposed transactions need to be flattened\n        var flat_assets = [];\n\n        var flatten = function flatten(obj) {\n          if (Array.isArray(obj)) {\n            for (var k = 0, _len2 = obj.length; k < _len2; k++) {\n              var item = obj[k];\n              flatten(item);\n            }\n          } else {\n            flat_assets.push(obj);\n          }\n        };\n\n        flatten(fees);\n\n        var asset_index = 0;\n\n        var set_fee = function set_fee(operation) {\n          if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === '0' // Long\n          ) {\n              operation.fee = flat_assets[asset_index];\n              // console.log(\"new operation.fee\", operation.fee)\n            } else {\n              // console.log(\"old operation.fee\", operation.fee)\n            }\n\n          asset_index++;\n\n          if (operation.proposed_ops) {\n            var result = [];\n\n            for (var y = 0; y < operation.proposed_ops.length; y++) {\n              result.push(set_fee(operation.proposed_ops[y].op[1]));\n            }\n\n            return result;\n          }\n        };\n\n        for (var _i2 = 0; _i2 < _this4.operations.length; _i2++) {\n          set_fee(_this4.operations[_i2][1]);\n        }\n      });\n      // DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets)\n    });\n  };\n\n  TransactionBuilder.prototype.get_potential_signatures = function get_potential_signatures() {\n    var tr_object = _serializer.ops.signed_transaction.toObject(this);\n    return Promise.all([_peerplaysjsWs.Apis.instance().db_api().exec('get_potential_signatures', [tr_object]), _peerplaysjsWs.Apis.instance().db_api().exec('get_potential_address_signatures', [tr_object])]).then(function (results) {\n      return { pubkeys: results[0], addys: results[1] };\n    });\n  };\n\n  TransactionBuilder.prototype.get_required_signatures = function get_required_signatures(available_keys) {\n    if (!available_keys.length) {\n      return Promise.resolve([]);\n    }\n\n    var tr_object = _serializer.ops.signed_transaction.toObject(this);\n    // DEBUG console.log('... tr_object',tr_object)\n    return _peerplaysjsWs.Apis.instance().db_api().exec('get_required_signatures', [tr_object, available_keys]).then(function (required_public_keys) {\n      return required_public_keys;\n    });\n  };\n\n  TransactionBuilder.prototype.add_signer = function add_signer(private_key) {\n    var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey();\n\n    (0, _assert2.default)(private_key.d, 'required PrivateKey object');\n\n    if (this.signed) {\n      throw new Error('already signed');\n    }\n\n    if (!public_key.Q) {\n      public_key = _ecc.PublicKey.fromPublicKeyString(public_key);\n    }\n\n    // prevent duplicates\n    var spHex = private_key.toHex();\n\n    var keys = Object.keys(this.signer_private_keys);\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var sp = this.signer_private_keys[keys[i]];\n\n      if (sp[0].toHex() === spHex) {\n        return;\n      }\n    }\n\n    this.signer_private_keys.push([private_key, public_key]);\n  };\n\n  TransactionBuilder.prototype.sign = function sign() {\n    var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.Apis.instance().chain_id;\n\n    if (!this.tr_buffer) {\n      throw new Error('not finalized');\n    }\n\n    if (this.signed) {\n      throw new Error('already signed');\n    }\n\n    if (!this.signer_private_keys.length) {\n      throw new Error('Transaction was not signed. Do you have a private key? [no_signers]');\n    }\n\n    var end = this.signer_private_keys.length;\n\n    for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) {\n      var _signer_private_keys$ = this.signer_private_keys[i],\n          private_key = _signer_private_keys$[0],\n          public_key = _signer_private_keys$[1];\n\n      var sig = _ecc.Signature.signBuffer(Buffer.concat([Buffer.from(chain_id, 'hex'), this.tr_buffer]), private_key, public_key);\n      this.signatures.push(sig.toBuffer());\n    }\n\n    this.signer_private_keys = [];\n    this.signed = true;\n  };\n\n  TransactionBuilder.prototype.serialize = function serialize() {\n    return _serializer.ops.signed_transaction.toObject(this);\n  };\n\n  TransactionBuilder.prototype.toObject = function toObject() {\n    return _serializer.ops.signed_transaction.toObject(this);\n  };\n\n  TransactionBuilder.prototype.broadcast = function broadcast(was_broadcast_callback) {\n    var _this5 = this;\n\n    if (this.tr_buffer) {\n      return this._broadcast(was_broadcast_callback);\n    }\n\n    return this.finalize().then(function () {\n      return _this5._broadcast(was_broadcast_callback);\n    });\n  };\n\n  TransactionBuilder.prototype._broadcast = function _broadcast(was_broadcast_callback) {\n    var _this6 = this;\n\n    return new Promise(function (resolve, reject) {\n      if (!_this6.signed) {\n        _this6.sign();\n      }\n\n      if (!_this6.tr_buffer) {\n        throw new Error('not finalized');\n      }\n\n      if (!_this6.signatures.length) {\n        throw new Error('not signed');\n      }\n\n      if (!_this6.operations.length) {\n        throw new Error('no operations');\n      }\n\n      var tr_object = _serializer.ops.signed_transaction.toObject(_this6);\n      // console.log('... broadcast_transaction_with_callback !!!')\n      _peerplaysjsWs.Apis.instance().network_api().exec('broadcast_transaction_with_callback', [function (res) {\n        return resolve(res);\n      }, tr_object]).then(function () {\n        // console.log('... broadcast success, waiting for callback')\n        if (was_broadcast_callback) {\n          was_broadcast_callback();\n        }\n      }).catch(function (error) {\n        // console.log may be redundant for network errors, other errors could occur\n        console.log(error);\n        var message = error.message;\n\n\n        if (!message) {\n          message = '';\n        }\n\n        reject(new Error(message + '\\n' + 'peerplays-crypto ' + (' digest ' + _ecc.hash.sha256(_this6.tr_buffer).toString('hex') + ' transaction ' + _this6.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object))));\n      });\n    });\n  };\n\n  TransactionBuilder.timeStringToDate = function timeStringToDate(time_string) {\n    if (!time_string) {\n      time_string = '1970-01-01T00:00:00.000Z';\n    }\n\n    if (!/Z$/.test(time_string)) {\n      // does not end in Z\n      // https://github.com/cryptonomex/graphene/issues/368\n      time_string += 'Z';\n    }\n\n    return new Date(time_string);\n  };\n\n  TransactionBuilder.prototype.getHeadBlockDate = function getHeadBlockDate() {\n    return TransactionBuilder.timeStringToDate(this.head_block_time_string);\n  };\n\n  TransactionBuilder.prototype.base_expiration_sec = function base_expiration_sec() {\n    var head_block_sec = Math.ceil(this.getHeadBlockDate().getTime() / 1000);\n    var now_sec = Math.ceil(Date.now() / 1000);\n\n    // The head block time should be updated every 3 seconds.  If it isn't\n    // then help the transaction to expire (use head_block_sec)\n    if (now_sec - head_block_sec > 30) {\n      return head_block_sec;\n    }\n\n    // If the user's clock is very far behind, use the head block time.\n    return Math.max(now_sec, head_block_sec);\n  };\n\n  return TransactionBuilder;\n}();\n\nexports.default = TransactionBuilder;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nfunction get(state) {\n  return function (key) {\n    return state[key] || '';\n  };\n}\n\nfunction set(state) {\n  var _this = this;\n\n  return function (key, value) {\n    state[key] = value;\n    return _this;\n  };\n}\n\nexports.get = get;\nexports.set = set;","'use strict';\n\nexports.__esModule = true;\nexports.key = exports.hash = exports.brainKey = exports.Signature = exports.PublicKey = exports.PrivateKey = exports.Aes = exports.Address = undefined;\n\nvar _address = require(12);\n\nvar _address2 = _interopRequireDefault(_address);\n\nvar _aes = require(13);\n\nvar _aes2 = _interopRequireDefault(_aes);\n\nvar _PrivateKey = require(10);\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _PublicKey = require(11);\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nvar _signature = require(18);\n\nvar _signature2 = _interopRequireDefault(_signature);\n\nvar _BrainKey = require(8);\n\nvar _BrainKey2 = _interopRequireDefault(_BrainKey);\n\nvar _hash = require(17);\n\nvar hash = _interopRequireWildcard(_hash);\n\nvar _KeyUtils = require(9);\n\nvar _KeyUtils2 = _interopRequireDefault(_KeyUtils);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Address = _address2.default;\nexports.Aes = _aes2.default;\nexports.PrivateKey = _PrivateKey2.default;\nexports.PublicKey = _PublicKey2.default;\nexports.Signature = _signature2.default;\nexports.brainKey = _BrainKey2.default;\nexports.hash = hash;\nexports.key = _KeyUtils2.default;","'use strict';\n\nexports.__esModule = true;\nexports.default = normalize;\nfunction normalize(brainKey) {\n  if (typeof brainKey !== 'string') {\n    throw new Error('string required for brainKey');\n  }\n\n  brainKey = brainKey.trim();\n  return brainKey.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n}\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _secureRandom = require('secure-random');\n\nvar _secureRandom2 = _interopRequireDefault(_secureRandom);\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _PrivateKey = require('./PrivateKey');\n\nvar _PrivateKey2 = _interopRequireDefault(_PrivateKey);\n\nvar _PublicKey = require('./PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nvar _address = require('./address');\n\nvar _address2 = _interopRequireDefault(_address);\n\nvar _aes = require('./aes');\n\nvar _aes2 = _interopRequireDefault(_aes);\n\nvar _hash = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// import dictionary from './dictionary_en';\n\n// hash for .25 second\nvar HASH_POWER_MILLS = 250;\n\nvar key = {\n  /** Uses 1 second of hashing power to create a key/password checksum.  An\n    implementation can re-call this method with the same password to re-match\n    the strength of the CPU (either after moving from a desktop to a mobile,\n    mobile to desktop, or N years from now when CPUs are presumably stronger).\n     A salt is used for all the normal reasons...\n     @return object {\n        aes_private: Aes,\n        checksum: \"{hash_iteration_count},{salt},{checksum}\"\n    }\n    */\n  aes_checksum: function aes_checksum(password) {\n    if (!(typeof password === 'string')) {\n      throw new 'password string required'();\n    }\n\n    var salt = _secureRandom2.default.randomBuffer(4).toString('hex');\n    var iterations = 0;\n    var secret = salt + password;\n    // hash for .1 second\n    var start_t = Date.now();\n\n    while (Date.now() - start_t < HASH_POWER_MILLS) {\n      secret = (0, _hash.sha256)(secret);\n      iterations += 1;\n    }\n\n    var checksum = (0, _hash.sha256)(secret);\n    var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(',');\n\n    return {\n      aes_private: _aes2.default.fromSeed(secret),\n      checksum: checksum_string\n    };\n  },\n\n\n  /** Provide a matching password and key_checksum.  A \"wrong password\"\n    error is thrown if the password does not match.  If this method takes\n    much more or less than 1 second to return, one should consider updating\n    all encyrpted fields using a new key.key_checksum.\n    */\n  aes_private: function aes_private(password, key_checksum) {\n    var _key_checksum$split = key_checksum.split(','),\n        iterations = _key_checksum$split[0],\n        salt = _key_checksum$split[1],\n        checksum = _key_checksum$split[2];\n\n    var secret = salt + password;\n\n    for (var i = 0; iterations > 0 ? i < iterations : i > iterations; iterations > 0 ? i++ : i++) {\n      secret = (0, _hash.sha256)(secret);\n    }\n\n    var new_checksum = (0, _hash.sha256)(secret);\n\n    if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) {\n      throw new Error('wrong password');\n    }\n\n    return _aes2.default.fromSeed(secret);\n  },\n\n\n  /**\n        A week random number generator can run out of entropy.\n        This should ensure even the worst random number implementation will be reasonably safe.\n         @param1 string entropy of at least 32 bytes\n    */\n  random32ByteBuffer: function random32ByteBuffer() {\n    var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy();\n\n    if (!(typeof entropy === 'string')) {\n      throw new Error('string required for entropy');\n    }\n\n    if (entropy.length < 32) {\n      throw new Error('expecting at least 32 bytes of entropy');\n    }\n\n    var start_t = Date.now();\n\n    while (Date.now() - start_t < HASH_POWER_MILLS) {\n      entropy = (0, _hash.sha256)(entropy);\n    }\n\n    var hash_array = [];\n    hash_array.push(entropy);\n\n    // Hashing for 1 second may helps the computer is not low on entropy\n    // (this method may be called back-to-back).\n    hash_array.push(_secureRandom2.default.randomBuffer(32));\n\n    return (0, _hash.sha256)(Buffer.concat(hash_array));\n  },\n  suggest_brain_key: function suggest_brain_key() {\n    var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ',';\n    var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy();\n\n    var randomBuffer = this.random32ByteBuffer(entropy);\n\n    var word_count = 16;\n    var dictionary_lines = dictionary.split(',');\n\n    if (!(dictionary_lines.length === 49744)) {\n      throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words');\n    }\n\n    var brainkey = [];\n    var end = word_count * 2;\n\n    for (var i = 0; i < end; i += 2) {\n      // randomBuffer has 256 bits / 16 bits per word == 16 words\n      var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; // eslint-disable-line\n\n      // convert into a number between 0 and 1 (inclusive)\n      var rndMultiplier = num / Math.pow(2, 16);\n      var wordIndex = Math.round(dictionary_lines.length * rndMultiplier);\n\n      brainkey.push(dictionary_lines[wordIndex]);\n    }\n\n    return this.normalize_brainKey(brainkey.join(' '));\n  },\n  get_random_key: function get_random_key(entropy) {\n    return _PrivateKey2.default.fromBuffer(this.random32ByteBuffer(entropy));\n  },\n  get_brainPrivateKey: function get_brainPrivateKey(brainKey) {\n    var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n    if (sequence < 0) {\n      throw new Error('invalid sequence');\n    }\n\n    brainKey = key.normalize_brainKey(brainKey);\n    return _PrivateKey2.default.fromBuffer((0, _hash.sha256)((0, _hash.sha512)(brainKey + ' ' + sequence)));\n  },\n\n\n  // Turn invisible space like characters into a single space\n  normalize_brainKey: function normalize_brainKey(brainKey) {\n    if (!(typeof brainKey === 'string')) {\n      throw new Error('string required for brainKey');\n    }\n\n    brainKey = brainKey.trim();\n    return brainKey.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n  },\n  browserEntropy: function browserEntropy() {\n    var entropyStr = '';\n\n    try {\n      entropyStr = new Date().toString() + ' ' + window.screen.height + ' ' + window.screen.width;\n      entropyStr = entropyStr + ' ' + window.screen.colorDepth + ' ' + window.screen.availHeight;\n      entropyStr = entropyStr + ' ' + window.screen.availWidth + ' ' + window.screen.pixelDepth;\n      entropyStr = entropyStr + ' ' + navigator.language + ' ' + window.location;\n      entropyStr = entropyStr + ' ' + window.history.length;\n\n      for (var i = 0, len = navigator.mimeTypes.length; i < len; i++) {\n        var mimeType = navigator.mimeTypes[i];\n        entropyStr += mimeType.description + ' ' + mimeType.type + ' ' + mimeType.suffixes + ' ';\n      }\n\n      console.log('INFO\\tbrowserEntropy gathered');\n    } catch (error) {\n      // nodejs:ReferenceError: window is not defined\n      entropyStr = (0, _hash.sha256)(new Date().toString());\n    }\n\n    var b = Buffer.from(entropyStr);\n    entropyStr += b.toString('binary') + ' ' + new Date().toString();\n    return entropyStr;\n  },\n\n\n  // @return array of 5 legacy addresses for a pubkey string parameter.\n  addresses: function addresses(pubkey) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var public_key = _PublicKey2.default.fromPublicKeyString(pubkey, address_prefix);\n    // S L O W\n    var address_string = [_address2.default.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed\n    _address2.default.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed\n    _address2.default.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed\n    _address2.default.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed\n    public_key.toAddressString(address_prefix) // bts_short, most recent format\n    ];\n    return address_string;\n  }\n};\n\nexports.default = key;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _ecurve = require('ecurve');\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _bs = require('bs58');\n\nvar _deepEqual = require('deep-equal');\n\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _hash = require('./hash');\n\nvar _PublicKey = require('./PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global ByteBuffer */\n\n\nvar secp256k1 = (0, _ecurve.getCurveByName)('secp256k1');\nvar n = secp256k1.n;\n\n\nfunction toPublic(data) {\n  if (!data || data.Q) {\n    return data;\n  }\n\n  return _PublicKey2.default.fromStringOrThrow(data);\n}\n\nvar PrivateKey = function () {\n  /**\n        @private see static functions\n        @param {BigInteger}\n    */\n  function PrivateKey(d) {\n    _classCallCheck(this, PrivateKey);\n\n    this.d = d;\n  }\n\n  PrivateKey.fromBuffer = function fromBuffer(buf) {\n    if (!Buffer.isBuffer(buf)) {\n      throw new Error('Expecting paramter to be a Buffer type');\n    }\n\n    if (buf.length !== 32) {\n      console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack);\n    }\n\n    if (buf.length === 0) {\n      throw new Error('Empty buffer');\n    }\n\n    return new PrivateKey(_bigi2.default.fromBuffer(buf));\n  };\n\n  /** @arg {string} seed - any length string.  This is private,\n   * the same seed produces the same private key every time.  */\n\n\n  PrivateKey.fromSeed = function fromSeed(seed) {\n    // generate_private_key\n    if (!(typeof seed === 'string')) {\n      throw new Error('seed must be of type string');\n    }\n\n    return PrivateKey.fromBuffer((0, _hash.sha256)(seed));\n  };\n\n  /** @return {string} Wallet Import Format (still a secret, Not encrypted) */\n\n\n  PrivateKey.fromWif = function fromWif(_private_wif) {\n    var private_wif = Buffer.from((0, _bs.decode)(_private_wif));\n    var version = private_wif.readUInt8(0);\n    _assert2.default.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version);\n    // checksum includes the version\n    var private_key = private_wif.slice(0, -4);\n    var checksum = private_wif.slice(-4);\n    var new_checksum = (0, _hash.sha256)(private_key);\n    new_checksum = (0, _hash.sha256)(new_checksum);\n    new_checksum = new_checksum.slice(0, 4);\n    var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum'\n\n    if (!isEqual) {\n      throw new Error('Checksum did not match');\n    }\n\n    private_key = private_key.slice(1);\n    private_key = private_key.slice(0, 32);\n    return PrivateKey.fromBuffer(private_key);\n  };\n\n  PrivateKey.prototype.toWif = function toWif() {\n    var private_key = this.toBuffer();\n    // checksum includes the version\n    private_key = Buffer.concat([Buffer.from([0x80]), private_key]);\n    var checksum = (0, _hash.sha256)(private_key);\n    checksum = (0, _hash.sha256)(checksum);\n    checksum = checksum.slice(0, 4);\n    var private_wif = Buffer.concat([private_key, checksum]);\n    return (0, _bs.encode)(private_wif);\n  };\n\n  /**\n        @return {Point}\n    */\n\n\n  PrivateKey.prototype.toPublicKeyPoint = function toPublicKeyPoint() {\n    var Q = secp256k1.G.multiply(this.d);\n    return Q;\n  };\n\n  PrivateKey.prototype.toPublicKey = function toPublicKey() {\n    if (this.public_key) {\n      return this.public_key;\n    }\n\n    this.public_key = _PublicKey2.default.fromPoint(this.toPublicKeyPoint());\n\n    return this.public_key;\n  };\n\n  PrivateKey.prototype.toBuffer = function toBuffer() {\n    return this.d.toBuffer(32);\n  };\n\n  /** ECIES */\n\n\n  PrivateKey.prototype.get_shared_secret = function get_shared_secret(public_key) {\n    var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n    public_key = toPublic(public_key);\n    var KB = public_key.toUncompressed().toBuffer();\n    var KBP = _ecurve.Point.fromAffine(secp256k1, _bigi2.default.fromBuffer(KB.slice(1, 33)), // x\n    _bigi2.default.fromBuffer(KB.slice(33, 65)) // y\n    );\n    var r = this.toBuffer();\n    var P = KBP.multiply(_bigi2.default.fromBuffer(r));\n    var S = P.affineX.toBuffer({ size: 32 });\n\n    /*\n        the input to sha512 must be exactly 32-bytes, to match the c++ implementation\n        of get_shared_secret.  Right now S will be shorter if the most significant\n        byte(s) is zero.  Pad it back to the full 32-bytes\n        */\n    if (!legacy && S.length < 32) {\n      var pad = Buffer.alloc(32 - S.length, 0);\n      S = Buffer.concat([pad, S]);\n    }\n\n    // SHA512 used in ECIES\n    return (0, _hash.sha512)(S);\n  };\n\n  // /** ECIES (does not always match the Point.fromAffine version above) */\n  // get_shared_secret(public_key){\n  //     public_key = toPublic(public_key)\n  //     var P = public_key.Q.multiply( this.d );\n  //     var S = P.affineX.toBuffer({size: 32});\n  //     // ECIES, adds an extra sha512\n  //     return sha512(S);\n  // }\n\n  /** @throws {Error} - overflow of the key could not be derived */\n\n\n  PrivateKey.prototype.child = function child(offset) {\n    offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);\n    offset = (0, _hash.sha256)(offset);\n    var c = _bigi2.default.fromBuffer(offset);\n\n    if (c.compareTo(n) >= 0) {\n      throw new Error('Child offset went out of bounds, try again');\n    }\n\n    var derived = this.d.add(c); // .mod(n)\n\n    if (derived.signum() === 0) {\n      throw new Error('Child offset derived to an invalid key, try again');\n    }\n\n    return new PrivateKey(derived);\n  };\n\n  /* <helper_functions> */\n\n  PrivateKey.prototype.toByteBuffer = function toByteBuffer() {\n    var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    this.appendByteBuffer(b);\n    return b.copy(0, b.offset);\n  };\n\n  PrivateKey.fromHex = function fromHex(hex) {\n    return PrivateKey.fromBuffer(Buffer.from(hex, 'hex'));\n  };\n\n  PrivateKey.prototype.toHex = function toHex() {\n    return this.toBuffer().toString('hex');\n  };\n\n  /* </helper_functions> */\n\n\n  return PrivateKey;\n}();\n\nexports.default = PrivateKey;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _ecurve = require('ecurve');\n\nvar _bs = require('bs58');\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _deepEqual = require('deep-equal');\n\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\n\nvar _hash = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global ByteBuffer */\n\n\nvar secp256k1 = (0, _ecurve.getCurveByName)('secp256k1');\n\nvar G = secp256k1.G,\n    n = secp256k1.n;\n\nvar PublicKey = function () {\n  /** @param {Point} public key */\n  function PublicKey(Q) {\n    _classCallCheck(this, PublicKey);\n\n    this.Q = Q;\n  }\n\n  PublicKey.fromBinary = function fromBinary(bin) {\n    return PublicKey.fromBuffer(Buffer.from(bin, 'binary'));\n  };\n\n  PublicKey.fromBuffer = function fromBuffer(buffer) {\n    if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') {\n      return new PublicKey(null);\n    }\n\n    return new PublicKey(_ecurve.Point.decodeFrom(secp256k1, buffer));\n  };\n\n  PublicKey.prototype.toBuffer = function toBuffer() {\n    var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null;\n\n    if (this.Q === null) {\n      return Buffer.from('000000000000000000000000000000000000000000000000000000000000000000', 'hex');\n    }\n\n    return this.Q.getEncoded(compressed);\n  };\n\n  PublicKey.fromPoint = function fromPoint(point) {\n    return new PublicKey(point);\n  };\n\n  PublicKey.prototype.toUncompressed = function toUncompressed() {\n    var buf = this.Q.getEncoded(false);\n    var point = _ecurve.Point.decodeFrom(secp256k1, buf);\n    return PublicKey.fromPoint(point);\n  };\n\n  /** bts::blockchain::address (unique but not a full public key) */\n\n\n  PublicKey.prototype.toBlockchainAddress = function toBlockchainAddress() {\n    var pub_buf = this.toBuffer();\n    var pub_sha = (0, _hash.sha512)(pub_buf);\n    return (0, _hash.ripemd160)(pub_sha);\n  };\n\n  /** Alias for {@link toPublicKeyString} */\n\n\n  PublicKey.prototype.toString = function toString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    return this.toPublicKeyString(address_prefix);\n  };\n\n  /**\n        Full public key\n        {return} string\n    */\n\n\n  PublicKey.prototype.toPublicKeyString = function toPublicKeyString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var pub_buf = this.toBuffer();\n    var checksum = (0, _hash.ripemd160)(pub_buf);\n    // Slice from the buffer directly, slicing from the checksum\n    // Uint8array will return the entire array each time.\n    var sliced = new Uint8Array(checksum.buffer.slice(0, 4));\n\n    // concat only accepts buffers so initialize the sliced Uint8array as a Buffer.\n    var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]);\n    return address_prefix + (0, _bs.encode)(addy);\n  };\n\n  /**\n        @arg {string} public_key - like GPHXyz...\n        @arg {string} address_prefix - like GPH\n        @return PublicKey or `null` (if the public_key string is invalid)\n    */\n\n\n  PublicKey.fromPublicKeyString = function fromPublicKeyString(public_key) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    try {\n      return PublicKey.fromStringOrThrow(public_key, address_prefix);\n    } catch (e) {\n      return null;\n    }\n  };\n\n  /**\n        @arg {string} public_key - like GPHXyz...\n        @arg {string} address_prefix - like GPH\n        @throws {Error} if public key is invalid\n        @return PublicKey\n    */\n\n\n  PublicKey.fromStringOrThrow = function fromStringOrThrow(public_key) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var prefix = public_key.slice(0, address_prefix.length);\n    _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n    public_key = public_key.slice(address_prefix.length);\n\n    public_key = Buffer.from((0, _bs.decode)(public_key), 'binary');\n    var checksum = public_key.slice(-4);\n    public_key = public_key.slice(0, -4);\n    var new_checksum = (0, _hash.ripemd160)(public_key);\n    new_checksum = new_checksum.slice(0, 4);\n    var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum'\n\n    if (!isEqual) {\n      throw new Error('Checksum did not match');\n    }\n\n    return PublicKey.fromBuffer(public_key);\n  };\n\n  PublicKey.prototype.toAddressString = function toAddressString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var pub_buf = this.toBuffer();\n    var pub_sha = (0, _hash.sha512)(pub_buf);\n    var addy = (0, _hash.ripemd160)(pub_sha);\n    var checksum = (0, _hash.ripemd160)(addy);\n    addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n    return address_prefix + (0, _bs.encode)(addy);\n  };\n\n  PublicKey.prototype.toPtsAddy = function toPtsAddy() {\n    var pub_buf = this.toBuffer();\n    var pub_sha = (0, _hash.sha256)(pub_buf);\n    var addy = (0, _hash.ripemd160)(pub_sha);\n    addy = Buffer.concat([Buffer.from([0x38]), addy]); // version 56(decimal)\n\n    var checksum = (0, _hash.sha256)(addy);\n    checksum = (0, _hash.sha256)(checksum);\n\n    addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n    return (0, _bs.encode)(addy);\n  };\n\n  PublicKey.prototype.child = function child(offset) {\n    (0, _assert2.default)(Buffer.isBuffer(offset), 'Buffer required: offset');\n    _assert2.default.equal(offset.length, 32, 'offset length');\n\n    offset = Buffer.concat([this.toBuffer(), offset]);\n    offset = (0, _hash.sha256)(offset);\n\n    var c = _bigi2.default.fromBuffer(offset);\n\n    if (c.compareTo(n) >= 0) {\n      throw new Error('Child offset went out of bounds, try again');\n    }\n\n    var cG = G.multiply(c);\n    var Qprime = this.Q.add(cG);\n\n    if (secp256k1.isInfinity(Qprime)) {\n      throw new Error('Child offset derived to an invalid key, try again');\n    }\n\n    return PublicKey.fromPoint(Qprime);\n  };\n\n  /* <HEX> */\n\n  PublicKey.prototype.toByteBuffer = function toByteBuffer() {\n    var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    this.appendByteBuffer(b);\n    return b.copy(0, b.offset);\n  };\n\n  PublicKey.fromHex = function fromHex(hex) {\n    return PublicKey.fromBuffer(Buffer.from(hex, 'hex'));\n  };\n\n  PublicKey.prototype.toHex = function toHex() {\n    return this.toBuffer().toString('hex');\n  };\n\n  PublicKey.fromPublicKeyStringHex = function fromPublicKeyStringHex(hex) {\n    return PublicKey.fromPublicKeyString(Buffer.from(hex, 'hex'));\n  };\n\n  /* </HEX> */\n\n\n  return PublicKey;\n}();\n\nexports.default = PublicKey;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _bs = require('bs58');\n\nvar _deepEqual = require('deep-equal');\n\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\n\nvar _hash2 = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** Addresses are shortened non-reversable hashes of a public key.  The full PublicKey is preferred.\n    @deprecated\n*/\nvar Address = function () {\n  function Address(addy) {\n    _classCallCheck(this, Address);\n\n    this.addy = addy;\n  }\n\n  Address.fromBuffer = function fromBuffer(buffer) {\n    var _hash = (0, _hash2.sha512)(buffer);\n    var addy = (0, _hash2.ripemd160)(_hash);\n    return new Address(addy);\n  };\n\n  Address.fromString = function fromString(string) {\n    var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var prefix = string.slice(0, address_prefix.length);\n    _assert2.default.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n    var addy = string.slice(address_prefix.length);\n    addy = Buffer.from((0, _bs.decode)(addy), 'binary');\n    var checksum = addy.slice(-4);\n    addy = addy.slice(0, -4);\n    var new_checksum = (0, _hash2.ripemd160)(addy);\n    new_checksum = new_checksum.slice(0, 4);\n    var isEqual = (0, _deepEqual2.default)(checksum, new_checksum); // , 'Invalid checksum'\n\n    if (!isEqual) {\n      throw new Error('Checksum did not match');\n    }\n\n    return new Address(addy);\n  };\n\n  /** @return Address - Compressed PTS format (by default) */\n\n\n  Address.fromPublic = function fromPublic(public_key) {\n    var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n    var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56;\n\n    var sha2 = (0, _hash2.sha256)(public_key.toBuffer(compressed));\n    var rep = (0, _hash2.ripemd160)(sha2);\n    var versionBuffer = Buffer.alloc(1);\n    versionBuffer.writeUInt8(0xff & version, 0); // eslint-disable-line\n    var addr = Buffer.concat([versionBuffer, rep]);\n    var check = (0, _hash2.sha256)(addr);\n    check = (0, _hash2.sha256)(check);\n    var buffer = Buffer.concat([addr, check.slice(0, 4)]);\n    return new Address((0, _hash2.ripemd160)(buffer));\n  };\n\n  Address.prototype.toBuffer = function toBuffer() {\n    return this.addy;\n  };\n\n  Address.prototype.toString = function toString() {\n    var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _peerplaysjsWs.ChainConfig.address_prefix;\n\n    var checksum = (0, _hash2.ripemd160)(this.addy);\n    var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]);\n    return address_prefix + (0, _bs.encode)(addy);\n  };\n\n  return Address;\n}();\n\nexports.default = Address;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _aes = require('crypto-js/aes');\n\nvar _aes2 = _interopRequireDefault(_aes);\n\nvar _encHex = require('crypto-js/enc-hex');\n\nvar _encHex2 = _interopRequireDefault(_encHex);\n\nvar _encBase = require('crypto-js/enc-base64');\n\nvar _encBase2 = _interopRequireDefault(_encBase);\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _hash2 = require('./hash');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } // https://code.google.com/p/crypto-js\n\n\n/** Provides symetric encrypt and decrypt via AES. */\nvar Aes = function () {\n  /** @private */\n  function Aes(iv, key) {\n    _classCallCheck(this, Aes);\n\n    this.iv = iv;\n    this.key = key;\n  }\n\n  /** This is an excellent way to ensure that all references to Aes can not operate anymore\n   * (example: a wallet becomes locked).  An application should ensure there is only one\n   * Aes object instance for a given secret `seed`. */\n\n\n  Aes.prototype.clear = function clear() {\n    this.iv = undefined;\n    this.key = undefined;\n    return undefined;\n  };\n\n  /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */\n\n\n  Aes.fromSeed = function fromSeed(seed) {\n    if (seed === undefined) {\n      throw new Error('seed is required');\n    }\n\n    var _hash = (0, _hash2.sha512)(seed);\n    _hash = _hash.toString('hex');\n    // DEBUG console.log('... fromSeed _hash',_hash)\n    return Aes.fromSha512(_hash);\n  };\n\n  /** @arg {string} hash - A 128 byte hex string, typically one\n   * would call {@link fromSeed} instead. */\n\n\n  Aes.fromSha512 = function fromSha512(hash) {\n    _assert2.default.equal(hash.length, 128, 'A Sha512 in HEX should be 128 characters long, instead got ' + hash.length);\n    var iv = _encHex2.default.parse(hash.substring(64, 96));\n    var key = _encHex2.default.parse(hash.substring(0, 64));\n    return new Aes(iv, key);\n  };\n\n  Aes.fromBuffer = function fromBuffer(buf) {\n    (0, _assert2.default)(Buffer.isBuffer(buf), 'Expecting Buffer');\n    _assert2.default.equal(buf.length, 64, 'A Sha512 Buffer should be 64 characters long, instead got ' + buf.length);\n    return Aes.fromSha512(buf.toString('hex'));\n  };\n\n  /**\n        @throws {Error} - \"Invalid Key, ...\"\n        @arg {PrivateKey} private_key - required and used for decryption\n        @arg {PublicKey} public_key - required and used to calcualte the shared secret\n        @arg {string} [nonce = \"\"] optional but should always be provided and be unique\n        when re-using the same private/public keys more than once.  This nonce is not a secret.\n        @arg {string|Buffer} message - Encrypted message containing a checksum\n        @return {Buffer}\n    */\n\n\n  Aes.decrypt_with_checksum = function decrypt_with_checksum(private_key, public_key, nonce, message) {\n    var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n    // Warning: Do not put `nonce = \"\"` in the arguments, in es6 this will\n    // not convert \"null\" into an emtpy string\n    if (nonce == null) {\n      nonce = '';\n    }\n\n    if (!Buffer.isBuffer(message)) {\n      message = Buffer.from(message, 'hex');\n    }\n\n    var S = private_key.get_shared_secret(public_key, legacy);\n    // D E B U G\n    // console.log('decrypt_with_checksum', {\n    //     priv_to_pub: private_key.toPublicKey().toString(),\n    //     pub: public_key.toPublicKeyString(),\n    //     nonce: nonce,\n    //     message: message.length,\n    //     S: S.toString('hex')\n    // })\n\n    var aes = Aes.fromSeed(Buffer.concat([\n    // A null or empty string nonce will not effect the hash\n    Buffer.from('' + nonce), Buffer.from(S.toString('hex'))]));\n\n    var planebuffer = aes.decrypt(message);\n\n    if (!(planebuffer.length >= 4)) {\n      throw new Error('Invalid key, could not decrypt message(1)');\n    }\n\n    // DEBUG console.log('... planebuffer',planebuffer)\n    var checksum = planebuffer.slice(0, 4);\n    var plaintext = planebuffer.slice(4);\n\n    // console.log('... checksum',checksum.toString('hex'))\n    // console.log('... plaintext',plaintext.toString())\n\n    var new_checksum = (0, _hash2.sha256)(plaintext);\n    new_checksum = new_checksum.slice(0, 4);\n    new_checksum = new_checksum.toString('hex');\n\n    if (!(checksum.toString('hex') === new_checksum)) {\n      throw new Error('Invalid key, could not decrypt message(2)');\n    }\n\n    return plaintext;\n  };\n\n  /** Identical to {@link decrypt_with_checksum} but used to encrypt.  Should not throw an error.\n        @return {Buffer} message - Encrypted message which includes a checksum\n    */\n\n\n  Aes.encrypt_with_checksum = function encrypt_with_checksum(private_key, public_key, nonce, message) {\n    // Warning: Do not put `nonce = \"\"` in the arguments, in es6 this will\n    // not convert \"null\" into an emtpy string\n\n    if (nonce == null) {\n      nonce = '';\n    }\n\n    if (!Buffer.isBuffer(message)) {\n      message = Buffer.from(message, 'binary');\n    }\n\n    var S = private_key.get_shared_secret(public_key);\n\n    // D E B U G\n    // console.log('encrypt_with_checksum', {\n    //     priv_to_pub: private_key.toPublicKey().toString()\n    //     pub: public_key.toPublicKeyString()\n    //     nonce: nonce\n    //     message: message.length\n    //     S: S.toString('hex')\n    // })\n\n    var aes = Aes.fromSeed(Buffer.concat([\n    // A null or empty string nonce will not effect the hash\n    Buffer.from('' + nonce), Buffer.from(S.toString('hex'))]));\n    // DEBUG console.log('... S',S.toString('hex'))\n    var checksum = (0, _hash2.sha256)(message).slice(0, 4);\n    var payload = Buffer.concat([checksum, message]);\n    // DEBUG console.log('... payload',payload.toString())\n    return aes.encrypt(payload);\n  };\n\n  /** @private */\n\n\n  Aes.prototype._decrypt_word_array = function _decrypt_word_array(cipher) {\n    // https://code.google.com/p/crypto-js/#Custom_Key_and_IV\n    // see wallet_records.cpp master_key::decrypt_key\n    return _aes2.default.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv });\n  };\n\n  /** @private */\n\n\n  Aes.prototype._encrypt_word_array = function _encrypt_word_array(plaintext) {\n    // https://code.google.com/p/crypto-js/issues/detail?id=85\n    var cipher = _aes2.default.encrypt(plaintext, this.key, { iv: this.iv });\n    return _encBase2.default.parse(cipher.toString());\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} ciphertext\n        @return {Buffer} binary\n    */\n\n\n  Aes.prototype.decrypt = function decrypt(ciphertext) {\n    if (typeof ciphertext === 'string') {\n      ciphertext = Buffer.from(ciphertext, 'binary');\n    }\n\n    if (!Buffer.isBuffer(ciphertext)) {\n      throw new Error('buffer required');\n    }\n\n    (0, _assert2.default)(ciphertext, 'Missing cipher text');\n    // hex is the only common format\n    var hex = this.decryptHex(ciphertext.toString('hex'));\n    return Buffer.from(hex, 'hex');\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} plaintext\n        @return {Buffer} binary\n    */\n\n\n  Aes.prototype.encrypt = function encrypt(plaintext) {\n    if (typeof plaintext === 'string') {\n      plaintext = Buffer.from(plaintext, 'binary');\n    }\n\n    if (!Buffer.isBuffer(plaintext)) {\n      throw new Error('buffer required');\n    }\n\n    // assert plaintext, \"Missing plain text\"\n    // hex is the only common format\n    var hex = this.encryptHex(plaintext.toString('hex'));\n    return Buffer.from(hex, 'hex');\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string|Buffer} plaintext\n        @return {string} hex\n    */\n\n\n  Aes.prototype.encryptToHex = function encryptToHex(plaintext) {\n    if (typeof plaintext === 'string') {\n      plaintext = Buffer.from(plaintext, 'binary');\n    }\n\n    if (!Buffer.isBuffer(plaintext)) {\n      throw new Error('buffer required');\n    }\n\n    // assert plaintext, \"Missing plain text\"\n    // hex is the only common format\n    return this.encryptHex(plaintext.toString('hex'));\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} cipher - hex\n        @return {string} binary (could easily be readable text)\n    */\n\n\n  Aes.prototype.decryptHex = function decryptHex(cipher) {\n    (0, _assert2.default)(cipher, 'Missing cipher text');\n    // Convert data into word arrays (used by Crypto)\n    var cipher_array = _encHex2.default.parse(cipher);\n    var plainwords = this._decrypt_word_array(cipher_array);\n    return _encHex2.default.stringify(plainwords);\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} cipher - hex\n        @return {Buffer} encoded as specified by the parameter\n    */\n\n\n  Aes.prototype.decryptHexToBuffer = function decryptHexToBuffer(cipher) {\n    (0, _assert2.default)(cipher, 'Missing cipher text');\n    // Convert data into word arrays (used by Crypto)\n    var cipher_array = _encHex2.default.parse(cipher);\n    var plainwords = this._decrypt_word_array(cipher_array);\n    var plainhex = _encHex2.default.stringify(plainwords);\n    return Buffer.from(plainhex, 'hex');\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} cipher - hex\n        @arg {string} [encoding = 'binary'] - a valid Buffer encoding\n        @return {String} encoded as specified by the parameter\n    */\n\n\n  Aes.prototype.decryptHexToText = function decryptHexToText(cipher) {\n    var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary';\n\n    return this.decryptHexToBuffer(cipher).toString(encoding);\n  };\n\n  /** This method does not use a checksum, the returned data must be validated some other way.\n        @arg {string} plainhex - hex format\n        @return {String} hex\n    */\n\n\n  Aes.prototype.encryptHex = function encryptHex(plainhex) {\n    var plain_array = _encHex2.default.parse(plainhex);\n    var cipher_array = this._encrypt_word_array(plain_array);\n    return _encHex2.default.stringify(cipher_array);\n  };\n\n  return Aes;\n}();\n\nexports.default = Aes;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.verifyRaw = exports.verify = exports.sign = exports.recoverPubKey = exports.deterministicGenerateK = exports.calcPubKeyRecoveryParam = undefined;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _hash = require('./hash');\n\nvar _enforce_types = require('./enforce_types');\n\nvar _enforce_types2 = _interopRequireDefault(_enforce_types);\n\nvar _ecsignature = require('./ecsignature');\n\nvar _ecsignature2 = _interopRequireDefault(_ecsignature);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// https://tools.ietf.org/html/rfc6979#section-3.2\n\n// from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa\nfunction deterministicGenerateK(curve, hash, d, checkSig, nonce) {\n  (0, _enforce_types2.default)('Buffer', hash);\n  (0, _enforce_types2.default)(_bigi2.default, d);\n\n  if (nonce) {\n    hash = (0, _hash.sha256)(Buffer.concat([hash, Buffer.alloc(nonce)]));\n  }\n\n  // sanity check\n  _assert2.default.equal(hash.length, 32, 'Hash must be 256 bit');\n\n  var x = d.toBuffer(32);\n  var k = Buffer.alloc(32);\n  var v = Buffer.alloc(32);\n\n  // Step B\n  v.fill(1);\n\n  // Step C\n  k.fill(0);\n\n  // Step D\n  k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0]), x, hash]), k);\n\n  // Step E\n  v = (0, _hash.HmacSHA256)(v, k);\n\n  // Step F\n  k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([1]), x, hash]), k);\n\n  // Step G\n  v = (0, _hash.HmacSHA256)(v, k);\n\n  // Step H1/H2a, ignored as tlen === qlen (256 bit)\n  // Step H2b\n  v = (0, _hash.HmacSHA256)(v, k);\n\n  var T = _bigi2.default.fromBuffer(v);\n\n  // Step H3, repeat until T is within the interval [1, n - 1]\n  while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) {\n    k = (0, _hash.HmacSHA256)(Buffer.concat([v, Buffer.from([0])]), k);\n    v = (0, _hash.HmacSHA256)(v, k);\n\n    // Step H1/H2a, again, ignored as tlen === qlen (256 bit)\n    // Step H2b again\n    v = (0, _hash.HmacSHA256)(v, k);\n\n    T = _bigi2.default.fromBuffer(v);\n  }\n\n  return T;\n}\n\nfunction sign(curve, hash, d, nonce) {\n  var e = _bigi2.default.fromBuffer(hash);\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = void 0;\n  var s = void 0;\n\n  deterministicGenerateK(curve, hash, d, function (key) {\n    // find canonically valid signature\n    var Q = G.multiply(key);\n\n    if (curve.isInfinity(Q)) {\n      return false;\n    }\n\n    r = Q.affineX.mod(n);\n\n    if (r.signum() === 0) {\n      return false;\n    }\n\n    s = key.modInverse(n).multiply(e.add(d.multiply(r))).mod(n);\n\n    if (s.signum() === 0) {\n      return false;\n    }\n\n    return true;\n  }, nonce);\n\n  var N_OVER_TWO = n.shiftRight(1);\n\n  // enforce low S values, see bip62: 'low s values in signatures'\n  if (s.compareTo(N_OVER_TWO) > 0) {\n    s = n.subtract(s);\n  }\n\n  return new _ecsignature2.default(r, s);\n}\n\nfunction verifyRaw(curve, e, signature, Q) {\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = signature.r;\n  var s = signature.s;\n\n  // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]\n  if (r.signum() <= 0 || r.compareTo(n) >= 0) {\n    return false;\n  }\n\n  if (s.signum() <= 0 || s.compareTo(n) >= 0) {\n    return false;\n  }\n\n  // c = s^-1 mod n\n  var c = s.modInverse(n);\n\n  // 1.4.4 Compute u1 = es^−1 mod n\n  //               u2 = rs^−1 mod n\n  var u1 = e.multiply(c).mod(n);\n  var u2 = r.multiply(c).mod(n);\n\n  // 1.4.5 Compute R = (xR, yR) = u1G + u2Q\n  var R = G.multiplyTwo(u1, Q, u2);\n\n  // 1.4.5 (cont.) Enforce R is not at infinity\n  if (curve.isInfinity(R)) {\n    return false;\n  }\n\n  // 1.4.6 Convert the field element R.x to an integer\n  var xR = R.affineX;\n\n  // 1.4.7 Set v = xR mod n\n  var v = xR.mod(n);\n\n  // 1.4.8 If v = r, output \"valid\", and if v != r, output \"invalid\"\n  return v.equals(r);\n}\n\nfunction verify(curve, hash, signature, Q) {\n  // 1.4.2 H = Hash(M), already done by the user\n  // 1.4.3 e = H\n  var e = _bigi2.default.fromBuffer(hash);\n  return verifyRaw(curve, e, signature, Q);\n}\n\n/**\n * Recover a public key from a signature.\n *\n * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, \"Public\n * Key Recovery Operation\".\n *\n * http://www.secg.org/download/aid-780/sec1-v2.pdf\n */\nfunction recoverPubKey(curve, e, signature, i) {\n  _assert2.default.strictEqual(i & 3, i, 'Recovery param is more than two bits'); // eslint-disable-line\n\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = signature.r;\n  var s = signature.s;\n\n  (0, _assert2.default)(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value');\n  (0, _assert2.default)(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value');\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = i & 1; // eslint-disable-line\n\n  // The more significant bit specifies whether we should use the\n  // first or second candidate key.\n  var isSecondKey = i >> 1; // eslint-disable-line\n\n  // 1.1 Let x = r + jn\n  var x = isSecondKey ? r.add(n) : r;\n  var R = curve.pointFromX(isYOdd, x);\n\n  // 1.4 Check that nR is at infinity\n  var nR = R.multiply(n);\n  (0, _assert2.default)(curve.isInfinity(nR), 'nR is not a valid curve point');\n\n  // Compute -e from e\n  var eNeg = e.negate().mod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  var rInv = r.modInverse(n);\n\n  var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv);\n  curve.validate(Q);\n\n  return Q;\n}\n\n/**\n * Calculate pubkey extraction parameter.\n *\n * When extracting a pubkey from a signature, we have to\n * distinguish four different cases. Rather than putting this\n * burden on the verifier, Bitcoin includes a 2-bit value with the\n * signature.\n *\n * This function simply tries all four cases and returns the value\n * that resulted in a successful pubkey recovery.\n */\nfunction calcPubKeyRecoveryParam(curve, e, signature, Q) {\n  for (var i = 0; i < 4; i++) {\n    var Qprime = recoverPubKey(curve, e, signature, i);\n\n    // 1.6.2 Verify Q\n    if (Qprime.equals(Q)) {\n      return i;\n    }\n  }\n\n  throw new Error('Unable to find valid recovery factor');\n}\n\nexports.calcPubKeyRecoveryParam = calcPubKeyRecoveryParam;\nexports.deterministicGenerateK = deterministicGenerateK;\nexports.recoverPubKey = recoverPubKey;\nexports.sign = sign;\nexports.verify = verify;\nexports.verifyRaw = verifyRaw;","'use strict';\n\nexports.__esModule = true;\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _enforce_types = require('./enforce_types');\n\nvar _enforce_types2 = _interopRequireDefault(_enforce_types);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// from https://github.com/bitcoinjs/bitcoinjs-lib\nfunction ECSignature(r, s) {\n  (0, _enforce_types2.default)(_bigi2.default, r);\n  (0, _enforce_types2.default)(_bigi2.default, s);\n\n  this.r = r;\n  this.s = s;\n}\n\n// Import operations\n/* eslint no-bitwise: \"off\" */\nECSignature.parseCompact = function (buffer) {\n  _assert2.default.equal(buffer.length, 65, 'Invalid signature length');\n  var i = buffer.readUInt8(0) - 27;\n\n  // At most 3 bits\n  _assert2.default.equal(i, i & 7, 'Invalid signature parameter');\n  var compressed = !!(i & 4);\n\n  // Recovery param only\n  i &= 3;\n\n  var r = _bigi2.default.fromBuffer(buffer.slice(1, 33));\n  var s = _bigi2.default.fromBuffer(buffer.slice(33));\n\n  return {\n    compressed: compressed,\n    i: i,\n    signature: new ECSignature(r, s)\n  };\n};\n\nECSignature.fromDER = function (buffer) {\n  _assert2.default.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence');\n  _assert2.default.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length');\n  _assert2.default.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer');\n\n  var rLen = buffer.readUInt8(3);\n  (0, _assert2.default)(rLen > 0, 'R length is zero');\n\n  var offset = 4 + rLen;\n  _assert2.default.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)');\n\n  var sLen = buffer.readUInt8(offset + 1);\n  (0, _assert2.default)(sLen > 0, 'S length is zero');\n\n  var rB = buffer.slice(4, offset);\n  var sB = buffer.slice(offset + 2);\n  offset += 2 + sLen;\n\n  if (rLen > 1 && rB.readUInt8(0) === 0x00) {\n    (0, _assert2.default)(rB.readUInt8(1) & 0x80, 'R value excessively padded');\n  }\n\n  if (sLen > 1 && sB.readUInt8(0) === 0x00) {\n    (0, _assert2.default)(sB.readUInt8(1) & 0x80, 'S value excessively padded');\n  }\n\n  _assert2.default.equal(offset, buffer.length, 'Invalid DER encoding');\n  var r = _bigi2.default.fromDERInteger(rB);\n  var s = _bigi2.default.fromDERInteger(sB);\n\n  (0, _assert2.default)(r.signum() >= 0, 'R value is negative');\n  (0, _assert2.default)(s.signum() >= 0, 'S value is negative');\n\n  return new ECSignature(r, s);\n};\n\n// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants,\n// importing Transaction causes a circular dependency\nECSignature.parseScriptSignature = function (buffer) {\n  var hashType = buffer.readUInt8(buffer.length - 1);\n  var hashTypeMod = hashType & ~0x80;\n\n  (0, _assert2.default)(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType');\n\n  return {\n    signature: ECSignature.fromDER(buffer.slice(0, -1)),\n    hashType: hashType\n  };\n};\n\n// Export operations\nECSignature.prototype.toCompact = function toCompact(i, compressed) {\n  if (compressed) {\n    i += 4;\n  }\n\n  i += 27;\n\n  var buffer = Buffer.alloc(65);\n  buffer.writeUInt8(i, 0);\n\n  this.r.toBuffer(32).copy(buffer, 1);\n  this.s.toBuffer(32).copy(buffer, 33);\n\n  return buffer;\n};\n\nECSignature.prototype.toDER = function toDER() {\n  var rBa = this.r.toDERInteger();\n  var sBa = this.s.toDERInteger();\n\n  var sequence = [];\n\n  // INTEGER\n  sequence.push(0x02, rBa.length);\n  sequence = sequence.concat(rBa);\n\n  // INTEGER\n  sequence.push(0x02, sBa.length);\n  sequence = sequence.concat(sBa);\n\n  // SEQUENCE\n  sequence.unshift(0x30, sequence.length);\n\n  return Buffer.from(sequence);\n};\n\nECSignature.prototype.toScriptSignature = function toScriptSignature(hashType) {\n  var hashTypeBuffer = Buffer.alloc(1);\n  hashTypeBuffer.writeUInt8(hashType, 0);\n\n  return Buffer.concat([this.toDER(), hashTypeBuffer]);\n};\n\nexports.default = ECSignature;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.default = enforce;\n\nfunction getName(fn) {\n  // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property\n  var match = fn.toString().match(/function (.*?)\\(/);\n  return match ? match[1] : null;\n}\n\nfunction enforce(type, value) {\n  // Copied from https://github.com/bitcoinjs/bitcoinjs-lib\n  switch (type) {\n    case 'Array':\n      {\n        if (Array.isArray(value)) {\n          return;\n        }\n\n        break;\n      }\n\n    case 'Boolean':\n      {\n        if (typeof value === 'boolean') {\n          return;\n        }\n\n        break;\n      }\n\n    case 'Buffer':\n      {\n        if (Buffer.isBuffer(value)) {\n          return;\n        }\n\n        break;\n      }\n\n    case 'Number':\n      {\n        if (typeof value === 'number') {\n          return;\n        }\n\n        break;\n      }\n\n    case 'String':\n      {\n        if (typeof value === 'string') {\n          return;\n        }\n\n        break;\n      }\n\n    default:\n      {\n        if (getName(value.constructor) === getName(type)) {\n          return;\n        }\n      }\n  }\n\n  throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value);\n}\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.ripemd160 = exports.HmacSHA256 = exports.sha512 = exports.sha256 = exports.sha1 = undefined;\n\nvar _createHash = require(41);\n\nvar _createHash2 = _interopRequireDefault(_createHash);\n\nvar _createHmac = require(43);\n\nvar _createHmac2 = _interopRequireDefault(_createHmac);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha1(data, encoding) {\n  return (0, _createHash2.default)('sha1').update(data).digest(encoding);\n}\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha256(data, encoding) {\n  return (0, _createHash2.default)('sha256').update(data).digest(encoding);\n}\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha512(data, encoding) {\n  return (0, _createHash2.default)('sha512').update(data).digest(encoding);\n}\n\nfunction HmacSHA256(buffer, secret) {\n  return (0, _createHmac2.default)('sha256', secret).update(buffer).digest();\n}\n\nfunction ripemd160(data) {\n  return (0, _createHash2.default)('rmd160').update(data).digest();\n}\n\n// function hash160(buffer) {\n//   return ripemd160(sha256(buffer))\n// }\n//\n// function hash256(buffer) {\n//   return sha256(sha256(buffer))\n// }\n\n//\n// function HmacSHA512(buffer, secret) {\n//   return crypto.createHmac('sha512', secret).update(buffer).digest()\n// }\n\nexports.sha1 = sha1;\nexports.sha256 = sha256;\nexports.sha512 = sha512;\nexports.HmacSHA256 = HmacSHA256;\nexports.ripemd160 = ripemd160;","'use strict';\n\nexports.__esModule = true;\n\nvar _ecurve = require('ecurve');\n\nvar _assert = require('assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _bigi = require('bigi');\n\nvar _bigi2 = _interopRequireDefault(_bigi);\n\nvar _hash2 = require('./hash');\n\nvar _ecdsa = require('./ecdsa');\n\nvar _PublicKey = require('./PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global ByteBuffer */\n\n\nvar secp256k1 = (0, _ecurve.getCurveByName)('secp256k1');\n\nvar Signature = function () {\n  function Signature(r1, s1, i1) {\n    _classCallCheck(this, Signature);\n\n    this.r = r1;\n    this.s = s1;\n    this.i = i1;\n    _assert2.default.equal(this.r != null, true, 'Missing parameter');\n    _assert2.default.equal(this.s != null, true, 'Missing parameter');\n    _assert2.default.equal(this.i != null, true, 'Missing parameter');\n  }\n\n  Signature.fromBuffer = function fromBuffer(buf) {\n    var i = void 0;\n    var r = void 0;\n    var s = void 0;\n    _assert2.default.equal(buf.length, 65, 'Invalid signature length');\n    i = buf.readUInt8(0);\n    _assert2.default.equal(i - 27, i - 27 & 7, 'Invalid signature parameter'); // eslint-disable-line\n    r = _bigi2.default.fromBuffer(buf.slice(1, 33));\n    s = _bigi2.default.fromBuffer(buf.slice(33));\n    return new Signature(r, s, i);\n  };\n\n  Signature.prototype.toBuffer = function toBuffer() {\n    var buf = void 0;\n    buf = Buffer.alloc(65);\n    buf.writeUInt8(this.i, 0);\n    this.r.toBuffer(32).copy(buf, 1);\n    this.s.toBuffer(32).copy(buf, 33);\n    return buf;\n  };\n\n  Signature.prototype.recoverPublicKeyFromBuffer = function recoverPublicKeyFromBuffer(buffer) {\n    return this.recoverPublicKey((0, _hash2.sha256)(buffer));\n  };\n\n  /**\n        @return {PublicKey}\n    */\n\n\n  Signature.prototype.recoverPublicKey = function recoverPublicKey(sha256_buffer) {\n    var Q = void 0;\n    var e = void 0;\n    var i = void 0;\n    e = _bigi2.default.fromBuffer(sha256_buffer);\n    i = this.i;\n    i -= 27;\n    i &= 3; // eslint-disable-line\n    Q = (0, _ecdsa.recoverPubKey)(secp256k1, e, this, i);\n    return _PublicKey2.default.fromPoint(Q);\n  };\n\n  /**\n        @param {Buffer} buf\n        @param {PrivateKey} private_key\n        @return {Signature}\n    */\n\n\n  Signature.signBuffer = function signBuffer(buf, private_key) {\n    var _hash = (0, _hash2.sha256)(buf);\n    return Signature.signBufferSha256(_hash, private_key);\n  };\n\n  /** Sign a buffer of exactally 32 bytes in size (sha256(text))\n        @param {Buffer} buf - 32 bytes binary\n        @param {PrivateKey} private_key\n        @return {Signature}\n    */\n\n\n  Signature.signBufferSha256 = function signBufferSha256(buf_sha256, private_key) {\n    if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) {\n      throw new Error('buf_sha256: 32 byte buffer requred');\n    }\n\n    var der = void 0;\n    var e = void 0;\n    var ecsignature = void 0;\n    var i = void 0;\n    var lenR = void 0;\n    var lenS = void 0;\n    var nonce = void 0;\n    i = null;\n    nonce = 0;\n    e = _bigi2.default.fromBuffer(buf_sha256);\n\n    var loop = true;\n\n    while (loop) {\n      ecsignature = (0, _ecdsa.sign)(secp256k1, buf_sha256, private_key.d, nonce++);\n      der = ecsignature.toDER();\n      lenR = der[3];\n      lenS = der[5 + lenR];\n\n      if (lenR === 32 && lenS === 32) {\n        i = (0, _ecdsa.calcPubKeyRecoveryParam)(secp256k1, e, ecsignature, private_key.toPublicKey().Q);\n        i += 4; // compressed\n        i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)\n        loop = false;\n        break;\n      }\n\n      if (nonce % 10 === 0) {\n        console.log('WARN: ' + nonce + ' attempts to find canonical signature');\n      }\n    }\n\n    return new Signature(ecsignature.r, ecsignature.s, i);\n  };\n\n  Signature.sign = function sign(string, private_key) {\n    return Signature.signBuffer(Buffer.from(string), private_key);\n  };\n\n  /**\n        @param {Buffer} un-hashed\n        @param {./PublicKey}\n        @return {boolean}\n    */\n\n\n  Signature.prototype.verifyBuffer = function verifyBuffer(buf, public_key) {\n    var _hash = (0, _hash2.sha256)(buf);\n    return this.verifyHash(_hash, public_key);\n  };\n\n  Signature.prototype.verifyHash = function verifyHash(hash, public_key) {\n    _assert2.default.equal(hash.length, 32, 'A SHA 256 should be 32 bytes long, instead got ' + hash.length);\n    return (0, _ecdsa.verify)(secp256k1, hash, {\n      r: this.r,\n      s: this.s\n    }, public_key.Q);\n  };\n\n  /* <HEX> */\n\n  Signature.prototype.toByteBuffer = function toByteBuffer() {\n    var b = void 0;\n    b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n    this.appendByteBuffer(b);\n    return b.copy(0, b.offset);\n  };\n\n  Signature.fromHex = function fromHex(hex) {\n    return Signature.fromBuffer(Buffer.from(hex, 'hex'));\n  };\n\n  Signature.prototype.toHex = function toHex() {\n    return this.toBuffer().toString('hex');\n  };\n\n  Signature.signHex = function signHex(hex, private_key) {\n    var buf = void 0;\n    buf = Buffer.from(hex, 'hex');\n    return Signature.signBuffer(buf, private_key);\n  };\n\n  Signature.prototype.verifyHex = function verifyHex(hex, public_key) {\n    var buf = void 0;\n    buf = Buffer.from(hex, 'hex');\n    return this.verifyBuffer(buf, public_key);\n  };\n\n  return Signature;\n}();\n\nexports.default = Signature;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.SerializerValidation = exports.template = exports.ops = exports.types = exports.fp = exports.Serializer = undefined;\n\nvar _serializer = require(24);\n\nvar _serializer2 = _interopRequireDefault(_serializer);\n\nvar _FastParser = require(20);\n\nvar _FastParser2 = _interopRequireDefault(_FastParser);\n\nvar _types = require(26);\n\nvar _types2 = _interopRequireDefault(_types);\n\nvar _operations = require(23);\n\nvar ops = _interopRequireWildcard(_operations);\n\nvar _template = require(25);\n\nvar _template2 = _interopRequireDefault(_template);\n\nvar _SerializerValidation = require(21);\n\nvar _SerializerValidation2 = _interopRequireDefault(_SerializerValidation);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Serializer = _serializer2.default;\nexports.fp = _FastParser2.default;\nexports.types = _types2.default;\nexports.ops = ops;\nexports.template = _template2.default;\nexports.SerializerValidation = _SerializerValidation2.default;","'use strict';\n\nexports.__esModule = true;\n\nvar _PublicKey = require('../../ecc/src/PublicKey');\n\nvar _PublicKey2 = _interopRequireDefault(_PublicKey);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar FastParser = function () {\n  function FastParser() {\n    _classCallCheck(this, FastParser);\n  }\n\n  FastParser.fixed_data = function fixed_data(b, len, buffer) {\n    if (!b) {\n      return;\n    }\n    if (buffer) {\n      var data = buffer.slice(0, len).toString('binary');\n      b.append(data, 'binary');\n      while (len-- > data.length) {\n        b.writeUint8(0);\n      }\n    } else {\n      var b_copy = b.copy(b.offset, b.offset + len);\n      b.skip(len);\n      return Buffer.from(b_copy.toBinary(), 'binary');\n    }\n  };\n\n  FastParser.public_key = function public_key(b, _public_key) {\n    var buffer = void 0;\n    if (!b) {\n      return;\n    }\n    if (_public_key) {\n      buffer = _public_key.toBuffer();\n      b.append(buffer.toString('binary'), 'binary');\n    } else {\n      buffer = FastParser.fixed_data(b, 33);\n      return _PublicKey2.default.fromBuffer(buffer);\n    }\n  };\n\n  FastParser.ripemd160 = function ripemd160(b, _ripemd) {\n    if (!b) {\n      return;\n    }\n    if (_ripemd) {\n      FastParser.fixed_data(b, 20, _ripemd);\n    } else {\n      return FastParser.fixed_data(b, 20);\n    }\n  };\n\n  FastParser.sha256 = function sha256(b, _sha) {\n    if (!b) {\n      return;\n    }\n    if (_sha) {\n      FastParser.fixed_data(b, 32, _sha);\n    } else {\n      return FastParser.fixed_data(b, 32);\n    }\n  };\n\n  FastParser.time_point_sec = function time_point_sec(b, epoch) {\n    if (epoch) {\n      epoch = Math.ceil(epoch / 1000);\n      b.writeInt32(epoch);\n    } else {\n      epoch = b.readInt32(); // fc::time_point_sec\n      return new Date(epoch * 1000);\n    }\n  };\n\n  return FastParser;\n}();\n\nexports.default = FastParser;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _bytebuffer = require(38);\n\nvar _ChainTypes = require(3);\n\nvar _ChainTypes2 = _interopRequireDefault(_ChainTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar MAX_SAFE_INT = 9007199254740991;\nvar MIN_SAFE_INT = -9007199254740991;\n\n/**\n    Most validations are skipped and the value returned unchanged when an empty string,\n    null, or undefined is encountered (except \"required\").\n    Validations support a string format for dealing with large numbers.\n*/\nvar _my = {\n  is_empty: function is_empty(value) {\n    return value === null || value === undefined;\n  },\n  required: function required(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      throw new Error('value required ' + field_name + ' | ' + value);\n    }\n\n    return value;\n  },\n  require_long: function require_long(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (!_bytebuffer.Long.isLong(value)) {\n      throw new Error('Long value required ' + field_name + ' | ' + value);\n    }\n\n    return value;\n  },\n  string: function string(value) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (typeof value !== 'string') {\n      throw new Error('string required: ' + value);\n    }\n\n    return value;\n  },\n  number: function number(value) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (typeof value !== 'number') {\n      throw new Error('number required: ' + value);\n    }\n\n    return value;\n  },\n  whole_number: function whole_number(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (/\\./.test(value)) {\n      throw new Error('whole number required ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  unsigned: function unsigned(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (/-/.test(value)) {\n      throw new Error('unsigned required ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  is_digits: function is_digits(value) {\n    if (typeof value === 'number') {\n      return true;\n    }\n\n    return (/^[0-9]+$/.test(value)\n    );\n  },\n  to_number: function to_number(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.no_overflow53(value, field_name);\n    var int_value = function () {\n      if (typeof value === 'number') {\n        return value;\n      }\n\n      return parseInt(value, 10);\n    }();\n    return int_value;\n  },\n  to_long: function to_long(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      return value;\n    }\n\n    this.no_overflow64(value, field_name);\n\n    if (typeof value === 'number') {\n      value = '' + value;\n    }\n\n    return _bytebuffer.Long.fromString(value);\n  },\n  to_ulong: function to_ulong(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      return value;\n    }\n\n    this.no_overflow64(value, field_name, true);\n\n    if (typeof value === 'number') {\n      value = '' + value;\n    }\n\n    return _bytebuffer.Long.fromString(value, true);\n  },\n  to_string: function to_string(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (typeof value === 'string') {\n      return value;\n    }\n\n    if (typeof value === 'number') {\n      this.no_overflow53(value, field_name);\n      return '' + value;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      return value.toString();\n    }\n\n    throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value);\n  },\n  require_test: function require_test(regex, value) {\n    var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    if (!regex.test(value)) {\n      throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  require_match: function require_match(regex, value) {\n    var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var match = value.match(regex);\n\n    if (match === null) {\n      throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value);\n    }\n\n    return match;\n  },\n  require_object_id: function require_object_id(value, field_name) {\n    return this.require_match(/^([0-9]+)\\.([0-9]+)\\.([0-9]+)$/, value, field_name);\n  },\n\n\n  // Does not support over 53 bits\n  require_range: function require_range(min, max, value) {\n    var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var num = this.to_number(value);\n\n    if (num < min || num > max) {\n      throw new Error('out of range ' + value + ' ' + field_name + ' ' + value);\n    }\n\n    return value;\n  },\n  require_object_type: function require_object_type() {\n    var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;\n    var type = arguments[1];\n    var value = arguments[2];\n    var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var object_type = _ChainTypes2.default.object_type[type];\n\n    if (!object_type) {\n      throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value);\n    }\n\n    var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$');\n\n    if (!re.test(value)) {\n      throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value));\n    }\n\n    return value;\n  },\n  get_instance: function get_instance(reserve_spaces, type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(reserve_spaces, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n  require_relative_type: function require_relative_type(type, value, field_name) {\n    this.require_object_type(0, type, value, field_name);\n    return value;\n  },\n  get_relative_instance: function get_relative_instance(type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(0, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n  require_protocol_type: function require_protocol_type(type, value, field_name) {\n    this.require_object_type(1, type, value, field_name);\n    return value;\n  },\n  get_protocol_instance: function get_protocol_instance(type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(1, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n  get_protocol_type: function get_protocol_type(value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_id(value, field_name);\n    var values = value.split('.');\n    return this.to_number(values[1]);\n  },\n  get_protocol_type_name: function get_protocol_type_name(value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    var type_id = this.get_protocol_type(value, field_name);\n    return Object.keys(_ChainTypes2.default.object_type)[type_id];\n  },\n  require_implementation_type: function require_implementation_type(type, value, field_name) {\n    this.require_object_type(2, type, value, field_name);\n    return value;\n  },\n  get_implementation_instance: function get_implementation_instance(type, value, field_name) {\n    if (this.is_empty(value)) {\n      return value;\n    }\n\n    this.require_object_type(2, type, value, field_name);\n    return this.to_number(value.split('.')[2]);\n  },\n\n\n  // signed / unsigned decimal\n  no_overflow53: function no_overflow53(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    if (typeof value === 'number') {\n      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n        throw new Error('overflow ' + field_name + ' ' + value);\n      }\n\n      return;\n    }\n\n    if (typeof value === 'string') {\n      var int = parseInt(value, 10);\n\n      if (int > MAX_SAFE_INT || int < MIN_SAFE_INT) {\n        throw new Error('overflow ' + field_name + ' ' + int);\n      }\n\n      return;\n    }\n\n    if (_bytebuffer.Long.isLong(value)) {\n      // typeof value.toInt() is 'number'\n      this.no_overflow53(value.toInt(), field_name);\n      return;\n    }\n\n    throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value);\n  },\n\n\n  // signed / unsigned whole numbers only\n  no_overflow64: function no_overflow64(value) {\n    var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n    var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n    // https://github.com/dcodeIO/Long.js/issues/20\n    if (_bytebuffer.Long.isLong(value)) {\n      return;\n    }\n\n    // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20\n    if (value.t !== undefined && value.s !== undefined) {\n      this.no_overflow64(value.toString(), field_name, unsigned);\n\n      return;\n    }\n\n    if (typeof value === 'string') {\n      // remove leading zeros, will cause a false positive\n      value = value.replace(/^0+/, '');\n\n      // remove trailing zeros\n      while (/0$/.test(value)) {\n        value = value.substring(0, value.length - 1);\n      }\n\n      if (/\\.$/.test(value)) {\n        // remove trailing dot\n        value = value.substring(0, value.length - 1);\n      }\n\n      if (value === '') {\n        value = '0';\n      }\n\n      var long_string = _bytebuffer.Long.fromString(value, unsigned).toString();\n\n      if (long_string !== value.trim()) {\n        throw new Error('overflow ' + field_name + ' ' + value);\n      }\n\n      return;\n    }\n\n    if (typeof value === 'number') {\n      if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n        throw new Error('overflow ' + field_name + ' ' + value);\n      }\n\n      return;\n    }\n\n    throw new Error('unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value);\n  }\n};\n\nexports.default = _my;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** Exception nesting.  */\nvar ErrorWithCause = function () {\n  function ErrorWithCause(message, cause) {\n    _classCallCheck(this, ErrorWithCause);\n\n    this.message = message;\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) {\n      this.message = 'cause\\t' + cause.message + '\\t' + this.message;\n    }\n\n    var stack = ''; // (new Error).stack\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) {\n      stack = 'caused by\\n\\t' + cause.stack + '\\t' + stack;\n    }\n\n    this.stack = this.message + '\\n' + stack;\n  }\n\n  ErrorWithCause.throw = function _throw(message, cause) {\n    var msg = message;\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.message : undefined) {\n      msg += '\\t cause: ' + cause.message + ' ';\n    }\n\n    if (typeof cause !== 'undefined' && cause !== null ? cause.stack : undefined) {\n      msg += '\\n stack: ' + cause.stack + ' ';\n    }\n\n    throw new Error(msg);\n  };\n\n  return ErrorWithCause;\n}();\n\nexports.default = ErrorWithCause;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\nexports.stealth_memo_data = exports.global_betting_statistics = exports.betting_market_position = exports.bet = exports.betting_market = exports.betting_market_group = exports.betting_market_rules = exports.event = exports.event_group = exports.sport = exports.signed_transaction = exports.transaction = exports.bet_adjusted = exports.betting_market_update = exports.betting_market_group_update = exports.tournament_leave = exports.tournament_payout = exports.payout_type = exports.bet_canceled = exports.bet_cancel = exports.bet_matched = exports.betting_market_group_cancel_unmatched_bets = exports.betting_market_group_resolved = exports.betting_market_group_resolve = exports.betting_market_resolution_type = exports.bet_place = exports.bet_type = exports.betting_market_create = exports.betting_market_group_create = exports.betting_market_rules_update = exports.betting_market_rules_create = exports.event_update = exports.event_create = exports.event_group_update = exports.event_group_create = exports.sport_update = exports.sport_create = exports.asset_dividend_distribution = exports.asset_update_dividend = exports.dividend_asset_options = exports.game_move = exports.rock_paper_scissors_throw_reveal = exports.rock_paper_scissors_throw_commit = exports.rock_paper_scissors_gesture = exports.tournament_join = exports.tournament_create = exports.tournament_options = exports.rock_paper_scissors_game_options = exports.fba_distribute = exports.asset_claim_fees = exports.asset_settle_cancel = exports.transfer_from_blind = exports.blind_transfer = exports.blind_input = exports.transfer_to_blind = exports.blind_output = exports.stealth_confirmation = exports.override_transfer = exports.balance_claim = exports.assert = exports.block_id_predicate = exports.asset_symbol_eq_lit_predicate = exports.account_name_eq_lit_predicate = exports.custom = exports.worker_create = exports.burn_worker_initializer = exports.vesting_balance_worker_initializer = exports.refund_worker_initializer = exports.vesting_balance_withdraw = exports.vesting_balance_create = exports.cdd_vesting_policy_initializer = exports.linear_vesting_policy_initializer = exports.committee_member_update_global_parameters = exports.chain_parameters = exports.committee_member_update = exports.committee_member_create = exports.withdraw_permission_delete = exports.withdraw_permission_claim = exports.withdraw_permission_update = exports.withdraw_permission_create = exports.proposal_delete = exports.proposal_update = exports.proposal_create = exports.op_wrapper = exports.witness_update = exports.witness_create = exports.asset_publish_feed = exports.price_feed = exports.asset_global_settle = exports.asset_settle = exports.asset_fund_fee_pool = exports.asset_reserve = exports.asset_issue = undefined;\nexports.asset_update_feed_producers = exports.asset_update_bitasset = exports.asset_update = exports.asset_create = exports.bitasset_options = exports.asset_options = exports.price = exports.account_transfer = exports.account_upgrade = exports.account_whitelist = exports.account_update = exports.account_create = exports.account_options = exports.authority = exports.fill_order = exports.call_order_update = exports.limit_order_cancel = exports.limit_order_create = exports.transfer = exports.memo_data = exports.signed_block_header = exports.block_header = exports.signed_block = exports.processed_transaction = exports.asset = exports.void_result = exports.fee_schedule = exports.bet_adjusted_operation_fee_parameters = exports.betting_market_update_operation_fee_parameters = exports.betting_market_group_update_operation_fee_parameters = exports.tournament_leave_operation_fee_parameters = exports.tournament_payout_operation_fee_parameters = exports.game_move_operation_fee_parameters = exports.tournament_join_operation_fee_parameters = exports.tournament_create_operation_fee_parameters = exports.bet_canceled_operation_fee_parameters = exports.bet_cancel_operation_fee_parameters = exports.bet_matched_operation_fee_parameters = exports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = exports.betting_market_group_resolved_operation_fee_parameters = exports.betting_market_group_resolve_operation_fee_parameters = exports.bet_place_operation_fee_parameters = exports.betting_market_create_operation_fee_parameters = exports.betting_market_group_create_operation_fee_parameters = exports.betting_market_rules_update_operation_fee_parameters = exports.betting_market_rules_create_operation_fee_parameters = exports.event_update_operation_fee_parameters = exports.event_create_operation_fee_parameters = exports.event_group_update_operation_fee_parameters = exports.event_group_create_operation_fee_parameters = exports.sport_update_operation_fee_parameters = exports.sport_create_operation_fee_parameters = exports.asset_dividend_distribution_operation_fee_parameters = exports.asset_update_dividend_operation_fee_parameters = exports.fba_distribute_operation_fee_parameters = exports.asset_claim_fees_operation_fee_parameters = exports.asset_settle_cancel_operation_fee_parameters = exports.transfer_from_blind_operation_fee_parameters = exports.blind_transfer_operation_fee_parameters = exports.transfer_to_blind_operation_fee_parameters = exports.override_transfer_operation_fee_parameters = exports.balance_claim_operation_fee_parameters = exports.assert_operation_fee_parameters = exports.custom_operation_fee_parameters = exports.worker_create_operation_fee_parameters = exports.vesting_balance_withdraw_operation_fee_parameters = exports.vesting_balance_create_operation_fee_parameters = exports.committee_member_update_global_parameters_operation_fee_parameters = exports.committee_member_update_operation_fee_parameters = exports.committee_member_create_operation_fee_parameters = exports.withdraw_permission_delete_operation_fee_parameters = exports.withdraw_permission_claim_operation_fee_parameters = exports.withdraw_permission_update_operation_fee_parameters = exports.withdraw_permission_create_operation_fee_parameters = exports.proposal_delete_operation_fee_parameters = exports.proposal_update_operation_fee_parameters = exports.proposal_create_operation_fee_parameters = exports.witness_update_operation_fee_parameters = exports.witness_create_operation_fee_parameters = exports.asset_publish_feed_operation_fee_parameters = exports.asset_global_settle_operation_fee_parameters = exports.asset_settle_operation_fee_parameters = exports.asset_fund_fee_pool_operation_fee_parameters = exports.asset_reserve_operation_fee_parameters = exports.asset_issue_operation_fee_parameters = exports.asset_update_feed_producers_operation_fee_parameters = exports.asset_update_bitasset_operation_fee_parameters = exports.asset_update_operation_fee_parameters = exports.asset_create_operation_fee_parameters = exports.account_transfer_operation_fee_parameters = exports.account_upgrade_operation_fee_parameters = exports.account_whitelist_operation_fee_parameters = exports.account_update_operation_fee_parameters = exports.account_create_operation_fee_parameters = exports.fill_order_operation_fee_parameters = exports.call_order_update_operation_fee_parameters = exports.limit_order_cancel_operation_fee_parameters = exports.limit_order_create_operation_fee_parameters = exports.transfer_operation_fee_parameters = exports.operation = undefined;\n\nvar _types = require(26);\n\nvar _types2 = _interopRequireDefault(_types);\n\nvar _serializer = require(24);\n\nvar _serializer2 = _interopRequireDefault(_serializer);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar uint8 = _types2.default.uint8,\n    uint16 = _types2.default.uint16,\n    uint32 = _types2.default.uint32,\n    int64 = _types2.default.int64,\n    uint64 = _types2.default.uint64,\n    string = _types2.default.string,\n    bytes = _types2.default.bytes,\n    bool = _types2.default.bool,\n    array = _types2.default.array,\n    protocol_id_type = _types2.default.protocol_id_type,\n    object_id_type = _types2.default.object_id_type,\n    vote_id = _types2.default.vote_id,\n    implementation_id_type = _types2.default.implementation_id_type,\n    static_variant = _types2.default.static_variant,\n    map = _types2.default.map,\n    set = _types2.default.set,\n    public_key = _types2.default.public_key,\n    address = _types2.default.address,\n    time_point_sec = _types2.default.time_point_sec,\n    optional = _types2.default.optional,\n    variant_object = _types2.default.variant_object,\n    enumeration = _types2.default.enumeration,\n    sha256 = _types2.default.sha256;\n\n\nvar future_extensions = _types2.default.void;\n\n/*\nWhen updating generated code\nReplace:  operation = static_variant [\nwith:     operation.st_operations = [\n\nDelete:\npublic_key = new Serializer(\n    \"public_key\"\n    key_data: bytes 33\n);\n*/\n\nfunction Serializer(operation_name, serilization_types_object) {\n  return new _serializer2.default(operation_name, serilization_types_object);\n}\n// Place-holder, their are dependencies on \"operation\" .. The final list of\n// operations is not avialble until the very end of the generated code.\n// See: operation.st_operations = ...\n// module.exports[\"operation\"] = operation;\n\nvar operation = static_variant();\n\n// Custom-types follow Generated code:\n\n// ##  Generated code follows\n// # programs/js_operation_serializer > npm i -g decaffeinate\n// ## -------------------------------\nvar transfer_operation_fee_parameters = new Serializer('transfer_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar limit_order_create_operation_fee_parameters = new Serializer('limit_order_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar limit_order_cancel_operation_fee_parameters = new Serializer('limit_order_cancel_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar call_order_update_operation_fee_parameters = new Serializer('call_order_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar fill_order_operation_fee_parameters = new Serializer('fill_order_operation_fee_parameters');\n\nvar account_create_operation_fee_parameters = new Serializer('account_create_operation_fee_parameters', {\n  basic_fee: uint64,\n  premium_fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar account_update_operation_fee_parameters = new Serializer('account_update_operation_fee_parameters', {\n  fee: int64,\n  price_per_kbyte: uint32\n});\n\nvar account_whitelist_operation_fee_parameters = new Serializer('account_whitelist_operation_fee_parameters', {\n  fee: int64\n});\n\nvar account_upgrade_operation_fee_parameters = new Serializer('account_upgrade_operation_fee_parameters', {\n  membership_annual_fee: uint64,\n  membership_lifetime_fee: uint64\n});\n\nvar account_transfer_operation_fee_parameters = new Serializer('account_transfer_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_create_operation_fee_parameters = new Serializer('asset_create_operation_fee_parameters', {\n  symbol3: uint64,\n  symbol4: uint64,\n  long_symbol: uint64,\n  price_per_kbyte: uint32\n});\n\nvar asset_update_operation_fee_parameters = new Serializer('asset_update_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar asset_update_bitasset_operation_fee_parameters = new Serializer('asset_update_bitasset_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_update_feed_producers_operation_fee_parameters = new Serializer('asset_update_feed_producers_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_issue_operation_fee_parameters = new Serializer('asset_issue_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar asset_reserve_operation_fee_parameters = new Serializer('asset_reserve_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_fund_fee_pool_operation_fee_parameters = new Serializer('asset_fund_fee_pool_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_settle_operation_fee_parameters = new Serializer('asset_settle_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_global_settle_operation_fee_parameters = new Serializer('asset_global_settle_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_publish_feed_operation_fee_parameters = new Serializer('asset_publish_feed_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar witness_create_operation_fee_parameters = new Serializer('witness_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar witness_update_operation_fee_parameters = new Serializer('witness_update_operation_fee_parameters', {\n  fee: int64\n});\n\nvar proposal_create_operation_fee_parameters = new Serializer('proposal_create_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar proposal_update_operation_fee_parameters = new Serializer('proposal_update_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar proposal_delete_operation_fee_parameters = new Serializer('proposal_delete_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar withdraw_permission_create_operation_fee_parameters = new Serializer('withdraw_permission_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar withdraw_permission_update_operation_fee_parameters = new Serializer('withdraw_permission_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar withdraw_permission_claim_operation_fee_parameters = new Serializer('withdraw_permission_claim_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar withdraw_permission_delete_operation_fee_parameters = new Serializer('withdraw_permission_delete_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar committee_member_create_operation_fee_parameters = new Serializer('committee_member_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar committee_member_update_operation_fee_parameters = new Serializer('committee_member_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar committee_member_update_global_parameters_operation_fee_parameters = new Serializer('committee_member_update_global_parameters_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar vesting_balance_create_operation_fee_parameters = new Serializer('vesting_balance_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar vesting_balance_withdraw_operation_fee_parameters = new Serializer('vesting_balance_withdraw_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar worker_create_operation_fee_parameters = new Serializer('worker_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar custom_operation_fee_parameters = new Serializer('custom_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar assert_operation_fee_parameters = new Serializer('assert_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar balance_claim_operation_fee_parameters = new Serializer('balance_claim_operation_fee_parameters');\n\nvar override_transfer_operation_fee_parameters = new Serializer('override_transfer_operation_fee_parameters', {\n  fee: uint64,\n  price_per_kbyte: uint32\n});\n\nvar transfer_to_blind_operation_fee_parameters = new Serializer('transfer_to_blind_operation_fee_parameters', {\n  fee: uint64,\n  price_per_output: uint32\n});\n\nvar blind_transfer_operation_fee_parameters = new Serializer('blind_transfer_operation_fee_parameters', {\n  fee: uint64,\n  price_per_output: uint32\n});\n\nvar transfer_from_blind_operation_fee_parameters = new Serializer('transfer_from_blind_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_settle_cancel_operation_fee_parameters = new Serializer('asset_settle_cancel_operation_fee_parameters');\n\nvar asset_claim_fees_operation_fee_parameters = new Serializer('asset_claim_fees_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar fba_distribute_operation_fee_parameters = new Serializer('fba_distribute_operation_fee_parameters', {});\n\nvar asset_update_dividend_operation_fee_parameters = new Serializer('asset_update_dividend_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar asset_dividend_distribution_operation_fee_parameters = new Serializer('asset_dividend_distribution_operation_fee_parameters', {\n  distribution_base_fee: uint64,\n  distribution_fee_per_holder: uint32\n});\n\nvar sport_create_operation_fee_parameters = new Serializer('sport_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar sport_update_operation_fee_parameters = new Serializer('sport_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_group_create_operation_fee_parameters = new Serializer('event_group_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_group_update_operation_fee_parameters = new Serializer('event_group_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_create_operation_fee_parameters = new Serializer('event_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar event_update_operation_fee_parameters = new Serializer('event_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_rules_create_operation_fee_parameters = new Serializer('betting_market_rules_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_rules_update_operation_fee_parameters = new Serializer('betting_market_rules_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_group_create_operation_fee_parameters = new Serializer('betting_market_group_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_create_operation_fee_parameters = new Serializer('betting_market_create_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_place_operation_fee_parameters = new Serializer('bet_place_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_group_resolve_operation_fee_parameters = new Serializer('betting_market_group_resolve_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_group_resolved_operation_fee_parameters = new Serializer('betting_market_group_resolved_operation_fee_parameters');\n\nvar betting_market_group_cancel_unmatched_bets_operation_fee_parameters = new Serializer('betting_market_group_cancel_unmatched_bets_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_matched_operation_fee_parameters = new Serializer('bet_matched_operation_fee_parameters');\n\nvar bet_cancel_operation_fee_parameters = new Serializer('bet_cancel_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_canceled_operation_fee_parameters = new Serializer('bet_canceled_operation_fee_parameters');\n\nvar tournament_create_operation_fee_parameters = new Serializer('tournament_create_operation_fee_parameters', {\n  fee: int64\n});\n\nvar tournament_join_operation_fee_parameters = new Serializer('tournament_join_operation_fee_parameters', {\n  fee: int64\n});\n\nvar game_move_operation_fee_parameters = new Serializer('game_move_operation_fee_parameters', {\n  fee: int64\n});\n\nvar tournament_payout_operation_fee_parameters = new Serializer('tournament_payout_operation_fee_parameters');\n\nvar tournament_leave_operation_fee_parameters = new Serializer('tournament_leave_operation_fee_parameters', {\n  fee: int64\n});\n\nvar betting_market_group_update_operation_fee_parameters = new Serializer('betting_market_group_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar betting_market_update_operation_fee_parameters = new Serializer('betting_market_update_operation_fee_parameters', {\n  fee: uint64\n});\n\nvar bet_adjusted_operation_fee_parameters = new Serializer('bet_adjusted_operation_fee_parameters');\n\nvar fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters, game_move_operation_fee_parameters, asset_update_dividend_operation_fee_parameters, asset_dividend_distribution_operation_fee_parameters, tournament_payout_operation_fee_parameters, tournament_leave_operation_fee_parameters, sport_create_operation_fee_parameters, sport_update_operation_fee_parameters, event_group_create_operation_fee_parameters, event_group_update_operation_fee_parameters, event_create_operation_fee_parameters, event_update_operation_fee_parameters, betting_market_rules_create_operation_fee_parameters, betting_market_rules_update_operation_fee_parameters, betting_market_group_create_operation_fee_parameters, betting_market_create_operation_fee_parameters, bet_place_operation_fee_parameters, betting_market_group_resolve_operation_fee_parameters, betting_market_group_resolved_operation_fee_parameters, bet_adjusted_operation_fee_parameters, betting_market_group_cancel_unmatched_bets_operation_fee_parameters, bet_matched_operation_fee_parameters, bet_cancel_operation_fee_parameters, bet_canceled_operation_fee_parameters, betting_market_group_update_operation_fee_parameters, betting_market_update_operation_fee_parameters\n// Missing event_update_status\n]);\n\nvar fee_schedule = new Serializer('fee_schedule', {\n  parameters: set(fee_parameters),\n  scale: uint32\n});\n\nvar void_result = new Serializer('void_result');\n\nvar asset = new Serializer('asset', {\n  amount: int64,\n  asset_id: protocol_id_type('asset')\n});\n\nvar operation_result = static_variant([void_result, object_id_type, asset]);\n\nvar processed_transaction = new Serializer('processed_transaction', {\n  ref_block_num: uint16,\n  ref_block_prefix: uint32,\n  expiration: time_point_sec,\n  operations: array(operation),\n  extensions: set(future_extensions),\n  signatures: array(bytes(65)),\n  operation_results: array(operation_result)\n});\n\nvar signed_block = new Serializer('signed_block', {\n  previous: bytes(20),\n  timestamp: time_point_sec,\n  witness: protocol_id_type('witness'),\n  next_secret_hash: bytes(20),\n  previous_secret: bytes(20),\n  transaction_merkle_root: bytes(20),\n  extensions: set(future_extensions),\n  witness_signature: bytes(65),\n  transactions: array(processed_transaction)\n});\n\nvar block_header = new Serializer('block_header', {\n  previous: bytes(20),\n  timestamp: time_point_sec,\n  witness: protocol_id_type('witness'),\n  next_secret_hash: bytes(20),\n  previous_secret: bytes(20),\n  transaction_merkle_root: bytes(20),\n  extensions: set(future_extensions)\n});\n\nvar signed_block_header = new Serializer('signed_block_header', {\n  previous: bytes(20),\n  timestamp: time_point_sec,\n  witness: protocol_id_type('witness'),\n  next_secret_hash: bytes(20),\n  previous_secret: bytes(20),\n  transaction_merkle_root: bytes(20),\n  extensions: set(future_extensions),\n  witness_signature: bytes(65)\n});\n\nvar memo_data = new Serializer('memo_data', {\n  from: public_key,\n  to: public_key,\n  nonce: uint64,\n  message: bytes()\n});\n\nvar transfer = new Serializer('transfer', {\n  fee: asset,\n  from: protocol_id_type('account'),\n  to: protocol_id_type('account'),\n  amount: asset,\n  memo: optional(memo_data),\n  extensions: set(future_extensions)\n});\n\nvar limit_order_create = new Serializer('limit_order_create', {\n  fee: asset,\n  seller: protocol_id_type('account'),\n  amount_to_sell: asset,\n  min_to_receive: asset,\n  expiration: time_point_sec,\n  fill_or_kill: bool,\n  extensions: set(future_extensions)\n});\n\nvar limit_order_cancel = new Serializer('limit_order_cancel', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  order: protocol_id_type('limit_order'),\n  extensions: set(future_extensions)\n});\n\nvar call_order_update = new Serializer('call_order_update', {\n  fee: asset,\n  funding_account: protocol_id_type('account'),\n  delta_collateral: asset,\n  delta_debt: asset,\n  extensions: set(future_extensions)\n});\n\nvar fill_order = new Serializer('fill_order', {\n  fee: asset,\n  order_id: object_id_type,\n  account_id: protocol_id_type('account'),\n  pays: asset,\n  receives: asset\n});\n\nvar authority = new Serializer('authority', {\n  weight_threshold: uint32,\n  account_auths: map(protocol_id_type('account'), uint16),\n  key_auths: map(public_key, uint16),\n  address_auths: map(address, uint16)\n});\n\nvar account_options = new Serializer('account_options', {\n  memo_key: public_key,\n  voting_account: protocol_id_type('account'),\n  num_witness: uint16,\n  num_committee: uint16,\n  votes: set(vote_id),\n  extensions: set(future_extensions)\n});\n\nvar account_create = new Serializer('account_create', {\n  fee: asset,\n  registrar: protocol_id_type('account'),\n  referrer: protocol_id_type('account'),\n  referrer_percent: uint16,\n  name: string,\n  owner: authority,\n  active: authority,\n  options: account_options,\n  extensions: set(future_extensions)\n});\n\nvar account_update = new Serializer('account_update', {\n  fee: asset,\n  account: protocol_id_type('account'),\n  owner: optional(authority),\n  active: optional(authority),\n  new_options: optional(account_options),\n  extensions: set(future_extensions)\n});\n\nvar account_whitelist = new Serializer('account_whitelist', {\n  fee: asset,\n  authorizing_account: protocol_id_type('account'),\n  account_to_list: protocol_id_type('account'),\n  new_listing: uint8,\n  extensions: set(future_extensions)\n});\n\nvar account_upgrade = new Serializer('account_upgrade', {\n  fee: asset,\n  account_to_upgrade: protocol_id_type('account'),\n  upgrade_to_lifetime_member: bool,\n  extensions: set(future_extensions)\n});\n\nvar account_transfer = new Serializer('account_transfer', {\n  fee: asset,\n  account_id: protocol_id_type('account'),\n  new_owner: protocol_id_type('account'),\n  extensions: set(future_extensions)\n});\n\nvar price = new Serializer('price', {\n  base: asset,\n  quote: asset\n});\n\nvar asset_options = new Serializer('asset_options', {\n  max_supply: int64,\n  market_fee_percent: uint16,\n  max_market_fee: int64,\n  issuer_permissions: uint16,\n  flags: uint16,\n  core_exchange_rate: price,\n  whitelist_authorities: set(protocol_id_type('account')),\n  blacklist_authorities: set(protocol_id_type('account')),\n  whitelist_markets: set(protocol_id_type('asset')),\n  blacklist_markets: set(protocol_id_type('asset')),\n  description: string,\n  extensions: set(future_extensions)\n});\n\nvar bitasset_options = new Serializer('bitasset_options', {\n  feed_lifetime_sec: uint32,\n  minimum_feeds: uint8,\n  force_settlement_delay_sec: uint32,\n  force_settlement_offset_percent: uint16,\n  maximum_force_settlement_volume: uint16,\n  short_backing_asset: protocol_id_type('asset'),\n  extensions: set(future_extensions)\n});\n\nvar asset_create = new Serializer('asset_create', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  symbol: string,\n  precision: uint8,\n  common_options: asset_options,\n  bitasset_opts: optional(bitasset_options),\n  is_prediction_market: bool,\n  extensions: set(future_extensions)\n});\n\nvar asset_update = new Serializer('asset_update', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_issuer: optional(protocol_id_type('account')),\n  new_options: asset_options,\n  extensions: set(future_extensions)\n});\n\nvar asset_update_bitasset = new Serializer('asset_update_bitasset', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_options: bitasset_options,\n  extensions: set(future_extensions)\n});\n\nvar asset_update_feed_producers = new Serializer('asset_update_feed_producers', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_feed_producers: set(protocol_id_type('account')),\n  extensions: set(future_extensions)\n});\n\nvar asset_issue = new Serializer('asset_issue', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_issue: asset,\n  issue_to_account: protocol_id_type('account'),\n  memo: optional(memo_data),\n  extensions: set(future_extensions)\n});\n\nvar asset_reserve = new Serializer('asset_reserve', {\n  fee: asset,\n  payer: protocol_id_type('account'),\n  amount_to_reserve: asset,\n  extensions: set(future_extensions)\n});\n\nvar asset_fund_fee_pool = new Serializer('asset_fund_fee_pool', {\n  fee: asset,\n  from_account: protocol_id_type('account'),\n  asset_id: protocol_id_type('asset'),\n  amount: int64,\n  extensions: set(future_extensions)\n});\n\nvar asset_settle = new Serializer('asset_settle', {\n  fee: asset,\n  account: protocol_id_type('account'),\n  amount: asset,\n  extensions: set(future_extensions)\n});\n\nvar asset_global_settle = new Serializer('asset_global_settle', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_settle: protocol_id_type('asset'),\n  settle_price: price,\n  extensions: set(future_extensions)\n});\n\nvar price_feed = new Serializer('price_feed', {\n  settlement_price: price,\n  maintenance_collateral_ratio: uint16,\n  maximum_short_squeeze_ratio: uint16,\n  core_exchange_rate: price\n});\n\nvar asset_publish_feed = new Serializer('asset_publish_feed', {\n  fee: asset,\n  publisher: protocol_id_type('account'),\n  asset_id: protocol_id_type('asset'),\n  feed: price_feed,\n  extensions: set(future_extensions)\n});\n\nvar witness_create = new Serializer('witness_create', {\n  fee: asset,\n  witness_account: protocol_id_type('account'),\n  url: string,\n  block_signing_key: public_key,\n  initial_secret: bytes(20)\n});\n\nvar witness_update = new Serializer('witness_update', {\n  fee: asset,\n  witness: protocol_id_type('witness'),\n  witness_account: protocol_id_type('account'),\n  new_url: optional(string),\n  new_signing_key: optional(public_key),\n  new_initial_secret: optional(bytes(20))\n});\n\nvar op_wrapper = new Serializer('op_wrapper', {\n  op: operation\n});\n\nvar proposal_create = new Serializer('proposal_create', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  expiration_time: time_point_sec,\n  proposed_ops: array(op_wrapper),\n  review_period_seconds: optional(uint32),\n  extensions: set(future_extensions)\n});\n\nvar proposal_update = new Serializer('proposal_update', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  proposal: protocol_id_type('proposal'),\n  active_approvals_to_add: set(protocol_id_type('account')),\n  active_approvals_to_remove: set(protocol_id_type('account')),\n  owner_approvals_to_add: set(protocol_id_type('account')),\n  owner_approvals_to_remove: set(protocol_id_type('account')),\n  key_approvals_to_add: set(public_key),\n  key_approvals_to_remove: set(public_key),\n  extensions: set(future_extensions)\n});\n\nvar proposal_delete = new Serializer('proposal_delete', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  using_owner_authority: bool,\n  proposal: protocol_id_type('proposal'),\n  extensions: set(future_extensions)\n});\n\nvar withdraw_permission_create = new Serializer('withdraw_permission_create', {\n  fee: asset,\n  withdraw_from_account: protocol_id_type('account'),\n  authorized_account: protocol_id_type('account'),\n  withdrawal_limit: asset,\n  withdrawal_period_sec: uint32,\n  periods_until_expiration: uint32,\n  period_start_time: time_point_sec\n});\n\nvar withdraw_permission_update = new Serializer('withdraw_permission_update', {\n  fee: asset,\n  withdraw_from_account: protocol_id_type('account'),\n  authorized_account: protocol_id_type('account'),\n  permission_to_update: protocol_id_type('withdraw_permission'),\n  withdrawal_limit: asset,\n  withdrawal_period_sec: uint32,\n  period_start_time: time_point_sec,\n  periods_until_expiration: uint32\n});\n\nvar withdraw_permission_claim = new Serializer('withdraw_permission_claim', {\n  fee: asset,\n  withdraw_permission: protocol_id_type('withdraw_permission'),\n  withdraw_from_account: protocol_id_type('account'),\n  withdraw_to_account: protocol_id_type('account'),\n  amount_to_withdraw: asset,\n  memo: optional(memo_data)\n});\n\nvar withdraw_permission_delete = new Serializer('withdraw_permission_delete', {\n  fee: asset,\n  withdraw_from_account: protocol_id_type('account'),\n  authorized_account: protocol_id_type('account'),\n  withdrawal_permission: protocol_id_type('withdraw_permission')\n});\n\nvar committee_member_create = new Serializer('committee_member_create', {\n  fee: asset,\n  committee_member_account: protocol_id_type('account'),\n  url: string\n});\n\nvar committee_member_update = new Serializer('committee_member_update', {\n  fee: asset,\n  committee_member: protocol_id_type('committee_member'),\n  committee_member_account: protocol_id_type('account'),\n  new_url: optional(string)\n});\n\nvar chain_parameters = new Serializer('chain_parameters', {\n  current_fees: fee_schedule,\n  block_interval: uint8,\n  maintenance_interval: uint32,\n  maintenance_skip_slots: uint8,\n  committee_proposal_review_period: uint32,\n  maximum_transaction_size: uint32,\n  maximum_block_size: uint32,\n  maximum_time_until_expiration: uint32,\n  maximum_proposal_lifetime: uint32,\n  maximum_asset_whitelist_authorities: uint8,\n  maximum_asset_feed_publishers: uint8,\n  maximum_witness_count: uint16,\n  maximum_committee_count: uint16,\n  maximum_authority_membership: uint16,\n  reserve_percent_of_fee: uint16,\n  network_percent_of_fee: uint16,\n  lifetime_referrer_percent_of_fee: uint16,\n  cashback_vesting_period_seconds: uint32,\n  cashback_vesting_threshold: int64,\n  count_non_member_votes: bool,\n  allow_non_member_whitelists: bool,\n  witness_pay_per_block: int64,\n  worker_budget_per_day: int64,\n  max_predicate_opcode: uint16,\n  fee_liquidation_threshold: int64,\n  accounts_per_fee_scale: uint16,\n  account_fee_scale_bitshifts: uint8,\n  max_authority_depth: uint8,\n  min_bet_multiplier: uint32,\n  max_bet_multiplier: uint32,\n  betting_rake_fee_percentage: uint16,\n  permitted_betting_odds_increments: map(uint32, uint32),\n  witness_schedule_algorithm: uint8,\n  live_betting_delay_time: uint16,\n  min_round_delay: uint32,\n  max_round_delay: uint32,\n  min_time_per_commit_move: uint32,\n  max_time_per_commit_move: uint32,\n  min_time_per_reveal_move: uint32,\n  max_time_per_reveal_move: uint32,\n  rake_fee_percentage: uint16,\n  maximum_registration_deadline: uint32,\n  maximum_players_in_tournament: uint16,\n  maximum_tournament_whitelist_length: uint16,\n  maximum_tournament_start_time_in_future: uint32,\n  maximum_tournament_start_delay: uint32,\n  maximum_tournament_number_of_wins: uint16,\n  extensions: set(future_extensions)\n});\n\nvar committee_member_update_global_parameters = new Serializer('committee_member_update_global_parameters', {\n  fee: asset,\n  new_parameters: chain_parameters\n});\n\nvar linear_vesting_policy_initializer = new Serializer('linear_vesting_policy_initializer', {\n  begin_timestamp: time_point_sec,\n  vesting_cliff_seconds: uint32,\n  vesting_duration_seconds: uint32\n});\n\nvar cdd_vesting_policy_initializer = new Serializer('cdd_vesting_policy_initializer', {\n  start_claim: time_point_sec,\n  vesting_seconds: uint32\n});\n\nvar vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]);\n\nvar vesting_balance_create = new Serializer('vesting_balance_create', {\n  fee: asset,\n  creator: protocol_id_type('account'),\n  owner: protocol_id_type('account'),\n  amount: asset,\n  policy: vesting_policy_initializer\n});\n\nvar vesting_balance_withdraw = new Serializer('vesting_balance_withdraw', {\n  fee: asset,\n  vesting_balance: protocol_id_type('vesting_balance'),\n  owner: protocol_id_type('account'),\n  amount: asset\n});\n\nvar refund_worker_initializer = new Serializer('refund_worker_initializer');\n\nvar vesting_balance_worker_initializer = new Serializer('vesting_balance_worker_initializer', {\n  pay_vesting_period_days: uint16\n});\n\nvar burn_worker_initializer = new Serializer('burn_worker_initializer');\n\nvar worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]);\n\nvar worker_create = new Serializer('worker_create', {\n  fee: asset,\n  owner: protocol_id_type('account'),\n  work_begin_date: time_point_sec,\n  work_end_date: time_point_sec,\n  daily_pay: int64,\n  name: string,\n  url: string,\n  initializer: worker_initializer\n});\n\nvar custom = new Serializer('custom', {\n  fee: asset,\n  payer: protocol_id_type('account'),\n  required_auths: set(protocol_id_type('account')),\n  id: uint16,\n  data: bytes()\n});\n\nvar account_name_eq_lit_predicate = new Serializer('account_name_eq_lit_predicate', {\n  account_id: protocol_id_type('account'),\n  name: string\n});\n\nvar asset_symbol_eq_lit_predicate = new Serializer('asset_symbol_eq_lit_predicate', {\n  asset_id: protocol_id_type('asset'),\n  symbol: string\n});\n\nvar block_id_predicate = new Serializer('block_id_predicate', {\n  id: bytes(20)\n});\n\nvar predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]);\n\nvar assert = new Serializer('assert', {\n  fee: asset,\n  fee_paying_account: protocol_id_type('account'),\n  predicates: array(predicate),\n  required_auths: set(protocol_id_type('account')),\n  extensions: set(future_extensions)\n});\n\nvar balance_claim = new Serializer('balance_claim', {\n  fee: asset,\n  deposit_to_account: protocol_id_type('account'),\n  balance_to_claim: protocol_id_type('balance'),\n  balance_owner_key: public_key,\n  total_claimed: asset\n});\n\nvar override_transfer = new Serializer('override_transfer', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  from: protocol_id_type('account'),\n  to: protocol_id_type('account'),\n  amount: asset,\n  memo: optional(memo_data),\n  extensions: set(future_extensions)\n});\n\nvar stealth_confirmation = new Serializer('stealth_confirmation', {\n  one_time_key: public_key,\n  to: optional(public_key),\n  encrypted_memo: bytes()\n});\n\nvar blind_output = new Serializer('blind_output', {\n  commitment: bytes(33),\n  range_proof: bytes(),\n  owner: authority,\n  stealth_memo: optional(stealth_confirmation)\n});\n\nvar transfer_to_blind = new Serializer('transfer_to_blind', {\n  fee: asset,\n  amount: asset,\n  from: protocol_id_type('account'),\n  blinding_factor: bytes(32),\n  outputs: array(blind_output)\n});\n\nvar blind_input = new Serializer('blind_input', {\n  commitment: bytes(33),\n  owner: authority\n});\n\nvar blind_transfer = new Serializer('blind_transfer', {\n  fee: asset,\n  inputs: array(blind_input),\n  outputs: array(blind_output)\n});\n\nvar transfer_from_blind = new Serializer('transfer_from_blind', {\n  fee: asset,\n  amount: asset,\n  to: protocol_id_type('account'),\n  blinding_factor: bytes(32),\n  inputs: array(blind_input)\n});\n\nvar asset_settle_cancel = new Serializer('asset_settle_cancel', {\n  fee: asset,\n  settlement: protocol_id_type('force_settlement'),\n  account: protocol_id_type('account'),\n  amount: asset,\n  extensions: set(future_extensions)\n});\n\nvar asset_claim_fees = new Serializer('asset_claim_fees', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  amount_to_claim: asset,\n  extensions: set(future_extensions)\n});\n\nvar fba_distribute = new Serializer('fba_distribute', {\n  fee: asset,\n  account_id: protocol_id_type('account'),\n  fba_id: protocol_id_type('fba_accumulator'),\n  amount: int64\n});\n\nvar rock_paper_scissors_game_options = new Serializer('rock_paper_scissors_game_options', {\n  insurance_enabled: bool,\n  time_per_commit_move: uint32,\n  time_per_reveal_move: uint32,\n  number_of_gestures: uint8\n});\n\nvar game_specific_details = static_variant([rock_paper_scissors_game_options]);\n\nvar tournament_options = new Serializer('tournament_options', {\n  type_of_game: uint16,\n  registration_deadline: time_point_sec,\n  number_of_players: uint32,\n  buy_in: asset,\n  whitelist: set(protocol_id_type('account')),\n  start_time: optional(time_point_sec),\n  start_delay: optional(uint32),\n  round_delay: uint32,\n  number_of_wins: uint32,\n  meta: variant_object,\n  game_options: game_specific_details\n});\n\nvar tournament_create = new Serializer('tournament_create', {\n  fee: asset,\n  creator: protocol_id_type('account'),\n  options: tournament_options,\n  extensions: set(future_extensions)\n});\n\nvar tournament_join = new Serializer('tournament_join', {\n  fee: asset,\n  payer_account_id: protocol_id_type('account'),\n  player_account_id: protocol_id_type('account'),\n  tournament_id: protocol_id_type('tournament'),\n  buy_in: asset,\n  extensions: set(future_extensions)\n});\n\nvar rock_paper_scissors_gesture = enumeration(['rock', 'paper', 'scissors', 'spock', 'lizard']);\n\nvar rock_paper_scissors_throw_commit = new Serializer('rock_paper_scissors_throw_commit', {\n  nonce1: uint64,\n  throw_hash: sha256\n});\n\nvar rock_paper_scissors_throw_reveal = new Serializer('rock_paper_scissors_throw_reveal', {\n  nonce2: uint64,\n  gesture: rock_paper_scissors_gesture\n});\n\nvar game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]);\n\nvar game_move = new Serializer('game_move', {\n  fee: asset,\n  game_id: protocol_id_type('game'),\n  player_account_id: protocol_id_type('account'),\n  move: game_specific_moves,\n  extensions: set(future_extensions)\n});\n\nvar dividend_asset_options = new Serializer('dividend_asset_options', {\n  next_payout_time: optional(time_point_sec),\n  payout_interval: optional(uint32),\n  minimum_fee_percentage: uint64,\n  minimum_distribution_interval: optional(uint32),\n  extensions: set(future_extensions)\n});\n\nvar asset_update_dividend = new Serializer('asset_update_dividend', {\n  fee: asset,\n  issuer: protocol_id_type('account'),\n  asset_to_update: protocol_id_type('asset'),\n  new_options: dividend_asset_options,\n  extensions: set(future_extensions)\n});\n\nvar asset_dividend_distribution = new Serializer('asset_dividend_distribution', {\n  fee: asset,\n  dividend_asset_id: protocol_id_type('asset'),\n  account_id: protocol_id_type('account'),\n  amounts: set(asset),\n  extensions: set(future_extensions)\n});\n\nvar sport_create = new Serializer('sport_create', {\n  fee: asset,\n  name: map(string, string),\n  extensions: set(future_extensions)\n});\n\nvar sport_update = new Serializer('sport_update', {\n  fee: asset,\n  sport_id: protocol_id_type('sport'),\n  new_name: optional(map(string, string)),\n  extensions: set(future_extensions)\n});\n\nvar event_group_create = new Serializer('event_group_create', {\n  fee: asset,\n  name: map(string, string),\n  sport_id: object_id_type,\n  extensions: set(future_extensions)\n});\n\nvar event_group_update = new Serializer('event_group_update', {\n  fee: asset,\n  new_sport_id: optional(protocol_id_type('sport')),\n  new_name: optional(map(string, string)),\n  event_group_id: protocol_id_type('event_group'),\n  extensions: set(future_extensions)\n});\n\nvar event_create = new Serializer('event_create', {\n  fee: asset,\n  name: map(string, string),\n  season: map(string, string),\n  start_time: optional(time_point_sec),\n  event_group_id: object_id_type,\n  extensions: set(future_extensions)\n});\n\nvar event_update = new Serializer('event_update', {\n  fee: asset,\n  event_id: protocol_id_type('event'),\n  new_event_group_id: optional(protocol_id_type('event_group')),\n  new_name: optional(map(string, string)),\n  new_season: optional(map(string, string)),\n  new_start_time: optional(time_point_sec),\n  is_live_market: optional(bool),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_rules_create = new Serializer('betting_market_rules_create', {\n  fee: asset,\n  name: map(string, string),\n  description: map(string, string),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_rules_update = new Serializer('betting_market_rules_update', {\n  fee: asset,\n  new_name: optional(map(string, string)),\n  new_description: optional(map(string, string)),\n  extensions: set(future_extensions),\n  betting_market_rules_id: protocol_id_type('betting_market_rules')\n});\n\nvar betting_market_group_create = new Serializer('betting_market_group_create', {\n  fee: asset,\n  description: map(string, string),\n  event_id: object_id_type,\n  rules_id: object_id_type,\n  asset_id: protocol_id_type('asset'),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_create = new Serializer('betting_market_create', {\n  fee: asset,\n  group_id: object_id_type,\n  description: map(string, string),\n  payout_condition: map(string, string),\n  extensions: set(future_extensions)\n});\n\nvar bet_type = enumeration(['back', 'lay']);\n\nvar bet_place = new Serializer('bet_place', {\n  fee: asset,\n  bettor_id: protocol_id_type('account'),\n  betting_market_id: protocol_id_type('betting_market'),\n  amount_to_bet: asset,\n  backer_multiplier: uint32,\n  back_or_lay: bet_type,\n  extensions: set(future_extensions)\n});\n\nvar betting_market_resolution_type = enumeration(['win', 'not_win', 'cancel', 'BETTING_MARKET_RESOLUTION_COUNT']);\n\nvar betting_market_group_resolve = new Serializer('betting_market_group_resolve', {\n  fee: asset,\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_group_resolved = new Serializer('betting_market_group_resolved', {\n  bettor_id: protocol_id_type('account'),\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  resolutions: map(protocol_id_type('betting_market'), betting_market_resolution_type),\n  winnings: int64,\n  fees_paid: int64,\n  fee: asset\n});\n\nvar betting_market_group_cancel_unmatched_bets = new Serializer('betting_market_group_cancel_unmatched_bets', {\n  fee: asset,\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  extensions: set(future_extensions)\n});\n\nvar bet_matched = new Serializer('bet_matched', {\n  bettor_id: protocol_id_type('account'),\n  bet_id: protocol_id_type('bet'),\n  betting_market_id: protocol_id_type('betting_market'),\n  amount_bet: asset,\n  fees_paid: int64,\n  backer_multiplier: uint32,\n  guaranteed_winnings_returned: int64\n});\n\nvar bet_cancel = new Serializer('bet_cancel', {\n  fee: asset,\n  bettor_id: protocol_id_type('account'),\n  bet_to_cancel: protocol_id_type('bet'),\n  extensions: set(future_extensions)\n});\n\nvar bet_canceled = new Serializer('bet_canceled', {\n  bettor_id: protocol_id_type('account'),\n  bet_id: protocol_id_type('bet'),\n  stake_returned: asset,\n  unused_fees_returned: asset\n});\n\nvar payout_type = enumeration(['prize_award', 'buyin_refund', 'rake_fee']);\n\nvar tournament_payout = new Serializer('tournament_payout', {\n  fee: asset,\n  payout_account_id: protocol_id_type('account'),\n  tournament_id: protocol_id_type('tournament'),\n  payout_amount: asset,\n  type: payout_type,\n  extensions: set(future_extensions)\n});\n\nvar tournament_leave = new Serializer('tournament_leave', {\n  fee: asset,\n  canceling_account_id: protocol_id_type('account'),\n  player_account_id: protocol_id_type('account'),\n  tournament_id: protocol_id_type('tournament'),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_group_update = new Serializer('betting_market_group_update', {\n  fee: asset,\n  betting_market_group_id: protocol_id_type('betting_market_group'),\n  new_description: optional(map(string, string)),\n  new_rules_id: optional(protocol_id_type('betting_market_rules')),\n  freeze: optional(bool),\n  delay_bets: optional(bool),\n  extensions: set(future_extensions)\n});\n\nvar betting_market_update = new Serializer('betting_market_update', {\n  fee: asset,\n  betting_market_id: protocol_id_type('betting_market'),\n  new_group_id: optional(protocol_id_type('betting_market_group')),\n  new_description: optional(map(string, string)),\n  new_payout_condition: optional(map(string, string)),\n  extensions: set(future_extensions)\n});\n\nvar bet_adjusted = new Serializer('bet_adjusted', {\n  bettor_id: protocol_id_type('account'),\n  bet_id: protocol_id_type('bet'),\n  stake_returned: asset\n});\n\noperation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend, asset_dividend_distribution, tournament_payout, tournament_leave, sport_create, sport_update, event_group_create, event_group_update, event_create, event_update, betting_market_rules_create, betting_market_rules_update, betting_market_group_create, betting_market_create, bet_place, betting_market_group_resolve, betting_market_group_resolved, bet_adjusted, betting_market_group_cancel_unmatched_bets, bet_matched, bet_cancel, bet_canceled, betting_market_group_update, betting_market_update];\n\nvar transaction = new Serializer('transaction', {\n  ref_block_num: uint16,\n  ref_block_prefix: uint32,\n  expiration: time_point_sec,\n  operations: array(operation),\n  extensions: set(future_extensions)\n});\n\nvar signed_transaction = new Serializer('signed_transaction', {\n  ref_block_num: uint16,\n  ref_block_prefix: uint32,\n  expiration: time_point_sec,\n  operations: array(operation),\n  extensions: set(future_extensions),\n  signatures: array(bytes(65))\n});\n// # -------------------------------\n// #  Generated code end\n// # -------------------------------\n\n// Betting Objects\n\nvar sport = new Serializer('sport', {\n  id: protocol_id_type('sport'),\n  name: map(string, string)\n});\n\nvar event_group = new Serializer('event_group', {\n  id: protocol_id_type('event_group'),\n  name: map(string, string),\n  sport_id: protocol_id_type('sport')\n});\n\nvar event_status = enumeration(['upcoming', 'in_progress', 'frozen', 'finished', 'completed', 'canceled', 'STATUS_COUNT']);\n\nvar betting_market_status = enumeration(['unresolved', 'frozen', 'graded', 'canceled', 'settled']);\n\nvar betting_market_group_status = enumeration(['upcoming', 'in_play', 'closed', 'graded', 're-grading', 'settled', 'frozen', 'canceled']);\n\nvar event = new Serializer('event', {\n  id: protocol_id_type('event'),\n  name: map(string, string),\n  season: map(string, string),\n  start_time: optional(time_point_sec),\n  event_group_id: protocol_id_type('event_group'),\n  is_live_market: bool,\n  status: event_status,\n  scores: array(string)\n});\n\nvar betting_market_rules = new Serializer('betting_market_rules', {\n  id: protocol_id_type('betting_market_rules'),\n  name: map(string, string),\n  description: map(string, string)\n});\n\nvar betting_market_group = new Serializer('betting_market_group', {\n  id: protocol_id_type('betting_market_group'),\n  description: map(string, string),\n  event_id: protocol_id_type('event'),\n  rules_id: protocol_id_type('betting_market_rules'),\n  asset_id: protocol_id_type('asset'),\n  total_matched_bets_amount: uint64,\n  frozen: bool,\n  delay_bets: bool,\n  status: betting_market_group_status\n});\n\nvar betting_market = new Serializer('betting_market', {\n  id: protocol_id_type('betting_market'),\n  group_id: protocol_id_type('betting_market_group'),\n  description: map(string, string),\n  payout_condition: map(string, string),\n  status: betting_market_status\n});\n\nvar bet = new Serializer('bet', {\n  id: protocol_id_type('bet'),\n  bettor_id: protocol_id_type('account'),\n  betting_market_id: protocol_id_type('betting_market'),\n  amount_to_bet: asset,\n  backer_multiplier: uint32,\n  back_or_lay: bet_type\n});\n\nvar betting_market_position = new Serializer('betting_market_position', {\n  id: implementation_id_type('betting_market_position'),\n  bettor_id: protocol_id_type('account'),\n  betting_market_id: protocol_id_type('betting_market'),\n  pay_if_payout_condition: int64,\n  pay_if_not_payout_condition: int64,\n  pay_if_canceled: int64,\n  pay_if_not_canceled: int64,\n  fees_collected: int64\n});\n\nvar global_betting_statistics = new Serializer('global_betting_statistics', {\n  id: implementation_id_type('global_betting_statistics'),\n  number_of_active_events: uint32,\n  total_amount_staked: map(protocol_id_type('asset'), int64)\n});\n\n// eof Betting Objects\n\n// Custom Types\n\nvar stealth_memo_data = new Serializer('stealth_memo_data', {\n  from: optional(public_key),\n  amount: asset,\n  blinding_factor: bytes(32),\n  commitment: bytes(33),\n  check: uint32\n});\n// var stealth_confirmation = new Serializer(\n//     \"stealth_confirmation\", {\n//     one_time_key: public_key,\n//     to: optional( public_key ),\n//     encrypted_memo: stealth_memo_data\n// })\n\nexports.operation = operation;\nexports.transfer_operation_fee_parameters = transfer_operation_fee_parameters;\nexports.limit_order_create_operation_fee_parameters = limit_order_create_operation_fee_parameters;\nexports.limit_order_cancel_operation_fee_parameters = limit_order_cancel_operation_fee_parameters;\nexports.call_order_update_operation_fee_parameters = call_order_update_operation_fee_parameters;\nexports.fill_order_operation_fee_parameters = fill_order_operation_fee_parameters;\nexports.account_create_operation_fee_parameters = account_create_operation_fee_parameters;\nexports.account_update_operation_fee_parameters = account_update_operation_fee_parameters;\nexports.account_whitelist_operation_fee_parameters = account_whitelist_operation_fee_parameters;\nexports.account_upgrade_operation_fee_parameters = account_upgrade_operation_fee_parameters;\nexports.account_transfer_operation_fee_parameters = account_transfer_operation_fee_parameters;\nexports.asset_create_operation_fee_parameters = asset_create_operation_fee_parameters;\nexports.asset_update_operation_fee_parameters = asset_update_operation_fee_parameters;\nexports.asset_update_bitasset_operation_fee_parameters = asset_update_bitasset_operation_fee_parameters;\nexports.asset_update_feed_producers_operation_fee_parameters = asset_update_feed_producers_operation_fee_parameters;\nexports.asset_issue_operation_fee_parameters = asset_issue_operation_fee_parameters;\nexports.asset_reserve_operation_fee_parameters = asset_reserve_operation_fee_parameters;\nexports.asset_fund_fee_pool_operation_fee_parameters = asset_fund_fee_pool_operation_fee_parameters;\nexports.asset_settle_operation_fee_parameters = asset_settle_operation_fee_parameters;\nexports.asset_global_settle_operation_fee_parameters = asset_global_settle_operation_fee_parameters;\nexports.asset_publish_feed_operation_fee_parameters = asset_publish_feed_operation_fee_parameters;\nexports.witness_create_operation_fee_parameters = witness_create_operation_fee_parameters;\nexports.witness_update_operation_fee_parameters = witness_update_operation_fee_parameters;\nexports.proposal_create_operation_fee_parameters = proposal_create_operation_fee_parameters;\nexports.proposal_update_operation_fee_parameters = proposal_update_operation_fee_parameters;\nexports.proposal_delete_operation_fee_parameters = proposal_delete_operation_fee_parameters;\nexports.withdraw_permission_create_operation_fee_parameters = withdraw_permission_create_operation_fee_parameters;\nexports.withdraw_permission_update_operation_fee_parameters = withdraw_permission_update_operation_fee_parameters;\nexports.withdraw_permission_claim_operation_fee_parameters = withdraw_permission_claim_operation_fee_parameters;\nexports.withdraw_permission_delete_operation_fee_parameters = withdraw_permission_delete_operation_fee_parameters;\nexports.committee_member_create_operation_fee_parameters = committee_member_create_operation_fee_parameters;\nexports.committee_member_update_operation_fee_parameters = committee_member_update_operation_fee_parameters;\nexports.committee_member_update_global_parameters_operation_fee_parameters = committee_member_update_global_parameters_operation_fee_parameters;\nexports.vesting_balance_create_operation_fee_parameters = vesting_balance_create_operation_fee_parameters;\nexports.vesting_balance_withdraw_operation_fee_parameters = vesting_balance_withdraw_operation_fee_parameters;\nexports.worker_create_operation_fee_parameters = worker_create_operation_fee_parameters;\nexports.custom_operation_fee_parameters = custom_operation_fee_parameters;\nexports.assert_operation_fee_parameters = assert_operation_fee_parameters;\nexports.balance_claim_operation_fee_parameters = balance_claim_operation_fee_parameters;\nexports.override_transfer_operation_fee_parameters = override_transfer_operation_fee_parameters;\nexports.transfer_to_blind_operation_fee_parameters = transfer_to_blind_operation_fee_parameters;\nexports.blind_transfer_operation_fee_parameters = blind_transfer_operation_fee_parameters;\nexports.transfer_from_blind_operation_fee_parameters = transfer_from_blind_operation_fee_parameters;\nexports.asset_settle_cancel_operation_fee_parameters = asset_settle_cancel_operation_fee_parameters;\nexports.asset_claim_fees_operation_fee_parameters = asset_claim_fees_operation_fee_parameters;\nexports.fba_distribute_operation_fee_parameters = fba_distribute_operation_fee_parameters;\nexports.asset_update_dividend_operation_fee_parameters = asset_update_dividend_operation_fee_parameters;\nexports.asset_dividend_distribution_operation_fee_parameters = asset_dividend_distribution_operation_fee_parameters;\nexports.sport_create_operation_fee_parameters = sport_create_operation_fee_parameters;\nexports.sport_update_operation_fee_parameters = sport_update_operation_fee_parameters;\nexports.event_group_create_operation_fee_parameters = event_group_create_operation_fee_parameters;\nexports.event_group_update_operation_fee_parameters = event_group_update_operation_fee_parameters;\nexports.event_create_operation_fee_parameters = event_create_operation_fee_parameters;\nexports.event_update_operation_fee_parameters = event_update_operation_fee_parameters;\nexports.betting_market_rules_create_operation_fee_parameters = betting_market_rules_create_operation_fee_parameters;\nexports.betting_market_rules_update_operation_fee_parameters = betting_market_rules_update_operation_fee_parameters;\nexports.betting_market_group_create_operation_fee_parameters = betting_market_group_create_operation_fee_parameters;\nexports.betting_market_create_operation_fee_parameters = betting_market_create_operation_fee_parameters;\nexports.bet_place_operation_fee_parameters = bet_place_operation_fee_parameters;\nexports.betting_market_group_resolve_operation_fee_parameters = betting_market_group_resolve_operation_fee_parameters;\nexports.betting_market_group_resolved_operation_fee_parameters = betting_market_group_resolved_operation_fee_parameters;\nexports.betting_market_group_cancel_unmatched_bets_operation_fee_parameters = betting_market_group_cancel_unmatched_bets_operation_fee_parameters;\nexports.bet_matched_operation_fee_parameters = bet_matched_operation_fee_parameters;\nexports.bet_cancel_operation_fee_parameters = bet_cancel_operation_fee_parameters;\nexports.bet_canceled_operation_fee_parameters = bet_canceled_operation_fee_parameters;\nexports.tournament_create_operation_fee_parameters = tournament_create_operation_fee_parameters;\nexports.tournament_join_operation_fee_parameters = tournament_join_operation_fee_parameters;\nexports.game_move_operation_fee_parameters = game_move_operation_fee_parameters;\nexports.tournament_payout_operation_fee_parameters = tournament_payout_operation_fee_parameters;\nexports.tournament_leave_operation_fee_parameters = tournament_leave_operation_fee_parameters;\nexports.betting_market_group_update_operation_fee_parameters = betting_market_group_update_operation_fee_parameters;\nexports.betting_market_update_operation_fee_parameters = betting_market_update_operation_fee_parameters;\nexports.bet_adjusted_operation_fee_parameters = bet_adjusted_operation_fee_parameters;\nexports.fee_schedule = fee_schedule;\nexports.void_result = void_result;\nexports.asset = asset;\nexports.processed_transaction = processed_transaction;\nexports.signed_block = signed_block;\nexports.block_header = block_header;\nexports.signed_block_header = signed_block_header;\nexports.memo_data = memo_data;\nexports.transfer = transfer;\nexports.limit_order_create = limit_order_create;\nexports.limit_order_cancel = limit_order_cancel;\nexports.call_order_update = call_order_update;\nexports.fill_order = fill_order;\nexports.authority = authority;\nexports.account_options = account_options;\nexports.account_create = account_create;\nexports.account_update = account_update;\nexports.account_whitelist = account_whitelist;\nexports.account_upgrade = account_upgrade;\nexports.account_transfer = account_transfer;\nexports.price = price;\nexports.asset_options = asset_options;\nexports.bitasset_options = bitasset_options;\nexports.asset_create = asset_create;\nexports.asset_update = asset_update;\nexports.asset_update_bitasset = asset_update_bitasset;\nexports.asset_update_feed_producers = asset_update_feed_producers;\nexports.asset_issue = asset_issue;\nexports.asset_reserve = asset_reserve;\nexports.asset_fund_fee_pool = asset_fund_fee_pool;\nexports.asset_settle = asset_settle;\nexports.asset_global_settle = asset_global_settle;\nexports.price_feed = price_feed;\nexports.asset_publish_feed = asset_publish_feed;\nexports.witness_create = witness_create;\nexports.witness_update = witness_update;\nexports.op_wrapper = op_wrapper;\nexports.proposal_create = proposal_create;\nexports.proposal_update = proposal_update;\nexports.proposal_delete = proposal_delete;\nexports.withdraw_permission_create = withdraw_permission_create;\nexports.withdraw_permission_update = withdraw_permission_update;\nexports.withdraw_permission_claim = withdraw_permission_claim;\nexports.withdraw_permission_delete = withdraw_permission_delete;\nexports.committee_member_create = committee_member_create;\nexports.committee_member_update = committee_member_update;\nexports.chain_parameters = chain_parameters;\nexports.committee_member_update_global_parameters = committee_member_update_global_parameters;\nexports.linear_vesting_policy_initializer = linear_vesting_policy_initializer;\nexports.cdd_vesting_policy_initializer = cdd_vesting_policy_initializer;\nexports.vesting_balance_create = vesting_balance_create;\nexports.vesting_balance_withdraw = vesting_balance_withdraw;\nexports.refund_worker_initializer = refund_worker_initializer;\nexports.vesting_balance_worker_initializer = vesting_balance_worker_initializer;\nexports.burn_worker_initializer = burn_worker_initializer;\nexports.worker_create = worker_create;\nexports.custom = custom;\nexports.account_name_eq_lit_predicate = account_name_eq_lit_predicate;\nexports.asset_symbol_eq_lit_predicate = asset_symbol_eq_lit_predicate;\nexports.block_id_predicate = block_id_predicate;\nexports.assert = assert;\nexports.balance_claim = balance_claim;\nexports.override_transfer = override_transfer;\nexports.stealth_confirmation = stealth_confirmation;\nexports.blind_output = blind_output;\nexports.transfer_to_blind = transfer_to_blind;\nexports.blind_input = blind_input;\nexports.blind_transfer = blind_transfer;\nexports.transfer_from_blind = transfer_from_blind;\nexports.asset_settle_cancel = asset_settle_cancel;\nexports.asset_claim_fees = asset_claim_fees;\nexports.fba_distribute = fba_distribute;\nexports.rock_paper_scissors_game_options = rock_paper_scissors_game_options;\nexports.tournament_options = tournament_options;\nexports.tournament_create = tournament_create;\nexports.tournament_join = tournament_join;\nexports.rock_paper_scissors_gesture = rock_paper_scissors_gesture;\nexports.rock_paper_scissors_throw_commit = rock_paper_scissors_throw_commit;\nexports.rock_paper_scissors_throw_reveal = rock_paper_scissors_throw_reveal;\nexports.game_move = game_move;\nexports.dividend_asset_options = dividend_asset_options;\nexports.asset_update_dividend = asset_update_dividend;\nexports.asset_dividend_distribution = asset_dividend_distribution;\nexports.sport_create = sport_create;\nexports.sport_update = sport_update;\nexports.event_group_create = event_group_create;\nexports.event_group_update = event_group_update;\nexports.event_create = event_create;\nexports.event_update = event_update;\nexports.betting_market_rules_create = betting_market_rules_create;\nexports.betting_market_rules_update = betting_market_rules_update;\nexports.betting_market_group_create = betting_market_group_create;\nexports.betting_market_create = betting_market_create;\nexports.bet_type = bet_type;\nexports.bet_place = bet_place;\nexports.betting_market_resolution_type = betting_market_resolution_type;\nexports.betting_market_group_resolve = betting_market_group_resolve;\nexports.betting_market_group_resolved = betting_market_group_resolved;\nexports.betting_market_group_cancel_unmatched_bets = betting_market_group_cancel_unmatched_bets;\nexports.bet_matched = bet_matched;\nexports.bet_cancel = bet_cancel;\nexports.bet_canceled = bet_canceled;\nexports.payout_type = payout_type;\nexports.tournament_payout = tournament_payout;\nexports.tournament_leave = tournament_leave;\nexports.betting_market_group_update = betting_market_group_update;\nexports.betting_market_update = betting_market_update;\nexports.bet_adjusted = bet_adjusted;\nexports.transaction = transaction;\nexports.signed_transaction = signed_transaction;\nexports.sport = sport;\nexports.event_group = event_group;\nexports.event = event;\nexports.betting_market_rules = betting_market_rules;\nexports.betting_market_group = betting_market_group;\nexports.betting_market = betting_market;\nexports.bet = bet;\nexports.betting_market_position = betting_market_position;\nexports.global_betting_statistics = global_betting_statistics;\nexports.stealth_memo_data = stealth_memo_data;","'use strict';\n\nexports.__esModule = true;\n\nvar _bytebuffer = require('bytebuffer');\n\nvar _bytebuffer2 = _interopRequireDefault(_bytebuffer);\n\nvar _error_with_cause = require('./error_with_cause');\n\nvar _error_with_cause2 = _interopRequireDefault(_error_with_cause);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump;\n\nvar Serializer = function () {\n  function Serializer(operation_name, types) {\n    _classCallCheck(this, Serializer);\n\n    this.operation_name = operation_name;\n    this.types = types;\n\n    if (this.types) {\n      this.keys = Object.keys(this.types);\n    }\n\n    Serializer.printDebug = true;\n  }\n\n  Serializer.prototype.fromByteBuffer = function fromByteBuffer(b) {\n    var object = {};\n    var field = null;\n\n    try {\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n\n        try {\n          if (HEX_DUMP) {\n            if (type.operation_name) {\n              console.error(type.operation_name);\n            } else {\n              var o1 = b.offset;\n              type.fromByteBuffer(b);\n              var o2 = b.offset;\n              b.offset = o1;\n              // b.reset()\n              var _b = b.copy(o1, o2);\n              console.error(this.operation_name + '.' + field + '\\t', _b.toHex());\n            }\n          }\n\n          object[field] = type.fromByteBuffer(b);\n        } catch (e) {\n          if (Serializer.printDebug) {\n            console.error('Error reading ' + this.operation_name + '.' + field + ' in data:');\n            b.printDebug();\n          }\n\n          throw e;\n        }\n      }\n    } catch (error) {\n      _error_with_cause2.default.throw(this.operation_name + '.' + field, error);\n    }\n\n    return object;\n  };\n\n  Serializer.prototype.appendByteBuffer = function appendByteBuffer(b, object) {\n    var field = null;\n\n    try {\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n        type.appendByteBuffer(b, object[field]);\n      }\n    } catch (error) {\n      try {\n        _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + JSON.stringify(object[field]), error);\n      } catch (e) {\n        // circular ref\n        _error_with_cause2.default.throw(this.operation_name + '.' + field + ' = ' + object[field], error);\n      }\n    }\n  };\n\n  Serializer.prototype.fromObject = function fromObject(serialized_object) {\n    var result = {};\n    var field = null;\n\n    try {\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n        var value = serialized_object[field];\n        // DEBUG value = value.resolve if value.resolve\n        // DEBUG console.log('... value',field,value)\n        var object = type.fromObject(value);\n        result[field] = object;\n      }\n    } catch (error) {\n      _error_with_cause2.default.throw(this.operation_name + '.' + field, error);\n    }\n\n    return result;\n  };\n\n  /**\n        @arg {boolean} [debug.use_default = false] - more template friendly\n        @arg {boolean} [debug.annotate = false] - add user-friendly information\n    */\n\n\n  Serializer.prototype.toObject = function toObject() {\n    var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false };\n\n    var result = {};\n    var field = null;\n\n    try {\n      if (!this.types) {\n        return result;\n      }\n\n      var iterable = this.keys;\n\n      for (var i = 0; i < iterable.length; i++) {\n        field = iterable[i];\n        var type = this.types[field];\n        var object = type.toObject(typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined, debug);\n        result[field] = object;\n\n        if (HEX_DUMP) {\n          var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN);\n          type.appendByteBuffer(b, typeof serialized_object !== 'undefined' && serialized_object !== null ? serialized_object[field] : undefined);\n          b = b.copy(0, b.offset);\n          console.error(this.operation_name + '.' + field, b.toHex());\n        }\n      }\n    } catch (error) {\n      _error_with_cause2.default.throw(this.operation_name + '.' + field, error);\n    }\n\n    return result;\n  };\n\n  /** Sort by the first element in a operation */\n\n\n  Serializer.prototype.compare = function compare(a, b) {\n    var first_key = this.keys[0];\n    var first_type = this.types[first_key];\n\n    var valA = a[first_key];\n    var valB = b[first_key];\n\n    if (first_type.compare) {\n      return first_type.compare(valA, valB);\n    }\n\n    if (typeof valA === 'number' && typeof valB === 'number') {\n      return valA - valB;\n    }\n\n    var encoding = void 0;\n\n    if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) {\n      // A binary string compare does not work.  If localeCompare is well supported that could\n      // replace HEX.  Performanance is very good so comparing HEX works.\n      encoding = 'hex';\n    }\n\n    var strA = valA.toString(encoding);\n    var strB = valB.toString(encoding);\n\n    var result = 0;\n\n    if (strA > strB) {\n      result = 1;\n    }\n\n    if (strA < strB) {\n      result = -1;\n    }\n\n    return result;\n  };\n\n  // <helper_functions>\n\n  Serializer.prototype.fromHex = function fromHex(hex) {\n    var b = _bytebuffer2.default.fromHex(hex, _bytebuffer2.default.LITTLE_ENDIAN);\n    return this.fromByteBuffer(b);\n  };\n\n  Serializer.prototype.fromBuffer = function fromBuffer(buffer) {\n    var b = _bytebuffer2.default.fromBinary(buffer.toString('binary'), _bytebuffer2.default.LITTLE_ENDIAN);\n    return this.fromByteBuffer(b);\n  };\n\n  Serializer.prototype.toHex = function toHex(object) {\n    // return this.toBuffer(object).toString(\"hex\")\n    var b = this.toByteBuffer(object);\n    return b.toHex();\n  };\n\n  Serializer.prototype.toByteBuffer = function toByteBuffer(object) {\n    var b = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN);\n    this.appendByteBuffer(b, object);\n    return b.copy(0, b.offset);\n  };\n\n  Serializer.prototype.toBuffer = function toBuffer(object) {\n    return Buffer.from(this.toByteBuffer(object).toBinary(), 'binary');\n  };\n\n  return Serializer;\n}();\n\nexports.default = Serializer;\nmodule.exports = exports['default'];","\"use strict\";\n\nexports.__esModule = true;\nexports.default = template;\n/** Console print any transaction object with zero default values. */\nfunction template(op) {\n  var object = op.toObject(undefined, { use_default: true, annotate: true });\n\n  // visual (with descriptions)\n  console.error(JSON.stringify(object, null, 4));\n\n  // usable in a copy-paste\n\n  object = op.toObject(undefined, { use_default: true, annotate: false });\n\n  // copy-paste one-lineer\n  console.error(JSON.stringify(object));\n}\nmodule.exports = exports[\"default\"];","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; // Low-level types that make up operations\n\nvar _peerplaysjsWs = require('peerplaysjs-ws');\n\nvar _SerializerValidation = require('./SerializerValidation');\n\nvar _SerializerValidation2 = _interopRequireDefault(_SerializerValidation);\n\nvar _FastParser = require('./FastParser');\n\nvar _FastParser2 = _interopRequireDefault(_FastParser);\n\nvar _ChainTypes = require('../../chain/src/ChainTypes');\n\nvar _ChainTypes2 = _interopRequireDefault(_ChainTypes);\n\nvar _ObjectId = require('../../chain/src/ObjectId');\n\nvar _ObjectId2 = _interopRequireDefault(_ObjectId);\n\nvar _ecc = require('../../ecc');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar MIN_SIGNED_32 = -1 * Math.pow(2, 31);\nvar MAX_SIGNED_32 = Math.pow(2, 31) - 1;\n\nvar HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump;\n\nvar strCmp = function strCmp(a, b) {\n  var result = 0;\n\n  if (a > b) {\n    result = 1;\n  }\n\n  if (a < b) {\n    result = -1;\n  }\n\n  return result;\n};\n\nvar firstEl = function firstEl(el) {\n  return Array.isArray(el) ? el[0] : el;\n};\n\nvar sortOperation = function sortOperation(array, st_operation) {\n  if (!st_operation.nosort) {\n    // If the operation has its own compare function.\n    if (st_operation.compare) {\n      return array.sort(function (a, b) {\n        return st_operation.compare(firstEl(a), firstEl(b));\n      });\n    }\n\n    return array.sort(function (a, b) {\n      var aFirst = firstEl(a);\n      var bFirst = firstEl(b);\n\n      // If both of the first elements are numbers.\n      if (typeof aFirst === 'number' && typeof bFirst === 'number') {\n        return aFirst - bFirst;\n      }\n\n      // If they are both buffers.\n      if (Buffer.isBuffer(aFirst) && Buffer.isBuffer(bFirst)) {\n        return strCmp(aFirst.toString('hex'), bFirst.toString('hex'));\n      }\n\n      // Otherwise\n      return strCmp(aFirst.toString(), bFirst.toString());\n    });\n  }\n\n  return array;\n};\n\nvar Types = {};\n\nTypes.uint8 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint8();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object);\n    b.writeUint8(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(0, 0xff, object, 'uint8 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.uint16 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint16();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object);\n    b.writeUint16(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(0, 0xffff, object, 'uint16 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.uint32 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint32();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object);\n    b.writeUint32(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(0, 0xffffffff, object, 'uint32 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.varint32 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readVarint32();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n    b.writeVarint32(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n    return object;\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return 0;\n    }\n\n    _SerializerValidation2.default.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n    return parseInt(object, 10);\n  }\n};\n\nTypes.int64 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readInt64();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n    b.writeInt64(_SerializerValidation2.default.to_long(object));\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n    return _SerializerValidation2.default.to_long(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0';\n    }\n\n    _SerializerValidation2.default.required(object);\n    return _SerializerValidation2.default.to_long(object).toString();\n  }\n};\n\nTypes.uint64 = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint64();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    b.writeUint64(_SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object)));\n  },\n  fromObject: function fromObject(object) {\n    return _SerializerValidation2.default.to_ulong(_SerializerValidation2.default.unsigned(object));\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0';\n    }\n\n    return _SerializerValidation2.default.to_ulong(object).toString();\n  }\n};\n\nTypes.string = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    var b_copy = void 0;\n    var len = b.readVarint32();\n    b_copy = b.copy(b.offset, b.offset + len);\n    b.skip(len);\n    return Buffer.from(b_copy.toBinary(), 'binary');\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n    b.writeVarint32(object.length);\n    b.append(object.toString('binary'), 'binary');\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n    return Buffer.from(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '';\n    }\n\n    return object.toString();\n  }\n};\n\nTypes.bytes = function (size) {\n  var bytes = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      if (size === undefined) {\n        var _b_copy = void 0;\n        var len = b.readVarint32();\n        _b_copy = b.copy(b.offset, b.offset + len);\n        b.skip(len);\n        return Buffer.from(_b_copy.toBinary(), 'binary');\n      }\n\n      var b_copy = b.copy(b.offset, b.offset + size);\n      b.skip(size);\n      return Buffer.from(b_copy.toBinary(), 'binary');\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n\n      if (typeof object === 'string') {\n        object = Buffer.from(object, 'hex');\n      }\n\n      if (size === undefined) {\n        b.writeVarint32(object.length);\n      }\n\n      b.append(object.toString('binary'), 'binary');\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n\n      if (Buffer.isBuffer(object)) {\n        return object;\n      }\n\n      return Buffer.from(object, 'hex');\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return new Array(size).join('00');\n      }\n\n      _SerializerValidation2.default.required(object);\n      return object.toString('hex');\n    }\n  };\n\n  return bytes;\n};\n\nTypes.bool = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint8() === 1;\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    // supports boolean or integer\n    b.writeUint8(JSON.parse(object) ? 1 : 0);\n  },\n  fromObject: function fromObject(object) {\n    return !!JSON.parse(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return false;\n    }\n\n    return !!JSON.parse(object);\n  }\n};\n\nTypes.void = {\n  fromByteBuffer: function fromByteBuffer() {\n    throw new Error('(void) undefined type');\n  },\n  appendByteBuffer: function appendByteBuffer() {\n    throw new Error('(void) undefined type');\n  },\n  fromObject: function fromObject() {\n    throw new Error('(void) undefined type');\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return undefined;\n    }\n\n    throw new Error('(void) undefined type');\n  }\n};\n\nTypes.array = function (st_operation) {\n  var array = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      var size = b.readVarint32();\n\n      if (HEX_DUMP) {\n        console.log('varint32 size = ' + size.toString(16));\n      }\n\n      var result = [];\n\n      for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) {\n        result.push(st_operation.fromByteBuffer(b));\n      }\n\n      return sortOperation(result, st_operation);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n      object = sortOperation(object, st_operation);\n      b.writeVarint32(object.length);\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        st_operation.appendByteBuffer(b, o);\n      }\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n      object = sortOperation(object, st_operation);\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push(st_operation.fromObject(o));\n      }\n\n      return result;\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [st_operation.toObject(object, debug)];\n      }\n\n      _SerializerValidation2.default.required(object);\n      object = sortOperation(object, st_operation);\n\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push(st_operation.toObject(o, debug));\n      }\n\n      return result;\n    }\n  };\n\n  return array;\n};\n\nTypes.time_point_sec = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return b.readUint32();\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    if (typeof object !== 'number') {\n      object = Types.time_point_sec.fromObject(object);\n    }\n\n    b.writeUint32(object);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (typeof object === 'number') {\n      return object;\n    }\n\n    if (object.getTime) {\n      return Math.floor(object.getTime() / 1000);\n    }\n\n    if (typeof object !== 'string') {\n      throw new Error('Unknown date type: ' + object);\n    }\n\n    // if(typeof object === \"string\" && !/Z$/.test(object))\n    //     object = object + \"Z\"\n\n    return Math.floor(new Date(object).getTime() / 1000);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return new Date(0).toISOString().split('.')[0];\n    }\n\n    _SerializerValidation2.default.required(object);\n\n    if (typeof object === 'string') {\n      return object;\n    }\n\n    if (object.getTime) {\n      return object.toISOString().split('.')[0];\n    }\n\n    var int = parseInt(object, 10);\n    _SerializerValidation2.default.require_range(0, 0xffffffff, int, 'uint32 ' + object);\n    return new Date(int * 1000).toISOString().split('.')[0];\n  }\n};\n\nTypes.set = function (st_operation) {\n  var set_object = {\n    validate: function validate(array) {\n      var dup_map = {};\n\n      for (var i = 0, len = array.length; i < len; i++) {\n        var o = array[i];\n        var ref = typeof o === 'undefined' ? 'undefined' : _typeof(o);\n\n        if (['string', 'number'].indexOf(ref) >= 0) {\n          if (dup_map[o] !== undefined) {\n            throw new Error('duplicate (set)');\n          }\n\n          dup_map[o] = true;\n        }\n      }\n\n      return sortOperation(array, st_operation);\n    },\n    fromByteBuffer: function fromByteBuffer(b) {\n      var size = b.readVarint32();\n\n      if (HEX_DUMP) {\n        console.log('varint32 size = ' + size.toString(16));\n      }\n\n      return this.validate(function () {\n        var result = [];\n\n        for (var i = 0; size > 0 ? i < size : i > size; size > 0 ? i++ : i++) {\n          result.push(st_operation.fromByteBuffer(b));\n        }\n\n        return result;\n      }());\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      if (!object) {\n        object = [];\n      }\n\n      b.writeVarint32(object.length);\n      var iterable = this.validate(object);\n\n      for (var i = 0, len = iterable.length; i < len; i++) {\n        var o = iterable[i];\n        st_operation.appendByteBuffer(b, o);\n      }\n    },\n    fromObject: function fromObject(object) {\n      if (!object) {\n        object = [];\n      }\n\n      return this.validate(function () {\n        var result = [];\n\n        for (var i = 0, len = object.length; i < len; i++) {\n          var o = object[i];\n          result.push(st_operation.fromObject(o));\n        }\n\n        return result;\n      }());\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [st_operation.toObject(object, debug)];\n      }\n\n      if (!object) {\n        object = [];\n      }\n\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push(st_operation.toObject(o, debug));\n      }\n\n      return this.validate(result);\n    }\n  };\n\n  return set_object;\n};\n\nTypes.fixed_array = function (count, st_operation) {\n  var fixed_array = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      var results = [];\n\n      for (var i = 0, ref = count; i < ref; i++) {\n        results.push(st_operation.fromByteBuffer(b));\n      }\n\n      return sortOperation(results, st_operation);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      if (count !== 0) {\n        _SerializerValidation2.default.required(object);\n        object = sortOperation(object, st_operation);\n      }\n\n      for (var i = 0, ref = count; i < ref; i++) {\n        st_operation.appendByteBuffer(b, object[i]);\n      }\n    },\n    fromObject: function fromObject(object) {\n      if (count !== 0) {\n        _SerializerValidation2.default.required(object);\n      }\n\n      var results = [];\n\n      for (var i = 0, ref = count; i < ref; i++) {\n        results.push(st_operation.fromObject(object[i]));\n      }\n\n      return results;\n    },\n    toObject: function toObject(object, debug) {\n      if (debug == null) {\n        debug = {};\n      }\n\n      var results = void 0;\n\n      if (debug.use_default && object === undefined) {\n        results = [];\n\n        for (var i = 0, ref = count; i < ref; i++) {\n          results.push(st_operation.toObject(undefined, debug));\n        }\n\n        return results;\n      }\n\n      if (count !== 0) {\n        _SerializerValidation2.default.required(object);\n      }\n\n      results = [];\n\n      for (var _i = 0, _ref = count; _i < _ref; _i++) {\n        results.push(st_operation.toObject(object[_i], debug));\n      }\n\n      return results;\n    }\n  };\n\n  return fixed_array;\n};\n\n/* Supports instance numbers (11) or object types (1.2.11).  Object type\nValidation is enforced when an object type is used. */\nTypes.id_type = function (reserved_spaces, object_type) {\n  _SerializerValidation2.default.required(reserved_spaces, 'reserved_spaces');\n  _SerializerValidation2.default.required(object_type, 'object_type');\n\n  var id_type_object = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      return b.readVarint32();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n\n      if (object.resolve !== undefined) {\n        object = object.resolve;\n      }\n\n      // convert 1.2.n into just n\n      if (/^[0-9]+\\.[0-9]+\\.[0-9]+$/.test(object)) {\n        object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object);\n      }\n\n      b.writeVarint32(_SerializerValidation2.default.to_number(object));\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n\n      if (object.resolve !== undefined) {\n        object = object.resolve;\n      }\n\n      if (_SerializerValidation2.default.is_digits(object)) {\n        return _SerializerValidation2.default.to_number(object);\n      }\n\n      return _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object);\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      var object_type_id = _ChainTypes2.default.object_type[object_type];\n\n      if (debug.use_default && object === undefined) {\n        return reserved_spaces + '.' + object_type_id + '.0';\n      }\n\n      _SerializerValidation2.default.required(object);\n\n      if (object.resolve !== undefined) {\n        object = object.resolve;\n      }\n\n      if (/^[0-9]+\\.[0-9]+\\.[0-9]+$/.test(object)) {\n        object = _SerializerValidation2.default.get_instance(reserved_spaces, object_type, object);\n      }\n\n      return reserved_spaces + '.' + object_type_id + '.' + object;\n    }\n  };\n\n  return id_type_object;\n};\n\nTypes.protocol_id_type = function (name) {\n  _SerializerValidation2.default.required(name, 'name');\n  return Types.id_type(_ChainTypes2.default.reserved_spaces.protocol_ids, name);\n};\n\nTypes.implementation_id_type = function (name) {\n  var result = Types.id_type(_ChainTypes2.default.reserved_spaces.implementation_ids, name);\n  return result;\n};\n\nTypes.object_id_type = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    return _ObjectId2.default.fromByteBuffer(b);\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    object = _ObjectId2.default.fromString(object);\n    object.appendByteBuffer(b);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    return _ObjectId2.default.fromString(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0.0.0';\n    }\n\n    _SerializerValidation2.default.required(object);\n\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    object = _ObjectId2.default.fromString(object);\n    return object.toString();\n  }\n};\n\nTypes.vote_id = {\n  TYPE: 0x000000ff,\n  ID: 0xffffff00,\n  fromByteBuffer: function fromByteBuffer(b) {\n    var value = b.readUint32();\n    return {\n      type: value & this.TYPE, // eslint-disable-line\n      id: value & this.ID // eslint-disable-line\n    };\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object === 'string') {\n      object = Types.vote_id.fromObject(object);\n    }\n\n    var value = object.id << 8 | object.type; // eslint-disable-line\n    b.writeUint32(value);\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object, '(type vote_id)');\n\n    if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object') {\n      _SerializerValidation2.default.required(object.type, 'type');\n      _SerializerValidation2.default.required(object.id, 'id');\n      return object;\n    }\n\n    _SerializerValidation2.default.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object);\n\n    var _object$split = object.split(':'),\n        type = _object$split[0],\n        id = _object$split[1];\n\n    _SerializerValidation2.default.require_range(0, 0xff, type, 'vote type ' + object);\n    _SerializerValidation2.default.require_range(0, 0xffffff, id, 'vote id ' + object);\n    return { type: type, id: id };\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return '0:0';\n    }\n\n    _SerializerValidation2.default.required(object);\n\n    if (typeof object === 'string') {\n      object = Types.vote_id.fromObject(object);\n    }\n\n    return object.type + ':' + object.id;\n  },\n  compare: function compare(a, b) {\n    if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== 'object') {\n      a = Types.vote_id.fromObject(a);\n    }\n\n    if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== 'object') {\n      b = Types.vote_id.fromObject(b);\n    }\n\n    return parseInt(a.id, 10) - parseInt(b.id, 10);\n  }\n};\n\nTypes.optional = function (st_operation) {\n  _SerializerValidation2.default.required(st_operation, 'st_operation');\n  return {\n    fromByteBuffer: function fromByteBuffer(b) {\n      if (!(b.readUint8() === 1)) {\n        return undefined;\n      }\n\n      return st_operation.fromByteBuffer(b);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      if (object !== null && object !== undefined) {\n        b.writeUint8(1);\n        st_operation.appendByteBuffer(b, object);\n      } else {\n        b.writeUint8(0);\n      }\n    },\n    fromObject: function fromObject(object) {\n      if (object === undefined) {\n        return undefined;\n      }\n\n      return st_operation.fromObject(object);\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      // toObject is only null save if use_default is true\n      var result_object = function () {\n        if (!debug.use_default && object === undefined) {\n          return undefined;\n        }\n\n        return st_operation.toObject(object, debug);\n      }();\n\n      if (debug.annotate) {\n        if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === 'object') {\n          result_object.__optional = 'parent is optional';\n        } else {\n          result_object = { __optional: result_object };\n        }\n      }\n\n      return result_object;\n    }\n  };\n};\n\nTypes.static_variant = function (_st_operations) {\n  var static_variant = {\n    nosort: true,\n    st_operations: _st_operations,\n    fromByteBuffer: function fromByteBuffer(b) {\n      var type_id = b.readVarint32();\n      var st_operation = this.st_operations[type_id];\n\n      if (HEX_DUMP) {\n        console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')');\n      }\n\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      return [type_id, st_operation.fromByteBuffer(b)];\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      _SerializerValidation2.default.required(object);\n      var type_id = object[0];\n      var st_operation = this.st_operations[type_id];\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      b.writeVarint32(type_id);\n      st_operation.appendByteBuffer(b, object[1]);\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n      var type_id = object[0];\n      var st_operation = this.st_operations[type_id];\n\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      return [type_id, st_operation.fromObject(object[1])];\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [0, this.st_operations[0].toObject(undefined, debug)];\n      }\n\n      _SerializerValidation2.default.required(object);\n      var type_id = object[0];\n      var st_operation = this.st_operations[type_id];\n      _SerializerValidation2.default.required(st_operation, 'operation ' + type_id);\n      return [type_id, st_operation.toObject(object[1], debug)];\n    }\n  };\n\n  return static_variant;\n};\n\nTypes.map = function (key_st_operation, value_st_operation) {\n  var map_object = {\n    validate: function validate(array) {\n      if (!Array.isArray(array)) {\n        throw new Error('expecting array');\n      }\n\n      var dup_map = {};\n\n      for (var i = 0, len = array.length; i < len; i++) {\n        var o = array[i];\n        var ref = void 0;\n\n        if (!(o.length === 2)) {\n          throw new Error('expecting two elements');\n        }\n\n        ref = _typeof(o[0]);\n\n        if (ref && ['number', 'string'].indexOf(ref) >= 0) {\n          if (dup_map[o[0]] !== undefined) {\n            throw new Error('duplicate (map)');\n          }\n\n          dup_map[o[0]] = true;\n        }\n      }\n\n      return sortOperation(array, key_st_operation);\n    },\n    fromByteBuffer: function fromByteBuffer(b) {\n      var result = [];\n      var end = b.readVarint32();\n\n      for (var i = 0; end > 0 ? i < end : i > end; end > 0 ? i++ : i++) {\n        result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]);\n      }\n\n      return this.validate(result);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      this.validate(object);\n      b.writeVarint32(object.length);\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        key_st_operation.appendByteBuffer(b, o[0]);\n        value_st_operation.appendByteBuffer(b, o[1]);\n      }\n    },\n    fromObject: function fromObject(object) {\n      _SerializerValidation2.default.required(object);\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]);\n      }\n\n      return this.validate(result);\n    },\n    toObject: function toObject(object) {\n      var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (debug.use_default && object === undefined) {\n        return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]];\n      }\n\n      _SerializerValidation2.default.required(object);\n      object = this.validate(object);\n      var result = [];\n\n      for (var i = 0, len = object.length; i < len; i++) {\n        var o = object[i];\n        result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]);\n      }\n\n      return result;\n    }\n  };\n\n  return map_object;\n};\n\nTypes.public_key = {\n  toPublic: function toPublic(object) {\n    if (object.resolve !== undefined) {\n      object = object.resolve;\n    }\n\n    if (object instanceof _ecc.PublicKey) {\n      return object;\n    }\n\n    var result = object;\n\n    if (!object) {\n      return null;\n    }\n\n    if (!object.Q) {\n      result = _ecc.PublicKey.fromStringOrThrow(object);\n    }\n\n    return result;\n  },\n  fromByteBuffer: function fromByteBuffer(b) {\n    return _FastParser2.default.public_key(b);\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _SerializerValidation2.default.required(object);\n    _FastParser2.default.public_key(b, Types.public_key.toPublic(object));\n  },\n  fromObject: function fromObject(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.Q) {\n      return object;\n    }\n\n    return Types.public_key.toPublic(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return _peerplaysjsWs.ChainConfig.address_prefix + '859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM';\n    }\n\n    _SerializerValidation2.default.required(object);\n    return object.toString();\n  },\n  compare: function compare(a, b) {\n    return strCmp(a.toAddressString(), b.toAddressString());\n  }\n};\n\nTypes.address = {\n  _to_address: function _to_address(object) {\n    _SerializerValidation2.default.required(object);\n\n    if (object.addy) {\n      return object;\n    }\n\n    return _ecc.Address.fromString(object);\n  },\n  fromByteBuffer: function fromByteBuffer(b) {\n    return new _ecc.Address(_FastParser2.default.ripemd160(b));\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    _FastParser2.default.ripemd160(b, Types.address._to_address(object).toBuffer());\n  },\n  fromObject: function fromObject(object) {\n    return Types.address._to_address(object);\n  },\n  toObject: function toObject(object) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (debug.use_default && object === undefined) {\n      return _peerplaysjsWs.ChainConfig.address_prefix + '664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S';\n    }\n\n    return Types.address._to_address(object).toString();\n  },\n  compare: function compare(a, b) {\n    return strCmp(a.toString(), b.toString());\n  }\n};\n\nTypes.variant = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    var type = b.readUint8();\n\n    switch (type) {\n      case 0:\n        return null;\n      case 1:\n        return Types.int64.fromByteBuffer(b);\n      case 2:\n        return Types.uint64.fromByteBuffer(b);\n      case 3:\n        return b.readDouble();\n      case 4:\n        return Types.bool.fromByteBuffer(b);\n      case 5:\n        return Types.string.fromByteBuffer(b);\n      case 6:\n        return Types.array(Types.variant).fromByteBuffer(b);\n      case 7:\n      default:\n        return Types.variant_object.fromByteBuffer(b);\n    }\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    if (typeof object === 'number') {\n      if (Number.isInteger(object)) {\n        if (object >= 0) {\n          b.writeUint8(2);\n          Types.uint64.appendByteBuffer(b, object);\n        } else {\n          b.writeUint8(1);\n          Types.int64.appendByteBuffer(b, object);\n        }\n      } else {\n        b.writeUint8(3);\n        b.writeDouble(Number.parseFloat(object));\n      }\n    } else if (typeof object === 'boolean') {\n      b.writeUint8(4);\n      Types.bool.appendByteBuffer(b, object);\n    } else if (typeof object === 'string') {\n      b.writeUint8(5);\n      Types.string.appendByteBuffer(b, object);\n    } else if (Array.isArray(object)) {\n      b.writeUint8(6);\n      Types.array(Types.variant).appendByteBuffer(b, object);\n    } else {\n      b.writeUint8(7);\n      Types.variant_object.appendByteBuffer(b, object);\n    }\n  },\n  fromObject: function fromObject(object) {\n    return JSON.parse(object);\n  },\n  toObject: function toObject(object) {\n    return JSON.parse(object);\n  }\n};\n\nTypes.variant_object = {\n  fromByteBuffer: function fromByteBuffer(b) {\n    var count = b.readVarint32();\n    var result = {};\n\n    for (var i = 0; i < count; ++i) {\n      var key = Types.string.fromByteBuffer(b);\n      result[key] = Types.variant.fromByteBuffer(b);\n    }\n\n    return result;\n  },\n  appendByteBuffer: function appendByteBuffer(b, object) {\n    var keys = Object.keys(object);\n\n    b.writeVarint32(keys.length); // number of key/value pairs\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var key = keys[i];\n      Types.string.appendByteBuffer(b, key);\n      Types.variant.appendByteBuffer(b, object[key]);\n    }\n  },\n  fromObject: function fromObject(object) {\n    var newObject = {};\n\n    var keys = Object.keys(object);\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var key = keys[i];\n      newObject[key] = object[key];\n    }\n\n    return newObject;\n  },\n  toObject: function toObject(object) {\n    var newObject = {};\n\n    var keys = Object.keys(object);\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n      var key = keys[i];\n      newObject[key] = object[key];\n    }\n\n    return newObject;\n  }\n};\n\nTypes.enumeration = function (values) {\n  var enumeration = {\n    fromByteBuffer: function fromByteBuffer(b) {\n      return values[b.readVarint32ZigZag()];\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n      b.writeVarint32ZigZag(values.indexOf(object));\n    },\n    fromObject: function fromObject(object) {\n      return object;\n    },\n    toObject: function toObject(object) {\n      return object;\n    }\n  };\n\n  return enumeration;\n};\n\nTypes.sha256 = Types.bytes(32);\n\nexports.default = Types;\nmodule.exports = exports['default'];","'use strict';\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","// base-x encoding\n// Forked from https://github.com/cryptocoinjs/bs58\n// Originally written by Mike Hearn for BitcoinJ\n// Copyright (c) 2011 Google Inc\n// Ported to JavaScript by Stefan Thomas\n// Merged Buffer refactorings from base58-native by Stephen Pair\n// Copyright (c) 2013 BitPay Inc\n\nmodule.exports = function base (ALPHABET) {\n  var ALPHABET_MAP = {}\n  var BASE = ALPHABET.length\n  var LEADER = ALPHABET.charAt(0)\n\n  // pre-compute lookup table\n  for (var i = 0; i < ALPHABET.length; i++) {\n    ALPHABET_MAP[ALPHABET.charAt(i)] = i\n  }\n\n  function encode (source) {\n    if (source.length === 0) return ''\n\n    var digits = [0]\n    for (var i = 0; i < source.length; ++i) {\n      for (var j = 0, carry = source[i]; j < digits.length; ++j) {\n        carry += digits[j] << 8\n        digits[j] = carry % BASE\n        carry = (carry / BASE) | 0\n      }\n\n      while (carry > 0) {\n        digits.push(carry % BASE)\n        carry = (carry / BASE) | 0\n      }\n    }\n\n    var string = ''\n\n    // deal with leading zeros\n    for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) string += ALPHABET[0]\n    // convert digits to a string\n    for (var q = digits.length - 1; q >= 0; --q) string += ALPHABET[digits[q]]\n\n    return string\n  }\n\n  function decodeUnsafe (string) {\n    if (string.length === 0) return []\n\n    var bytes = [0]\n    for (var i = 0; i < string.length; i++) {\n      var value = ALPHABET_MAP[string[i]]\n      if (value === undefined) return\n\n      for (var j = 0, carry = value; j < bytes.length; ++j) {\n        carry += bytes[j] * BASE\n        bytes[j] = carry & 0xff\n        carry >>= 8\n      }\n\n      while (carry > 0) {\n        bytes.push(carry & 0xff)\n        carry >>= 8\n      }\n    }\n\n    // deal with leading zeros\n    for (var k = 0; string[k] === LEADER && k < string.length - 1; ++k) {\n      bytes.push(0)\n    }\n\n    return bytes.reverse()\n  }\n\n  function decode (string) {\n    var array = decodeUnsafe(string)\n    if (array) return array\n\n    throw new Error('Non-base' + BASE + ' character')\n  }\n\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","// (public) Constructor\nfunction BigInteger(a, b, c) {\n  if (!(this instanceof BigInteger))\n    return new BigInteger(a, b, c)\n\n  if (a != null) {\n    if (\"number\" == typeof a) this.fromNumber(a, b, c)\n    else if (b == null && \"string\" != typeof a) this.fromString(a, 256)\n    else this.fromString(a, b)\n  }\n}\n\nvar proto = BigInteger.prototype\n\n// duck-typed isBigInteger\nproto.__bigi = require(33).version\nBigInteger.isBigInteger = function (obj, check_ver) {\n  return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi)\n}\n\n// Bits per digit\nvar dbits\n\n// am: Compute w_j += (x*this_i), propagate carries,\n// c is initial carry, returns final carry.\n// c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n// We need to select the fastest one that works in this environment.\n\n// am1: use a single mult and divide to get the high bits,\n// max digit bits should be 26 because\n// max internal value = 2*dvalue^2-2*dvalue (< 2^53)\nfunction am1(i, x, w, j, c, n) {\n  while (--n >= 0) {\n    var v = x * this[i++] + w[j] + c\n    c = Math.floor(v / 0x4000000)\n    w[j++] = v & 0x3ffffff\n  }\n  return c\n}\n// am2 avoids a big mult-and-extract completely.\n// Max digit bits should be <= 30 because we do bitwise ops\n// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\nfunction am2(i, x, w, j, c, n) {\n  var xl = x & 0x7fff,\n    xh = x >> 15\n  while (--n >= 0) {\n    var l = this[i] & 0x7fff\n    var h = this[i++] >> 15\n    var m = xh * l + h * xl\n    l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)\n    c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)\n    w[j++] = l & 0x3fffffff\n  }\n  return c\n}\n// Alternately, set max digit bits to 28 since some\n// browsers slow down when dealing with 32-bit numbers.\nfunction am3(i, x, w, j, c, n) {\n  var xl = x & 0x3fff,\n    xh = x >> 14\n  while (--n >= 0) {\n    var l = this[i] & 0x3fff\n    var h = this[i++] >> 14\n    var m = xh * l + h * xl\n    l = xl * l + ((m & 0x3fff) << 14) + w[j] + c\n    c = (l >> 28) + (m >> 14) + xh * h\n    w[j++] = l & 0xfffffff\n  }\n  return c\n}\n\n// wtf?\nBigInteger.prototype.am = am1\ndbits = 26\n\nBigInteger.prototype.DB = dbits\nBigInteger.prototype.DM = ((1 << dbits) - 1)\nvar DV = BigInteger.prototype.DV = (1 << dbits)\n\nvar BI_FP = 52\nBigInteger.prototype.FV = Math.pow(2, BI_FP)\nBigInteger.prototype.F1 = BI_FP - dbits\nBigInteger.prototype.F2 = 2 * dbits - BI_FP\n\n// Digit conversions\nvar BI_RM = \"0123456789abcdefghijklmnopqrstuvwxyz\"\nvar BI_RC = new Array()\nvar rr, vv\nrr = \"0\".charCodeAt(0)\nfor (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv\nrr = \"a\".charCodeAt(0)\nfor (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv\nrr = \"A\".charCodeAt(0)\nfor (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv\n\nfunction int2char(n) {\n  return BI_RM.charAt(n)\n}\n\nfunction intAt(s, i) {\n  var c = BI_RC[s.charCodeAt(i)]\n  return (c == null) ? -1 : c\n}\n\n// (protected) copy this to r\nfunction bnpCopyTo(r) {\n  for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]\n  r.t = this.t\n  r.s = this.s\n}\n\n// (protected) set from integer value x, -DV <= x < DV\nfunction bnpFromInt(x) {\n  this.t = 1\n  this.s = (x < 0) ? -1 : 0\n  if (x > 0) this[0] = x\n  else if (x < -1) this[0] = x + DV\n  else this.t = 0\n}\n\n// return bigint initialized to value\nfunction nbv(i) {\n  var r = new BigInteger()\n  r.fromInt(i)\n  return r\n}\n\n// (protected) set from string and radix\nfunction bnpFromString(s, b) {\n  var self = this\n\n  var k\n  if (b == 16) k = 4\n  else if (b == 8) k = 3\n  else if (b == 256) k = 8; // byte array\n  else if (b == 2) k = 1\n  else if (b == 32) k = 5\n  else if (b == 4) k = 2\n  else {\n    self.fromRadix(s, b)\n    return\n  }\n  self.t = 0\n  self.s = 0\n  var i = s.length,\n    mi = false,\n    sh = 0\n  while (--i >= 0) {\n    var x = (k == 8) ? s[i] & 0xff : intAt(s, i)\n    if (x < 0) {\n      if (s.charAt(i) == \"-\") mi = true\n      continue\n    }\n    mi = false\n    if (sh == 0)\n      self[self.t++] = x\n    else if (sh + k > self.DB) {\n      self[self.t - 1] |= (x & ((1 << (self.DB - sh)) - 1)) << sh\n      self[self.t++] = (x >> (self.DB - sh))\n    } else\n      self[self.t - 1] |= x << sh\n    sh += k\n    if (sh >= self.DB) sh -= self.DB\n  }\n  if (k == 8 && (s[0] & 0x80) != 0) {\n    self.s = -1\n    if (sh > 0) self[self.t - 1] |= ((1 << (self.DB - sh)) - 1) << sh\n  }\n  self.clamp()\n  if (mi) BigInteger.ZERO.subTo(self, self)\n}\n\n// (protected) clamp off excess high words\nfunction bnpClamp() {\n  var c = this.s & this.DM\n  while (this.t > 0 && this[this.t - 1] == c)--this.t\n}\n\n// (public) return string representation in given radix\nfunction bnToString(b) {\n  var self = this\n  if (self.s < 0) return \"-\" + self.negate()\n    .toString(b)\n  var k\n  if (b == 16) k = 4\n  else if (b == 8) k = 3\n  else if (b == 2) k = 1\n  else if (b == 32) k = 5\n  else if (b == 4) k = 2\n  else return self.toRadix(b)\n  var km = (1 << k) - 1,\n    d, m = false,\n    r = \"\",\n    i = self.t\n  var p = self.DB - (i * self.DB) % k\n  if (i-- > 0) {\n    if (p < self.DB && (d = self[i] >> p) > 0) {\n      m = true\n      r = int2char(d)\n    }\n    while (i >= 0) {\n      if (p < k) {\n        d = (self[i] & ((1 << p) - 1)) << (k - p)\n        d |= self[--i] >> (p += self.DB - k)\n      } else {\n        d = (self[i] >> (p -= k)) & km\n        if (p <= 0) {\n          p += self.DB\n          --i\n        }\n      }\n      if (d > 0) m = true\n      if (m) r += int2char(d)\n    }\n  }\n  return m ? r : \"0\"\n}\n\n// (public) -this\nfunction bnNegate() {\n  var r = new BigInteger()\n  BigInteger.ZERO.subTo(this, r)\n  return r\n}\n\n// (public) |this|\nfunction bnAbs() {\n  return (this.s < 0) ? this.negate() : this\n}\n\n// (public) return + if this > a, - if this < a, 0 if equal\nfunction bnCompareTo(a) {\n  var r = this.s - a.s\n  if (r != 0) return r\n  var i = this.t\n  r = i - a.t\n  if (r != 0) return (this.s < 0) ? -r : r\n  while (--i >= 0)\n    if ((r = this[i] - a[i]) != 0) return r\n  return 0\n}\n\n// returns bit length of the integer x\nfunction nbits(x) {\n  var r = 1,\n    t\n  if ((t = x >>> 16) != 0) {\n    x = t\n    r += 16\n  }\n  if ((t = x >> 8) != 0) {\n    x = t\n    r += 8\n  }\n  if ((t = x >> 4) != 0) {\n    x = t\n    r += 4\n  }\n  if ((t = x >> 2) != 0) {\n    x = t\n    r += 2\n  }\n  if ((t = x >> 1) != 0) {\n    x = t\n    r += 1\n  }\n  return r\n}\n\n// (public) return the number of bits in \"this\"\nfunction bnBitLength() {\n  if (this.t <= 0) return 0\n  return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))\n}\n\n// (public) return the number of bytes in \"this\"\nfunction bnByteLength() {\n  return this.bitLength() >> 3\n}\n\n// (protected) r = this << n*DB\nfunction bnpDLShiftTo(n, r) {\n  var i\n  for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]\n  for (i = n - 1; i >= 0; --i) r[i] = 0\n  r.t = this.t + n\n  r.s = this.s\n}\n\n// (protected) r = this >> n*DB\nfunction bnpDRShiftTo(n, r) {\n  for (var i = n; i < this.t; ++i) r[i - n] = this[i]\n  r.t = Math.max(this.t - n, 0)\n  r.s = this.s\n}\n\n// (protected) r = this << n\nfunction bnpLShiftTo(n, r) {\n  var self = this\n  var bs = n % self.DB\n  var cbs = self.DB - bs\n  var bm = (1 << cbs) - 1\n  var ds = Math.floor(n / self.DB),\n    c = (self.s << bs) & self.DM,\n    i\n  for (i = self.t - 1; i >= 0; --i) {\n    r[i + ds + 1] = (self[i] >> cbs) | c\n    c = (self[i] & bm) << bs\n  }\n  for (i = ds - 1; i >= 0; --i) r[i] = 0\n  r[ds] = c\n  r.t = self.t + ds + 1\n  r.s = self.s\n  r.clamp()\n}\n\n// (protected) r = this >> n\nfunction bnpRShiftTo(n, r) {\n  var self = this\n  r.s = self.s\n  var ds = Math.floor(n / self.DB)\n  if (ds >= self.t) {\n    r.t = 0\n    return\n  }\n  var bs = n % self.DB\n  var cbs = self.DB - bs\n  var bm = (1 << bs) - 1\n  r[0] = self[ds] >> bs\n  for (var i = ds + 1; i < self.t; ++i) {\n    r[i - ds - 1] |= (self[i] & bm) << cbs\n    r[i - ds] = self[i] >> bs\n  }\n  if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs\n  r.t = self.t - ds\n  r.clamp()\n}\n\n// (protected) r = this - a\nfunction bnpSubTo(a, r) {\n  var self = this\n  var i = 0,\n    c = 0,\n    m = Math.min(a.t, self.t)\n  while (i < m) {\n    c += self[i] - a[i]\n    r[i++] = c & self.DM\n    c >>= self.DB\n  }\n  if (a.t < self.t) {\n    c -= a.s\n    while (i < self.t) {\n      c += self[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += self.s\n  } else {\n    c += self.s\n    while (i < a.t) {\n      c -= a[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c -= a.s\n  }\n  r.s = (c < 0) ? -1 : 0\n  if (c < -1) r[i++] = self.DV + c\n  else if (c > 0) r[i++] = c\n  r.t = i\n  r.clamp()\n}\n\n// (protected) r = this * a, r != this,a (HAC 14.12)\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyTo(a, r) {\n  var x = this.abs(),\n    y = a.abs()\n  var i = x.t\n  r.t = i + y.t\n  while (--i >= 0) r[i] = 0\n  for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)\n  r.s = 0\n  r.clamp()\n  if (this.s != a.s) BigInteger.ZERO.subTo(r, r)\n}\n\n// (protected) r = this^2, r != this (HAC 14.16)\nfunction bnpSquareTo(r) {\n  var x = this.abs()\n  var i = r.t = 2 * x.t\n  while (--i >= 0) r[i] = 0\n  for (i = 0; i < x.t - 1; ++i) {\n    var c = x.am(i, x[i], r, 2 * i, 0, 1)\n    if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {\n      r[i + x.t] -= x.DV\n      r[i + x.t + 1] = 1\n    }\n  }\n  if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)\n  r.s = 0\n  r.clamp()\n}\n\n// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n// r != q, this != m.  q or r may be null.\nfunction bnpDivRemTo(m, q, r) {\n  var self = this\n  var pm = m.abs()\n  if (pm.t <= 0) return\n  var pt = self.abs()\n  if (pt.t < pm.t) {\n    if (q != null) q.fromInt(0)\n    if (r != null) self.copyTo(r)\n    return\n  }\n  if (r == null) r = new BigInteger()\n  var y = new BigInteger(),\n    ts = self.s,\n    ms = m.s\n  var nsh = self.DB - nbits(pm[pm.t - 1]); // normalize modulus\n  if (nsh > 0) {\n    pm.lShiftTo(nsh, y)\n    pt.lShiftTo(nsh, r)\n  } else {\n    pm.copyTo(y)\n    pt.copyTo(r)\n  }\n  var ys = y.t\n  var y0 = y[ys - 1]\n  if (y0 == 0) return\n  var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0)\n  var d1 = self.FV / yt,\n    d2 = (1 << self.F1) / yt,\n    e = 1 << self.F2\n  var i = r.t,\n    j = i - ys,\n    t = (q == null) ? new BigInteger() : q\n  y.dlShiftTo(j, t)\n  if (r.compareTo(t) >= 0) {\n    r[r.t++] = 1\n    r.subTo(t, r)\n  }\n  BigInteger.ONE.dlShiftTo(ys, t)\n  t.subTo(y, y); // \"negative\" y so we can replace sub with am later\n  while (y.t < ys) y[y.t++] = 0\n  while (--j >= 0) {\n    // Estimate quotient digit\n    var qd = (r[--i] == y0) ? self.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)\n    if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out\n      y.dlShiftTo(j, t)\n      r.subTo(t, r)\n      while (r[i] < --qd) r.subTo(t, r)\n    }\n  }\n  if (q != null) {\n    r.drShiftTo(ys, q)\n    if (ts != ms) BigInteger.ZERO.subTo(q, q)\n  }\n  r.t = ys\n  r.clamp()\n  if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder\n  if (ts < 0) BigInteger.ZERO.subTo(r, r)\n}\n\n// (public) this mod a\nfunction bnMod(a) {\n  var r = new BigInteger()\n  this.abs()\n    .divRemTo(a, null, r)\n  if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r)\n  return r\n}\n\n// Modular reduction using \"classic\" algorithm\nfunction Classic(m) {\n  this.m = m\n}\n\nfunction cConvert(x) {\n  if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m)\n  else return x\n}\n\nfunction cRevert(x) {\n  return x\n}\n\nfunction cReduce(x) {\n  x.divRemTo(this.m, null, x)\n}\n\nfunction cMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nfunction cSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\nClassic.prototype.convert = cConvert\nClassic.prototype.revert = cRevert\nClassic.prototype.reduce = cReduce\nClassic.prototype.mulTo = cMulTo\nClassic.prototype.sqrTo = cSqrTo\n\n// (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n// justification:\n//         xy == 1 (mod m)\n//         xy =  1+km\n//   xy(2-xy) = (1+km)(1-km)\n// x[y(2-xy)] = 1-k^2m^2\n// x[y(2-xy)] == 1 (mod m^2)\n// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n// JS multiply \"overflows\" differently from C/C++, so care is needed here.\nfunction bnpInvDigit() {\n  if (this.t < 1) return 0\n  var x = this[0]\n  if ((x & 1) == 0) return 0\n  var y = x & 3; // y == 1/x mod 2^2\n  y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4\n  y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8\n  y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16\n  // last step - calculate inverse mod DV directly\n  // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n  y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits\n  // we really want the negative inverse, and -DV < y < DV\n  return (y > 0) ? this.DV - y : -y\n}\n\n// Montgomery reduction\nfunction Montgomery(m) {\n  this.m = m\n  this.mp = m.invDigit()\n  this.mpl = this.mp & 0x7fff\n  this.mph = this.mp >> 15\n  this.um = (1 << (m.DB - 15)) - 1\n  this.mt2 = 2 * m.t\n}\n\n// xR mod m\nfunction montConvert(x) {\n  var r = new BigInteger()\n  x.abs()\n    .dlShiftTo(this.m.t, r)\n  r.divRemTo(this.m, null, r)\n  if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)\n  return r\n}\n\n// x/R mod m\nfunction montRevert(x) {\n  var r = new BigInteger()\n  x.copyTo(r)\n  this.reduce(r)\n  return r\n}\n\n// x = x/R mod m (HAC 14.32)\nfunction montReduce(x) {\n  while (x.t <= this.mt2) // pad x so am has enough room later\n    x[x.t++] = 0\n  for (var i = 0; i < this.m.t; ++i) {\n    // faster way of calculating u0 = x[i]*mp mod DV\n    var j = x[i] & 0x7fff\n    var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM\n    // use am to combine the multiply-shift-add into one call\n    j = i + this.m.t\n    x[j] += this.m.am(0, u0, x, i, 0, this.m.t)\n    // propagate carry\n    while (x[j] >= x.DV) {\n      x[j] -= x.DV\n      x[++j]++\n    }\n  }\n  x.clamp()\n  x.drShiftTo(this.m.t, x)\n  if (x.compareTo(this.m) >= 0) x.subTo(this.m, x)\n}\n\n// r = \"x^2/R mod m\"; x != r\nfunction montSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\n// r = \"xy/R mod m\"; x,y != r\nfunction montMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nMontgomery.prototype.convert = montConvert\nMontgomery.prototype.revert = montRevert\nMontgomery.prototype.reduce = montReduce\nMontgomery.prototype.mulTo = montMulTo\nMontgomery.prototype.sqrTo = montSqrTo\n\n// (protected) true iff this is even\nfunction bnpIsEven() {\n  return ((this.t > 0) ? (this[0] & 1) : this.s) == 0\n}\n\n// (protected) this^e, e < 2^32, doing sqr and mul with \"r\" (HAC 14.79)\nfunction bnpExp(e, z) {\n  if (e > 0xffffffff || e < 1) return BigInteger.ONE\n  var r = new BigInteger(),\n    r2 = new BigInteger(),\n    g = z.convert(this),\n    i = nbits(e) - 1\n  g.copyTo(r)\n  while (--i >= 0) {\n    z.sqrTo(r, r2)\n    if ((e & (1 << i)) > 0) z.mulTo(r2, g, r)\n    else {\n      var t = r\n      r = r2\n      r2 = t\n    }\n  }\n  return z.revert(r)\n}\n\n// (public) this^e % m, 0 <= e < 2^32\nfunction bnModPowInt(e, m) {\n  var z\n  if (e < 256 || m.isEven()) z = new Classic(m)\n  else z = new Montgomery(m)\n  return this.exp(e, z)\n}\n\n// protected\nproto.copyTo = bnpCopyTo\nproto.fromInt = bnpFromInt\nproto.fromString = bnpFromString\nproto.clamp = bnpClamp\nproto.dlShiftTo = bnpDLShiftTo\nproto.drShiftTo = bnpDRShiftTo\nproto.lShiftTo = bnpLShiftTo\nproto.rShiftTo = bnpRShiftTo\nproto.subTo = bnpSubTo\nproto.multiplyTo = bnpMultiplyTo\nproto.squareTo = bnpSquareTo\nproto.divRemTo = bnpDivRemTo\nproto.invDigit = bnpInvDigit\nproto.isEven = bnpIsEven\nproto.exp = bnpExp\n\n// public\nproto.toString = bnToString\nproto.negate = bnNegate\nproto.abs = bnAbs\nproto.compareTo = bnCompareTo\nproto.bitLength = bnBitLength\nproto.byteLength = bnByteLength\nproto.mod = bnMod\nproto.modPowInt = bnModPowInt\n\n// (public)\nfunction bnClone() {\n  var r = new BigInteger()\n  this.copyTo(r)\n  return r\n}\n\n// (public) return value as integer\nfunction bnIntValue() {\n  if (this.s < 0) {\n    if (this.t == 1) return this[0] - this.DV\n    else if (this.t == 0) return -1\n  } else if (this.t == 1) return this[0]\n  else if (this.t == 0) return 0\n  // assumes 16 < DB < 32\n  return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]\n}\n\n// (public) return value as byte\nfunction bnByteValue() {\n  return (this.t == 0) ? this.s : (this[0] << 24) >> 24\n}\n\n// (public) return value as short (assumes DB>=16)\nfunction bnShortValue() {\n  return (this.t == 0) ? this.s : (this[0] << 16) >> 16\n}\n\n// (protected) return x s.t. r^x < DV\nfunction bnpChunkSize(r) {\n  return Math.floor(Math.LN2 * this.DB / Math.log(r))\n}\n\n// (public) 0 if this == 0, 1 if this > 0\nfunction bnSigNum() {\n  if (this.s < 0) return -1\n  else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0\n  else return 1\n}\n\n// (protected) convert to radix string\nfunction bnpToRadix(b) {\n  if (b == null) b = 10\n  if (this.signum() == 0 || b < 2 || b > 36) return \"0\"\n  var cs = this.chunkSize(b)\n  var a = Math.pow(b, cs)\n  var d = nbv(a),\n    y = new BigInteger(),\n    z = new BigInteger(),\n    r = \"\"\n  this.divRemTo(d, y, z)\n  while (y.signum() > 0) {\n    r = (a + z.intValue())\n      .toString(b)\n      .substr(1) + r\n    y.divRemTo(d, y, z)\n  }\n  return z.intValue()\n    .toString(b) + r\n}\n\n// (protected) convert from radix string\nfunction bnpFromRadix(s, b) {\n  var self = this\n  self.fromInt(0)\n  if (b == null) b = 10\n  var cs = self.chunkSize(b)\n  var d = Math.pow(b, cs),\n    mi = false,\n    j = 0,\n    w = 0\n  for (var i = 0; i < s.length; ++i) {\n    var x = intAt(s, i)\n    if (x < 0) {\n      if (s.charAt(i) == \"-\" && self.signum() == 0) mi = true\n      continue\n    }\n    w = b * w + x\n    if (++j >= cs) {\n      self.dMultiply(d)\n      self.dAddOffset(w, 0)\n      j = 0\n      w = 0\n    }\n  }\n  if (j > 0) {\n    self.dMultiply(Math.pow(b, j))\n    self.dAddOffset(w, 0)\n  }\n  if (mi) BigInteger.ZERO.subTo(self, self)\n}\n\n// (protected) alternate constructor\nfunction bnpFromNumber(a, b, c) {\n  var self = this\n  if (\"number\" == typeof b) {\n    // new BigInteger(int,int,RNG)\n    if (a < 2) self.fromInt(1)\n    else {\n      self.fromNumber(a, c)\n      if (!self.testBit(a - 1)) // force MSB set\n        self.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, self)\n      if (self.isEven()) self.dAddOffset(1, 0); // force odd\n      while (!self.isProbablePrime(b)) {\n        self.dAddOffset(2, 0)\n        if (self.bitLength() > a) self.subTo(BigInteger.ONE.shiftLeft(a - 1), self)\n      }\n    }\n  } else {\n    // new BigInteger(int,RNG)\n    var x = new Array(),\n      t = a & 7\n    x.length = (a >> 3) + 1\n    b.nextBytes(x)\n    if (t > 0) x[0] &= ((1 << t) - 1)\n    else x[0] = 0\n    self.fromString(x, 256)\n  }\n}\n\n// (public) convert to bigendian byte array\nfunction bnToByteArray() {\n  var self = this\n  var i = self.t,\n    r = new Array()\n  r[0] = self.s\n  var p = self.DB - (i * self.DB) % 8,\n    d, k = 0\n  if (i-- > 0) {\n    if (p < self.DB && (d = self[i] >> p) != (self.s & self.DM) >> p)\n      r[k++] = d | (self.s << (self.DB - p))\n    while (i >= 0) {\n      if (p < 8) {\n        d = (self[i] & ((1 << p) - 1)) << (8 - p)\n        d |= self[--i] >> (p += self.DB - 8)\n      } else {\n        d = (self[i] >> (p -= 8)) & 0xff\n        if (p <= 0) {\n          p += self.DB\n          --i\n        }\n      }\n      if ((d & 0x80) != 0) d |= -256\n      if (k === 0 && (self.s & 0x80) != (d & 0x80))++k\n      if (k > 0 || d != self.s) r[k++] = d\n    }\n  }\n  return r\n}\n\nfunction bnEquals(a) {\n  return (this.compareTo(a) == 0)\n}\n\nfunction bnMin(a) {\n  return (this.compareTo(a) < 0) ? this : a\n}\n\nfunction bnMax(a) {\n  return (this.compareTo(a) > 0) ? this : a\n}\n\n// (protected) r = this op a (bitwise)\nfunction bnpBitwiseTo(a, op, r) {\n  var self = this\n  var i, f, m = Math.min(a.t, self.t)\n  for (i = 0; i < m; ++i) r[i] = op(self[i], a[i])\n  if (a.t < self.t) {\n    f = a.s & self.DM\n    for (i = m; i < self.t; ++i) r[i] = op(self[i], f)\n    r.t = self.t\n  } else {\n    f = self.s & self.DM\n    for (i = m; i < a.t; ++i) r[i] = op(f, a[i])\n    r.t = a.t\n  }\n  r.s = op(self.s, a.s)\n  r.clamp()\n}\n\n// (public) this & a\nfunction op_and(x, y) {\n  return x & y\n}\n\nfunction bnAnd(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_and, r)\n  return r\n}\n\n// (public) this | a\nfunction op_or(x, y) {\n  return x | y\n}\n\nfunction bnOr(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_or, r)\n  return r\n}\n\n// (public) this ^ a\nfunction op_xor(x, y) {\n  return x ^ y\n}\n\nfunction bnXor(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_xor, r)\n  return r\n}\n\n// (public) this & ~a\nfunction op_andnot(x, y) {\n  return x & ~y\n}\n\nfunction bnAndNot(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_andnot, r)\n  return r\n}\n\n// (public) ~this\nfunction bnNot() {\n  var r = new BigInteger()\n  for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i]\n  r.t = this.t\n  r.s = ~this.s\n  return r\n}\n\n// (public) this << n\nfunction bnShiftLeft(n) {\n  var r = new BigInteger()\n  if (n < 0) this.rShiftTo(-n, r)\n  else this.lShiftTo(n, r)\n  return r\n}\n\n// (public) this >> n\nfunction bnShiftRight(n) {\n  var r = new BigInteger()\n  if (n < 0) this.lShiftTo(-n, r)\n  else this.rShiftTo(n, r)\n  return r\n}\n\n// return index of lowest 1-bit in x, x < 2^31\nfunction lbit(x) {\n  if (x == 0) return -1\n  var r = 0\n  if ((x & 0xffff) == 0) {\n    x >>= 16\n    r += 16\n  }\n  if ((x & 0xff) == 0) {\n    x >>= 8\n    r += 8\n  }\n  if ((x & 0xf) == 0) {\n    x >>= 4\n    r += 4\n  }\n  if ((x & 3) == 0) {\n    x >>= 2\n    r += 2\n  }\n  if ((x & 1) == 0)++r\n  return r\n}\n\n// (public) returns index of lowest 1-bit (or -1 if none)\nfunction bnGetLowestSetBit() {\n  for (var i = 0; i < this.t; ++i)\n    if (this[i] != 0) return i * this.DB + lbit(this[i])\n  if (this.s < 0) return this.t * this.DB\n  return -1\n}\n\n// return number of 1 bits in x\nfunction cbit(x) {\n  var r = 0\n  while (x != 0) {\n    x &= x - 1\n    ++r\n  }\n  return r\n}\n\n// (public) return number of set bits\nfunction bnBitCount() {\n  var r = 0,\n    x = this.s & this.DM\n  for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x)\n  return r\n}\n\n// (public) true iff nth bit is set\nfunction bnTestBit(n) {\n  var j = Math.floor(n / this.DB)\n  if (j >= this.t) return (this.s != 0)\n  return ((this[j] & (1 << (n % this.DB))) != 0)\n}\n\n// (protected) this op (1<<n)\nfunction bnpChangeBit(n, op) {\n  var r = BigInteger.ONE.shiftLeft(n)\n  this.bitwiseTo(r, op, r)\n  return r\n}\n\n// (public) this | (1<<n)\nfunction bnSetBit(n) {\n  return this.changeBit(n, op_or)\n}\n\n// (public) this & ~(1<<n)\nfunction bnClearBit(n) {\n  return this.changeBit(n, op_andnot)\n}\n\n// (public) this ^ (1<<n)\nfunction bnFlipBit(n) {\n  return this.changeBit(n, op_xor)\n}\n\n// (protected) r = this + a\nfunction bnpAddTo(a, r) {\n  var self = this\n\n  var i = 0,\n    c = 0,\n    m = Math.min(a.t, self.t)\n  while (i < m) {\n    c += self[i] + a[i]\n    r[i++] = c & self.DM\n    c >>= self.DB\n  }\n  if (a.t < self.t) {\n    c += a.s\n    while (i < self.t) {\n      c += self[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += self.s\n  } else {\n    c += self.s\n    while (i < a.t) {\n      c += a[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += a.s\n  }\n  r.s = (c < 0) ? -1 : 0\n  if (c > 0) r[i++] = c\n  else if (c < -1) r[i++] = self.DV + c\n  r.t = i\n  r.clamp()\n}\n\n// (public) this + a\nfunction bnAdd(a) {\n  var r = new BigInteger()\n  this.addTo(a, r)\n  return r\n}\n\n// (public) this - a\nfunction bnSubtract(a) {\n  var r = new BigInteger()\n  this.subTo(a, r)\n  return r\n}\n\n// (public) this * a\nfunction bnMultiply(a) {\n  var r = new BigInteger()\n  this.multiplyTo(a, r)\n  return r\n}\n\n// (public) this^2\nfunction bnSquare() {\n  var r = new BigInteger()\n  this.squareTo(r)\n  return r\n}\n\n// (public) this / a\nfunction bnDivide(a) {\n  var r = new BigInteger()\n  this.divRemTo(a, r, null)\n  return r\n}\n\n// (public) this % a\nfunction bnRemainder(a) {\n  var r = new BigInteger()\n  this.divRemTo(a, null, r)\n  return r\n}\n\n// (public) [this/a,this%a]\nfunction bnDivideAndRemainder(a) {\n  var q = new BigInteger(),\n    r = new BigInteger()\n  this.divRemTo(a, q, r)\n  return new Array(q, r)\n}\n\n// (protected) this *= n, this >= 0, 1 < n < DV\nfunction bnpDMultiply(n) {\n  this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)\n  ++this.t\n  this.clamp()\n}\n\n// (protected) this += n << w words, this >= 0\nfunction bnpDAddOffset(n, w) {\n  if (n == 0) return\n  while (this.t <= w) this[this.t++] = 0\n  this[w] += n\n  while (this[w] >= this.DV) {\n    this[w] -= this.DV\n    if (++w >= this.t) this[this.t++] = 0\n    ++this[w]\n  }\n}\n\n// A \"null\" reducer\nfunction NullExp() {}\n\nfunction nNop(x) {\n  return x\n}\n\nfunction nMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n}\n\nfunction nSqrTo(x, r) {\n  x.squareTo(r)\n}\n\nNullExp.prototype.convert = nNop\nNullExp.prototype.revert = nNop\nNullExp.prototype.mulTo = nMulTo\nNullExp.prototype.sqrTo = nSqrTo\n\n// (public) this^e\nfunction bnPow(e) {\n  return this.exp(e, new NullExp())\n}\n\n// (protected) r = lower n words of \"this * a\", a.t <= n\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyLowerTo(a, n, r) {\n  var i = Math.min(this.t + a.t, n)\n  r.s = 0; // assumes a,this >= 0\n  r.t = i\n  while (i > 0) r[--i] = 0\n  var j\n  for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t)\n  for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i)\n  r.clamp()\n}\n\n// (protected) r = \"this * a\" without lower n words, n > 0\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyUpperTo(a, n, r) {\n  --n\n  var i = r.t = this.t + a.t - n\n  r.s = 0; // assumes a,this >= 0\n  while (--i >= 0) r[i] = 0\n  for (i = Math.max(n - this.t, 0); i < a.t; ++i)\n    r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n)\n  r.clamp()\n  r.drShiftTo(1, r)\n}\n\n// Barrett modular reduction\nfunction Barrett(m) {\n  // setup Barrett\n  this.r2 = new BigInteger()\n  this.q3 = new BigInteger()\n  BigInteger.ONE.dlShiftTo(2 * m.t, this.r2)\n  this.mu = this.r2.divide(m)\n  this.m = m\n}\n\nfunction barrettConvert(x) {\n  if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m)\n  else if (x.compareTo(this.m) < 0) return x\n  else {\n    var r = new BigInteger()\n    x.copyTo(r)\n    this.reduce(r)\n    return r\n  }\n}\n\nfunction barrettRevert(x) {\n  return x\n}\n\n// x = x mod m (HAC 14.42)\nfunction barrettReduce(x) {\n  var self = this\n  x.drShiftTo(self.m.t - 1, self.r2)\n  if (x.t > self.m.t + 1) {\n    x.t = self.m.t + 1\n    x.clamp()\n  }\n  self.mu.multiplyUpperTo(self.r2, self.m.t + 1, self.q3)\n  self.m.multiplyLowerTo(self.q3, self.m.t + 1, self.r2)\n  while (x.compareTo(self.r2) < 0) x.dAddOffset(1, self.m.t + 1)\n  x.subTo(self.r2, x)\n  while (x.compareTo(self.m) >= 0) x.subTo(self.m, x)\n}\n\n// r = x^2 mod m; x != r\nfunction barrettSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\n// r = x*y mod m; x,y != r\nfunction barrettMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nBarrett.prototype.convert = barrettConvert\nBarrett.prototype.revert = barrettRevert\nBarrett.prototype.reduce = barrettReduce\nBarrett.prototype.mulTo = barrettMulTo\nBarrett.prototype.sqrTo = barrettSqrTo\n\n// (public) this^e % m (HAC 14.85)\nfunction bnModPow(e, m) {\n  var i = e.bitLength(),\n    k, r = nbv(1),\n    z\n  if (i <= 0) return r\n  else if (i < 18) k = 1\n  else if (i < 48) k = 3\n  else if (i < 144) k = 4\n  else if (i < 768) k = 5\n  else k = 6\n  if (i < 8)\n    z = new Classic(m)\n  else if (m.isEven())\n    z = new Barrett(m)\n  else\n    z = new Montgomery(m)\n\n  // precomputation\n  var g = new Array(),\n    n = 3,\n    k1 = k - 1,\n    km = (1 << k) - 1\n  g[1] = z.convert(this)\n  if (k > 1) {\n    var g2 = new BigInteger()\n    z.sqrTo(g[1], g2)\n    while (n <= km) {\n      g[n] = new BigInteger()\n      z.mulTo(g2, g[n - 2], g[n])\n      n += 2\n    }\n  }\n\n  var j = e.t - 1,\n    w, is1 = true,\n    r2 = new BigInteger(),\n    t\n  i = nbits(e[j]) - 1\n  while (j >= 0) {\n    if (i >= k1) w = (e[j] >> (i - k1)) & km\n    else {\n      w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)\n      if (j > 0) w |= e[j - 1] >> (this.DB + i - k1)\n    }\n\n    n = k\n    while ((w & 1) == 0) {\n      w >>= 1\n      --n\n    }\n    if ((i -= n) < 0) {\n      i += this.DB\n      --j\n    }\n    if (is1) { // ret == 1, don't bother squaring or multiplying it\n      g[w].copyTo(r)\n      is1 = false\n    } else {\n      while (n > 1) {\n        z.sqrTo(r, r2)\n        z.sqrTo(r2, r)\n        n -= 2\n      }\n      if (n > 0) z.sqrTo(r, r2)\n      else {\n        t = r\n        r = r2\n        r2 = t\n      }\n      z.mulTo(r2, g[w], r)\n    }\n\n    while (j >= 0 && (e[j] & (1 << i)) == 0) {\n      z.sqrTo(r, r2)\n      t = r\n      r = r2\n      r2 = t\n      if (--i < 0) {\n        i = this.DB - 1\n        --j\n      }\n    }\n  }\n  return z.revert(r)\n}\n\n// (public) gcd(this,a) (HAC 14.54)\nfunction bnGCD(a) {\n  var x = (this.s < 0) ? this.negate() : this.clone()\n  var y = (a.s < 0) ? a.negate() : a.clone()\n  if (x.compareTo(y) < 0) {\n    var t = x\n    x = y\n    y = t\n  }\n  var i = x.getLowestSetBit(),\n    g = y.getLowestSetBit()\n  if (g < 0) return x\n  if (i < g) g = i\n  if (g > 0) {\n    x.rShiftTo(g, x)\n    y.rShiftTo(g, y)\n  }\n  while (x.signum() > 0) {\n    if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x)\n    if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y)\n    if (x.compareTo(y) >= 0) {\n      x.subTo(y, x)\n      x.rShiftTo(1, x)\n    } else {\n      y.subTo(x, y)\n      y.rShiftTo(1, y)\n    }\n  }\n  if (g > 0) y.lShiftTo(g, y)\n  return y\n}\n\n// (protected) this % n, n < 2^26\nfunction bnpModInt(n) {\n  if (n <= 0) return 0\n  var d = this.DV % n,\n    r = (this.s < 0) ? n - 1 : 0\n  if (this.t > 0)\n    if (d == 0) r = this[0] % n\n    else\n      for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n\n  return r\n}\n\n// (public) 1/this % m (HAC 14.61)\nfunction bnModInverse(m) {\n  var ac = m.isEven()\n  if (this.signum() === 0) throw new Error('division by zero')\n  if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO\n  var u = m.clone(),\n    v = this.clone()\n  var a = nbv(1),\n    b = nbv(0),\n    c = nbv(0),\n    d = nbv(1)\n  while (u.signum() != 0) {\n    while (u.isEven()) {\n      u.rShiftTo(1, u)\n      if (ac) {\n        if (!a.isEven() || !b.isEven()) {\n          a.addTo(this, a)\n          b.subTo(m, b)\n        }\n        a.rShiftTo(1, a)\n      } else if (!b.isEven()) b.subTo(m, b)\n      b.rShiftTo(1, b)\n    }\n    while (v.isEven()) {\n      v.rShiftTo(1, v)\n      if (ac) {\n        if (!c.isEven() || !d.isEven()) {\n          c.addTo(this, c)\n          d.subTo(m, d)\n        }\n        c.rShiftTo(1, c)\n      } else if (!d.isEven()) d.subTo(m, d)\n      d.rShiftTo(1, d)\n    }\n    if (u.compareTo(v) >= 0) {\n      u.subTo(v, u)\n      if (ac) a.subTo(c, a)\n      b.subTo(d, b)\n    } else {\n      v.subTo(u, v)\n      if (ac) c.subTo(a, c)\n      d.subTo(b, d)\n    }\n  }\n  if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO\n  while (d.compareTo(m) >= 0) d.subTo(m, d)\n  while (d.signum() < 0) d.addTo(m, d)\n  return d\n}\n\nvar lowprimes = [\n  2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,\n  73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,\n  157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,\n  239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,\n  331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,\n  421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,\n  509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,\n  613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,\n  709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,\n  821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,\n  919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997\n]\n\nvar lplim = (1 << 26) / lowprimes[lowprimes.length - 1]\n\n// (public) test primality with certainty >= 1-.5^t\nfunction bnIsProbablePrime(t) {\n  var i, x = this.abs()\n  if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {\n    for (i = 0; i < lowprimes.length; ++i)\n      if (x[0] == lowprimes[i]) return true\n    return false\n  }\n  if (x.isEven()) return false\n  i = 1\n  while (i < lowprimes.length) {\n    var m = lowprimes[i],\n      j = i + 1\n    while (j < lowprimes.length && m < lplim) m *= lowprimes[j++]\n    m = x.modInt(m)\n    while (i < j) if (m % lowprimes[i++] == 0) return false\n  }\n  return x.millerRabin(t)\n}\n\n// (protected) true if probably prime (HAC 4.24, Miller-Rabin)\nfunction bnpMillerRabin(t) {\n  var n1 = this.subtract(BigInteger.ONE)\n  var k = n1.getLowestSetBit()\n  if (k <= 0) return false\n  var r = n1.shiftRight(k)\n  t = (t + 1) >> 1\n  if (t > lowprimes.length) t = lowprimes.length\n  var a = new BigInteger(null)\n  var j, bases = []\n  for (var i = 0; i < t; ++i) {\n    for (;;) {\n      j = lowprimes[Math.floor(Math.random() * lowprimes.length)]\n      if (bases.indexOf(j) == -1) break\n    }\n    bases.push(j)\n    a.fromInt(j)\n    var y = a.modPow(r, this)\n    if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {\n      var j = 1\n      while (j++ < k && y.compareTo(n1) != 0) {\n        y = y.modPowInt(2, this)\n        if (y.compareTo(BigInteger.ONE) == 0) return false\n      }\n      if (y.compareTo(n1) != 0) return false\n    }\n  }\n  return true\n}\n\n// protected\nproto.chunkSize = bnpChunkSize\nproto.toRadix = bnpToRadix\nproto.fromRadix = bnpFromRadix\nproto.fromNumber = bnpFromNumber\nproto.bitwiseTo = bnpBitwiseTo\nproto.changeBit = bnpChangeBit\nproto.addTo = bnpAddTo\nproto.dMultiply = bnpDMultiply\nproto.dAddOffset = bnpDAddOffset\nproto.multiplyLowerTo = bnpMultiplyLowerTo\nproto.multiplyUpperTo = bnpMultiplyUpperTo\nproto.modInt = bnpModInt\nproto.millerRabin = bnpMillerRabin\n\n// public\nproto.clone = bnClone\nproto.intValue = bnIntValue\nproto.byteValue = bnByteValue\nproto.shortValue = bnShortValue\nproto.signum = bnSigNum\nproto.toByteArray = bnToByteArray\nproto.equals = bnEquals\nproto.min = bnMin\nproto.max = bnMax\nproto.and = bnAnd\nproto.or = bnOr\nproto.xor = bnXor\nproto.andNot = bnAndNot\nproto.not = bnNot\nproto.shiftLeft = bnShiftLeft\nproto.shiftRight = bnShiftRight\nproto.getLowestSetBit = bnGetLowestSetBit\nproto.bitCount = bnBitCount\nproto.testBit = bnTestBit\nproto.setBit = bnSetBit\nproto.clearBit = bnClearBit\nproto.flipBit = bnFlipBit\nproto.add = bnAdd\nproto.subtract = bnSubtract\nproto.multiply = bnMultiply\nproto.divide = bnDivide\nproto.remainder = bnRemainder\nproto.divideAndRemainder = bnDivideAndRemainder\nproto.modPow = bnModPow\nproto.modInverse = bnModInverse\nproto.pow = bnPow\nproto.gcd = bnGCD\nproto.isProbablePrime = bnIsProbablePrime\n\n// JSBN-specific extension\nproto.square = bnSquare\n\n// constants\nBigInteger.ZERO = nbv(0)\nBigInteger.ONE = nbv(1)\nBigInteger.valueOf = nbv\n\nmodule.exports = BigInteger\n","// FIXME: Kind of a weird way to throw exceptions, consider removing\nvar assert = require('assert')\nvar BigInteger = require('./bigi')\n\n/**\n * Turns a byte array into a big integer.\n *\n * This function will interpret a byte array as a big integer in big\n * endian notation.\n */\nBigInteger.fromByteArrayUnsigned = function(byteArray) {\n  // BigInteger expects a DER integer conformant byte array\n  if (byteArray[0] & 0x80) {\n    return new BigInteger([0].concat(byteArray))\n  }\n\n  return new BigInteger(byteArray)\n}\n\n/**\n * Returns a byte array representation of the big integer.\n *\n * This returns the absolute of the contained value in big endian\n * form. A value of zero results in an empty array.\n */\nBigInteger.prototype.toByteArrayUnsigned = function() {\n  var byteArray = this.toByteArray()\n  return byteArray[0] === 0 ? byteArray.slice(1) : byteArray\n}\n\nBigInteger.fromDERInteger = function(byteArray) {\n  return new BigInteger(byteArray)\n}\n\n/*\n * Converts BigInteger to a DER integer representation.\n *\n * The format for this value uses the most significant bit as a sign\n * bit.  If the most significant bit is already set and the integer is\n * positive, a 0x00 is prepended.\n *\n * Examples:\n *\n *      0 =>     0x00\n *      1 =>     0x01\n *     -1 =>     0xff\n *    127 =>     0x7f\n *   -127 =>     0x81\n *    128 =>   0x0080\n *   -128 =>     0x80\n *    255 =>   0x00ff\n *   -255 =>   0xff01\n *  16300 =>   0x3fac\n * -16300 =>   0xc054\n *  62300 => 0x00f35c\n * -62300 => 0xff0ca4\n*/\nBigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray\n\nBigInteger.fromBuffer = function(buffer) {\n  // BigInteger expects a DER integer conformant byte array\n  if (buffer[0] & 0x80) {\n    var byteArray = Array.prototype.slice.call(buffer)\n\n    return new BigInteger([0].concat(byteArray))\n  }\n\n  return new BigInteger(buffer)\n}\n\nBigInteger.fromHex = function(hex) {\n  if (hex === '') return BigInteger.ZERO\n\n  assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')\n  assert.equal(hex.length % 2, 0, 'Incomplete hex')\n  return new BigInteger(hex, 16)\n}\n\nBigInteger.prototype.toBuffer = function(size) {\n  var byteArray = this.toByteArrayUnsigned()\n  var zeros = []\n\n  var padding = size - byteArray.length\n  while (zeros.length < padding) zeros.push(0)\n\n  return new Buffer(zeros.concat(byteArray))\n}\n\nBigInteger.prototype.toHex = function(size) {\n  return this.toBuffer(size).toString('hex')\n}\n","var BigInteger = require(30)\n\n//addons\nrequire(31)\n\nmodule.exports = BigInteger","module.exports={\n  \"bugs\": {\n    \"url\": \"https://github.com/cryptocoinjs/bigi/issues\"\n  },\n  \"bundleDependencies\": false,\n  \"dependencies\": {},\n  \"deprecated\": false,\n  \"description\": \"Big integers.\",\n  \"devDependencies\": {\n    \"coveralls\": \"^2.11.2\",\n    \"istanbul\": \"^0.3.5\",\n    \"jshint\": \"^2.5.1\",\n    \"mocha\": \"^2.1.0\",\n    \"mochify\": \"^2.1.0\"\n  },\n  \"homepage\": \"https://github.com/cryptocoinjs/bigi#readme\",\n  \"keywords\": [\n    \"cryptography\",\n    \"math\",\n    \"bitcoin\",\n    \"arbitrary\",\n    \"precision\",\n    \"arithmetic\",\n    \"big\",\n    \"integer\",\n    \"int\",\n    \"number\",\n    \"biginteger\",\n    \"bigint\",\n    \"bignumber\",\n    \"decimal\",\n    \"float\"\n  ],\n  \"main\": \"./lib/index.js\",\n  \"name\": \"bigi\",\n  \"repository\": {\n    \"url\": \"git+https://github.com/cryptocoinjs/bigi.git\",\n    \"type\": \"git\"\n  },\n  \"scripts\": {\n    \"browser-test\": \"mochify --wd -R spec\",\n    \"coverage\": \"istanbul cover ./node_modules/.bin/_mocha -- --reporter list test/*.js\",\n    \"coveralls\": \"npm run-script coverage && node ./node_modules/.bin/coveralls < coverage/lcov.info\",\n    \"jshint\": \"jshint --config jshint.json lib/*.js ; true\",\n    \"test\": \"_mocha -- test/*.js\",\n    \"unit\": \"mocha\"\n  },\n  \"testling\": {\n    \"files\": \"test/*.js\",\n    \"harness\": \"mocha\",\n    \"browsers\": [\n      \"ie/9..latest\",\n      \"firefox/latest\",\n      \"chrome/latest\",\n      \"safari/6.0..latest\",\n      \"iphone/6.0..latest\",\n      \"android-browser/4.2..latest\"\n    ]\n  },\n  \"version\": \"1.4.2\"\n}","","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar Buffer = require(35).Buffer;\n\nvar isBufferEncoding = Buffer.isEncoding\n  || function(encoding) {\n       switch (encoding && encoding.toLowerCase()) {\n         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;\n         default: return false;\n       }\n     }\n\n\nfunction assertEncoding(encoding) {\n  if (encoding && !isBufferEncoding(encoding)) {\n    throw new Error('Unknown encoding: ' + encoding);\n  }\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters. CESU-8 is handled as part of the UTF-8 encoding.\n//\n// @TODO Handling all encodings inside a single object makes it very difficult\n// to reason about this code, so it should be split up in the future.\n// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code\n// points as used by CESU-8.\nvar StringDecoder = exports.StringDecoder = function(encoding) {\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\n  assertEncoding(encoding);\n  switch (this.encoding) {\n    case 'utf8':\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\n      this.surrogateSize = 3;\n      break;\n    case 'ucs2':\n    case 'utf16le':\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\n      this.surrogateSize = 2;\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\n      break;\n    case 'base64':\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\n      this.surrogateSize = 3;\n      this.detectIncompleteChar = base64DetectIncompleteChar;\n      break;\n    default:\n      this.write = passThroughWrite;\n      return;\n  }\n\n  // Enough space to store all bytes of a single character. UTF-8 needs 4\n  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).\n  this.charBuffer = new Buffer(6);\n  // Number of bytes received for the current incomplete multi-byte character.\n  this.charReceived = 0;\n  // Number of bytes expected for the current incomplete multi-byte character.\n  this.charLength = 0;\n};\n\n\n// write decodes the given buffer and returns it as JS string that is\n// guaranteed to not contain any partial multi-byte characters. Any partial\n// character found at the end of the buffer is buffered up, and will be\n// returned when calling write again with the remaining bytes.\n//\n// Note: Converting a Buffer containing an orphan surrogate to a String\n// currently works, but converting a String to a Buffer (via `new Buffer`, or\n// Buffer#write) will replace incomplete surrogates with the unicode\n// replacement character. See https://codereview.chromium.org/121173009/ .\nStringDecoder.prototype.write = function(buffer) {\n  var charStr = '';\n  // if our last write ended with an incomplete multibyte character\n  while (this.charLength) {\n    // determine how many remaining bytes this buffer has to offer for this char\n    var available = (buffer.length >= this.charLength - this.charReceived) ?\n        this.charLength - this.charReceived :\n        buffer.length;\n\n    // add the new bytes to the char buffer\n    buffer.copy(this.charBuffer, this.charReceived, 0, available);\n    this.charReceived += available;\n\n    if (this.charReceived < this.charLength) {\n      // still not enough chars in this buffer? wait for more ...\n      return '';\n    }\n\n    // remove bytes belonging to the current character from the buffer\n    buffer = buffer.slice(available, buffer.length);\n\n    // get the character that was split\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\n\n    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n    var charCode = charStr.charCodeAt(charStr.length - 1);\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n      this.charLength += this.surrogateSize;\n      charStr = '';\n      continue;\n    }\n    this.charReceived = this.charLength = 0;\n\n    // if there are no more bytes in this buffer, just emit our char\n    if (buffer.length === 0) {\n      return charStr;\n    }\n    break;\n  }\n\n  // determine and set charLength / charReceived\n  this.detectIncompleteChar(buffer);\n\n  var end = buffer.length;\n  if (this.charLength) {\n    // buffer the incomplete character bytes we got\n    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);\n    end -= this.charReceived;\n  }\n\n  charStr += buffer.toString(this.encoding, 0, end);\n\n  var end = charStr.length - 1;\n  var charCode = charStr.charCodeAt(end);\n  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n    var size = this.surrogateSize;\n    this.charLength += size;\n    this.charReceived += size;\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\n    buffer.copy(this.charBuffer, 0, 0, size);\n    return charStr.substring(0, end);\n  }\n\n  // or just emit the charStr\n  return charStr;\n};\n\n// detectIncompleteChar determines if there is an incomplete UTF-8 character at\n// the end of the given buffer. If so, it sets this.charLength to the byte\n// length that character, and sets this.charReceived to the number of bytes\n// that are available for this character.\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\n  // determine how many bytes we have to check at the end of this buffer\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\n\n  // Figure out if one of the last i bytes of our buffer announces an\n  // incomplete char.\n  for (; i > 0; i--) {\n    var c = buffer[buffer.length - i];\n\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\n\n    // 110XXXXX\n    if (i == 1 && c >> 5 == 0x06) {\n      this.charLength = 2;\n      break;\n    }\n\n    // 1110XXXX\n    if (i <= 2 && c >> 4 == 0x0E) {\n      this.charLength = 3;\n      break;\n    }\n\n    // 11110XXX\n    if (i <= 3 && c >> 3 == 0x1E) {\n      this.charLength = 4;\n      break;\n    }\n  }\n  this.charReceived = i;\n};\n\nStringDecoder.prototype.end = function(buffer) {\n  var res = '';\n  if (buffer && buffer.length)\n    res = this.write(buffer);\n\n  if (this.charReceived) {\n    var cr = this.charReceived;\n    var buf = this.charBuffer;\n    var enc = this.encoding;\n    res += buf.slice(0, cr).toString(enc);\n  }\n\n  return res;\n};\n\nfunction passThroughWrite(buffer) {\n  return buffer.toString(this.encoding);\n}\n\nfunction utf16DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 2;\n  this.charLength = this.charReceived ? 2 : 0;\n}\n\nfunction base64DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 3;\n  this.charLength = this.charReceived ? 3 : 0;\n}\n","var basex = require(28)\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","/*\r\n Copyright 2013-2014 Daniel Wirtz <dcode@dcode.io>\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license bytebuffer.js (c) 2015 Daniel Wirtz <dcode@dcode.io>\r\n * Backing buffer: ArrayBuffer, Accessor: Uint8Array\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/bytebuffer.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([\"long\"], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module['exports'] = (function() {\r\n            var Long; try { Long = require(68); } catch (e) {}\r\n            return factory(Long);\r\n        })();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"ByteBuffer\"] = factory(global[\"dcodeIO\"][\"Long\"]);\r\n\r\n})(this, function(Long) {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a new ByteBuffer.\r\n     * @class The swiss army knife for binary data in JavaScript.\r\n     * @exports ByteBuffer\r\n     * @constructor\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @expose\r\n     */\r\n    var ByteBuffer = function(capacity, littleEndian, noAssert) {\r\n        if (typeof capacity === 'undefined')\r\n            capacity = ByteBuffer.DEFAULT_CAPACITY;\r\n        if (typeof littleEndian === 'undefined')\r\n            littleEndian = ByteBuffer.DEFAULT_ENDIAN;\r\n        if (typeof noAssert === 'undefined')\r\n            noAssert = ByteBuffer.DEFAULT_NOASSERT;\r\n        if (!noAssert) {\r\n            capacity = capacity | 0;\r\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity\");\r\n            littleEndian = !!littleEndian;\r\n            noAssert = !!noAssert;\r\n        }\r\n\r\n        /**\r\n         * Backing ArrayBuffer.\r\n         * @type {!ArrayBuffer}\r\n         * @expose\r\n         */\r\n        this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);\r\n\r\n        /**\r\n         * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.\r\n         * @type {?Uint8Array}\r\n         * @expose\r\n         */\r\n        this.view = capacity === 0 ? null : new Uint8Array(this.buffer);\r\n\r\n        /**\r\n         * Absolute read/write offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.offset = 0;\r\n\r\n        /**\r\n         * Marked offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#mark\r\n         * @see ByteBuffer#reset\r\n         */\r\n        this.markedOffset = -1;\r\n\r\n        /**\r\n         * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.limit = capacity;\r\n\r\n        /**\r\n         * Whether to use little endian byte order, defaults to `false` for big endian.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.littleEndian = littleEndian;\r\n\r\n        /**\r\n         * Whether to skip assertions of offsets and values, defaults to `false`.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.noAssert = noAssert;\r\n    };\r\n\r\n    /**\r\n     * ByteBuffer version.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.VERSION = \"5.0.1\";\r\n\r\n    /**\r\n     * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.LITTLE_ENDIAN = true;\r\n\r\n    /**\r\n     * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.BIG_ENDIAN = false;\r\n\r\n    /**\r\n     * Default initial capacity of `16`.\r\n     * @type {number}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_CAPACITY = 16;\r\n\r\n    /**\r\n     * Default endianess of `false` for big endian.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;\r\n\r\n    /**\r\n     * Default no assertions flag of `false`.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_NOASSERT = false;\r\n\r\n    /**\r\n     * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded\r\n     *  and int64 support is not available.\r\n     * @type {?Long}\r\n     * @const\r\n     * @see https://github.com/dcodeIO/long.js\r\n     * @expose\r\n     */\r\n    ByteBuffer.Long = Long || null;\r\n\r\n    /**\r\n     * @alias ByteBuffer.prototype\r\n     * @inner\r\n     */\r\n    var ByteBufferPrototype = ByteBuffer.prototype;\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a ByteBuffer or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     * @private\r\n     */\r\n    ByteBufferPrototype.__isByteBuffer__;\r\n\r\n    Object.defineProperty(ByteBufferPrototype, \"__isByteBuffer__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    // helpers\r\n\r\n    /**\r\n     * @type {!ArrayBuffer}\r\n     * @inner\r\n     */\r\n    var EMPTY_BUFFER = new ArrayBuffer(0);\r\n\r\n    /**\r\n     * String.fromCharCode reference for compile-time renaming.\r\n     * @type {function(...number):string}\r\n     * @inner\r\n     */\r\n    var stringFromCharCode = String.fromCharCode;\r\n\r\n    /**\r\n     * Creates a source function for a string.\r\n     * @param {string} s String to read from\r\n     * @returns {function():number|null} Source function returning the next char code respectively `null` if there are\r\n     *  no more characters left.\r\n     * @throws {TypeError} If the argument is invalid\r\n     * @inner\r\n     */\r\n    function stringSource(s) {\r\n        var i=0; return function() {\r\n            return i < s.length ? s.charCodeAt(i++) : null;\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Creates a destination function for a string.\r\n     * @returns {function(number=):undefined|string} Destination function successively called with the next char code.\r\n     *  Returns the final string when called without arguments.\r\n     * @inner\r\n     */\r\n    function stringDestination() {\r\n        var cs = [], ps = []; return function() {\r\n            if (arguments.length === 0)\r\n                return ps.join('')+stringFromCharCode.apply(String, cs);\r\n            if (cs.length + arguments.length > 1024)\r\n                ps.push(stringFromCharCode.apply(String, cs)),\r\n                    cs.length = 0;\r\n            Array.prototype.push.apply(cs, arguments);\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Gets the accessor type.\r\n     * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.accessor = function() {\r\n        return Uint8Array;\r\n    };\r\n    /**\r\n     * Allocates a new ByteBuffer backed by a buffer of the specified capacity.\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {\r\n        return new ByteBuffer(capacity, littleEndian, noAssert);\r\n    };\r\n\r\n    /**\r\n     * Concatenates multiple ByteBuffers into one.\r\n     * @param {!Array.<!ByteBuffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate\r\n     * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string (\"base64\", \"hex\", \"binary\",\r\n     *  defaults to \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults\r\n     *  to {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} Concatenated ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding === 'boolean' || typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var capacity = 0;\r\n        for (var i=0, k=buffers.length, length; i<k; ++i) {\r\n            if (!ByteBuffer.isByteBuffer(buffers[i]))\r\n                buffers[i] = ByteBuffer.wrap(buffers[i], encoding);\r\n            length = buffers[i].limit - buffers[i].offset;\r\n            if (length > 0) capacity += length;\r\n        }\r\n        if (capacity === 0)\r\n            return new ByteBuffer(0, littleEndian, noAssert);\r\n        var bb = new ByteBuffer(capacity, littleEndian, noAssert),\r\n            bi;\r\n        i=0; while (i<k) {\r\n            bi = buffers[i++];\r\n            length = bi.limit - bi.offset;\r\n            if (length <= 0) continue;\r\n            bb.view.set(bi.view.subarray(bi.offset, bi.limit), bb.offset);\r\n            bb.offset += length;\r\n        }\r\n        bb.limit = bb.offset;\r\n        bb.offset = 0;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Tests if the specified type is a ByteBuffer.\r\n     * @param {*} bb ByteBuffer to test\r\n     * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`\r\n     * @expose\r\n     */\r\n    ByteBuffer.isByteBuffer = function(bb) {\r\n        return (bb && bb[\"__isByteBuffer__\"]) === true;\r\n    };\r\n    /**\r\n     * Gets the backing buffer type.\r\n     * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.type = function() {\r\n        return ArrayBuffer;\r\n    };\r\n    /**\r\n     * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its\r\n     *  {@link ByteBuffer#limit} to the length of the wrapped data.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped\r\n     * @param {(string|boolean)=} encoding String encoding if `buffer` is a string (\"base64\", \"hex\", \"binary\", defaults to\r\n     *  \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`\r\n     * @expose\r\n     */\r\n    ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        if (typeof buffer === 'string') {\r\n            if (typeof encoding === 'undefined')\r\n                encoding = \"utf8\";\r\n            switch (encoding) {\r\n                case \"base64\":\r\n                    return ByteBuffer.fromBase64(buffer, littleEndian);\r\n                case \"hex\":\r\n                    return ByteBuffer.fromHex(buffer, littleEndian);\r\n                case \"binary\":\r\n                    return ByteBuffer.fromBinary(buffer, littleEndian);\r\n                case \"utf8\":\r\n                    return ByteBuffer.fromUTF8(buffer, littleEndian);\r\n                case \"debug\":\r\n                    return ByteBuffer.fromDebug(buffer, littleEndian);\r\n                default:\r\n                    throw Error(\"Unsupported encoding: \"+encoding);\r\n            }\r\n        }\r\n        if (buffer === null || typeof buffer !== 'object')\r\n            throw TypeError(\"Illegal buffer\");\r\n        var bb;\r\n        if (ByteBuffer.isByteBuffer(buffer)) {\r\n            bb = ByteBufferPrototype.clone.call(buffer);\r\n            bb.markedOffset = -1;\r\n            return bb;\r\n        }\r\n        if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER\r\n                bb.buffer = buffer.buffer;\r\n                bb.offset = buffer.byteOffset;\r\n                bb.limit = buffer.byteOffset + buffer.byteLength;\r\n                bb.view = new Uint8Array(buffer.buffer);\r\n            }\r\n        } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.byteLength > 0) {\r\n                bb.buffer = buffer;\r\n                bb.offset = 0;\r\n                bb.limit = buffer.byteLength;\r\n                bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null;\r\n            }\r\n        } else if (Object.prototype.toString.call(buffer) === \"[object Array]\") { // Create from octets\r\n            bb = new ByteBuffer(buffer.length, littleEndian, noAssert);\r\n            bb.limit = buffer.length;\r\n            for (var i=0; i<buffer.length; ++i)\r\n                bb.view[i] = buffer[i];\r\n        } else\r\n            throw TypeError(\"Illegal buffer\"); // Otherwise fail\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Writes the array as a bitset.\r\n     * @param {Array<boolean>} value Array of booleans to write\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBitSet = function(value, offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n      if (!this.noAssert) {\r\n        if (!(value instanceof Array))\r\n          throw TypeError(\"Illegal BitSet: Not an array\");\r\n        if (typeof offset !== 'number' || offset % 1 !== 0)\n            throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n        offset >>>= 0;\n        if (offset < 0 || offset + 0 > this.buffer.byteLength)\n            throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n      }\r\n\r\n      var start = offset,\r\n          bits = value.length,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          k;\r\n\r\n      offset += this.writeVarint32(bits,offset);\r\n\r\n      while(bytes--) {\r\n        k = (!!value[bit++] & 1) |\r\n            ((!!value[bit++] & 1) << 1) |\r\n            ((!!value[bit++] & 1) << 2) |\r\n            ((!!value[bit++] & 1) << 3) |\r\n            ((!!value[bit++] & 1) << 4) |\r\n            ((!!value[bit++] & 1) << 5) |\r\n            ((!!value[bit++] & 1) << 6) |\r\n            ((!!value[bit++] & 1) << 7);\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0; k = 0;\r\n        while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n        return this;\r\n      }\r\n      return offset - start;\r\n    }\r\n\r\n    /**\r\n     * Reads a BitSet as an array of booleans.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {Array<boolean>\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBitSet = function(offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n\r\n      var ret = this.readVarint32(offset),\r\n          bits = ret.value,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          value = [],\r\n          k;\r\n\r\n      offset += ret.length;\r\n\r\n      while(bytes--) {\r\n        k = this.readByte(offset++);\r\n        value[bit++] = !!(k & 0x01);\r\n        value[bit++] = !!(k & 0x02);\r\n        value[bit++] = !!(k & 0x04);\r\n        value[bit++] = !!(k & 0x08);\r\n        value[bit++] = !!(k & 0x10);\r\n        value[bit++] = !!(k & 0x20);\r\n        value[bit++] = !!(k & 0x40);\r\n        value[bit++] = !!(k & 0x80);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0;\r\n        k = this.readByte(offset++);\r\n        while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n      }\r\n      return value;\r\n    }\r\n    /**\r\n     * Reads the specified number of bytes.\r\n     * @param {number} length Number of bytes to read\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBytes = function(length, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + length > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n        }\r\n        var slice = this.slice(offset, offset + length);\r\n        if (relative) this.offset += length;\n        return slice;\r\n    };\r\n\r\n    /**\r\n     * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.\r\n     * @function\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;\r\n\r\n    // types/ints/int8\r\n\r\n    /**\r\n     * Writes an 8bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity0 = this.buffer.byteLength;\n        if (offset > capacity0)\n            this.resize((capacity0 *= 2) > offset ? capacity0 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;\r\n\r\n    /**\r\n     * Reads an 8bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity1 = this.buffer.byteLength;\n        if (offset > capacity1)\n            this.resize((capacity1 *= 2) > offset ? capacity1 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;\r\n\r\n    // types/ints/int16\r\n\r\n    /**\r\n     * Writes a 16bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity2 = this.buffer.byteLength;\n        if (offset > capacity2)\n            this.resize((capacity2 *= 2) > offset ? capacity2 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;\r\n\r\n    /**\r\n     * Reads a 16bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity3 = this.buffer.byteLength;\n        if (offset > capacity3)\n            this.resize((capacity3 *= 2) > offset ? capacity3 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;\r\n\r\n    // types/ints/int32\r\n\r\n    /**\r\n     * Writes a 32bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity4 = this.buffer.byteLength;\n        if (offset > capacity4)\n            this.resize((capacity4 *= 2) > offset ? capacity4 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;\r\n\r\n    /**\r\n     * Reads a 32bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        value |= 0; // Cast to signed\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity5 = this.buffer.byteLength;\n        if (offset > capacity5)\n            this.resize((capacity5 *= 2) > offset ? capacity5 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;\r\n\r\n    // types/ints/int64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Writes a 64bit signed integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeInt64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity6 = this.buffer.byteLength;\n            if (offset > capacity6)\n                this.resize((capacity6 *= 2) > offset ? capacity6 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;\r\n\r\n        /**\r\n         * Reads a 64bit signed integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readInt64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, false);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity7 = this.buffer.byteLength;\n            if (offset > capacity7)\n                this.resize((capacity7 *= 2) > offset ? capacity7 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.\r\n         * @function\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, true);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.\r\n         * @function\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;\r\n\r\n    } // Long\r\n\r\n\r\n    // types/floats/float32\r\n\r\n    /*\r\n     ieee754 - https://github.com/feross/ieee754\r\n\r\n     The MIT License (MIT)\r\n\r\n     Copyright (c) Feross Aboukhadijeh\r\n\r\n     Permission is hereby granted, free of charge, to any person obtaining a copy\r\n     of this software and associated documentation files (the \"Software\"), to deal\r\n     in the Software without restriction, including without limitation the rights\r\n     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n     copies of the Software, and to permit persons to whom the Software is\r\n     furnished to do so, subject to the following conditions:\r\n\r\n     The above copyright notice and this permission notice shall be included in\r\n     all copies or substantial portions of the Software.\r\n\r\n     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n     THE SOFTWARE.\r\n    */\r\n\r\n    /**\r\n     * Reads an IEEE754 float from a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    function ieee754_read(buffer, offset, isLE, mLen, nBytes) {\r\n        var e, m,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            nBits = -7,\r\n            i = isLE ? (nBytes - 1) : 0,\r\n            d = isLE ? -1 : 1,\r\n            s = buffer[offset + i];\r\n\r\n        i += d;\r\n\r\n        e = s & ((1 << (-nBits)) - 1);\r\n        s >>= (-nBits);\r\n        nBits += eLen;\r\n        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        m = e & ((1 << (-nBits)) - 1);\r\n        e >>= (-nBits);\r\n        nBits += mLen;\r\n        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        if (e === 0) {\r\n            e = 1 - eBias;\r\n        } else if (e === eMax) {\r\n            return m ? NaN : ((s ? -1 : 1) * Infinity);\r\n        } else {\r\n            m = m + Math.pow(2, mLen);\r\n            e = e - eBias;\r\n        }\r\n        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\r\n    }\r\n\r\n    /**\r\n     * Writes an IEEE754 float to a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} value\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @inner\r\n     */\r\n    function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) {\r\n        var e, m, c,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),\r\n            i = isLE ? 0 : (nBytes - 1),\r\n            d = isLE ? 1 : -1,\r\n            s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\r\n\r\n        value = Math.abs(value);\r\n\r\n        if (isNaN(value) || value === Infinity) {\r\n            m = isNaN(value) ? 1 : 0;\r\n            e = eMax;\r\n        } else {\r\n            e = Math.floor(Math.log(value) / Math.LN2);\r\n            if (value * (c = Math.pow(2, -e)) < 1) {\r\n                e--;\r\n                c *= 2;\r\n            }\r\n            if (e + eBias >= 1) {\r\n                value += rt / c;\r\n            } else {\r\n                value += rt * Math.pow(2, 1 - eBias);\r\n            }\r\n            if (value * c >= 2) {\r\n                e++;\r\n                c /= 2;\r\n            }\r\n\r\n            if (e + eBias >= eMax) {\r\n                m = 0;\r\n                e = eMax;\r\n            } else if (e + eBias >= 1) {\r\n                m = (value * c - 1) * Math.pow(2, mLen);\r\n                e = e + eBias;\r\n            } else {\r\n                m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\r\n                e = 0;\r\n            }\r\n        }\r\n\r\n        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\r\n\r\n        e = (e << mLen) | m;\r\n        eLen += mLen;\r\n        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\r\n\r\n        buffer[offset + i - d] |= s * 128;\r\n    }\r\n\r\n    /**\r\n     * Writes a 32bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity8 = this.buffer.byteLength;\n        if (offset > capacity8)\n            this.resize((capacity8 *= 2) > offset ? capacity8 : offset);\n        offset -= 4;\n        ieee754_write(this.view, value, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;\r\n\r\n    /**\r\n     * Reads a 32bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;\r\n\r\n    // types/floats/float64\r\n\r\n    /**\r\n     * Writes a 64bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat64 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 8;\n        var capacity9 = this.buffer.byteLength;\n        if (offset > capacity9)\n            this.resize((capacity9 *= 2) > offset ? capacity9 : offset);\n        offset -= 8;\n        ieee754_write(this.view, value, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64;\r\n\r\n    /**\r\n     * Reads a 64bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat64 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;\r\n\r\n\r\n    // types/varints/varint32\r\n\r\n    /**\r\n     * Maximum number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @type {number}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.MAX_VARINT32_BYTES = 5;\r\n\r\n    /**\r\n     * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to encode\r\n     * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateVarint32 = function(value) {\r\n        // ref: src/google/protobuf/io/coded_stream.cc\r\n        value = value >>> 0;\r\n             if (value < 1 << 7 ) return 1;\r\n        else if (value < 1 << 14) return 2;\r\n        else if (value < 1 << 21) return 3;\r\n        else if (value < 1 << 28) return 4;\r\n        else                      return 5;\r\n    };\r\n\r\n    /**\r\n     * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.\r\n     * @param {number} n Signed 32bit integer\r\n     * @returns {number} Unsigned zigzag encoded 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagEncode32 = function(n) {\r\n        return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Decodes a zigzag encoded signed 32bit integer.\r\n     * @param {number} n Unsigned zigzag encoded 32bit integer\r\n     * @returns {number} Signed 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagDecode32 = function(n) {\r\n        return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var size = ByteBuffer.calculateVarint32(value),\r\n            b;\r\n        offset += size;\n        var capacity10 = this.buffer.byteLength;\n        if (offset > capacity10)\n            this.resize((capacity10 *= 2) > offset ? capacity10 : offset);\n        offset -= size;\n        value >>>= 0;\r\n        while (value >= 0x80) {\r\n            b = (value & 0x7f) | 0x80;\r\n            this.view[offset++] = b;\r\n            value >>>= 7;\r\n        }\r\n        this.view[offset++] = value;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return size;\r\n    };\r\n\r\n    /**\r\n     * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {\r\n        return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available\r\n     *  to fully decode the varint.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var c = 0,\r\n            value = 0 >>> 0,\r\n            b;\r\n        do {\r\n            if (!this.noAssert && offset > this.limit) {\r\n                var err = Error(\"Truncated\");\r\n                err['truncated'] = true;\r\n                throw err;\r\n            }\r\n            b = this.view[offset++];\r\n            if (c < 5)\r\n                value |= (b & 0x7f) << (7*c);\r\n            ++c;\r\n        } while ((b & 0x80) !== 0);\r\n        value |= 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return value;\r\n        }\r\n        return {\r\n            \"value\": value,\r\n            \"length\": c\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32ZigZag = function(offset) {\r\n        var val = this.readVarint32(offset);\r\n        if (typeof val === 'object')\r\n            val[\"value\"] = ByteBuffer.zigZagDecode32(val[\"value\"]);\r\n        else\r\n            val = ByteBuffer.zigZagDecode32(val);\r\n        return val;\r\n    };\r\n\r\n    // types/varints/varint64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Maximum number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @type {number}\r\n         * @const\r\n         * @expose\r\n         */\r\n        ByteBuffer.MAX_VARINT64_BYTES = 10;\r\n\r\n        /**\r\n         * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @param {number|!Long} value Value to encode\r\n         * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}\r\n         * @expose\r\n         */\r\n        ByteBuffer.calculateVarint64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            if (part2 == 0) {\r\n                if (part1 == 0) {\r\n                    if (part0 < 1 << 14)\r\n                        return part0 < 1 << 7 ? 1 : 2;\r\n                    else\r\n                        return part0 < 1 << 21 ? 3 : 4;\r\n                } else {\r\n                    if (part1 < 1 << 14)\r\n                        return part1 < 1 << 7 ? 5 : 6;\r\n                    else\r\n                        return part1 < 1 << 21 ? 7 : 8;\r\n                }\r\n            } else\r\n                return part2 < 1 << 7 ? 9 : 10;\r\n        };\r\n\r\n        /**\r\n         * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.\r\n         * @param {number|!Long} value Signed long\r\n         * @returns {!Long} Unsigned zigzag encoded long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagEncode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();\r\n        };\r\n\r\n        /**\r\n         * Decodes a zigzag encoded signed 64bit integer.\r\n         * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number\r\n         * @returns {!Long} Signed long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagDecode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            var size = ByteBuffer.calculateVarint64(value),\r\n                part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            offset += size;\n            var capacity11 = this.buffer.byteLength;\n            if (offset > capacity11)\n                this.resize((capacity11 *= 2) > offset ? capacity11 : offset);\n            offset -= size;\n            switch (size) {\r\n                case 10: this.view[offset+9] = (part2 >>>  7) & 0x01;\r\n                case 9 : this.view[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;\r\n                case 8 : this.view[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;\r\n                case 7 : this.view[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;\r\n                case 6 : this.view[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;\r\n                case 5 : this.view[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;\r\n                case 4 : this.view[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;\r\n                case 3 : this.view[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;\r\n                case 2 : this.view[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;\r\n                case 1 : this.view[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;\r\n            }\r\n            if (relative) {\r\n                this.offset += size;\r\n                return this;\r\n            } else {\r\n                return size;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Writes a zig-zag encoded 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {\r\n            return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n            }\r\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var start = offset,\r\n                part0 = 0,\r\n                part1 = 0,\r\n                part2 = 0,\r\n                b  = 0;\r\n            b = this.view[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            throw Error(\"Buffer overrun\"); }}}}}}}}}}\r\n            var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return value;\r\n            } else {\r\n                return {\r\n                    'value': value,\r\n                    'length': offset-start\r\n                };\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64ZigZag = function(offset) {\r\n            var val = this.readVarint64(offset);\r\n            if (val && val['value'] instanceof Long)\r\n                val[\"value\"] = ByteBuffer.zigZagDecode64(val[\"value\"]);\r\n            else\r\n                val = ByteBuffer.zigZagDecode64(val);\r\n            return val;\r\n        };\r\n\r\n    } // Long\r\n\r\n\r\n    // types/strings/cstring\r\n\r\n    /**\r\n     * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL\r\n     *  characters itself.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  contained in `str` + 1 if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeCString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        var i,\r\n            k = str.length;\r\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            for (i=0; i<k; ++i) {\r\n                if (str.charCodeAt(i) === 0)\r\n                    throw RangeError(\"Illegal str: Contains NULL-characters\");\r\n            }\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character, so:\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k+1;\n        var capacity12 = this.buffer.byteLength;\n        if (offset > capacity12)\n            this.resize((capacity12 *= 2) > offset ? capacity12 : offset);\n        offset -= k+1;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        this.view[offset++] = 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return k;\r\n    };\r\n\r\n    /**\r\n     * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters\r\n     *  itself.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readCString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            temp;\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:\r\n        var sd, b = -1;\r\n        utfx.decodeUTF8toUTF16(function() {\r\n            if (b === 0) return null;\r\n            if (offset >= this.limit)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" < \"+this.limit);\r\n            b = this.view[offset++];\r\n            return b === 0 ? null : b;\r\n        }.bind(this), sd = stringDestination(), true);\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return sd();\r\n        } else {\r\n            return {\r\n                \"string\": sd(),\r\n                \"length\": offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/istring\r\n\r\n    /**\r\n     * Writes a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeIString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        offset += 4+k;\n        var capacity13 = this.buffer.byteLength;\n        if (offset > capacity13)\n            this.resize((capacity13 *= 2) > offset ? capacity13 : offset);\n        offset -= 4+k;\n        if (this.littleEndian) {\n            this.view[offset+3] = (k >>> 24) & 0xFF;\n            this.view[offset+2] = (k >>> 16) & 0xFF;\n            this.view[offset+1] = (k >>>  8) & 0xFF;\n            this.view[offset  ] =  k         & 0xFF;\n        } else {\n            this.view[offset  ] = (k >>> 24) & 0xFF;\n            this.view[offset+1] = (k >>> 16) & 0xFF;\n            this.view[offset+2] = (k >>>  8) & 0xFF;\n            this.view[offset+3] =  k         & 0xFF;\n        }\n        offset += 4;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start + 4 + k)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+4+k));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readIString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readUint32(offset);\r\n        var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/utf8string\r\n\r\n    /**\r\n     * Metrics representing number of UTF8 characters. Evaluates to `c`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_CHARS = 'c';\r\n\r\n    /**\r\n     * Metrics representing number of bytes. Evaluates to `b`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_BYTES = 'b';\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUTF8String = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var k;\r\n        var start = offset;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k;\n        var capacity14 = this.buffer.byteLength;\n        if (offset > capacity14)\n            this.resize((capacity14 *= 2) > offset ? capacity14 : offset);\n        offset -= k;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.\r\n     * @function\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;\r\n\r\n    /**\r\n     * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's\r\n     *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 characters\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Chars = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[0];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Bytes = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.\r\n     * @function\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string.\r\n     * @param {number} length Number of characters or bytes to read.\r\n     * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {\r\n        if (typeof metrics === 'number') {\r\n            offset = metrics;\r\n            metrics = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var i = 0,\r\n            start = offset,\r\n            sd;\r\n        if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser\r\n            sd = stringDestination();\r\n            utfx.decodeUTF8(function() {\r\n                return i < length && offset < this.limit ? this.view[offset++] : null;\r\n            }.bind(this), function(cp) {\r\n                ++i; utfx.UTF8toUTF16(cp, sd);\r\n            });\r\n            if (i !== length)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+i+\" == \"+length);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    \"string\": sd(),\r\n                    \"length\": offset - start\r\n                };\r\n            }\r\n        } else if (metrics === ByteBuffer.METRICS_BYTES) {\r\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + length > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n            }\r\n            var k = offset + length;\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return offset < k ? this.view[offset++] : null;\r\n            }.bind(this), sd = stringDestination(), this.noAssert);\r\n            if (offset !== k)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+k);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    'string': sd(),\r\n                    'length': offset - start\r\n                };\r\n            }\r\n        } else\r\n            throw TypeError(\"Unsupported metrics: \"+metrics);\r\n    };\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.\r\n     * @function\r\n     * @param {number} length Number of characters or bytes to read\r\n     * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;\r\n\r\n    // types/strings/vstring\r\n\r\n    /**\r\n     * Writes a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeVString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k, l;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        l = ByteBuffer.calculateVarint32(k);\r\n        offset += l+k;\n        var capacity15 = this.buffer.byteLength;\n        if (offset > capacity15)\n            this.resize((capacity15 *= 2) > offset ? capacity15 : offset);\n        offset -= l+k;\n        offset += this.writeVarint32(k, offset);\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start+k+l)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+k+l));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readVString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readVarint32(offset);\r\n        var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n\r\n    /**\r\n     * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended\r\n     *  data's length.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`\r\n     * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`\r\n     */\r\n    ByteBufferPrototype.append = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var length = source.limit - source.offset;\r\n        if (length <= 0) return this; // Nothing to append\r\n        offset += length;\n        var capacity16 = this.buffer.byteLength;\n        if (offset > capacity16)\n            this.resize((capacity16 *= 2) > offset ? capacity16 : offset);\n        offset -= length;\n        this.view.set(source.view.subarray(source.offset, source.limit), offset);\r\n        source.offset += length;\r\n        if (relative) this.offset += length;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the\r\n        specified offset up to the length of this ByteBuffer's data.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#append\r\n     */\r\n    ByteBufferPrototype.appendTo = function(target, offset) {\r\n        target.append(this, offset);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to\r\n     *  disable them if your code already makes sure that everything is valid.\r\n     * @param {boolean} assert `true` to enable assertions, otherwise `false`\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.assert = function(assert) {\r\n        this.noAssert = !assert;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Gets the capacity of this ByteBuffer's backing buffer.\r\n     * @returns {number} Capacity of the backing buffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.capacity = function() {\r\n        return this.buffer.byteLength;\r\n    };\r\n    /**\r\n     * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the\r\n     *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clear = function() {\r\n        this.offset = 0;\r\n        this.limit = this.buffer.byteLength;\r\n        this.markedOffset = -1;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},\r\n     *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`\r\n     * @returns {!ByteBuffer} Cloned instance\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clone = function(copy) {\r\n        var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        if (copy) {\r\n            bb.buffer = new ArrayBuffer(this.buffer.byteLength);\r\n            bb.view = new Uint8Array(bb.buffer);\r\n        } else {\r\n            bb.buffer = this.buffer;\r\n            bb.view = this.view;\r\n        }\r\n        bb.offset = this.offset;\r\n        bb.markedOffset = this.markedOffset;\r\n        bb.limit = this.limit;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes\r\n     *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and\r\n     *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.compact = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === 0 && end === this.buffer.byteLength)\r\n            return this; // Already compacted\r\n        var len = end - begin;\r\n        if (len === 0) {\r\n            this.buffer = EMPTY_BUFFER;\r\n            this.view = null;\r\n            if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n            this.offset = 0;\r\n            this.limit = 0;\r\n            return this;\r\n        }\r\n        var buffer = new ArrayBuffer(len);\r\n        var view = new Uint8Array(buffer);\r\n        view.set(this.view.subarray(begin, end));\r\n        this.buffer = buffer;\r\n        this.view = view;\r\n        if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n        this.offset = 0;\r\n        this.limit = len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Copy\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copy = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        var capacity = end - begin,\r\n            bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);\r\n        bb.offset = 0;\r\n        bb.limit = capacity;\r\n        if (bb.markedOffset >= 0) bb.markedOffset -= begin;\r\n        this.copyTo(bb, 0, begin, end);\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}\r\n     *  by the number of bytes copied if omitted.\r\n     * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the\r\n     *  number of bytes copied if omitted.\r\n     * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {\r\n        var relative,\r\n            targetRelative;\r\n        if (!this.noAssert) {\r\n            if (!ByteBuffer.isByteBuffer(target))\r\n                throw TypeError(\"Illegal target: Not a ByteBuffer\");\r\n        }\r\n        targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;\r\n        sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;\r\n        sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;\r\n\r\n        if (targetOffset < 0 || targetOffset > target.buffer.byteLength)\r\n            throw RangeError(\"Illegal target range: 0 <= \"+targetOffset+\" <= \"+target.buffer.byteLength);\r\n        if (sourceOffset < 0 || sourceLimit > this.buffer.byteLength)\r\n            throw RangeError(\"Illegal source range: 0 <= \"+sourceOffset+\" <= \"+this.buffer.byteLength);\r\n\r\n        var len = sourceLimit - sourceOffset;\r\n        if (len === 0)\r\n            return target; // Nothing to copy\r\n\r\n        target.ensureCapacity(targetOffset + len);\r\n\r\n        target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset);\r\n\r\n        if (relative) this.offset += len;\r\n        if (targetRelative) target.offset += len;\r\n\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the\r\n     *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,\r\n     *  the required capacity will be used instead.\r\n     * @param {number} capacity Required capacity\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.ensureCapacity = function(capacity) {\r\n        var current = this.buffer.byteLength;\r\n        if (current < capacity)\r\n            return this.resize((current *= 2) > capacity ? current : capacity);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {number|string} value Byte value to fill with. If given as a string, the first character is used.\r\n     * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted. defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes\r\n     */\r\n    ByteBufferPrototype.fill = function(value, begin, end) {\r\n        var relative = typeof begin === 'undefined';\n        if (relative) begin = this.offset;\n        if (typeof value === 'string' && value.length > 0)\r\n            value = value.charCodeAt(0);\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin >= end)\r\n            return this; // Nothing to fill\r\n        while (begin < end) this.view[begin++] = value;\r\n        if (relative) this.offset = begin;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and\r\n     *  `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.flip = function() {\r\n        this.limit = this.offset;\r\n        this.offset = 0;\r\n        return this;\r\n    };\r\n    /**\r\n     * Marks an offset on this ByteBuffer to be used later.\r\n     * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @see ByteBuffer#reset\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.mark = function(offset) {\r\n        offset = typeof offset === 'undefined' ? this.offset : offset;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        this.markedOffset = offset;\r\n        return this;\r\n    };\r\n    /**\r\n     * Sets the byte order.\r\n     * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.order = function(littleEndian) {\r\n        if (!this.noAssert) {\r\n            if (typeof littleEndian !== 'boolean')\r\n                throw TypeError(\"Illegal littleEndian: Not a boolean\");\r\n        }\r\n        this.littleEndian = !!littleEndian;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) little endian byte order.\r\n     * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.LE = function(littleEndian) {\r\n        this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) big endian byte order.\r\n     * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.BE = function(bigEndian) {\r\n        this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false;\r\n        return this;\r\n    };\r\n    /**\r\n     * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer|string|!ArrayBuffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be\r\n     *  modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|`\r\n     * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|`\r\n     */\r\n    ByteBufferPrototype.prepend = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var len = source.limit - source.offset;\r\n        if (len <= 0) return this; // Nothing to prepend\r\n        var diff = len - offset;\r\n        if (diff > 0) { // Not enough space before offset, so resize + move\r\n            var buffer = new ArrayBuffer(this.buffer.byteLength + diff);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view.subarray(offset, this.buffer.byteLength), len);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n            this.offset += diff;\r\n            if (this.markedOffset >= 0) this.markedOffset += diff;\r\n            this.limit += diff;\r\n            offset += diff;\r\n        } else {\r\n            var arrayView = new Uint8Array(this.buffer);\r\n        }\r\n        this.view.set(source.view.subarray(source.offset, source.limit), offset - len);\r\n\r\n        source.offset = source.limit;\r\n        if (relative)\r\n            this.offset -= len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#prepend\r\n     */\r\n    ByteBufferPrototype.prependTo = function(target, offset) {\r\n        target.prepend(this, offset);\r\n        return this;\r\n    };\r\n    /**\r\n     * Prints debug information about this ByteBuffer's contents.\r\n     * @param {function(string)=} out Output function to call, defaults to console.log\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.printDebug = function(out) {\r\n        if (typeof out !== 'function') out = console.log.bind(console);\r\n        out(\r\n            this.toString()+\"\\n\"+\r\n            \"-------------------------------------------------------------------\\n\"+\r\n            this.toDebug(/* columns */ true)\r\n        );\r\n    };\r\n\r\n    /**\r\n     * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}, so this returns `limit - offset`.\r\n     * @returns {number} Remaining readable bytes. May be negative if `offset > limit`.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.remaining = function() {\r\n        return this.limit - this.offset;\r\n    };\r\n    /**\r\n     * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark}\r\n     *  before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been\r\n     *  marked, sets `offset = 0`.\r\n     * @returns {!ByteBuffer} this\r\n     * @see ByteBuffer#mark\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reset = function() {\r\n        if (this.markedOffset >= 0) {\r\n            this.offset = this.markedOffset;\r\n            this.markedOffset = -1;\r\n        } else {\r\n            this.offset = 0;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that\r\n     *  large or larger.\r\n     * @param {number} capacity Capacity required\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `capacity` is not a number\r\n     * @throws {RangeError} If `capacity < 0`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.resize = function(capacity) {\r\n        if (!this.noAssert) {\r\n            if (typeof capacity !== 'number' || capacity % 1 !== 0)\n                throw TypeError(\"Illegal capacity: \"+capacity+\" (not an integer)\");\n            capacity |= 0;\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity: 0 <= \"+capacity);\r\n        }\r\n        if (this.buffer.byteLength < capacity) {\r\n            var buffer = new ArrayBuffer(capacity);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Reverses this ByteBuffer's contents.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reverse = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return this; // Nothing to reverse\r\n        Array.prototype.reverse.call(this.view.subarray(begin, end));\r\n        return this;\r\n    };\r\n    /**\r\n     * Skips the next `length` bytes. This will just advance\r\n     * @param {number} length Number of bytes to skip. May also be negative to move the offset back.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.skip = function(length) {\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n        }\r\n        var offset = this.offset + length;\r\n        if (!this.noAssert) {\r\n            if (offset < 0 || offset > this.buffer.byteLength)\r\n                throw RangeError(\"Illegal length: 0 <= \"+this.offset+\" + \"+length+\" <= \"+this.buffer.byteLength);\r\n        }\r\n        this.offset = offset;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.slice = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var bb = this.clone();\r\n        bb.offset = begin;\r\n        bb.limit = end;\r\n        return bb;\r\n    };\r\n    /**\r\n     * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if\r\n     *  possible. Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBuffer = function(forceCopy) {\r\n        var offset = this.offset,\r\n            limit = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: Not an integer\");\n            offset >>>= 0;\n            if (typeof limit !== 'number' || limit % 1 !== 0)\n                throw TypeError(\"Illegal limit: Not an integer\");\n            limit >>>= 0;\n            if (offset < 0 || offset > limit || limit > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+offset+\" <= \"+limit+\" <= \"+this.buffer.byteLength);\n        }\r\n        // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is\r\n        // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So:\r\n        if (!forceCopy && offset === 0 && limit === this.buffer.byteLength)\r\n            return this.buffer;\r\n        if (offset === limit)\r\n            return EMPTY_BUFFER;\r\n        var buffer = new ArrayBuffer(limit - offset);\r\n        new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0);\r\n        return buffer;\r\n    };\r\n\r\n    /**\r\n     * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}.\r\n     * @function\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory.\r\n     *  Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer;\r\n\r\n    /**\r\n     * Converts the ByteBuffer's contents to a string.\r\n     * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows\r\n     *  direct conversion to \"utf8\", \"hex\", \"base64\" and \"binary\" encoding. \"debug\" returns a hex representation with\r\n     *  highlighted offsets.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {string} String representation\r\n     * @throws {Error} If `encoding` is invalid\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toString = function(encoding, begin, end) {\r\n        if (typeof encoding === 'undefined')\r\n            return \"ByteBufferAB(offset=\"+this.offset+\",markedOffset=\"+this.markedOffset+\",limit=\"+this.limit+\",capacity=\"+this.capacity()+\")\";\r\n        if (typeof encoding === 'number')\r\n            encoding = \"utf8\",\r\n            begin = encoding,\r\n            end = begin;\r\n        switch (encoding) {\r\n            case \"utf8\":\r\n                return this.toUTF8(begin, end);\r\n            case \"base64\":\r\n                return this.toBase64(begin, end);\r\n            case \"hex\":\r\n                return this.toHex(begin, end);\r\n            case \"binary\":\r\n                return this.toBinary(begin, end);\r\n            case \"debug\":\r\n                return this.toDebug();\r\n            case \"columns\":\r\n                return this.toColumns();\r\n            default:\r\n                throw Error(\"Unsupported encoding: \"+encoding);\r\n        }\r\n    };\r\n\r\n    // lxiv-embeddable\r\n\r\n    /**\r\n     * lxiv-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/lxiv for details\r\n     */\r\n    var lxiv = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * lxiv namespace.\r\n         * @type {!Object.<string,*>}\r\n         * @exports lxiv\r\n         */\r\n        var lxiv = {};\r\n\r\n        /**\r\n         * Character codes for output.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var aout = [\r\n            65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,\r\n            81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102,\r\n            103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,\r\n            119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47\r\n        ];\r\n\r\n        /**\r\n         * Character codes for input.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var ain = [];\r\n        for (var i=0, k=aout.length; i<k; ++i)\r\n            ain[aout[i]] = i;\r\n\r\n        /**\r\n         * Encodes bytes to base64 char codes.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if\r\n         *  there are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each encoded char\r\n         *  code.\r\n         */\r\n        lxiv.encode = function(src, dst) {\r\n            var b, t;\r\n            while ((b = src()) !== null) {\r\n                dst(aout[(b>>2)&0x3f]);\r\n                t = (b&0x3)<<4;\r\n                if ((b = src()) !== null) {\r\n                    t |= (b>>4)&0xf;\r\n                    dst(aout[(t|((b>>4)&0xf))&0x3f]);\r\n                    t = (b&0xf)<<2;\r\n                    if ((b = src()) !== null)\r\n                        dst(aout[(t|((b>>6)&0x3))&0x3f]),\r\n                        dst(aout[b&0x3f]);\r\n                    else\r\n                        dst(aout[t&0x3f]),\r\n                        dst(61);\r\n                } else\r\n                    dst(aout[t&0x3f]),\r\n                    dst(61),\r\n                    dst(61);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes base64 char codes to bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         * @throws {Error} If a character code is invalid\r\n         */\r\n        lxiv.decode = function(src, dst) {\r\n            var c, t1, t2;\r\n            function fail(c) {\r\n                throw Error(\"Illegal character code: \"+c);\r\n            }\r\n            while ((c = src()) !== null) {\r\n                t1 = ain[c];\r\n                if (typeof t1 === 'undefined') fail(c);\r\n                if ((c = src()) !== null) {\r\n                    t2 = ain[c];\r\n                    if (typeof t2 === 'undefined') fail(c);\r\n                    dst((t1<<2)>>>0|(t2&0x30)>>4);\r\n                    if ((c = src()) !== null) {\r\n                        t1 = ain[c];\r\n                        if (typeof t1 === 'undefined')\r\n                            if (c === 61) break; else fail(c);\r\n                        dst(((t2&0xf)<<4)>>>0|(t1&0x3c)>>2);\r\n                        if ((c = src()) !== null) {\r\n                            t2 = ain[c];\r\n                            if (typeof t2 === 'undefined')\r\n                                if (c === 61) break; else fail(c);\r\n                            dst(((t1&0x3)<<6)>>>0|t2);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Tests if a string is valid base64.\r\n         * @param {string} str String to test\r\n         * @returns {boolean} `true` if valid, otherwise `false`\r\n         */\r\n        lxiv.test = function(str) {\r\n            return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(str);\r\n        };\r\n\r\n        return lxiv;\r\n    }();\r\n\r\n    // encodings/base64\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a base64 encoded string.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Base64 encoded string\r\n     * @throws {RangeError} If `begin` or `end` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBase64 = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin = begin | 0; end = end | 0;\r\n        if (begin < 0 || end > this.capacity || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        var sd; lxiv.encode(function() {\r\n            return begin < end ? this.view[begin++] : null;\r\n        }.bind(this), sd = stringDestination());\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBase64 = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var bb = new ByteBuffer(str.length/4*3, littleEndian),\r\n            i = 0;\r\n        lxiv.decode(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Encodes a binary string to base64 like `window.btoa` does.\r\n     * @param {string} str Binary string\r\n     * @returns {string} Base64 encoded string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa\r\n     * @expose\r\n     */\r\n    ByteBuffer.btoa = function(str) {\r\n        return ByteBuffer.fromBinary(str).toBase64();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to binary like `window.atob` does.\r\n     * @param {string} b64 Base64 encoded string\r\n     * @returns {string} Binary string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob\r\n     * @expose\r\n     */\r\n    ByteBuffer.atob = function(b64) {\r\n        return ByteBuffer.fromBase64(b64).toBinary();\r\n    };\r\n\r\n    // encodings/binary\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Binary encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBinary = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin |= 0; end |= 0;\r\n        if (begin < 0 || end > this.capacity() || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        if (begin === end)\r\n            return \"\";\r\n        var chars = [],\r\n            parts = [];\r\n        while (begin < end) {\r\n            chars.push(this.view[begin++]);\r\n            if (chars.length >= 1024)\r\n                parts.push(String.fromCharCode.apply(String, chars)),\r\n                chars = [];\r\n        }\r\n        return parts.join('') + String.fromCharCode.apply(String, chars);\r\n    };\r\n\r\n    /**\r\n     * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBinary = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var i = 0,\r\n            k = str.length,\r\n            charCode,\r\n            bb = new ByteBuffer(k, littleEndian);\r\n        while (i<k) {\r\n            charCode = str.charCodeAt(i);\r\n            if (charCode > 0xff)\r\n                throw RangeError(\"illegal char code: \"+charCode);\r\n            bb.view[i++] = charCode;\r\n        }\r\n        bb.limit = k;\r\n        return bb;\r\n    };\r\n\r\n    // encodings/debug\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are:\r\n     * * `<` : offset,\r\n     * * `'` : markedOffset,\r\n     * * `>` : limit,\r\n     * * `|` : offset and limit,\r\n     * * `[` : offset and markedOffset,\r\n     * * `]` : markedOffset and limit,\r\n     * * `!` : offset, markedOffset and limit\r\n     * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false`\r\n     * @returns {string|!Array.<string>} Debug string or array of lines if `asArray = true`\r\n     * @expose\r\n     * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3`\r\n     * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4`\r\n     * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1`\r\n     * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1`\r\n     */\r\n    ByteBufferPrototype.toDebug = function(columns) {\r\n        var i = -1,\r\n            k = this.buffer.byteLength,\r\n            b,\r\n            hex = \"\",\r\n            asc = \"\",\r\n            out = \"\";\r\n        while (i<k) {\r\n            if (i !== -1) {\r\n                b = this.view[i];\r\n                if (b < 0x10) hex += \"0\"+b.toString(16).toUpperCase();\r\n                else hex += b.toString(16).toUpperCase();\r\n                if (columns)\r\n                    asc += b > 32 && b < 127 ? String.fromCharCode(b) : '.';\r\n            }\r\n            ++i;\r\n            if (columns) {\r\n                if (i > 0 && i % 16 === 0 && i !== k) {\r\n                    while (hex.length < 3*16+3) hex += \" \";\r\n                    out += hex+asc+\"\\n\";\r\n                    hex = asc = \"\";\r\n                }\r\n            }\r\n            if (i === this.offset && i === this.limit)\r\n                hex += i === this.markedOffset ? \"!\" : \"|\";\r\n            else if (i === this.offset)\r\n                hex += i === this.markedOffset ? \"[\" : \"<\";\r\n            else if (i === this.limit)\r\n                hex += i === this.markedOffset ? \"]\" : \">\";\r\n            else\r\n                hex += i === this.markedOffset ? \"'\" : (columns || (i !== 0 && i !== k) ? \" \" : \"\");\r\n        }\r\n        if (columns && hex !== \" \") {\r\n            while (hex.length < 3*16+3)\r\n                hex += \" \";\r\n            out += hex + asc + \"\\n\";\r\n        }\r\n        return columns ? out : hex;\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string with marked offsets to a ByteBuffer.\r\n     * @param {string} str Debug string to decode (not be generated with `columns = true`)\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     * @see ByteBuffer#toDebug\r\n     */\r\n    ByteBuffer.fromDebug = function(str, littleEndian, noAssert) {\r\n        var k = str.length,\r\n            bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert);\r\n        var i = 0, j = 0, ch, b,\r\n            rs = false, // Require symbol next\r\n            ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)?\r\n            fail = false;\r\n        while (i<k) {\r\n            switch (ch = str.charAt(i++)) {\r\n                case '!':\r\n                    if (!noAssert) {\r\n                        if (ho || hm || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = hl = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '|':\r\n                    if (!noAssert) {\r\n                        if (ho || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hl = true;\r\n                    }\r\n                    bb.offset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '[':\r\n                    if (!noAssert) {\r\n                        if (ho || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '<':\r\n                    if (!noAssert) {\r\n                        if (ho) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = true;\r\n                    }\r\n                    bb.offset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ']':\r\n                    if (!noAssert) {\r\n                        if (hl || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = hm = true;\r\n                    }\r\n                    bb.limit = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '>':\r\n                    if (!noAssert) {\r\n                        if (hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = true;\r\n                    }\r\n                    bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case \"'\":\r\n                    if (!noAssert) {\r\n                        if (hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hm = true;\r\n                    }\r\n                    bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ' ':\r\n                    rs = false;\r\n                    break;\r\n                default:\r\n                    if (!noAssert) {\r\n                        if (rs) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                    }\r\n                    b = parseInt(ch+str.charAt(i++), 16);\r\n                    if (!noAssert) {\r\n                        if (isNaN(b) || b < 0 || b > 255)\r\n                            throw TypeError(\"Illegal str: Not a debug encoded string\");\r\n                    }\r\n                    bb.view[j++] = b;\r\n                    rs = true;\r\n            }\r\n            if (fail)\r\n                throw TypeError(\"Illegal str: Invalid symbol at \"+i);\r\n        }\r\n        if (!noAssert) {\r\n            if (!ho || !hl)\r\n                throw TypeError(\"Illegal str: Missing offset or limit\");\r\n            if (j<bb.buffer.byteLength)\r\n                throw TypeError(\"Illegal str: Not a debug encoded string (is it hex?) \"+j+\" < \"+k);\r\n        }\r\n        return bb;\r\n    };\r\n\r\n    // encodings/hex\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a hex encoded string.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Hex encoded string\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toHex = function(begin, end) {\r\n        begin = typeof begin === 'undefined' ? this.offset : begin;\r\n        end = typeof end === 'undefined' ? this.limit : end;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var out = new Array(end - begin),\r\n            b;\r\n        while (begin < end) {\r\n            b = this.view[begin++];\r\n            if (b < 0x10)\r\n                out.push(\"0\", b.toString(16));\r\n            else out.push(b.toString(16));\r\n        }\r\n        return out.join('');\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromHex = function(str, littleEndian, noAssert) {\r\n        if (!noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (str.length % 2 !== 0)\r\n                throw TypeError(\"Illegal str: Length not a multiple of 2\");\r\n        }\r\n        var k = str.length,\r\n            bb = new ByteBuffer((k / 2) | 0, littleEndian),\r\n            b;\r\n        for (var i=0, j=0; i<k; i+=2) {\r\n            b = parseInt(str.substring(i, i+2), 16);\r\n            if (!noAssert)\r\n                if (!isFinite(b) || b < 0 || b > 255)\r\n                    throw TypeError(\"Illegal str: Contains non-hex characters\");\r\n            bb.view[j++] = b;\r\n        }\r\n        bb.limit = j;\r\n        return bb;\r\n    };\r\n\r\n    // utfx-embeddable\r\n\r\n    /**\r\n     * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/utfx for details\r\n     */\r\n    var utfx = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * utfx namespace.\r\n         * @inner\r\n         * @type {!Object.<string,*>}\r\n         */\r\n        var utfx = {};\r\n\r\n        /**\r\n         * Maximum valid code point.\r\n         * @type {number}\r\n         * @const\r\n         */\r\n        utfx.MAX_CODEPOINT = 0x10FFFF;\r\n\r\n        /**\r\n         * Encodes UTF8 code points to UTF8 bytes.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte\r\n         */\r\n        utfx.encodeUTF8 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src,\r\n                src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp < 0x80)\r\n                    dst(cp&0x7F);\r\n                else if (cp < 0x800)\r\n                    dst(((cp>>6)&0x1F)|0xC0),\r\n                    dst((cp&0x3F)|0x80);\r\n                else if (cp < 0x10000)\r\n                    dst(((cp>>12)&0x0F)|0xE0),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                else\r\n                    dst(((cp>>18)&0x07)|0xF0),\r\n                    dst(((cp>>12)&0x3F)|0x80),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes UTF8 bytes to UTF8 code points.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the\r\n         *  remaining bytes.\r\n         */\r\n        utfx.decodeUTF8 = function(src, dst) {\r\n            var a, b, c, d, fail = function(b) {\r\n                b = b.slice(0, b.indexOf(null));\r\n                var err = Error(b.toString());\r\n                err.name = \"TruncatedError\";\r\n                err['bytes'] = b;\r\n                throw err;\r\n            };\r\n            while ((a = src()) !== null) {\r\n                if ((a&0x80) === 0)\r\n                    dst(a);\r\n                else if ((a&0xE0) === 0xC0)\r\n                    ((b = src()) === null) && fail([a, b]),\r\n                    dst(((a&0x1F)<<6) | (b&0x3F));\r\n                else if ((a&0xF0) === 0xE0)\r\n                    ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),\r\n                    dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));\r\n                else if ((a&0xF8) === 0xF0)\r\n                    ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),\r\n                    dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));\r\n                else throw RangeError(\"Illegal starting byte: \"+a);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts UTF16 characters to UTF8 code points.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each converted code\r\n         *  point.\r\n         */\r\n        utfx.UTF16toUTF8 = function(src, dst) {\r\n            var c1, c2 = null;\r\n            while (true) {\r\n                if ((c1 = c2 !== null ? c2 : src()) === null)\r\n                    break;\r\n                if (c1 >= 0xD800 && c1 <= 0xDFFF) {\r\n                    if ((c2 = src()) !== null) {\r\n                        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {\r\n                            dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);\r\n                            c2 = null; continue;\r\n                        }\r\n                    }\r\n                }\r\n                dst(c1);\r\n            }\r\n            if (c2 !== null) dst(c2);\r\n        };\r\n\r\n        /**\r\n         * Converts UTF8 code points to UTF16 characters.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a code point is out of range\r\n         */\r\n        utfx.UTF8toUTF16 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src, src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp <= 0xFFFF)\r\n                    dst(cp);\r\n                else\r\n                    cp -= 0x10000,\r\n                    dst((cp>>10)+0xD800),\r\n                    dst((cp%0x400)+0xDC00);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts and encodes UTF16 characters to UTF8 bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`\r\n         *  if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         */\r\n        utfx.encodeUTF16toUTF8 = function(src, dst) {\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                utfx.encodeUTF8(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Decodes and converts UTF8 bytes to UTF16 characters.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.\r\n         */\r\n        utfx.decodeUTF8toUTF16 = function(src, dst) {\r\n            utfx.decodeUTF8(src, function(cp) {\r\n                utfx.UTF8toUTF16(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Calculates the byte length of an UTF8 code point.\r\n         * @param {number} cp UTF8 code point\r\n         * @returns {number} Byte length\r\n         */\r\n        utfx.calculateCodePoint = function(cp) {\r\n            return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 bytes required to store UTF8 code points.\r\n         * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively\r\n         *  `null` if there are no more code points left.\r\n         * @returns {number} The number of UTF8 bytes required\r\n         */\r\n        utfx.calculateUTF8 = function(src) {\r\n            var cp, l=0;\r\n            while ((cp = src()) !== null)\r\n                l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            return l;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.\r\n         * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.\r\n         */\r\n        utfx.calculateUTF16asUTF8 = function(src) {\r\n            var n=0, l=0;\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            });\r\n            return [n,l];\r\n        };\r\n\r\n        return utfx;\r\n    }();\r\n\r\n    // encodings/utf8\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded\r\n     *  string.\r\n     * @returns {string} Hex encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toUTF8 = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var sd; try {\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return begin < end ? this.view[begin++] : null;\r\n            }.bind(this), sd = stringDestination());\r\n        } catch (e) {\r\n            if (begin !== end)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+begin+\" != \"+end);\r\n        }\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes an UTF8 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) {\r\n        if (!noAssert)\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n        var bb = new ByteBuffer(utfx.calculateUTF16asUTF8(stringSource(str), true)[1], littleEndian, noAssert),\r\n            i = 0;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    return ByteBuffer;\r\n});\r\n","var Buffer = require(93).Buffer\nvar Transform = require(103).Transform\nvar StringDecoder = require(36).StringDecoder\nvar inherits = require(65)\n\nfunction CipherBase (hashMode) {\n  Transform.call(this)\n  this.hashMode = typeof hashMode === 'string'\n  if (this.hashMode) {\n    this[hashMode] = this._finalOrDigest\n  } else {\n    this.final = this._finalOrDigest\n  }\n  if (this._final) {\n    this.__final = this._final\n    this._final = null\n  }\n  this._decoder = null\n  this._encoding = null\n}\ninherits(CipherBase, Transform)\n\nCipherBase.prototype.update = function (data, inputEnc, outputEnc) {\n  if (typeof data === 'string') {\n    data = Buffer.from(data, inputEnc)\n  }\n\n  var outData = this._update(data)\n  if (this.hashMode) return this\n\n  if (outputEnc) {\n    outData = this._toString(outData, outputEnc)\n  }\n\n  return outData\n}\n\nCipherBase.prototype.setAutoPadding = function () {}\nCipherBase.prototype.getAuthTag = function () {\n  throw new Error('trying to get auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAuthTag = function () {\n  throw new Error('trying to set auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAAD = function () {\n  throw new Error('trying to set aad in unsupported state')\n}\n\nCipherBase.prototype._transform = function (data, _, next) {\n  var err\n  try {\n    if (this.hashMode) {\n      this._update(data)\n    } else {\n      this.push(this._update(data))\n    }\n  } catch (e) {\n    err = e\n  } finally {\n    next(err)\n  }\n}\nCipherBase.prototype._flush = function (done) {\n  var err\n  try {\n    this.push(this.__final())\n  } catch (e) {\n    err = e\n  }\n\n  done(err)\n}\nCipherBase.prototype._finalOrDigest = function (outputEnc) {\n  var outData = this.__final() || Buffer.alloc(0)\n  if (outputEnc) {\n    outData = this._toString(outData, outputEnc, true)\n  }\n  return outData\n}\n\nCipherBase.prototype._toString = function (value, enc, fin) {\n  if (!this._decoder) {\n    this._decoder = new StringDecoder(enc)\n    this._encoding = enc\n  }\n\n  if (this._encoding !== enc) throw new Error('can\\'t switch encodings')\n\n  var out = this._decoder.write(value)\n  if (fin) {\n    out += this._decoder.end()\n  }\n\n  return out\n}\n\nmodule.exports = CipherBase\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","'use strict'\nvar inherits = require(65)\nvar MD5 = require(69)\nvar RIPEMD160 = require(92)\nvar sha = require(96)\nvar Base = require(39)\n\nfunction Hash (hash) {\n  Base.call(this, 'digest')\n\n  this._hash = hash\n}\n\ninherits(Hash, Base)\n\nHash.prototype._update = function (data) {\n  this._hash.update(data)\n}\n\nHash.prototype._final = function () {\n  return this._hash.digest()\n}\n\nmodule.exports = function createHash (alg) {\n  alg = alg.toLowerCase()\n  if (alg === 'md5') return new MD5()\n  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()\n\n  return new Hash(sha(alg))\n}\n","var MD5 = require(69)\n\nmodule.exports = function (buffer) {\n  return new MD5().update(buffer).digest()\n}\n","'use strict'\nvar inherits = require(65)\nvar Legacy = require(44)\nvar Base = require(39)\nvar Buffer = require(93).Buffer\nvar md5 = require(42)\nvar RIPEMD160 = require(92)\n\nvar sha = require(96)\n\nvar ZEROS = Buffer.alloc(128)\n\nfunction Hmac (alg, key) {\n  Base.call(this, 'digest')\n  if (typeof key === 'string') {\n    key = Buffer.from(key)\n  }\n\n  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64\n\n  this._alg = alg\n  this._key = key\n  if (key.length > blocksize) {\n    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n    key = hash.update(key).digest()\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n  var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n  this._hash.update(ipad)\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n  this._hash.update(data)\n}\n\nHmac.prototype._final = function () {\n  var h = this._hash.digest()\n  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)\n  return hash.update(this._opad).update(h).digest()\n}\n\nmodule.exports = function createHmac (alg, key) {\n  alg = alg.toLowerCase()\n  if (alg === 'rmd160' || alg === 'ripemd160') {\n    return new Hmac('rmd160', key)\n  }\n  if (alg === 'md5') {\n    return new Legacy(md5, key)\n  }\n  return new Hmac(alg, key)\n}\n","'use strict'\nvar inherits = require(65)\nvar Buffer = require(93).Buffer\n\nvar Base = require(39)\n\nvar ZEROS = Buffer.alloc(128)\nvar blocksize = 64\n\nfunction Hmac (alg, key) {\n  Base.call(this, 'digest')\n  if (typeof key === 'string') {\n    key = Buffer.from(key)\n  }\n\n  this._alg = alg\n  this._key = key\n\n  if (key.length > blocksize) {\n    key = alg(key)\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n  var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n\n  this._hash = [ipad]\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n  this._hash.push(data)\n}\n\nHmac.prototype._final = function () {\n  var h = this._alg(Buffer.concat(this._hash))\n  return this._alg(Buffer.concat([this._opad, h]))\n}\nmodule.exports = Hmac\n",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47), require(48), require(52), require(50), require(46));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./enc-base64\", \"./md5\", \"./evpkdf\", \"./cipher-core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var BlockCipher = C_lib.BlockCipher;\n\t    var C_algo = C.algo;\n\n\t    // Lookup tables\n\t    var SBOX = [];\n\t    var INV_SBOX = [];\n\t    var SUB_MIX_0 = [];\n\t    var SUB_MIX_1 = [];\n\t    var SUB_MIX_2 = [];\n\t    var SUB_MIX_3 = [];\n\t    var INV_SUB_MIX_0 = [];\n\t    var INV_SUB_MIX_1 = [];\n\t    var INV_SUB_MIX_2 = [];\n\t    var INV_SUB_MIX_3 = [];\n\n\t    // Compute lookup tables\n\t    (function () {\n\t        // Compute double table\n\t        var d = [];\n\t        for (var i = 0; i < 256; i++) {\n\t            if (i < 128) {\n\t                d[i] = i << 1;\n\t            } else {\n\t                d[i] = (i << 1) ^ 0x11b;\n\t            }\n\t        }\n\n\t        // Walk GF(2^8)\n\t        var x = 0;\n\t        var xi = 0;\n\t        for (var i = 0; i < 256; i++) {\n\t            // Compute sbox\n\t            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);\n\t            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;\n\t            SBOX[x] = sx;\n\t            INV_SBOX[sx] = x;\n\n\t            // Compute multiplication\n\t            var x2 = d[x];\n\t            var x4 = d[x2];\n\t            var x8 = d[x4];\n\n\t            // Compute sub bytes, mix columns tables\n\t            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);\n\t            SUB_MIX_0[x] = (t << 24) | (t >>> 8);\n\t            SUB_MIX_1[x] = (t << 16) | (t >>> 16);\n\t            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);\n\t            SUB_MIX_3[x] = t;\n\n\t            // Compute inv sub bytes, inv mix columns tables\n\t            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);\n\t            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);\n\t            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);\n\t            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);\n\t            INV_SUB_MIX_3[sx] = t;\n\n\t            // Compute next counter\n\t            if (!x) {\n\t                x = xi = 1;\n\t            } else {\n\t                x = x2 ^ d[d[d[x8 ^ x2]]];\n\t                xi ^= d[d[xi]];\n\t            }\n\t        }\n\t    }());\n\n\t    // Precomputed Rcon lookup\n\t    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];\n\n\t    /**\n\t     * AES block cipher algorithm.\n\t     */\n\t    var AES = C_algo.AES = BlockCipher.extend({\n\t        _doReset: function () {\n\t            // Skip reset of nRounds has been set before and key did not change\n\t            if (this._nRounds && this._keyPriorReset === this._key) {\n\t                return;\n\t            }\n\n\t            // Shortcuts\n\t            var key = this._keyPriorReset = this._key;\n\t            var keyWords = key.words;\n\t            var keySize = key.sigBytes / 4;\n\n\t            // Compute number of rounds\n\t            var nRounds = this._nRounds = keySize + 6;\n\n\t            // Compute number of key schedule rows\n\t            var ksRows = (nRounds + 1) * 4;\n\n\t            // Compute key schedule\n\t            var keySchedule = this._keySchedule = [];\n\t            for (var ksRow = 0; ksRow < ksRows; ksRow++) {\n\t                if (ksRow < keySize) {\n\t                    keySchedule[ksRow] = keyWords[ksRow];\n\t                } else {\n\t                    var t = keySchedule[ksRow - 1];\n\n\t                    if (!(ksRow % keySize)) {\n\t                        // Rot word\n\t                        t = (t << 8) | (t >>> 24);\n\n\t                        // Sub word\n\t                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\n\t                        // Mix Rcon\n\t                        t ^= RCON[(ksRow / keySize) | 0] << 24;\n\t                    } else if (keySize > 6 && ksRow % keySize == 4) {\n\t                        // Sub word\n\t                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\t                    }\n\n\t                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;\n\t                }\n\t            }\n\n\t            // Compute inv key schedule\n\t            var invKeySchedule = this._invKeySchedule = [];\n\t            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {\n\t                var ksRow = ksRows - invKsRow;\n\n\t                if (invKsRow % 4) {\n\t                    var t = keySchedule[ksRow];\n\t                } else {\n\t                    var t = keySchedule[ksRow - 4];\n\t                }\n\n\t                if (invKsRow < 4 || ksRow <= 4) {\n\t                    invKeySchedule[invKsRow] = t;\n\t                } else {\n\t                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^\n\t                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];\n\t                }\n\t            }\n\t        },\n\n\t        encryptBlock: function (M, offset) {\n\t            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);\n\t        },\n\n\t        decryptBlock: function (M, offset) {\n\t            // Swap 2nd and 4th rows\n\t            var t = M[offset + 1];\n\t            M[offset + 1] = M[offset + 3];\n\t            M[offset + 3] = t;\n\n\t            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);\n\n\t            // Inv swap 2nd and 4th rows\n\t            var t = M[offset + 1];\n\t            M[offset + 1] = M[offset + 3];\n\t            M[offset + 3] = t;\n\t        },\n\n\t        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {\n\t            // Shortcut\n\t            var nRounds = this._nRounds;\n\n\t            // Get input, add round key\n\t            var s0 = M[offset]     ^ keySchedule[0];\n\t            var s1 = M[offset + 1] ^ keySchedule[1];\n\t            var s2 = M[offset + 2] ^ keySchedule[2];\n\t            var s3 = M[offset + 3] ^ keySchedule[3];\n\n\t            // Key schedule row counter\n\t            var ksRow = 4;\n\n\t            // Rounds\n\t            for (var round = 1; round < nRounds; round++) {\n\t                // Shift rows, sub bytes, mix columns, add round key\n\t                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];\n\t                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];\n\t                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];\n\t                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];\n\n\t                // Update state\n\t                s0 = t0;\n\t                s1 = t1;\n\t                s2 = t2;\n\t                s3 = t3;\n\t            }\n\n\t            // Shift rows, sub bytes, add round key\n\t            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];\n\n\t            // Set output\n\t            M[offset]     = t0;\n\t            M[offset + 1] = t1;\n\t            M[offset + 2] = t2;\n\t            M[offset + 3] = t3;\n\t        },\n\n\t        keySize: 256/32\n\t    });\n\n\t    /**\n\t     * Shortcut functions to the cipher's object interface.\n\t     *\n\t     * @example\n\t     *\n\t     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);\n\t     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);\n\t     */\n\t    C.AES = BlockCipher._createHelper(AES);\n\t}());\n\n\n\treturn CryptoJS.AES;\n\n}));",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47), require(50));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./evpkdf\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t/**\n\t * Cipher core components.\n\t */\n\tCryptoJS.lib.Cipher || (function (undefined) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var WordArray = C_lib.WordArray;\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;\n\t    var C_enc = C.enc;\n\t    var Utf8 = C_enc.Utf8;\n\t    var Base64 = C_enc.Base64;\n\t    var C_algo = C.algo;\n\t    var EvpKDF = C_algo.EvpKDF;\n\n\t    /**\n\t     * Abstract base cipher template.\n\t     *\n\t     * @property {number} keySize This cipher's key size. Default: 4 (128 bits)\n\t     * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)\n\t     * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.\n\t     * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.\n\t     */\n\t    var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {WordArray} iv The IV to use for this operation.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Creates this cipher in encryption mode.\n\t         *\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {Cipher} A cipher instance.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });\n\t         */\n\t        createEncryptor: function (key, cfg) {\n\t            return this.create(this._ENC_XFORM_MODE, key, cfg);\n\t        },\n\n\t        /**\n\t         * Creates this cipher in decryption mode.\n\t         *\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {Cipher} A cipher instance.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });\n\t         */\n\t        createDecryptor: function (key, cfg) {\n\t            return this.create(this._DEC_XFORM_MODE, key, cfg);\n\t        },\n\n\t        /**\n\t         * Initializes a newly created cipher.\n\t         *\n\t         * @param {number} xformMode Either the encryption or decryption transormation mode constant.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });\n\t         */\n\t        init: function (xformMode, key, cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Store transform mode and key\n\t            this._xformMode = xformMode;\n\t            this._key = key;\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this cipher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     cipher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-cipher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Adds data to be encrypted or decrypted.\n\t         *\n\t         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.\n\t         *\n\t         * @return {WordArray} The data after processing.\n\t         *\n\t         * @example\n\t         *\n\t         *     var encrypted = cipher.process('data');\n\t         *     var encrypted = cipher.process(wordArray);\n\t         */\n\t        process: function (dataUpdate) {\n\t            // Append\n\t            this._append(dataUpdate);\n\n\t            // Process available blocks\n\t            return this._process();\n\t        },\n\n\t        /**\n\t         * Finalizes the encryption or decryption process.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.\n\t         *\n\t         * @return {WordArray} The data after final processing.\n\t         *\n\t         * @example\n\t         *\n\t         *     var encrypted = cipher.finalize();\n\t         *     var encrypted = cipher.finalize('data');\n\t         *     var encrypted = cipher.finalize(wordArray);\n\t         */\n\t        finalize: function (dataUpdate) {\n\t            // Final data update\n\t            if (dataUpdate) {\n\t                this._append(dataUpdate);\n\t            }\n\n\t            // Perform concrete-cipher logic\n\t            var finalProcessedData = this._doFinalize();\n\n\t            return finalProcessedData;\n\t        },\n\n\t        keySize: 128/32,\n\n\t        ivSize: 128/32,\n\n\t        _ENC_XFORM_MODE: 1,\n\n\t        _DEC_XFORM_MODE: 2,\n\n\t        /**\n\t         * Creates shortcut functions to a cipher's object interface.\n\t         *\n\t         * @param {Cipher} cipher The cipher to create a helper for.\n\t         *\n\t         * @return {Object} An object with encrypt and decrypt shortcut functions.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);\n\t         */\n\t        _createHelper: (function () {\n\t            function selectCipherStrategy(key) {\n\t                if (typeof key == 'string') {\n\t                    return PasswordBasedCipher;\n\t                } else {\n\t                    return SerializableCipher;\n\t                }\n\t            }\n\n\t            return function (cipher) {\n\t                return {\n\t                    encrypt: function (message, key, cfg) {\n\t                        return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);\n\t                    },\n\n\t                    decrypt: function (ciphertext, key, cfg) {\n\t                        return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);\n\t                    }\n\t                };\n\t            };\n\t        }())\n\t    });\n\n\t    /**\n\t     * Abstract base stream cipher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)\n\t     */\n\t    var StreamCipher = C_lib.StreamCipher = Cipher.extend({\n\t        _doFinalize: function () {\n\t            // Process partial blocks\n\t            var finalProcessedBlocks = this._process(!!'flush');\n\n\t            return finalProcessedBlocks;\n\t        },\n\n\t        blockSize: 1\n\t    });\n\n\t    /**\n\t     * Mode namespace.\n\t     */\n\t    var C_mode = C.mode = {};\n\n\t    /**\n\t     * Abstract base block cipher mode template.\n\t     */\n\t    var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({\n\t        /**\n\t         * Creates this mode for encryption.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);\n\t         */\n\t        createEncryptor: function (cipher, iv) {\n\t            return this.Encryptor.create(cipher, iv);\n\t        },\n\n\t        /**\n\t         * Creates this mode for decryption.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);\n\t         */\n\t        createDecryptor: function (cipher, iv) {\n\t            return this.Decryptor.create(cipher, iv);\n\t        },\n\n\t        /**\n\t         * Initializes a newly created mode.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);\n\t         */\n\t        init: function (cipher, iv) {\n\t            this._cipher = cipher;\n\t            this._iv = iv;\n\t        }\n\t    });\n\n\t    /**\n\t     * Cipher Block Chaining mode.\n\t     */\n\t    var CBC = C_mode.CBC = (function () {\n\t        /**\n\t         * Abstract base CBC mode.\n\t         */\n\t        var CBC = BlockCipherMode.extend();\n\n\t        /**\n\t         * CBC encryptor.\n\t         */\n\t        CBC.Encryptor = CBC.extend({\n\t            /**\n\t             * Processes the data block at offset.\n\t             *\n\t             * @param {Array} words The data words to operate on.\n\t             * @param {number} offset The offset where the block starts.\n\t             *\n\t             * @example\n\t             *\n\t             *     mode.processBlock(data.words, offset);\n\t             */\n\t            processBlock: function (words, offset) {\n\t                // Shortcuts\n\t                var cipher = this._cipher;\n\t                var blockSize = cipher.blockSize;\n\n\t                // XOR and encrypt\n\t                xorBlock.call(this, words, offset, blockSize);\n\t                cipher.encryptBlock(words, offset);\n\n\t                // Remember this block to use with next block\n\t                this._prevBlock = words.slice(offset, offset + blockSize);\n\t            }\n\t        });\n\n\t        /**\n\t         * CBC decryptor.\n\t         */\n\t        CBC.Decryptor = CBC.extend({\n\t            /**\n\t             * Processes the data block at offset.\n\t             *\n\t             * @param {Array} words The data words to operate on.\n\t             * @param {number} offset The offset where the block starts.\n\t             *\n\t             * @example\n\t             *\n\t             *     mode.processBlock(data.words, offset);\n\t             */\n\t            processBlock: function (words, offset) {\n\t                // Shortcuts\n\t                var cipher = this._cipher;\n\t                var blockSize = cipher.blockSize;\n\n\t                // Remember this block to use with next block\n\t                var thisBlock = words.slice(offset, offset + blockSize);\n\n\t                // Decrypt and XOR\n\t                cipher.decryptBlock(words, offset);\n\t                xorBlock.call(this, words, offset, blockSize);\n\n\t                // This block becomes the previous block\n\t                this._prevBlock = thisBlock;\n\t            }\n\t        });\n\n\t        function xorBlock(words, offset, blockSize) {\n\t            // Shortcut\n\t            var iv = this._iv;\n\n\t            // Choose mixing block\n\t            if (iv) {\n\t                var block = iv;\n\n\t                // Remove IV for subsequent blocks\n\t                this._iv = undefined;\n\t            } else {\n\t                var block = this._prevBlock;\n\t            }\n\n\t            // XOR blocks\n\t            for (var i = 0; i < blockSize; i++) {\n\t                words[offset + i] ^= block[i];\n\t            }\n\t        }\n\n\t        return CBC;\n\t    }());\n\n\t    /**\n\t     * Padding namespace.\n\t     */\n\t    var C_pad = C.pad = {};\n\n\t    /**\n\t     * PKCS #5/7 padding strategy.\n\t     */\n\t    var Pkcs7 = C_pad.Pkcs7 = {\n\t        /**\n\t         * Pads data using the algorithm defined in PKCS #5/7.\n\t         *\n\t         * @param {WordArray} data The data to pad.\n\t         * @param {number} blockSize The multiple that the data should be padded to.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);\n\t         */\n\t        pad: function (data, blockSize) {\n\t            // Shortcut\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count padding bytes\n\t            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;\n\n\t            // Create padding word\n\t            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;\n\n\t            // Create padding\n\t            var paddingWords = [];\n\t            for (var i = 0; i < nPaddingBytes; i += 4) {\n\t                paddingWords.push(paddingWord);\n\t            }\n\t            var padding = WordArray.create(paddingWords, nPaddingBytes);\n\n\t            // Add padding\n\t            data.concat(padding);\n\t        },\n\n\t        /**\n\t         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.\n\t         *\n\t         * @param {WordArray} data The data to unpad.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     CryptoJS.pad.Pkcs7.unpad(wordArray);\n\t         */\n\t        unpad: function (data) {\n\t            // Get number of padding bytes from last byte\n\t            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;\n\n\t            // Remove padding\n\t            data.sigBytes -= nPaddingBytes;\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract base block cipher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)\n\t     */\n\t    var BlockCipher = C_lib.BlockCipher = Cipher.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {Mode} mode The block mode to use. Default: CBC\n\t         * @property {Padding} padding The padding strategy to use. Default: Pkcs7\n\t         */\n\t        cfg: Cipher.cfg.extend({\n\t            mode: CBC,\n\t            padding: Pkcs7\n\t        }),\n\n\t        reset: function () {\n\t            // Reset cipher\n\t            Cipher.reset.call(this);\n\n\t            // Shortcuts\n\t            var cfg = this.cfg;\n\t            var iv = cfg.iv;\n\t            var mode = cfg.mode;\n\n\t            // Reset block mode\n\t            if (this._xformMode == this._ENC_XFORM_MODE) {\n\t                var modeCreator = mode.createEncryptor;\n\t            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n\t                var modeCreator = mode.createDecryptor;\n\t                // Keep at least one block in the buffer for unpadding\n\t                this._minBufferSize = 1;\n\t            }\n\n\t            if (this._mode && this._mode.__creator == modeCreator) {\n\t                this._mode.init(this, iv && iv.words);\n\t            } else {\n\t                this._mode = modeCreator.call(mode, this, iv && iv.words);\n\t                this._mode.__creator = modeCreator;\n\t            }\n\t        },\n\n\t        _doProcessBlock: function (words, offset) {\n\t            this._mode.processBlock(words, offset);\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcut\n\t            var padding = this.cfg.padding;\n\n\t            // Finalize\n\t            if (this._xformMode == this._ENC_XFORM_MODE) {\n\t                // Pad data\n\t                padding.pad(this._data, this.blockSize);\n\n\t                // Process final blocks\n\t                var finalProcessedBlocks = this._process(!!'flush');\n\t            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n\t                // Process final blocks\n\t                var finalProcessedBlocks = this._process(!!'flush');\n\n\t                // Unpad data\n\t                padding.unpad(finalProcessedBlocks);\n\t            }\n\n\t            return finalProcessedBlocks;\n\t        },\n\n\t        blockSize: 128/32\n\t    });\n\n\t    /**\n\t     * A collection of cipher parameters.\n\t     *\n\t     * @property {WordArray} ciphertext The raw ciphertext.\n\t     * @property {WordArray} key The key to this ciphertext.\n\t     * @property {WordArray} iv The IV used in the ciphering operation.\n\t     * @property {WordArray} salt The salt used with a key derivation function.\n\t     * @property {Cipher} algorithm The cipher algorithm.\n\t     * @property {Mode} mode The block mode used in the ciphering operation.\n\t     * @property {Padding} padding The padding scheme used in the ciphering operation.\n\t     * @property {number} blockSize The block size of the cipher.\n\t     * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.\n\t     */\n\t    var CipherParams = C_lib.CipherParams = Base.extend({\n\t        /**\n\t         * Initializes a newly created cipher params object.\n\t         *\n\t         * @param {Object} cipherParams An object with any of the possible cipher parameters.\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipherParams = CryptoJS.lib.CipherParams.create({\n\t         *         ciphertext: ciphertextWordArray,\n\t         *         key: keyWordArray,\n\t         *         iv: ivWordArray,\n\t         *         salt: saltWordArray,\n\t         *         algorithm: CryptoJS.algo.AES,\n\t         *         mode: CryptoJS.mode.CBC,\n\t         *         padding: CryptoJS.pad.PKCS7,\n\t         *         blockSize: 4,\n\t         *         formatter: CryptoJS.format.OpenSSL\n\t         *     });\n\t         */\n\t        init: function (cipherParams) {\n\t            this.mixIn(cipherParams);\n\t        },\n\n\t        /**\n\t         * Converts this cipher params object to a string.\n\t         *\n\t         * @param {Format} formatter (Optional) The formatting strategy to use.\n\t         *\n\t         * @return {string} The stringified cipher params.\n\t         *\n\t         * @throws Error If neither the formatter nor the default formatter is set.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = cipherParams + '';\n\t         *     var string = cipherParams.toString();\n\t         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);\n\t         */\n\t        toString: function (formatter) {\n\t            return (formatter || this.formatter).stringify(this);\n\t        }\n\t    });\n\n\t    /**\n\t     * Format namespace.\n\t     */\n\t    var C_format = C.format = {};\n\n\t    /**\n\t     * OpenSSL formatting strategy.\n\t     */\n\t    var OpenSSLFormatter = C_format.OpenSSL = {\n\t        /**\n\t         * Converts a cipher params object to an OpenSSL-compatible string.\n\t         *\n\t         * @param {CipherParams} cipherParams The cipher params object.\n\t         *\n\t         * @return {string} The OpenSSL-compatible string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);\n\t         */\n\t        stringify: function (cipherParams) {\n\t            // Shortcuts\n\t            var ciphertext = cipherParams.ciphertext;\n\t            var salt = cipherParams.salt;\n\n\t            // Format\n\t            if (salt) {\n\t                var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);\n\t            } else {\n\t                var wordArray = ciphertext;\n\t            }\n\n\t            return wordArray.toString(Base64);\n\t        },\n\n\t        /**\n\t         * Converts an OpenSSL-compatible string to a cipher params object.\n\t         *\n\t         * @param {string} openSSLStr The OpenSSL-compatible string.\n\t         *\n\t         * @return {CipherParams} The cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);\n\t         */\n\t        parse: function (openSSLStr) {\n\t            // Parse base64\n\t            var ciphertext = Base64.parse(openSSLStr);\n\n\t            // Shortcut\n\t            var ciphertextWords = ciphertext.words;\n\n\t            // Test for salt\n\t            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {\n\t                // Extract salt\n\t                var salt = WordArray.create(ciphertextWords.slice(2, 4));\n\n\t                // Remove salt from ciphertext\n\t                ciphertextWords.splice(0, 4);\n\t                ciphertext.sigBytes -= 16;\n\t            }\n\n\t            return CipherParams.create({ ciphertext: ciphertext, salt: salt });\n\t        }\n\t    };\n\n\t    /**\n\t     * A cipher wrapper that returns ciphertext as a serializable cipher params object.\n\t     */\n\t    var SerializableCipher = C_lib.SerializableCipher = Base.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL\n\t         */\n\t        cfg: Base.extend({\n\t            format: OpenSSLFormatter\n\t        }),\n\n\t        /**\n\t         * Encrypts a message.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {WordArray|string} message The message to encrypt.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {CipherParams} A cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         */\n\t        encrypt: function (cipher, message, key, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Encrypt\n\t            var encryptor = cipher.createEncryptor(key, cfg);\n\t            var ciphertext = encryptor.finalize(message);\n\n\t            // Shortcut\n\t            var cipherCfg = encryptor.cfg;\n\n\t            // Create and return serializable cipher params\n\t            return CipherParams.create({\n\t                ciphertext: ciphertext,\n\t                key: key,\n\t                iv: cipherCfg.iv,\n\t                algorithm: cipher,\n\t                mode: cipherCfg.mode,\n\t                padding: cipherCfg.padding,\n\t                blockSize: cipher.blockSize,\n\t                formatter: cfg.format\n\t            });\n\t        },\n\n\t        /**\n\t         * Decrypts serialized ciphertext.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {WordArray} The plaintext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         */\n\t        decrypt: function (cipher, ciphertext, key, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Convert string to CipherParams\n\t            ciphertext = this._parse(ciphertext, cfg.format);\n\n\t            // Decrypt\n\t            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);\n\n\t            return plaintext;\n\t        },\n\n\t        /**\n\t         * Converts serialized ciphertext to CipherParams,\n\t         * else assumed CipherParams already and returns ciphertext unchanged.\n\t         *\n\t         * @param {CipherParams|string} ciphertext The ciphertext.\n\t         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.\n\t         *\n\t         * @return {CipherParams} The unserialized ciphertext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);\n\t         */\n\t        _parse: function (ciphertext, format) {\n\t            if (typeof ciphertext == 'string') {\n\t                return format.parse(ciphertext, this);\n\t            } else {\n\t                return ciphertext;\n\t            }\n\t        }\n\t    });\n\n\t    /**\n\t     * Key derivation function namespace.\n\t     */\n\t    var C_kdf = C.kdf = {};\n\n\t    /**\n\t     * OpenSSL key derivation function.\n\t     */\n\t    var OpenSSLKdf = C_kdf.OpenSSL = {\n\t        /**\n\t         * Derives a key and IV from a password.\n\t         *\n\t         * @param {string} password The password to derive from.\n\t         * @param {number} keySize The size in words of the key to generate.\n\t         * @param {number} ivSize The size in words of the IV to generate.\n\t         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.\n\t         *\n\t         * @return {CipherParams} A cipher params object with the key, IV, and salt.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);\n\t         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');\n\t         */\n\t        execute: function (password, keySize, ivSize, salt) {\n\t            // Generate random salt\n\t            if (!salt) {\n\t                salt = WordArray.random(64/8);\n\t            }\n\n\t            // Derive key and IV\n\t            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);\n\n\t            // Separate key and IV\n\t            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);\n\t            key.sigBytes = keySize * 4;\n\n\t            // Return params\n\t            return CipherParams.create({ key: key, iv: iv, salt: salt });\n\t        }\n\t    };\n\n\t    /**\n\t     * A serializable cipher wrapper that derives the key from a password,\n\t     * and returns ciphertext as a serializable cipher params object.\n\t     */\n\t    var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL\n\t         */\n\t        cfg: SerializableCipher.cfg.extend({\n\t            kdf: OpenSSLKdf\n\t        }),\n\n\t        /**\n\t         * Encrypts a message using a password.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {WordArray|string} message The message to encrypt.\n\t         * @param {string} password The password.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {CipherParams} A cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');\n\t         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });\n\t         */\n\t        encrypt: function (cipher, message, password, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Derive key and other params\n\t            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);\n\n\t            // Add IV to config\n\t            cfg.iv = derivedParams.iv;\n\n\t            // Encrypt\n\t            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);\n\n\t            // Mix in derived params\n\t            ciphertext.mixIn(derivedParams);\n\n\t            return ciphertext;\n\t        },\n\n\t        /**\n\t         * Decrypts serialized ciphertext using a password.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n\t         * @param {string} password The password.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {WordArray} The plaintext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });\n\t         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });\n\t         */\n\t        decrypt: function (cipher, ciphertext, password, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Convert string to CipherParams\n\t            ciphertext = this._parse(ciphertext, cfg.format);\n\n\t            // Derive key and other params\n\t            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);\n\n\t            // Add IV to config\n\t            cfg.iv = derivedParams.iv;\n\n\t            // Decrypt\n\t            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);\n\n\t            return plaintext;\n\t        }\n\t    });\n\t}());\n\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory();\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\troot.CryptoJS = factory();\n\t}\n}(this, function () {\n\n\t/**\n\t * CryptoJS core components.\n\t */\n\tvar CryptoJS = CryptoJS || (function (Math, undefined) {\n\t    /*\n\t     * Local polyfil of Object.create\n\t     */\n\t    var create = Object.create || (function () {\n\t        function F() {};\n\n\t        return function (obj) {\n\t            var subtype;\n\n\t            F.prototype = obj;\n\n\t            subtype = new F();\n\n\t            F.prototype = null;\n\n\t            return subtype;\n\t        };\n\t    }())\n\n\t    /**\n\t     * CryptoJS namespace.\n\t     */\n\t    var C = {};\n\n\t    /**\n\t     * Library namespace.\n\t     */\n\t    var C_lib = C.lib = {};\n\n\t    /**\n\t     * Base object for prototypal inheritance.\n\t     */\n\t    var Base = C_lib.Base = (function () {\n\n\n\t        return {\n\t            /**\n\t             * Creates a new object that inherits from this object.\n\t             *\n\t             * @param {Object} overrides Properties to copy into the new object.\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         field: 'value',\n\t             *\n\t             *         method: function () {\n\t             *         }\n\t             *     });\n\t             */\n\t            extend: function (overrides) {\n\t                // Spawn\n\t                var subtype = create(this);\n\n\t                // Augment\n\t                if (overrides) {\n\t                    subtype.mixIn(overrides);\n\t                }\n\n\t                // Create default initializer\n\t                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n\t                    subtype.init = function () {\n\t                        subtype.$super.init.apply(this, arguments);\n\t                    };\n\t                }\n\n\t                // Initializer's prototype is the subtype object\n\t                subtype.init.prototype = subtype;\n\n\t                // Reference supertype\n\t                subtype.$super = this;\n\n\t                return subtype;\n\t            },\n\n\t            /**\n\t             * Extends this object and runs the init method.\n\t             * Arguments to create() will be passed to init().\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var instance = MyType.create();\n\t             */\n\t            create: function () {\n\t                var instance = this.extend();\n\t                instance.init.apply(instance, arguments);\n\n\t                return instance;\n\t            },\n\n\t            /**\n\t             * Initializes a newly created object.\n\t             * Override this method to add some logic when your objects are created.\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         init: function () {\n\t             *             // ...\n\t             *         }\n\t             *     });\n\t             */\n\t            init: function () {\n\t            },\n\n\t            /**\n\t             * Copies properties into this object.\n\t             *\n\t             * @param {Object} properties The properties to mix in.\n\t             *\n\t             * @example\n\t             *\n\t             *     MyType.mixIn({\n\t             *         field: 'value'\n\t             *     });\n\t             */\n\t            mixIn: function (properties) {\n\t                for (var propertyName in properties) {\n\t                    if (properties.hasOwnProperty(propertyName)) {\n\t                        this[propertyName] = properties[propertyName];\n\t                    }\n\t                }\n\n\t                // IE won't copy toString using the loop above\n\t                if (properties.hasOwnProperty('toString')) {\n\t                    this.toString = properties.toString;\n\t                }\n\t            },\n\n\t            /**\n\t             * Creates a copy of this object.\n\t             *\n\t             * @return {Object} The clone.\n\t             *\n\t             * @example\n\t             *\n\t             *     var clone = instance.clone();\n\t             */\n\t            clone: function () {\n\t                return this.init.prototype.extend(this);\n\t            }\n\t        };\n\t    }());\n\n\t    /**\n\t     * An array of 32-bit words.\n\t     *\n\t     * @property {Array} words The array of 32-bit words.\n\t     * @property {number} sigBytes The number of significant bytes in this word array.\n\t     */\n\t    var WordArray = C_lib.WordArray = Base.extend({\n\t        /**\n\t         * Initializes a newly created word array.\n\t         *\n\t         * @param {Array} words (Optional) An array of 32-bit words.\n\t         * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.create();\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n\t         */\n\t        init: function (words, sigBytes) {\n\t            words = this.words = words || [];\n\n\t            if (sigBytes != undefined) {\n\t                this.sigBytes = sigBytes;\n\t            } else {\n\t                this.sigBytes = words.length * 4;\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts this word array to a string.\n\t         *\n\t         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n\t         *\n\t         * @return {string} The stringified word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = wordArray + '';\n\t         *     var string = wordArray.toString();\n\t         *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n\t         */\n\t        toString: function (encoder) {\n\t            return (encoder || Hex).stringify(this);\n\t        },\n\n\t        /**\n\t         * Concatenates a word array to this word array.\n\t         *\n\t         * @param {WordArray} wordArray The word array to append.\n\t         *\n\t         * @return {WordArray} This word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray1.concat(wordArray2);\n\t         */\n\t        concat: function (wordArray) {\n\t            // Shortcuts\n\t            var thisWords = this.words;\n\t            var thatWords = wordArray.words;\n\t            var thisSigBytes = this.sigBytes;\n\t            var thatSigBytes = wordArray.sigBytes;\n\n\t            // Clamp excess bits\n\t            this.clamp();\n\n\t            // Concat\n\t            if (thisSigBytes % 4) {\n\t                // Copy one byte at a time\n\t                for (var i = 0; i < thatSigBytes; i++) {\n\t                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n\t                }\n\t            } else {\n\t                // Copy one word at a time\n\t                for (var i = 0; i < thatSigBytes; i += 4) {\n\t                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n\t                }\n\t            }\n\t            this.sigBytes += thatSigBytes;\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Removes insignificant bits.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray.clamp();\n\t         */\n\t        clamp: function () {\n\t            // Shortcuts\n\t            var words = this.words;\n\t            var sigBytes = this.sigBytes;\n\n\t            // Clamp\n\t            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n\t            words.length = Math.ceil(sigBytes / 4);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this word array.\n\t         *\n\t         * @return {WordArray} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = wordArray.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone.words = this.words.slice(0);\n\n\t            return clone;\n\t        },\n\n\t        /**\n\t         * Creates a word array filled with random bytes.\n\t         *\n\t         * @param {number} nBytes The number of random bytes to generate.\n\t         *\n\t         * @return {WordArray} The random word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.random(16);\n\t         */\n\t        random: function (nBytes) {\n\t            var words = [];\n\n\t            var r = (function (m_w) {\n\t                var m_w = m_w;\n\t                var m_z = 0x3ade68b1;\n\t                var mask = 0xffffffff;\n\n\t                return function () {\n\t                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;\n\t                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;\n\t                    var result = ((m_z << 0x10) + m_w) & mask;\n\t                    result /= 0x100000000;\n\t                    result += 0.5;\n\t                    return result * (Math.random() > .5 ? 1 : -1);\n\t                }\n\t            });\n\n\t            for (var i = 0, rcache; i < nBytes; i += 4) {\n\t                var _r = r((rcache || Math.random()) * 0x100000000);\n\n\t                rcache = _r() * 0x3ade67b7;\n\t                words.push((_r() * 0x100000000) | 0);\n\t            }\n\n\t            return new WordArray.init(words, nBytes);\n\t        }\n\t    });\n\n\t    /**\n\t     * Encoder namespace.\n\t     */\n\t    var C_enc = C.enc = {};\n\n\t    /**\n\t     * Hex encoding strategy.\n\t     */\n\t    var Hex = C_enc.Hex = {\n\t        /**\n\t         * Converts a word array to a hex string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The hex string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var hexChars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                hexChars.push((bite >>> 4).toString(16));\n\t                hexChars.push((bite & 0x0f).toString(16));\n\t            }\n\n\t            return hexChars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a hex string to a word array.\n\t         *\n\t         * @param {string} hexStr The hex string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n\t         */\n\t        parse: function (hexStr) {\n\t            // Shortcut\n\t            var hexStrLength = hexStr.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < hexStrLength; i += 2) {\n\t                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n\t            }\n\n\t            return new WordArray.init(words, hexStrLength / 2);\n\t        }\n\t    };\n\n\t    /**\n\t     * Latin1 encoding strategy.\n\t     */\n\t    var Latin1 = C_enc.Latin1 = {\n\t        /**\n\t         * Converts a word array to a Latin1 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Latin1 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var latin1Chars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                latin1Chars.push(String.fromCharCode(bite));\n\t            }\n\n\t            return latin1Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Latin1 string to a word array.\n\t         *\n\t         * @param {string} latin1Str The Latin1 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n\t         */\n\t        parse: function (latin1Str) {\n\t            // Shortcut\n\t            var latin1StrLength = latin1Str.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < latin1StrLength; i++) {\n\t                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n\t            }\n\n\t            return new WordArray.init(words, latin1StrLength);\n\t        }\n\t    };\n\n\t    /**\n\t     * UTF-8 encoding strategy.\n\t     */\n\t    var Utf8 = C_enc.Utf8 = {\n\t        /**\n\t         * Converts a word array to a UTF-8 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The UTF-8 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            try {\n\t                return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n\t            } catch (e) {\n\t                throw new Error('Malformed UTF-8 data');\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts a UTF-8 string to a word array.\n\t         *\n\t         * @param {string} utf8Str The UTF-8 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n\t         */\n\t        parse: function (utf8Str) {\n\t            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract buffered block algorithm template.\n\t     *\n\t     * The property blockSize must be implemented in a concrete subtype.\n\t     *\n\t     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n\t     */\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\t        /**\n\t         * Resets this block algorithm's data buffer to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm.reset();\n\t         */\n\t        reset: function () {\n\t            // Initial values\n\t            this._data = new WordArray.init();\n\t            this._nDataBytes = 0;\n\t        },\n\n\t        /**\n\t         * Adds new data to this block algorithm's buffer.\n\t         *\n\t         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm._append('data');\n\t         *     bufferedBlockAlgorithm._append(wordArray);\n\t         */\n\t        _append: function (data) {\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof data == 'string') {\n\t                data = Utf8.parse(data);\n\t            }\n\n\t            // Append\n\t            this._data.concat(data);\n\t            this._nDataBytes += data.sigBytes;\n\t        },\n\n\t        /**\n\t         * Processes available data blocks.\n\t         *\n\t         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n\t         *\n\t         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n\t         *\n\t         * @return {WordArray} The processed data.\n\t         *\n\t         * @example\n\t         *\n\t         *     var processedData = bufferedBlockAlgorithm._process();\n\t         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n\t         */\n\t        _process: function (doFlush) {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\t            var dataSigBytes = data.sigBytes;\n\t            var blockSize = this.blockSize;\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count blocks ready\n\t            var nBlocksReady = dataSigBytes / blockSizeBytes;\n\t            if (doFlush) {\n\t                // Round up to include partial blocks\n\t                nBlocksReady = Math.ceil(nBlocksReady);\n\t            } else {\n\t                // Round down to include only full blocks,\n\t                // less the number of blocks that must remain in the buffer\n\t                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n\t            }\n\n\t            // Count words ready\n\t            var nWordsReady = nBlocksReady * blockSize;\n\n\t            // Count bytes ready\n\t            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n\t            // Process blocks\n\t            if (nWordsReady) {\n\t                for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n\t                    // Perform concrete-algorithm logic\n\t                    this._doProcessBlock(dataWords, offset);\n\t                }\n\n\t                // Remove processed words\n\t                var processedWords = dataWords.splice(0, nWordsReady);\n\t                data.sigBytes -= nBytesReady;\n\t            }\n\n\t            // Return processed words\n\t            return new WordArray.init(processedWords, nBytesReady);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this object.\n\t         *\n\t         * @return {Object} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = bufferedBlockAlgorithm.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone._data = this._data.clone();\n\n\t            return clone;\n\t        },\n\n\t        _minBufferSize: 0\n\t    });\n\n\t    /**\n\t     * Abstract hasher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n\t     */\n\t    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Initializes a newly created hasher.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hasher = CryptoJS.algo.SHA256.create();\n\t         */\n\t        init: function (cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this hasher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-hasher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Updates this hasher with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {Hasher} This hasher.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.update('message');\n\t         *     hasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            // Append\n\t            this._append(messageUpdate);\n\n\t            // Update the hash\n\t            this._process();\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the hash computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The hash.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hash = hasher.finalize();\n\t         *     var hash = hasher.finalize('message');\n\t         *     var hash = hasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Final message update\n\t            if (messageUpdate) {\n\t                this._append(messageUpdate);\n\t            }\n\n\t            // Perform concrete-hasher logic\n\t            var hash = this._doFinalize();\n\n\t            return hash;\n\t        },\n\n\t        blockSize: 512/32,\n\n\t        /**\n\t         * Creates a shortcut function to a hasher's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to create a helper for.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHelper: function (hasher) {\n\t            return function (message, cfg) {\n\t                return new hasher.init(cfg).finalize(message);\n\t            };\n\t        },\n\n\t        /**\n\t         * Creates a shortcut function to the HMAC's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to use in this HMAC helper.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHmacHelper: function (hasher) {\n\t            return function (message, key) {\n\t                return new C_algo.HMAC.init(hasher, key).finalize(message);\n\t            };\n\t        }\n\t    });\n\n\t    /**\n\t     * Algorithm namespace.\n\t     */\n\t    var C_algo = C.algo = {};\n\n\t    return C;\n\t}(Math));\n\n\n\treturn CryptoJS;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var C_enc = C.enc;\n\n\t    /**\n\t     * Base64 encoding strategy.\n\t     */\n\t    var Base64 = C_enc.Base64 = {\n\t        /**\n\t         * Converts a word array to a Base64 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Base64 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\t            var map = this._map;\n\n\t            // Clamp excess bits\n\t            wordArray.clamp();\n\n\t            // Convert\n\t            var base64Chars = [];\n\t            for (var i = 0; i < sigBytes; i += 3) {\n\t                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;\n\t                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n\t                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n\t                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n\t                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {\n\t                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n\t                }\n\t            }\n\n\t            // Add padding\n\t            var paddingChar = map.charAt(64);\n\t            if (paddingChar) {\n\t                while (base64Chars.length % 4) {\n\t                    base64Chars.push(paddingChar);\n\t                }\n\t            }\n\n\t            return base64Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Base64 string to a word array.\n\t         *\n\t         * @param {string} base64Str The Base64 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);\n\t         */\n\t        parse: function (base64Str) {\n\t            // Shortcuts\n\t            var base64StrLength = base64Str.length;\n\t            var map = this._map;\n\t            var reverseMap = this._reverseMap;\n\n\t            if (!reverseMap) {\n\t                    reverseMap = this._reverseMap = [];\n\t                    for (var j = 0; j < map.length; j++) {\n\t                        reverseMap[map.charCodeAt(j)] = j;\n\t                    }\n\t            }\n\n\t            // Ignore padding\n\t            var paddingChar = map.charAt(64);\n\t            if (paddingChar) {\n\t                var paddingIndex = base64Str.indexOf(paddingChar);\n\t                if (paddingIndex !== -1) {\n\t                    base64StrLength = paddingIndex;\n\t                }\n\t            }\n\n\t            // Convert\n\t            return parseLoop(base64Str, base64StrLength, reverseMap);\n\n\t        },\n\n\t        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='\n\t    };\n\n\t    function parseLoop(base64Str, base64StrLength, reverseMap) {\n\t      var words = [];\n\t      var nBytes = 0;\n\t      for (var i = 0; i < base64StrLength; i++) {\n\t          if (i % 4) {\n\t              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);\n\t              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);\n\t              words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);\n\t              nBytes++;\n\t          }\n\t      }\n\t      return WordArray.create(words, nBytes);\n\t    }\n\t}());\n\n\n\treturn CryptoJS.enc.Base64;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\treturn CryptoJS.enc.Hex;\n\n}));",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47), require(53), require(51));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./sha1\", \"./hmac\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var WordArray = C_lib.WordArray;\n\t    var C_algo = C.algo;\n\t    var MD5 = C_algo.MD5;\n\n\t    /**\n\t     * This key derivation function is meant to conform with EVP_BytesToKey.\n\t     * www.openssl.org/docs/crypto/EVP_BytesToKey.html\n\t     */\n\t    var EvpKDF = C_algo.EvpKDF = Base.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\n\t         * @property {Hasher} hasher The hash algorithm to use. Default: MD5\n\t         * @property {number} iterations The number of iterations to perform. Default: 1\n\t         */\n\t        cfg: Base.extend({\n\t            keySize: 128/32,\n\t            hasher: MD5,\n\t            iterations: 1\n\t        }),\n\n\t        /**\n\t         * Initializes a newly created key derivation function.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for the derivation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create();\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });\n\t         */\n\t        init: function (cfg) {\n\t            this.cfg = this.cfg.extend(cfg);\n\t        },\n\n\t        /**\n\t         * Derives a key from a password.\n\t         *\n\t         * @param {WordArray|string} password The password.\n\t         * @param {WordArray|string} salt A salt.\n\t         *\n\t         * @return {WordArray} The derived key.\n\t         *\n\t         * @example\n\t         *\n\t         *     var key = kdf.compute(password, salt);\n\t         */\n\t        compute: function (password, salt) {\n\t            // Shortcut\n\t            var cfg = this.cfg;\n\n\t            // Init hasher\n\t            var hasher = cfg.hasher.create();\n\n\t            // Initial values\n\t            var derivedKey = WordArray.create();\n\n\t            // Shortcuts\n\t            var derivedKeyWords = derivedKey.words;\n\t            var keySize = cfg.keySize;\n\t            var iterations = cfg.iterations;\n\n\t            // Generate key\n\t            while (derivedKeyWords.length < keySize) {\n\t                if (block) {\n\t                    hasher.update(block);\n\t                }\n\t                var block = hasher.update(password).finalize(salt);\n\t                hasher.reset();\n\n\t                // Iterations\n\t                for (var i = 1; i < iterations; i++) {\n\t                    block = hasher.finalize(block);\n\t                    hasher.reset();\n\t                }\n\n\t                derivedKey.concat(block);\n\t            }\n\t            derivedKey.sigBytes = keySize * 4;\n\n\t            return derivedKey;\n\t        }\n\t    });\n\n\t    /**\n\t     * Derives a key from a password.\n\t     *\n\t     * @param {WordArray|string} password The password.\n\t     * @param {WordArray|string} salt A salt.\n\t     * @param {Object} cfg (Optional) The configuration options to use for this computation.\n\t     *\n\t     * @return {WordArray} The derived key.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var key = CryptoJS.EvpKDF(password, salt);\n\t     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });\n\t     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });\n\t     */\n\t    C.EvpKDF = function (password, salt, cfg) {\n\t        return EvpKDF.create(cfg).compute(password, salt);\n\t    };\n\t}());\n\n\n\treturn CryptoJS.EvpKDF;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var C_enc = C.enc;\n\t    var Utf8 = C_enc.Utf8;\n\t    var C_algo = C.algo;\n\n\t    /**\n\t     * HMAC algorithm.\n\t     */\n\t    var HMAC = C_algo.HMAC = Base.extend({\n\t        /**\n\t         * Initializes a newly created HMAC.\n\t         *\n\t         * @param {Hasher} hasher The hash algorithm to use.\n\t         * @param {WordArray|string} key The secret key.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);\n\t         */\n\t        init: function (hasher, key) {\n\t            // Init hasher\n\t            hasher = this._hasher = new hasher.init();\n\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof key == 'string') {\n\t                key = Utf8.parse(key);\n\t            }\n\n\t            // Shortcuts\n\t            var hasherBlockSize = hasher.blockSize;\n\t            var hasherBlockSizeBytes = hasherBlockSize * 4;\n\n\t            // Allow arbitrary length keys\n\t            if (key.sigBytes > hasherBlockSizeBytes) {\n\t                key = hasher.finalize(key);\n\t            }\n\n\t            // Clamp excess bits\n\t            key.clamp();\n\n\t            // Clone key for inner and outer pads\n\t            var oKey = this._oKey = key.clone();\n\t            var iKey = this._iKey = key.clone();\n\n\t            // Shortcuts\n\t            var oKeyWords = oKey.words;\n\t            var iKeyWords = iKey.words;\n\n\t            // XOR keys with pad constants\n\t            for (var i = 0; i < hasherBlockSize; i++) {\n\t                oKeyWords[i] ^= 0x5c5c5c5c;\n\t                iKeyWords[i] ^= 0x36363636;\n\t            }\n\t            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this HMAC to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hmacHasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Shortcut\n\t            var hasher = this._hasher;\n\n\t            // Reset\n\t            hasher.reset();\n\t            hasher.update(this._iKey);\n\t        },\n\n\t        /**\n\t         * Updates this HMAC with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {HMAC} This HMAC instance.\n\t         *\n\t         * @example\n\t         *\n\t         *     hmacHasher.update('message');\n\t         *     hmacHasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            this._hasher.update(messageUpdate);\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the HMAC computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The HMAC.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hmac = hmacHasher.finalize();\n\t         *     var hmac = hmacHasher.finalize('message');\n\t         *     var hmac = hmacHasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Shortcut\n\t            var hasher = this._hasher;\n\n\t            // Compute HMAC\n\t            var innerHash = hasher.finalize(messageUpdate);\n\t            hasher.reset();\n\t            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));\n\n\t            return hmac;\n\t        }\n\t    });\n\t}());\n\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function (Math) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Constants table\n\t    var T = [];\n\n\t    // Compute constants\n\t    (function () {\n\t        for (var i = 0; i < 64; i++) {\n\t            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n\t        }\n\t    }());\n\n\t    /**\n\t     * MD5 hash algorithm.\n\t     */\n\t    var MD5 = C_algo.MD5 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Swap endian\n\t            for (var i = 0; i < 16; i++) {\n\t                // Shortcuts\n\t                var offset_i = offset + i;\n\t                var M_offset_i = M[offset_i];\n\n\t                M[offset_i] = (\n\t                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |\n\t                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)\n\t                );\n\t            }\n\n\t            // Shortcuts\n\t            var H = this._hash.words;\n\n\t            var M_offset_0  = M[offset + 0];\n\t            var M_offset_1  = M[offset + 1];\n\t            var M_offset_2  = M[offset + 2];\n\t            var M_offset_3  = M[offset + 3];\n\t            var M_offset_4  = M[offset + 4];\n\t            var M_offset_5  = M[offset + 5];\n\t            var M_offset_6  = M[offset + 6];\n\t            var M_offset_7  = M[offset + 7];\n\t            var M_offset_8  = M[offset + 8];\n\t            var M_offset_9  = M[offset + 9];\n\t            var M_offset_10 = M[offset + 10];\n\t            var M_offset_11 = M[offset + 11];\n\t            var M_offset_12 = M[offset + 12];\n\t            var M_offset_13 = M[offset + 13];\n\t            var M_offset_14 = M[offset + 14];\n\t            var M_offset_15 = M[offset + 15];\n\n\t            // Working varialbes\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\n\t            // Computation\n\t            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);\n\t            d = FF(d, a, b, c, M_offset_1,  12, T[1]);\n\t            c = FF(c, d, a, b, M_offset_2,  17, T[2]);\n\t            b = FF(b, c, d, a, M_offset_3,  22, T[3]);\n\t            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);\n\t            d = FF(d, a, b, c, M_offset_5,  12, T[5]);\n\t            c = FF(c, d, a, b, M_offset_6,  17, T[6]);\n\t            b = FF(b, c, d, a, M_offset_7,  22, T[7]);\n\t            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);\n\t            d = FF(d, a, b, c, M_offset_9,  12, T[9]);\n\t            c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n\t            b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n\t            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);\n\t            d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n\t            c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n\t            b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\n\t            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);\n\t            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);\n\t            c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n\t            b = GG(b, c, d, a, M_offset_0,  20, T[19]);\n\t            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);\n\t            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);\n\t            c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n\t            b = GG(b, c, d, a, M_offset_4,  20, T[23]);\n\t            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);\n\t            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);\n\t            c = GG(c, d, a, b, M_offset_3,  14, T[26]);\n\t            b = GG(b, c, d, a, M_offset_8,  20, T[27]);\n\t            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);\n\t            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);\n\t            c = GG(c, d, a, b, M_offset_7,  14, T[30]);\n\t            b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\n\t            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);\n\t            d = HH(d, a, b, c, M_offset_8,  11, T[33]);\n\t            c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n\t            b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n\t            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);\n\t            d = HH(d, a, b, c, M_offset_4,  11, T[37]);\n\t            c = HH(c, d, a, b, M_offset_7,  16, T[38]);\n\t            b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n\t            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);\n\t            d = HH(d, a, b, c, M_offset_0,  11, T[41]);\n\t            c = HH(c, d, a, b, M_offset_3,  16, T[42]);\n\t            b = HH(b, c, d, a, M_offset_6,  23, T[43]);\n\t            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);\n\t            d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n\t            c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n\t            b = HH(b, c, d, a, M_offset_2,  23, T[47]);\n\n\t            a = II(a, b, c, d, M_offset_0,  6,  T[48]);\n\t            d = II(d, a, b, c, M_offset_7,  10, T[49]);\n\t            c = II(c, d, a, b, M_offset_14, 15, T[50]);\n\t            b = II(b, c, d, a, M_offset_5,  21, T[51]);\n\t            a = II(a, b, c, d, M_offset_12, 6,  T[52]);\n\t            d = II(d, a, b, c, M_offset_3,  10, T[53]);\n\t            c = II(c, d, a, b, M_offset_10, 15, T[54]);\n\t            b = II(b, c, d, a, M_offset_1,  21, T[55]);\n\t            a = II(a, b, c, d, M_offset_8,  6,  T[56]);\n\t            d = II(d, a, b, c, M_offset_15, 10, T[57]);\n\t            c = II(c, d, a, b, M_offset_6,  15, T[58]);\n\t            b = II(b, c, d, a, M_offset_13, 21, T[59]);\n\t            a = II(a, b, c, d, M_offset_4,  6,  T[60]);\n\t            d = II(d, a, b, c, M_offset_11, 10, T[61]);\n\t            c = II(c, d, a, b, M_offset_2,  15, T[62]);\n\t            b = II(b, c, d, a, M_offset_9,  21, T[63]);\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\n\t            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n\t            var nBitsTotalL = nBitsTotal;\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n\t                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)\n\t            );\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n\t                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)\n\t            );\n\n\t            data.sigBytes = (dataWords.length + 1) * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Shortcuts\n\t            var hash = this._hash;\n\t            var H = hash.words;\n\n\t            // Swap endian\n\t            for (var i = 0; i < 4; i++) {\n\t                // Shortcut\n\t                var H_i = H[i];\n\n\t                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |\n\t                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);\n\t            }\n\n\t            // Return final computed hash\n\t            return hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    function FF(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & c) | (~b & d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function GG(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & d) | (c & ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function HH(a, b, c, d, x, s, t) {\n\t        var n = a + (b ^ c ^ d) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function II(a, b, c, d, x, s, t) {\n\t        var n = a + (c ^ (b | ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.MD5('message');\n\t     *     var hash = CryptoJS.MD5(wordArray);\n\t     */\n\t    C.MD5 = Hasher._createHelper(MD5);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacMD5(message, key);\n\t     */\n\t    C.HmacMD5 = Hasher._createHmacHelper(MD5);\n\t}(Math));\n\n\n\treturn CryptoJS.MD5;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(47));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Reusable object\n\t    var W = [];\n\n\t    /**\n\t     * SHA-1 hash algorithm.\n\t     */\n\t    var SHA1 = C_algo.SHA1 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476,\n\t                0xc3d2e1f0\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Shortcut\n\t            var H = this._hash.words;\n\n\t            // Working variables\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\t            var e = H[4];\n\n\t            // Computation\n\t            for (var i = 0; i < 80; i++) {\n\t                if (i < 16) {\n\t                    W[i] = M[offset + i] | 0;\n\t                } else {\n\t                    var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n\t                    W[i] = (n << 1) | (n >>> 31);\n\t                }\n\n\t                var t = ((a << 5) | (a >>> 27)) + e + W[i];\n\t                if (i < 20) {\n\t                    t += ((b & c) | (~b & d)) + 0x5a827999;\n\t                } else if (i < 40) {\n\t                    t += (b ^ c ^ d) + 0x6ed9eba1;\n\t                } else if (i < 60) {\n\t                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;\n\t                } else /* if (i < 80) */ {\n\t                    t += (b ^ c ^ d) - 0x359d3e2a;\n\t                }\n\n\t                e = d;\n\t                d = c;\n\t                c = (b << 30) | (b >>> 2);\n\t                b = a;\n\t                a = t;\n\t            }\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t            H[4] = (H[4] + e) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n\t            data.sigBytes = dataWords.length * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Return final computed hash\n\t            return this._hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.SHA1('message');\n\t     *     var hash = CryptoJS.SHA1(wordArray);\n\t     */\n\t    C.SHA1 = Hasher._createHelper(SHA1);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacSHA1(message, key);\n\t     */\n\t    C.HmacSHA1 = Hasher._createHmacHelper(SHA1);\n\t}());\n\n\n\treturn CryptoJS.SHA1;\n\n}));","var pSlice = Array.prototype.slice;\nvar objectKeys = require(56);\nvar isArguments = require(55);\n\nvar deepEqual = module.exports = function (actual, expected, opts) {\n  if (!opts) opts = {};\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n\n  } else if (actual instanceof Date && expected instanceof Date) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {\n    return opts.strict ? actual === expected : actual == expected;\n\n  // 7.4. For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else {\n    return objEquiv(actual, expected, opts);\n  }\n}\n\nfunction isUndefinedOrNull(value) {\n  return value === null || value === undefined;\n}\n\nfunction isBuffer (x) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false;\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') return false;\n  return true;\n}\n\nfunction objEquiv(a, b, opts) {\n  var i, key;\n  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))\n    return false;\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) return false;\n  //~~~I've managed to break Object.keys through screwy arguments passing.\n  //   Converting to array solves the problem.\n  if (isArguments(a)) {\n    if (!isArguments(b)) {\n      return false;\n    }\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return deepEqual(a, b, opts);\n  }\n  if (isBuffer(a)) {\n    if (!isBuffer(b)) {\n      return false;\n    }\n    if (a.length !== b.length) return false;\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) return false;\n    }\n    return true;\n  }\n  try {\n    var ka = objectKeys(a),\n        kb = objectKeys(b);\n  } catch (e) {//happens when one is a string literal and the other isn't\n    return false;\n  }\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length != kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], opts)) return false;\n  }\n  return typeof a === typeof b;\n}\n","var supportsArgumentsClass = (function(){\n  return Object.prototype.toString.call(arguments)\n})() == '[object Arguments]';\n\nexports = module.exports = supportsArgumentsClass ? supported : unsupported;\n\nexports.supported = supported;\nfunction supported(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n};\n\nexports.unsupported = unsupported;\nfunction unsupported(object){\n  return object &&\n    typeof object == 'object' &&\n    typeof object.length == 'number' &&\n    Object.prototype.hasOwnProperty.call(object, 'callee') &&\n    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||\n    false;\n};\n","exports = module.exports = typeof Object.keys === 'function'\n  ? Object.keys : shim;\n\nexports.shim = shim;\nfunction shim (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n}\n","var assert = require(27)\nvar BigInteger = require(32)\n\nvar Point = require(61)\n\nfunction Curve (p, a, b, Gx, Gy, n, h) {\n  this.p = p\n  this.a = a\n  this.b = b\n  this.G = Point.fromAffine(this, Gx, Gy)\n  this.n = n\n  this.h = h\n\n  this.infinity = new Point(this, null, null, BigInteger.ZERO)\n\n  // result caching\n  this.pOverFour = p.add(BigInteger.ONE).shiftRight(2)\n\n  // determine size of p in bytes\n  this.pLength = Math.floor((this.p.bitLength() + 7) / 8)\n}\n\nCurve.prototype.pointFromX = function (isOdd, x) {\n  var alpha = x.pow(3).add(this.a.multiply(x)).add(this.b).mod(this.p)\n  var beta = alpha.modPow(this.pOverFour, this.p) // XXX: not compatible with all curves\n\n  var y = beta\n  if (beta.isEven() ^ !isOdd) {\n    y = this.p.subtract(y) // -y % p\n  }\n\n  return Point.fromAffine(this, x, y)\n}\n\nCurve.prototype.isInfinity = function (Q) {\n  if (Q === this.infinity) return true\n\n  return Q.z.signum() === 0 && Q.y.signum() !== 0\n}\n\nCurve.prototype.isOnCurve = function (Q) {\n  if (this.isInfinity(Q)) return true\n\n  var x = Q.affineX\n  var y = Q.affineY\n  var a = this.a\n  var b = this.b\n  var p = this.p\n\n  // Check that xQ and yQ are integers in the interval [0, p - 1]\n  if (x.signum() < 0 || x.compareTo(p) >= 0) return false\n  if (y.signum() < 0 || y.compareTo(p) >= 0) return false\n\n  // and check that y^2 = x^3 + ax + b (mod p)\n  var lhs = y.square().mod(p)\n  var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p)\n  return lhs.equals(rhs)\n}\n\n/**\n * Validate an elliptic curve point.\n *\n * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive\n */\nCurve.prototype.validate = function (Q) {\n  // Check Q != O\n  assert(!this.isInfinity(Q), 'Point is at infinity')\n  assert(this.isOnCurve(Q), 'Point is not on the curve')\n\n  // Check nQ = O (where Q is a scalar multiple of G)\n  var nQ = Q.multiply(this.n)\n  assert(this.isInfinity(nQ), 'Point is not a scalar multiple of G')\n\n  return true\n}\n\nmodule.exports = Curve\n","module.exports={\n  \"secp128r1\": {\n    \"p\": \"fffffffdffffffffffffffffffffffff\",\n    \"a\": \"fffffffdfffffffffffffffffffffffc\",\n    \"b\": \"e87579c11079f43dd824993c2cee5ed3\",\n    \"n\": \"fffffffe0000000075a30d1b9038a115\",\n    \"h\": \"01\",\n    \"Gx\": \"161ff7528b899b2d0c28607ca52c5b86\",\n    \"Gy\": \"cf5ac8395bafeb13c02da292dded7a83\"\n  },\n  \"secp160k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffeffffac73\",\n    \"a\": \"00\",\n    \"b\": \"07\",\n    \"n\": \"0100000000000000000001b8fa16dfab9aca16b6b3\",\n    \"h\": \"01\",\n    \"Gx\": \"3b4c382ce37aa192a4019e763036f4f5dd4d7ebb\",\n    \"Gy\": \"938cf935318fdced6bc28286531733c3f03c4fee\"\n  },\n  \"secp160r1\": {\n    \"p\": \"ffffffffffffffffffffffffffffffff7fffffff\",\n    \"a\": \"ffffffffffffffffffffffffffffffff7ffffffc\",\n    \"b\": \"1c97befc54bd7a8b65acf89f81d4d4adc565fa45\",\n    \"n\": \"0100000000000000000001f4c8f927aed3ca752257\",\n    \"h\": \"01\",\n    \"Gx\": \"4a96b5688ef573284664698968c38bb913cbfc82\",\n    \"Gy\": \"23a628553168947d59dcc912042351377ac5fb32\"\n  },\n  \"secp192k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffffffffffeffffee37\",\n    \"a\": \"00\",\n    \"b\": \"03\",\n    \"n\": \"fffffffffffffffffffffffe26f2fc170f69466a74defd8d\",\n    \"h\": \"01\",\n    \"Gx\": \"db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d\",\n    \"Gy\": \"9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d\"\n  },\n  \"secp192r1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffeffffffffffffffff\",\n    \"a\": \"fffffffffffffffffffffffffffffffefffffffffffffffc\",\n    \"b\": \"64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1\",\n    \"n\": \"ffffffffffffffffffffffff99def836146bc9b1b4d22831\",\n    \"h\": \"01\",\n    \"Gx\": \"188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012\",\n    \"Gy\": \"07192b95ffc8da78631011ed6b24cdd573f977a11e794811\"\n  },\n  \"secp256k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f\",\n    \"a\": \"00\",\n    \"b\": \"07\",\n    \"n\": \"fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141\",\n    \"h\": \"01\",\n    \"Gx\": \"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\n    \"Gy\": \"483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8\"\n  },\n  \"secp256r1\": {\n    \"p\": \"ffffffff00000001000000000000000000000000ffffffffffffffffffffffff\",\n    \"a\": \"ffffffff00000001000000000000000000000000fffffffffffffffffffffffc\",\n    \"b\": \"5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b\",\n    \"n\": \"ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551\",\n    \"h\": \"01\",\n    \"Gx\": \"6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296\",\n    \"Gy\": \"4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5\"\n  }\n}\n","var Point = require(61)\nvar Curve = require(57)\n\nvar getCurveByName = require(60)\n\nmodule.exports = {\n  Curve: Curve,\n  Point: Point,\n  getCurveByName: getCurveByName\n}\n","var BigInteger = require(32)\n\nvar curves = require(58)\nvar Curve = require(57)\n\nfunction getCurveByName (name) {\n  var curve = curves[name]\n  if (!curve) return null\n\n  var p = new BigInteger(curve.p, 16)\n  var a = new BigInteger(curve.a, 16)\n  var b = new BigInteger(curve.b, 16)\n  var n = new BigInteger(curve.n, 16)\n  var h = new BigInteger(curve.h, 16)\n  var Gx = new BigInteger(curve.Gx, 16)\n  var Gy = new BigInteger(curve.Gy, 16)\n\n  return new Curve(p, a, b, Gx, Gy, n, h)\n}\n\nmodule.exports = getCurveByName\n","var assert = require(27)\nvar Buffer = require(93).Buffer\nvar BigInteger = require(32)\n\nvar THREE = BigInteger.valueOf(3)\n\nfunction Point (curve, x, y, z) {\n  assert.notStrictEqual(z, undefined, 'Missing Z coordinate')\n\n  this.curve = curve\n  this.x = x\n  this.y = y\n  this.z = z\n  this._zInv = null\n\n  this.compressed = true\n}\n\nObject.defineProperty(Point.prototype, 'zInv', {\n  get: function () {\n    if (this._zInv === null) {\n      this._zInv = this.z.modInverse(this.curve.p)\n    }\n\n    return this._zInv\n  }\n})\n\nObject.defineProperty(Point.prototype, 'affineX', {\n  get: function () {\n    return this.x.multiply(this.zInv).mod(this.curve.p)\n  }\n})\n\nObject.defineProperty(Point.prototype, 'affineY', {\n  get: function () {\n    return this.y.multiply(this.zInv).mod(this.curve.p)\n  }\n})\n\nPoint.fromAffine = function (curve, x, y) {\n  return new Point(curve, x, y, BigInteger.ONE)\n}\n\nPoint.prototype.equals = function (other) {\n  if (other === this) return true\n  if (this.curve.isInfinity(this)) return this.curve.isInfinity(other)\n  if (this.curve.isInfinity(other)) return this.curve.isInfinity(this)\n\n  // u = Y2 * Z1 - Y1 * Z2\n  var u = other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p)\n\n  if (u.signum() !== 0) return false\n\n  // v = X2 * Z1 - X1 * Z2\n  var v = other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p)\n\n  return v.signum() === 0\n}\n\nPoint.prototype.negate = function () {\n  var y = this.curve.p.subtract(this.y)\n\n  return new Point(this.curve, this.x, y, this.z)\n}\n\nPoint.prototype.add = function (b) {\n  if (this.curve.isInfinity(this)) return b\n  if (this.curve.isInfinity(b)) return this\n\n  var x1 = this.x\n  var y1 = this.y\n  var x2 = b.x\n  var y2 = b.y\n\n  // u = Y2 * Z1 - Y1 * Z2\n  var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p)\n  // v = X2 * Z1 - X1 * Z2\n  var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p)\n\n  if (v.signum() === 0) {\n    if (u.signum() === 0) {\n      return this.twice() // this == b, so double\n    }\n\n    return this.curve.infinity // this = -b, so infinity\n  }\n\n  var v2 = v.square()\n  var v3 = v2.multiply(v)\n  var x1v2 = x1.multiply(v2)\n  var zu2 = u.square().multiply(this.z)\n\n  // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)\n  var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.p)\n  // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3\n  var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.p)\n  // z3 = v^3 * z1 * z2\n  var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.p)\n\n  return new Point(this.curve, x3, y3, z3)\n}\n\nPoint.prototype.twice = function () {\n  if (this.curve.isInfinity(this)) return this\n  if (this.y.signum() === 0) return this.curve.infinity\n\n  var x1 = this.x\n  var y1 = this.y\n\n  var y1z1 = y1.multiply(this.z).mod(this.curve.p)\n  var y1sqz1 = y1z1.multiply(y1).mod(this.curve.p)\n  var a = this.curve.a\n\n  // w = 3 * x1^2 + a * z1^2\n  var w = x1.square().multiply(THREE)\n\n  if (a.signum() !== 0) {\n    w = w.add(this.z.square().multiply(a))\n  }\n\n  w = w.mod(this.curve.p)\n  // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)\n  var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.p)\n  // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3\n  var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.pow(3)).mod(this.curve.p)\n  // z3 = 8 * (y1 * z1)^3\n  var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.p)\n\n  return new Point(this.curve, x3, y3, z3)\n}\n\n// Simple NAF (Non-Adjacent Form) multiplication algorithm\n// TODO: modularize the multiplication algorithm\nPoint.prototype.multiply = function (k) {\n  if (this.curve.isInfinity(this)) return this\n  if (k.signum() === 0) return this.curve.infinity\n\n  var e = k\n  var h = e.multiply(THREE)\n\n  var neg = this.negate()\n  var R = this\n\n  for (var i = h.bitLength() - 2; i > 0; --i) {\n    var hBit = h.testBit(i)\n    var eBit = e.testBit(i)\n\n    R = R.twice()\n\n    if (hBit !== eBit) {\n      R = R.add(hBit ? this : neg)\n    }\n  }\n\n  return R\n}\n\n// Compute this*j + x*k (simultaneous multiplication)\nPoint.prototype.multiplyTwo = function (j, x, k) {\n  var i = Math.max(j.bitLength(), k.bitLength()) - 1\n  var R = this.curve.infinity\n  var both = this.add(x)\n\n  while (i >= 0) {\n    var jBit = j.testBit(i)\n    var kBit = k.testBit(i)\n\n    R = R.twice()\n\n    if (jBit) {\n      if (kBit) {\n        R = R.add(both)\n      } else {\n        R = R.add(this)\n      }\n    } else if (kBit) {\n      R = R.add(x)\n    }\n    --i\n  }\n\n  return R\n}\n\nPoint.prototype.getEncoded = function (compressed) {\n  if (compressed == null) compressed = this.compressed\n  if (this.curve.isInfinity(this)) return Buffer.alloc(1, 0) // Infinity point encoded is simply '00'\n\n  var x = this.affineX\n  var y = this.affineY\n  var byteLength = this.curve.pLength\n  var buffer\n\n  // 0x02/0x03 | X\n  if (compressed) {\n    buffer = Buffer.allocUnsafe(1 + byteLength)\n    buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0)\n\n  // 0x04 | X | Y\n  } else {\n    buffer = Buffer.allocUnsafe(1 + byteLength + byteLength)\n    buffer.writeUInt8(0x04, 0)\n\n    y.toBuffer(byteLength).copy(buffer, 1 + byteLength)\n  }\n\n  x.toBuffer(byteLength).copy(buffer, 1)\n\n  return buffer\n}\n\nPoint.decodeFrom = function (curve, buffer) {\n  var type = buffer.readUInt8(0)\n  var compressed = (type !== 4)\n\n  var byteLength = Math.floor((curve.p.bitLength() + 7) / 8)\n  var x = BigInteger.fromBuffer(buffer.slice(1, 1 + byteLength))\n\n  var Q\n  if (compressed) {\n    assert.equal(buffer.length, byteLength + 1, 'Invalid sequence length')\n    assert(type === 0x02 || type === 0x03, 'Invalid sequence tag')\n\n    var isOdd = (type === 0x03)\n    Q = curve.pointFromX(isOdd, x)\n  } else {\n    assert.equal(buffer.length, 1 + byteLength + byteLength, 'Invalid sequence length')\n\n    var y = BigInteger.fromBuffer(buffer.slice(1 + byteLength))\n    Q = Point.fromAffine(curve, x, y)\n  }\n\n  Q.compressed = compressed\n  return Q\n}\n\nPoint.prototype.toString = function () {\n  if (this.curve.isInfinity(this)) return '(INFINITY)'\n\n  return '(' + this.affineX.toString() + ',' + this.affineY.toString() + ')'\n}\n\nmodule.exports = Point\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","'use strict'\nvar Buffer = require(93).Buffer\nvar Transform = require(103).Transform\nvar inherits = require(65)\n\nfunction throwIfNotStringOrBuffer (val, prefix) {\n  if (!Buffer.isBuffer(val) && typeof val !== 'string') {\n    throw new TypeError(prefix + ' must be a string or a buffer')\n  }\n}\n\nfunction HashBase (blockSize) {\n  Transform.call(this)\n\n  this._block = Buffer.allocUnsafe(blockSize)\n  this._blockSize = blockSize\n  this._blockOffset = 0\n  this._length = [0, 0, 0, 0]\n\n  this._finalized = false\n}\n\ninherits(HashBase, Transform)\n\nHashBase.prototype._transform = function (chunk, encoding, callback) {\n  var error = null\n  try {\n    this.update(chunk, encoding)\n  } catch (err) {\n    error = err\n  }\n\n  callback(error)\n}\n\nHashBase.prototype._flush = function (callback) {\n  var error = null\n  try {\n    this.push(this.digest())\n  } catch (err) {\n    error = err\n  }\n\n  callback(error)\n}\n\nHashBase.prototype.update = function (data, encoding) {\n  throwIfNotStringOrBuffer(data, 'Data')\n  if (this._finalized) throw new Error('Digest already called')\n  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n  // consume data\n  var block = this._block\n  var offset = 0\n  while (this._blockOffset + data.length - offset >= this._blockSize) {\n    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]\n    this._update()\n    this._blockOffset = 0\n  }\n  while (offset < data.length) block[this._blockOffset++] = data[offset++]\n\n  // update length\n  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {\n    this._length[j] += carry\n    carry = (this._length[j] / 0x0100000000) | 0\n    if (carry > 0) this._length[j] -= 0x0100000000 * carry\n  }\n\n  return this\n}\n\nHashBase.prototype._update = function () {\n  throw new Error('_update is not implemented')\n}\n\nHashBase.prototype.digest = function (encoding) {\n  if (this._finalized) throw new Error('Digest already called')\n  this._finalized = true\n\n  var digest = this._digest()\n  if (encoding !== undefined) digest = digest.toString(encoding)\n\n  // reset state\n  this._block.fill(0)\n  this._blockOffset = 0\n  for (var i = 0; i < 4; ++i) this._length[i] = 0\n\n  return digest\n}\n\nHashBase.prototype._digest = function () {\n  throw new Error('_digest is not implemented')\n}\n\nmodule.exports = HashBase\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\r\n Copyright 2013 Daniel Wirtz <dcode@dcode.io>\r\n Copyright 2009 The Closure Library Authors. All Rights Reserved.\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS-IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/long.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module[\"exports\"] = factory();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"Long\"] = factory();\r\n\r\n})(this, function() {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n     *  See the from* functions below for more convenient ways of constructing Longs.\r\n     * @exports Long\r\n     * @class A Long class for representing a 64 bit two's-complement integer value.\r\n     * @param {number} low The low (signed) 32 bits of the long\r\n     * @param {number} high The high (signed) 32 bits of the long\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @constructor\r\n     */\r\n    function Long(low, high, unsigned) {\r\n\r\n        /**\r\n         * The low 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.low = low | 0;\r\n\r\n        /**\r\n         * The high 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.high = high | 0;\r\n\r\n        /**\r\n         * Whether unsigned or not.\r\n         * @type {boolean}\r\n         */\r\n        this.unsigned = !!unsigned;\r\n    }\r\n\r\n    // The internal representation of a long is the two given signed, 32-bit values.\r\n    // We use 32-bit pieces because these are the size of integers on which\r\n    // Javascript performs bit-operations.  For operations like addition and\r\n    // multiplication, we split each number into 16 bit pieces, which can easily be\r\n    // multiplied within Javascript's floating-point representation without overflow\r\n    // or change in sign.\r\n    //\r\n    // In the algorithms below, we frequently reduce the negative case to the\r\n    // positive case by negating the input(s) and then post-processing the result.\r\n    // Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n    // a positive number, it overflows back into a negative).  Not handling this\r\n    // case would often result in infinite recursion.\r\n    //\r\n    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n    // methods on which they depend.\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a Long or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @private\r\n     */\r\n    Long.prototype.__isLong__;\r\n\r\n    Object.defineProperty(Long.prototype, \"__isLong__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    /**\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     * @inner\r\n     */\r\n    function isLong(obj) {\r\n        return (obj && obj[\"__isLong__\"]) === true;\r\n    }\r\n\r\n    /**\r\n     * Tests if the specified object is a Long.\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     */\r\n    Long.isLong = isLong;\r\n\r\n    /**\r\n     * A cache of the Long representations of small integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var INT_CACHE = {};\r\n\r\n    /**\r\n     * A cache of the Long representations of small unsigned integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var UINT_CACHE = {};\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromInt(value, unsigned) {\r\n        var obj, cachedObj, cache;\r\n        if (unsigned) {\r\n            value >>>= 0;\r\n            if (cache = (0 <= value && value < 256)) {\r\n                cachedObj = UINT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n            if (cache)\r\n                UINT_CACHE[value] = obj;\r\n            return obj;\r\n        } else {\r\n            value |= 0;\r\n            if (cache = (-128 <= value && value < 128)) {\r\n                cachedObj = INT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n            if (cache)\r\n                INT_CACHE[value] = obj;\r\n            return obj;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given 32 bit integer value.\r\n     * @function\r\n     * @param {number} value The 32 bit integer in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromInt = fromInt;\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromNumber(value, unsigned) {\r\n        if (isNaN(value) || !isFinite(value))\r\n            return unsigned ? UZERO : ZERO;\r\n        if (unsigned) {\r\n            if (value < 0)\r\n                return UZERO;\r\n            if (value >= TWO_PWR_64_DBL)\r\n                return MAX_UNSIGNED_VALUE;\r\n        } else {\r\n            if (value <= -TWO_PWR_63_DBL)\r\n                return MIN_VALUE;\r\n            if (value + 1 >= TWO_PWR_63_DBL)\r\n                return MAX_VALUE;\r\n        }\r\n        if (value < 0)\r\n            return fromNumber(-value, unsigned).neg();\r\n        return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n     * @function\r\n     * @param {number} value The number in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromNumber = fromNumber;\r\n\r\n    /**\r\n     * @param {number} lowBits\r\n     * @param {number} highBits\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromBits(lowBits, highBits, unsigned) {\r\n        return new Long(lowBits, highBits, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n     *  assumed to use 32 bits.\r\n     * @function\r\n     * @param {number} lowBits The low 32 bits\r\n     * @param {number} highBits The high 32 bits\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromBits = fromBits;\r\n\r\n    /**\r\n     * @function\r\n     * @param {number} base\r\n     * @param {number} exponent\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n    /**\r\n     * @param {string} str\r\n     * @param {(boolean|number)=} unsigned\r\n     * @param {number=} radix\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromString(str, unsigned, radix) {\r\n        if (str.length === 0)\r\n            throw Error('empty string');\r\n        if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n            return ZERO;\r\n        if (typeof unsigned === 'number') {\r\n            // For goog.math.long compatibility\r\n            radix = unsigned,\r\n            unsigned = false;\r\n        } else {\r\n            unsigned = !! unsigned;\r\n        }\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n\r\n        var p;\r\n        if ((p = str.indexOf('-')) > 0)\r\n            throw Error('interior hyphen');\r\n        else if (p === 0) {\r\n            return fromString(str.substring(1), unsigned, radix).neg();\r\n        }\r\n\r\n        // Do several (8) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n        var result = ZERO;\r\n        for (var i = 0; i < str.length; i += 8) {\r\n            var size = Math.min(8, str.length - i),\r\n                value = parseInt(str.substring(i, i + size), radix);\r\n            if (size < 8) {\r\n                var power = fromNumber(pow_dbl(radix, size));\r\n                result = result.mul(power).add(fromNumber(value));\r\n            } else {\r\n                result = result.mul(radixToPower);\r\n                result = result.add(fromNumber(value));\r\n            }\r\n        }\r\n        result.unsigned = unsigned;\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representation of the given string, written using the specified radix.\r\n     * @function\r\n     * @param {string} str The textual representation of the Long\r\n     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromString = fromString;\r\n\r\n    /**\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromValue(val) {\r\n        if (val /* is compatible */ instanceof Long)\r\n            return val;\r\n        if (typeof val === 'number')\r\n            return fromNumber(val);\r\n        if (typeof val === 'string')\r\n            return fromString(val);\r\n        // Throws for non-objects, converts non-instanceof Long:\r\n        return fromBits(val.low, val.high, val.unsigned);\r\n    }\r\n\r\n    /**\r\n     * Converts the specified value to a Long.\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n     * @returns {!Long}\r\n     */\r\n    Long.fromValue = fromValue;\r\n\r\n    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n    // no runtime penalty for these.\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_16_DBL = 1 << 16;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24_DBL = 1 << 24;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ZERO = fromInt(0);\r\n\r\n    /**\r\n     * Signed zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.ZERO = ZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UZERO = fromInt(0, true);\r\n\r\n    /**\r\n     * Unsigned zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.UZERO = UZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ONE = fromInt(1);\r\n\r\n    /**\r\n     * Signed one.\r\n     * @type {!Long}\r\n     */\r\n    Long.ONE = ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UONE = fromInt(1, true);\r\n\r\n    /**\r\n     * Unsigned one.\r\n     * @type {!Long}\r\n     */\r\n    Long.UONE = UONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var NEG_ONE = fromInt(-1);\r\n\r\n    /**\r\n     * Signed negative one.\r\n     * @type {!Long}\r\n     */\r\n    Long.NEG_ONE = NEG_ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n    /**\r\n     * Maximum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_VALUE = MAX_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n    /**\r\n     * Maximum unsigned value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n    /**\r\n     * Minimum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MIN_VALUE = MIN_VALUE;\r\n\r\n    /**\r\n     * @alias Long.prototype\r\n     * @inner\r\n     */\r\n    var LongPrototype = Long.prototype;\r\n\r\n    /**\r\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toInt = function toInt() {\r\n        return this.unsigned ? this.low >>> 0 : this.low;\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toNumber = function toNumber() {\r\n        if (this.unsigned)\r\n            return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a string written in the specified radix.\r\n     * @param {number=} radix Radix (2-36), defaults to 10\r\n     * @returns {string}\r\n     * @override\r\n     * @throws {RangeError} If `radix` is out of range\r\n     */\r\n    LongPrototype.toString = function toString(radix) {\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n        if (this.isZero())\r\n            return '0';\r\n        if (this.isNegative()) { // Unsigned Longs are never negative\r\n            if (this.eq(MIN_VALUE)) {\r\n                // We need to change the Long value before it can be negated, so we remove\r\n                // the bottom-most digit in this base and then recurse to do the rest.\r\n                var radixLong = fromNumber(radix),\r\n                    div = this.div(radixLong),\r\n                    rem1 = div.mul(radixLong).sub(this);\r\n                return div.toString(radix) + rem1.toInt().toString(radix);\r\n            } else\r\n                return '-' + this.neg().toString(radix);\r\n        }\r\n\r\n        // Do several (6) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n            rem = this;\r\n        var result = '';\r\n        while (true) {\r\n            var remDiv = rem.div(radixToPower),\r\n                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n                digits = intval.toString(radix);\r\n            rem = remDiv;\r\n            if (rem.isZero())\r\n                return digits + result;\r\n            else {\r\n                while (digits.length < 6)\r\n                    digits = '0' + digits;\r\n                result = '' + digits + result;\r\n            }\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as a signed integer.\r\n     * @returns {number} Signed high bits\r\n     */\r\n    LongPrototype.getHighBits = function getHighBits() {\r\n        return this.high;\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned high bits\r\n     */\r\n    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n        return this.high >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as a signed integer.\r\n     * @returns {number} Signed low bits\r\n     */\r\n    LongPrototype.getLowBits = function getLowBits() {\r\n        return this.low;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned low bits\r\n     */\r\n    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n        return this.low >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the number of bits needed to represent the absolute value of this Long.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n        if (this.isNegative()) // Unsigned Longs are never negative\r\n            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n        var val = this.high != 0 ? this.high : this.low;\r\n        for (var bit = 31; bit > 0; bit--)\r\n            if ((val & (1 << bit)) != 0)\r\n                break;\r\n        return this.high != 0 ? bit + 33 : bit + 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals zero.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isZero = function isZero() {\r\n        return this.high === 0 && this.low === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is negative.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isNegative = function isNegative() {\r\n        return !this.unsigned && this.high < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is positive.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isPositive = function isPositive() {\r\n        return this.unsigned || this.high >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is odd.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isOdd = function isOdd() {\r\n        return (this.low & 1) === 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is even.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isEven = function isEven() {\r\n        return (this.low & 1) === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.equals = function equals(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n            return false;\r\n        return this.high === other.high && this.low === other.low;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.eq = LongPrototype.equals;\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.notEquals = function notEquals(other) {\r\n        return !this.eq(/* validates */ other);\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.neq = LongPrototype.notEquals;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThan = function lessThan(other) {\r\n        return this.comp(/* validates */ other) < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lt = LongPrototype.lessThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) <= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThan = function greaterThan(other) {\r\n        return this.comp(/* validates */ other) > 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.compare = function compare(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.eq(other))\r\n            return 0;\r\n        var thisNeg = this.isNegative(),\r\n            otherNeg = other.isNegative();\r\n        if (thisNeg && !otherNeg)\r\n            return -1;\r\n        if (!thisNeg && otherNeg)\r\n            return 1;\r\n        // At this point the sign bits are the same\r\n        if (!this.unsigned)\r\n            return this.sub(other).isNegative() ? -1 : 1;\r\n        // Both are positive if at least one is unsigned\r\n        return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n    };\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.comp = LongPrototype.compare;\r\n\r\n    /**\r\n     * Negates this Long's value.\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.negate = function negate() {\r\n        if (!this.unsigned && this.eq(MIN_VALUE))\r\n            return MIN_VALUE;\r\n        return this.not().add(ONE);\r\n    };\r\n\r\n    /**\r\n     * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n     * @function\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.neg = LongPrototype.negate;\r\n\r\n    /**\r\n     * Returns the sum of this and the specified Long.\r\n     * @param {!Long|number|string} addend Addend\r\n     * @returns {!Long} Sum\r\n     */\r\n    LongPrototype.add = function add(addend) {\r\n        if (!isLong(addend))\r\n            addend = fromValue(addend);\r\n\r\n        // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = addend.high >>> 16;\r\n        var b32 = addend.high & 0xFFFF;\r\n        var b16 = addend.low >>> 16;\r\n        var b00 = addend.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 + b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 + b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 + b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 + b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long.\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.subtract = function subtract(subtrahend) {\r\n        if (!isLong(subtrahend))\r\n            subtrahend = fromValue(subtrahend);\r\n        return this.add(subtrahend.neg());\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n     * @function\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.sub = LongPrototype.subtract;\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long.\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.multiply = function multiply(multiplier) {\r\n        if (this.isZero())\r\n            return ZERO;\r\n        if (!isLong(multiplier))\r\n            multiplier = fromValue(multiplier);\r\n        if (multiplier.isZero())\r\n            return ZERO;\r\n        if (this.eq(MIN_VALUE))\r\n            return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n        if (multiplier.eq(MIN_VALUE))\r\n            return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n        if (this.isNegative()) {\r\n            if (multiplier.isNegative())\r\n                return this.neg().mul(multiplier.neg());\r\n            else\r\n                return this.neg().mul(multiplier).neg();\r\n        } else if (multiplier.isNegative())\r\n            return this.mul(multiplier.neg()).neg();\r\n\r\n        // If both longs are small, use float multiplication\r\n        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n            return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n        // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n        // We can skip products that would overflow.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = multiplier.high >>> 16;\r\n        var b32 = multiplier.high & 0xFFFF;\r\n        var b16 = multiplier.low >>> 16;\r\n        var b00 = multiplier.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 * b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 * b00;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c16 += a00 * b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 * b00;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a16 * b16;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a00 * b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n     * @function\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.mul = LongPrototype.multiply;\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n     *  unsigned if this Long is unsigned.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.divide = function divide(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        if (divisor.isZero())\r\n            throw Error('division by zero');\r\n        if (this.isZero())\r\n            return this.unsigned ? UZERO : ZERO;\r\n        var approx, rem, res;\r\n        if (!this.unsigned) {\r\n            // This section is only relevant for signed longs and is derived from the\r\n            // closure library as a whole.\r\n            if (this.eq(MIN_VALUE)) {\r\n                if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                    return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n                else if (divisor.eq(MIN_VALUE))\r\n                    return ONE;\r\n                else {\r\n                    // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                    var halfThis = this.shr(1);\r\n                    approx = halfThis.div(divisor).shl(1);\r\n                    if (approx.eq(ZERO)) {\r\n                        return divisor.isNegative() ? ONE : NEG_ONE;\r\n                    } else {\r\n                        rem = this.sub(divisor.mul(approx));\r\n                        res = approx.add(rem.div(divisor));\r\n                        return res;\r\n                    }\r\n                }\r\n            } else if (divisor.eq(MIN_VALUE))\r\n                return this.unsigned ? UZERO : ZERO;\r\n            if (this.isNegative()) {\r\n                if (divisor.isNegative())\r\n                    return this.neg().div(divisor.neg());\r\n                return this.neg().div(divisor).neg();\r\n            } else if (divisor.isNegative())\r\n                return this.div(divisor.neg()).neg();\r\n            res = ZERO;\r\n        } else {\r\n            // The algorithm below has not been made for unsigned longs. It's therefore\r\n            // required to take special care of the MSB prior to running it.\r\n            if (!divisor.unsigned)\r\n                divisor = divisor.toUnsigned();\r\n            if (divisor.gt(this))\r\n                return UZERO;\r\n            if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n                return UONE;\r\n            res = UZERO;\r\n        }\r\n\r\n        // Repeat the following until the remainder is less than other:  find a\r\n        // floating-point that approximates remainder / other *from below*, add this\r\n        // into the result, and subtract it from the remainder.  It is critical that\r\n        // the approximate value is less than or equal to the real value so that the\r\n        // remainder never becomes negative.\r\n        rem = this;\r\n        while (rem.gte(divisor)) {\r\n            // Approximate the result of division. This may be a little greater or\r\n            // smaller than the actual value.\r\n            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n            // We will tweak the approximate result by changing it in the 48-th digit or\r\n            // the smallest non-fractional digit, whichever is larger.\r\n            var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n                delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n            // Decrease the approximation until it is smaller than the remainder.  Note\r\n            // that if it is too large, the product overflows and is negative.\r\n                approxRes = fromNumber(approx),\r\n                approxRem = approxRes.mul(divisor);\r\n            while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n                approx -= delta;\r\n                approxRes = fromNumber(approx, this.unsigned);\r\n                approxRem = approxRes.mul(divisor);\r\n            }\r\n\r\n            // We know the answer can't be zero... and actually, zero would cause\r\n            // infinite recursion since we would make no progress.\r\n            if (approxRes.isZero())\r\n                approxRes = ONE;\r\n\r\n            res = res.add(approxRes);\r\n            rem = rem.sub(approxRem);\r\n        }\r\n        return res;\r\n    };\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.div = LongPrototype.divide;\r\n\r\n    /**\r\n     * Returns this Long modulo the specified.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.modulo = function modulo(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        return this.sub(this.div(divisor).mul(divisor));\r\n    };\r\n\r\n    /**\r\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.mod = LongPrototype.modulo;\r\n\r\n    /**\r\n     * Returns the bitwise NOT of this Long.\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.not = function not() {\r\n        return fromBits(~this.low, ~this.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise AND of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.and = function and(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise OR of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.or = function or(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise XOR of this Long and the given one.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.xor = function xor(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n        else\r\n            return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRight = function shiftRight(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n        else\r\n            return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        numBits &= 63;\r\n        if (numBits === 0)\r\n            return this;\r\n        else {\r\n            var high = this.high;\r\n            if (numBits < 32) {\r\n                var low = this.low;\r\n                return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n            } else if (numBits === 32)\r\n                return fromBits(high, 0, this.unsigned);\r\n            else\r\n                return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n    /**\r\n     * Converts this Long to signed.\r\n     * @returns {!Long} Signed long\r\n     */\r\n    LongPrototype.toSigned = function toSigned() {\r\n        if (!this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, false);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to unsigned.\r\n     * @returns {!Long} Unsigned long\r\n     */\r\n    LongPrototype.toUnsigned = function toUnsigned() {\r\n        if (this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, true);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to its byte representation.\r\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n     * @returns {!Array.<number>} Byte representation\r\n     */\r\n    LongPrototype.toBytes = function(le) {\r\n        return le ? this.toBytesLE() : this.toBytesBE();\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its little endian byte representation.\r\n     * @returns {!Array.<number>} Little endian byte representation\r\n     */\r\n    LongPrototype.toBytesLE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n             lo         & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n             hi         & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>> 24) & 0xff\r\n        ];\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its big endian byte representation.\r\n     * @returns {!Array.<number>} Big endian byte representation\r\n     */\r\n    LongPrototype.toBytesBE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n            (hi >>> 24) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n             hi         & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n             lo         & 0xff\r\n        ];\r\n    }\r\n\r\n    return Long;\r\n});\r\n","'use strict'\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n  var M = ARRAY16\n  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n  var a = this._a\n  var b = this._b\n  var c = this._c\n  var d = this._d\n\n  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n  c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n  c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n  b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n  a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n  a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n  d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n  c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n  b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n  d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n  d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n  d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n  b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n  a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n  d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n  c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n  this._a = (this._a + a) | 0\n  this._b = (this._b + b) | 0\n  this._c = (this._c + c) | 0\n  this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = new Buffer(16)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n  return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n","'use strict';\n\nexports.__esModule = true;\nexports.Manager = exports.ChainConfig = exports.Apis = undefined;\n\nvar _ApiInstances = require(71);\n\nvar _ApiInstances2 = _interopRequireDefault(_ApiInstances);\n\nvar _ConnectionManager = require(74);\n\nvar _ConnectionManager2 = _interopRequireDefault(_ConnectionManager);\n\nvar _ChainConfig = require(72);\n\nvar _ChainConfig2 = _interopRequireDefault(_ChainConfig);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Apis = _ApiInstances2.default;\nexports.ChainConfig = _ChainConfig2.default;\nexports.Manager = _ConnectionManager2.default;","'use strict';\n\nexports.__esModule = true;\n\nvar _ChainWebSocket = require(73);\n\nvar _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket);\n\nvar _GrapheneApi = require(75);\n\nvar _GrapheneApi2 = _interopRequireDefault(_GrapheneApi);\n\nvar _ChainConfig = require(72);\n\nvar _ChainConfig2 = _interopRequireDefault(_ChainConfig);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar inst = void 0;\n\nvar ApisInstance = function () {\n  function ApisInstance() {\n    _classCallCheck(this, ApisInstance);\n  }\n\n  /** @arg {string} connection .. */\n  ApisInstance.prototype.connect = function connect(cs, connectTimeout) {\n    var _this = this;\n\n    var rpc_user = '';\n    var rpc_password = '';\n\n    if (typeof window !== 'undefined' && window.location && window.location.protocol === 'https:' && cs.indexOf('wss://') < 0) {\n      throw new Error('Secure domains require wss connection');\n    }\n\n    this.ws_rpc = new _ChainWebSocket2.default(cs, this.statusCb, connectTimeout);\n\n    this.init_promise = this.ws_rpc.login(rpc_user, rpc_password).then(function () {\n      console.log('Connected to API node:', cs);\n      _this._db = new _GrapheneApi2.default(_this.ws_rpc, 'database');\n      _this._net = new _GrapheneApi2.default(_this.ws_rpc, 'network_broadcast');\n      _this._hist = new _GrapheneApi2.default(_this.ws_rpc, 'history');\n      _this._crypto = new _GrapheneApi2.default(_this.ws_rpc, 'crypto');\n      _this._bookie = new _GrapheneApi2.default(_this.ws_rpc, 'bookie');\n      var db_promise = _this._db.init().then(function () {\n        return _this._db.exec('get_chain_id', []).then(function (_chain_id) {\n          _this.chain_id = _chain_id;\n          return _ChainConfig2.default.setChainId(_chain_id);\n        });\n      });\n\n      _this.ws_rpc.on_reconnect = function () {\n        _this.ws_rpc.login('', '').then(function () {\n          _this._db.init().then(function () {\n            if (_this.statusCb) {\n              _this.statusCb(_ChainWebSocket2.default.status.RECONNECTED);\n            }\n          });\n          _this._net.init();\n          _this._hist.init();\n          _this._crypto.init();\n          _this._bookie.init();\n        });\n      };\n\n      return Promise.all([db_promise, _this._net.init(), _this._hist.init(),\n      // Temporary squash crypto API error until the API is upgraded everywhere\n      _this._crypto.init().catch(function (e) {\n        return console.error('ApiInstance\\tCrypto API Error', e);\n      }), _this._bookie.init()]);\n    });\n  };\n\n  ApisInstance.prototype.close = function close() {\n    if (this.ws_rpc) {\n      this.ws_rpc.close();\n    }\n\n    this.ws_rpc = null;\n  };\n\n  ApisInstance.prototype.db_api = function db_api() {\n    return this._db;\n  };\n\n  ApisInstance.prototype.network_api = function network_api() {\n    return this._net;\n  };\n\n  ApisInstance.prototype.history_api = function history_api() {\n    return this._hist;\n  };\n\n  ApisInstance.prototype.crypto_api = function crypto_api() {\n    return this._crypto;\n  };\n\n  ApisInstance.prototype.bookie_api = function bookie_api() {\n    return this._bookie;\n  };\n\n  ApisInstance.prototype.setRpcConnectionStatusCallback = function setRpcConnectionStatusCallback(callback) {\n    this.statusCb = callback;\n  };\n\n  return ApisInstance;\n}();\n\n/**\n    Configure: configure as follows `Apis.instance(\"ws://localhost:8090\").init_promise`.  This\n    returns a promise, once resolved the connection is ready.\n\n    Import: import { Apis } from \"@graphene/chain\"\n\n    Short-hand: Apis.db(\"method\", \"parm1\", 2, 3, ...).  Returns a promise with results.\n\n    Additional usage: Apis.instance().db_api().exec(\"method\", [\"method\", \"parm1\", 2, 3, ...]).\n    Returns a promise with results.\n*/\n\nexports.default = {\n  setRpcConnectionStatusCallback: function setRpcConnectionStatusCallback(callback) {\n    this.statusCb = callback;\n\n    if (inst) {\n      inst.setRpcConnectionStatusCallback(callback);\n    }\n  },\n\n  /**\n        @arg {string} cs is only provided in the first call\n        @return {Apis} singleton .. Check Apis.instance().init_promise to\n        know when the connection is established\n    */\n  reset: function reset() {\n    var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090';\n    var connect = arguments[1];\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;\n\n    if (inst) {\n      inst.close();\n      inst = null;\n    }\n\n    inst = new ApisInstance();\n    inst.setRpcConnectionStatusCallback(this.statusCb);\n\n    if (inst && connect) {\n      inst.connect(cs, connectTimeout);\n    }\n\n    return inst;\n  },\n  instance: function instance() {\n    var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090';\n    var connect = arguments[1];\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;\n\n    if (!inst) {\n      inst = new ApisInstance();\n      inst.setRpcConnectionStatusCallback(this.statusCb);\n    }\n\n    if (inst && connect) {\n      inst.connect(cs, connectTimeout);\n    }\n\n    return inst;\n  },\n  chainId: function chainId() {\n    return this.instance().chain_id;\n  },\n  close: function close() {\n    if (inst) {\n      inst.close();\n      inst = null;\n    }\n  }\n  // db: (method, ...args) => Apis.instance().db_api().exec(method, toStrings(args)),\n  // network: (method, ...args) => Apis.instance().network_api().exec(method, toStrings(args)),\n  // history: (method, ...args) => Apis.instance().history_api().exec(method, toStrings(args)),\n  // crypto: (method, ...args) => Apis.instance().crypto_api().exec(method, toStrings(args))\n\n};","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar defaults = {\n  core_asset: 'PPY',\n  address_prefix: 'PPY',\n  expire_in_secs: 15,\n  expire_in_secs_proposal: 24 * 60 * 60,\n  review_in_secs_committee: 24 * 60 * 60\n};\n\nvar networks = {\n  networks: {\n    Peerplays: {\n      core_asset: 'PPY',\n      address_prefix: 'PPY',\n      chain_id: '6b6b5f0ce7a36d323768e534f3edb41c6d6332a541a95725b98e28d140850134'\n    },\n    PeerplaysTestnet: {\n      core_asset: 'PPYTEST',\n      address_prefix: 'PPYTEST',\n      chain_id: 'be6b79295e728406cbb7494bcb626e62ad278fa4018699cf8f75739f4c1a81fd'\n    }\n  }\n};\n\nvar ChainConfig = function () {\n  function ChainConfig() {\n    _classCallCheck(this, ChainConfig);\n\n    this.reset();\n  }\n\n  ChainConfig.prototype.reset = function reset() {\n    Object.assign(this, defaults);\n  };\n\n  ChainConfig.prototype.setChainId = function setChainId(chainID) {\n    var ref = Object.keys(networks);\n\n    for (var i = 0, len = ref.length; i < len; i++) {\n      var network_name = ref[i];\n      var network = networks[network_name];\n\n      if (network.chain_id === chainID) {\n        this.network_name = network_name;\n\n        if (network.address_prefix) {\n          this.address_prefix = network.address_prefix;\n        }\n\n        return {\n          network_name: network_name,\n          network: network\n        };\n      }\n    }\n\n    if (!this.network_name) {\n      console.log('Unknown chain id (this may be a testnet)', chainID);\n    }\n  };\n\n  ChainConfig.prototype.setPrefix = function setPrefix() {\n    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'PPY';\n\n    this.address_prefix = prefix;\n  };\n\n  return ChainConfig;\n}();\n\nexports.default = new ChainConfig();","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar SOCKET_DEBUG = false;\nvar WebSocketClient = null;\n\nif (typeof WebSocket !== 'undefined') {\n  WebSocketClient = WebSocket;\n} else {\n  WebSocketClient = require(34); // eslint-disable-line global-require\n}\n\nvar SUBSCRIBE_OPERATIONS = ['set_subscribe_callback', 'subscribe_to_market', 'broadcast_transaction_with_callback', 'set_pending_transaction_callback'];\n\nvar UNSUBSCRIBE_OPERATIONS = ['unsubscribe_from_market', 'unsubscribe_from_accounts'];\n\nvar HEALTH_CHECK_INTERVAL = 10000;\n\nvar ChainWebSocket = function () {\n  /**\n   *Creates an instance of ChainWebSocket.\n   * @param {string}    serverAddress           The address of the websocket to connect to.\n   * @param {function}  statusCb                Called when status events occur.\n   * @param {number}    [connectTimeout=10000]  The time for a connection attempt to complete.\n   * @memberof ChainWebSocket\n   */\n  function ChainWebSocket(serverAddress, statusCb) {\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10000;\n\n    _classCallCheck(this, ChainWebSocket);\n\n    this.statusCb = statusCb;\n    this.serverAddress = serverAddress;\n    this.timeoutInterval = connectTimeout;\n\n    // The currenct connection state of the websocket.\n    this.connected = false;\n    this.reconnectTimeout = null;\n\n    // Callback to execute when the websocket is reconnected.\n    this.on_reconnect = null;\n\n    // An incrementing ID for each request so that we can pair it with the\n    // response from the websocket.\n    this.cbId = 0;\n\n    // Objects to store key/value pairs for callbacks, subscription callbacks\n    // and unsubscribe callbacks.\n    this.cbs = {};\n    this.subs = {};\n    this.unsub = {};\n\n    // Current connection promises' rejection\n    this.currentResolve = null;\n    this.currentReject = null;\n\n    // Health check for the connection to the BlockChain.\n    this.healthCheck = null;\n\n    // Copy the constants to this instance.\n    this.status = ChainWebSocket.status;\n\n    // Bind the functions to the instance.\n    this.onConnectionOpen = this.onConnectionOpen.bind(this);\n    this.onConnectionClose = this.onConnectionClose.bind(this);\n    this.onConnectionTerminate = this.onConnectionTerminate.bind(this);\n    this.onConnectionError = this.onConnectionError.bind(this);\n    this.onConnectionTimeout = this.onConnectionTimeout.bind(this);\n    this.createConnection = this.createConnection.bind(this);\n    this.createConnectionPromise = this.createConnectionPromise.bind(this);\n    this.listener = this.listener.bind(this);\n\n    // Create the initial connection the blockchain.\n    this.createConnection();\n  }\n\n  /**\n   * Create the connection to the Blockchain.\n   *\n   * @returns\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.createConnection = function createConnection() {\n    this.debug('!!! ChainWebSocket create connection');\n\n    // Clear any possible reconnect timers.\n    this.reconnectTimeout = null;\n\n    // Create the promise for this connection\n    if (!this.connect_promise) {\n      this.connect_promise = new Promise(this.createConnectionPromise);\n    }\n\n    // Attempt to create the websocket\n    try {\n      this.ws = new WebSocketClient(this.serverAddress);\n    } catch (error) {\n      // Set a timeout to try and reconnect here.\n      return this.resetConnection();\n    }\n\n    this.addEventListeners();\n\n    // Handle timeouts to the websocket's initial connection.\n    this.connectionTimeout = setTimeout(this.onConnectionTimeout, this.timeoutInterval);\n  };\n\n  /**\n   * Reset the connection to the BlockChain.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.resetConnection = function resetConnection() {\n    // Close the Websocket if its still 'half-open'\n    this.close();\n\n    // Make sure we only ever have one timeout running to reconnect.\n    if (!this.reconnectTimeout) {\n      this.debug('!!! ChainWebSocket reset connection', this.timeoutInterval);\n      this.reconnectTimeout = setTimeout(this.createConnection, this.timeoutInterval);\n    }\n\n    // Reject the current promise if there is one.\n    if (this.currentReject) {\n      this.currentReject(new Error('Connection attempt failed: ' + this.serverAddress));\n    }\n  };\n\n  /**\n   * Add event listeners to the WebSocket.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.addEventListeners = function addEventListeners() {\n    this.debug('!!! ChainWebSocket add event listeners');\n    this.ws.addEventListener('open', this.onConnectionOpen);\n    this.ws.addEventListener('close', this.onConnectionClose);\n    this.ws.addEventListener('error', this.onConnectionError);\n    this.ws.addEventListener('message', this.listener);\n  };\n\n  /**\n   * Remove the event listers from the WebSocket. Its important to remove the event listerers\n   * for garbaage collection. Because we are creating a new WebSocket on each connection attempt\n   * any listeners that are still attached could prevent the old sockets from\n   * being garbage collected.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.removeEventListeners = function removeEventListeners() {\n    this.debug('!!! ChainWebSocket remove event listeners');\n    this.ws.removeEventListener('open', this.onConnectionOpen);\n    this.ws.removeEventListener('close', this.onConnectionClose);\n    this.ws.removeEventListener('error', this.onConnectionError);\n    this.ws.removeEventListener('message', this.listener);\n  };\n\n  /**\n   * A function that is passed to a new promise that stores the resolve and reject callbacks\n   * in the state.\n   *\n   * @param {function} resolve A callback to be executed when the promise is resolved.\n   * @param {function} reject A callback to be executed when the promise is rejected.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.createConnectionPromise = function createConnectionPromise(resolve, reject) {\n    this.debug('!!! ChainWebSocket createPromise');\n    this.currentResolve = resolve;\n    this.currentReject = reject;\n  };\n\n  /**\n   * Called when a new Websocket connection is opened.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionOpen = function onConnectionOpen() {\n    this.debug('!!! ChainWebSocket Connected ');\n\n    this.connected = true;\n\n    clearTimeout(this.connectionTimeout);\n    this.connectionTimeout = null;\n\n    // This will trigger the login process as well as some additional setup in ApiInstances\n    if (this.on_reconnect) {\n      this.on_reconnect();\n    }\n\n    if (this.currentResolve) {\n      this.currentResolve();\n    }\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.OPEN);\n    }\n  };\n\n  /**\n   * called when the connection attempt times out.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionTimeout = function onConnectionTimeout() {\n    this.debug('!!! ChainWebSocket timeout');\n    this.onConnectionClose(new Error('Connection timed out.'));\n  };\n\n  /**\n   * Called when the Websocket is not responding to the health checks.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionTerminate = function onConnectionTerminate() {\n    this.debug('!!! ChainWebSocket terminate');\n    this.onConnectionClose(new Error('Connection was terminated.'));\n  };\n\n  /**\n   * Called when the connection to the Blockchain is closed.\n   *\n   * @param {*} error\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionClose = function onConnectionClose(error) {\n    this.debug('!!! ChainWebSocket Close ', error);\n\n    this.resetConnection();\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.CLOSED);\n    }\n  };\n\n  /**\n   * Called when the Websocket encounters an error.\n   *\n   * @param {*} error\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionError = function onConnectionError(error) {\n    this.debug('!!! ChainWebSocket On Connection Error ', error);\n\n    this.resetConnection();\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.ERROR);\n    }\n  };\n\n  /**\n   * Entry point to make RPC calls on the BlockChain.\n   *\n   * @param {array} params An array of params to be passed to the rpc call. [method, ...params]\n   * @returns A new promise for this specific call.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.call = function call(params) {\n    var _this = this;\n\n    if (!this.connected) {\n      this.debug('!!! ChainWebSocket Call not connected. ');\n      return Promise.reject(new Error('Disconnected from the BlockChain.'));\n    }\n\n    this.debug('!!! ChainWebSocket Call connected. ', params);\n\n    var request = {\n      method: params[1],\n      params: params,\n      id: this.cbId + 1\n    };\n\n    this.cbId = request.id;\n\n    if (SUBSCRIBE_OPERATIONS.includes(request.method)) {\n      // Store callback in subs map\n      this.subs[request.id] = {\n        callback: request.params[2][0]\n      };\n\n      // Replace callback with the callback id\n      request.params[2][0] = request.id;\n    }\n\n    if (UNSUBSCRIBE_OPERATIONS.includes(request.method)) {\n      if (typeof request.params[2][0] !== 'function') {\n        throw new Error('First parameter of unsub must be the original callback');\n      }\n\n      var unSubCb = request.params[2].splice(0, 1)[0];\n\n      // Find the corresponding subscription\n      for (var id in this.subs) {\n        // eslint-disable-line\n        if (this.subs[id].callback === unSubCb) {\n          this.unsub[request.id] = id;\n          break;\n        }\n      }\n    }\n\n    if (!this.healthCheck) {\n      this.healthCheck = setTimeout(this.onConnectionTerminate.bind(this), HEALTH_CHECK_INTERVAL);\n    }\n\n    return new Promise(function (resolve, reject) {\n      _this.cbs[request.id] = {\n        time: new Date(),\n        resolve: resolve,\n        reject: reject\n      };\n\n      // Set all requests to be 'call' methods.\n      request.method = 'call';\n\n      try {\n        _this.ws.send(JSON.stringify(request));\n      } catch (error) {\n        _this.debug('Caught a nasty error : ', error);\n      }\n    });\n  };\n\n  /**\n   * Called when messages are received on the Websocket.\n   *\n   * @param {*} response The message received.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.listener = function listener(response) {\n    var responseJSON = null;\n\n    try {\n      responseJSON = JSON.parse(response.data);\n    } catch (error) {\n      responseJSON.error = 'Error parsing response: ' + error.stack;\n      this.debug('Error parsing response: ', response);\n    }\n\n    // Clear the health check timeout, we've just received a healthy response from the server.\n    if (this.healthCheck) {\n      clearTimeout(this.healthCheck);\n      this.healthCheck = null;\n    }\n\n    var sub = false;\n    var callback = null;\n\n    if (responseJSON.method === 'notice') {\n      sub = true;\n      responseJSON.id = responseJSON.params[0];\n    }\n\n    if (!sub) {\n      callback = this.cbs[responseJSON.id];\n    } else {\n      callback = this.subs[responseJSON.id].callback;\n    }\n\n    if (callback && !sub) {\n      if (responseJSON.error) {\n        this.debug('----> responseJSON : ', responseJSON);\n        callback.reject(responseJSON.error);\n      } else {\n        callback.resolve(responseJSON.result);\n      }\n\n      delete this.cbs[responseJSON.id];\n\n      if (this.unsub[responseJSON.id]) {\n        delete this.subs[this.unsub[responseJSON.id]];\n        delete this.unsub[responseJSON.id];\n      }\n    } else if (callback && sub) {\n      callback(responseJSON.params[1]);\n    } else {\n      this.debug('Warning: unknown websocket responseJSON: ', responseJSON);\n    }\n  };\n\n  /**\n   * Login to the Blockchain.\n   *\n   * @param {string} user Username\n   * @param {string} password Password\n   * @returns A promise that is fulfilled after login.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.login = function login(user, password) {\n    var _this2 = this;\n\n    this.debug('!!! ChainWebSocket login.', user, password);\n    return this.connect_promise.then(function () {\n      return _this2.call([1, 'login', [user, password]]);\n    });\n  };\n\n  /**\n   * Close the connection to the Blockchain.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.close = function close() {\n    if (this.ws) {\n      this.removeEventListeners();\n\n      // Try and fire close on the connection.\n      this.ws.close();\n\n      // Clear our references so that it can be garbage collected.\n      this.ws = null;\n    }\n\n    // Clear our timeouts for connection timeout and health check.\n    clearTimeout(this.connectionTimeout);\n    this.connectionTimeout = null;\n\n    clearTimeout(this.healthCheck);\n    this.healthCheck = null;\n\n    clearTimeout(this.reconnectTimeout);\n    this.reconnectTimeout = null;\n\n    // Toggle the connected flag.\n    this.connected = false;\n  };\n\n  ChainWebSocket.prototype.debug = function debug() {\n    if (SOCKET_DEBUG) {\n      for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) {\n        params[_key] = arguments[_key];\n      }\n\n      console.log.apply(null, params);\n    }\n  };\n\n  return ChainWebSocket;\n}();\n\n// Constants for STATE\n\n\nChainWebSocket.status = {\n  RECONNECTED: 'reconnected',\n  OPEN: 'open',\n  CLOSED: 'closed',\n  ERROR: 'error'\n};\n\nexports.default = ChainWebSocket;","'use strict';\n\nexports.__esModule = true;\n\nvar _ApiInstances = require(71);\n\nvar _ApiInstances2 = _interopRequireDefault(_ApiInstances);\n\nvar _ChainWebSocket = require(73);\n\nvar _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Manager = function () {\n  function Manager(_ref) {\n    var url = _ref.url,\n        urls = _ref.urls;\n\n    _classCallCheck(this, Manager);\n\n    this.url = url;\n    this.urls = urls.filter(function (a) {\n      return a !== url;\n    });\n  }\n\n  Manager.prototype.logFailure = function logFailure(url) {\n    console.error('Unable to connect to', url + ', skipping to next full node API server');\n  };\n\n  Manager.prototype.connect = function connect() {\n    var _connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n    var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url;\n\n    return new Promise(function (resolve, reject) {\n      _ApiInstances2.default.instance(url, _connect).init_promise.then(resolve).catch(function (error) {\n        _ApiInstances2.default.instance().close();\n        reject(error);\n      });\n    });\n  };\n\n  Manager.prototype.connectWithFallback = function connectWithFallback() {\n    var connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n    var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url;\n    var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n\n    var _this = this;\n\n    var resolve = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    var reject = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n\n    if (reject && index > this.urls.length - 1) {\n      return reject(new Error('Tried ' + (index + 1) + ' connections, none of which worked: ' + JSON.stringify(this.urls.concat(this.url))));\n    }\n\n    var fallback = function fallback(resolve, reject) {\n      _this.logFailure(url);\n      return _this.connectWithFallback(connect, _this.urls[index], index + 1, resolve, reject);\n    };\n\n    if (resolve && reject) {\n      return this.connect(connect, url).then(resolve).catch(function () {\n        fallback(resolve, reject);\n      });\n    }\n\n    return new Promise(function (resolve, reject) {\n      _this.connect(connect).then(resolve).catch(function () {\n        fallback(resolve, reject);\n      });\n    });\n  };\n\n  Manager.prototype.checkConnections = function checkConnections() {\n    var rpc_user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    var rpc_password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    var _this2 = this;\n\n    var resolve = arguments[2];\n    var reject = arguments[3];\n\n    var connectionStartTimes = {};\n\n    var checkFunction = function checkFunction(resolve, reject) {\n      var fullList = _this2.urls.concat(_this2.url);\n      var connectionPromises = [];\n\n      fullList.forEach(function (url) {\n        var conn = new _ChainWebSocket2.default(url, function () {});\n        connectionStartTimes[url] = new Date().getTime();\n        connectionPromises.push(function () {\n          return conn.login(rpc_user, rpc_password).then(function () {\n            var _ref2;\n\n            conn.close();\n            return _ref2 = {}, _ref2[url] = new Date().getTime() - connectionStartTimes[url], _ref2;\n          }).catch(function () {\n            if (url === _this2.url) {\n              _this2.url = _this2.urls[0];\n            } else {\n              _this2.urls = _this2.urls.filter(function (a) {\n                return a !== url;\n              });\n            }\n\n            conn.close();\n            return null;\n          });\n        });\n      });\n\n      Promise.all(connectionPromises.map(function (a) {\n        return a();\n      })).then(function (res) {\n        resolve(res.filter(function (a) {\n          return !!a;\n        }).reduce(function (f, a) {\n          var key = Object.keys(a)[0];\n          f[key] = a[key];\n          return f;\n        }, {}));\n      }).catch(function () {\n        return _this2.checkConnections(rpc_user, rpc_password, resolve, reject);\n      });\n    };\n\n    if (resolve && reject) {\n      checkFunction(resolve, reject);\n    } else {\n      return new Promise(checkFunction);\n    }\n  };\n\n  return Manager;\n}();\n\nexports.default = Manager;","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar GrapheneApi = function () {\n  function GrapheneApi(ws_rpc, api_name) {\n    _classCallCheck(this, GrapheneApi);\n\n    this.ws_rpc = ws_rpc;\n    this.api_name = api_name;\n  }\n\n  GrapheneApi.prototype.init = function init() {\n    var _this = this;\n\n    return this.ws_rpc.call([1, this.api_name, []]).then(function (response) {\n      _this.api_id = response;\n      return _this;\n    });\n  };\n\n  GrapheneApi.prototype.exec = function exec(method, params) {\n    return this.ws_rpc.call([this.api_id, method, params]).catch(function (error) {\n      console.log('!!! GrapheneApi error: ', method, params, error, JSON.stringify(error));\n      throw error;\n    });\n  };\n\n  return GrapheneApi;\n}();\n\nexports.default = GrapheneApi;","'use strict';\n\nif (!process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // 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\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // 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.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = require(79);\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require(76);\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require(40);\nutil.inherits = require(87);\n/*</replacement>*/\n\nvar Readable = require(81);\nvar Writable = require(83);\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require(82);\n\n/*<replacement>*/\nvar util = require(40);\nutil.inherits = require(87);\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  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]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    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);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require(79);\n\n/*<replacement>*/\nvar util = require(40);\nutil.inherits = require(87);\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  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);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require(93).Buffer;\nvar util = require(34);\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","'use strict';\n\n/*<replacement>*/\n\nvar pna = require(76);\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","module.exports = require(62).EventEmitter;\n","module.exports = require(89).PassThrough\n","exports = module.exports = require(81);\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require(83);\nexports.Duplex = require(79);\nexports.Transform = require(82);\nexports.PassThrough = require(80);\n","module.exports = require(89).Transform\n","module.exports = require(83);\n","'use strict'\nvar Buffer = require(35).Buffer\nvar inherits = require(65)\nvar HashBase = require(63)\n\nvar ARRAY16 = new Array(16)\n\nvar zl = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n]\n\nvar zr = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n]\n\nvar sl = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n]\n\nvar sr = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n]\n\nvar hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]\nvar hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]\n\nfunction RIPEMD160 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n}\n\ninherits(RIPEMD160, HashBase)\n\nRIPEMD160.prototype._update = function () {\n  var words = ARRAY16\n  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)\n\n  var al = this._a | 0\n  var bl = this._b | 0\n  var cl = this._c | 0\n  var dl = this._d | 0\n  var el = this._e | 0\n\n  var ar = this._a | 0\n  var br = this._b | 0\n  var cr = this._c | 0\n  var dr = this._d | 0\n  var er = this._e | 0\n\n  // computation\n  for (var i = 0; i < 80; i += 1) {\n    var tl\n    var tr\n    if (i < 16) {\n      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])\n      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])\n    } else if (i < 32) {\n      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])\n      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])\n    } else if (i < 48) {\n      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])\n      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])\n    } else if (i < 64) {\n      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])\n      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])\n    } else { // if (i<80) {\n      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])\n      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])\n    }\n\n    al = el\n    el = dl\n    dl = rotl(cl, 10)\n    cl = bl\n    bl = tl\n\n    ar = er\n    er = dr\n    dr = rotl(cr, 10)\n    cr = br\n    br = tr\n  }\n\n  // update state\n  var t = (this._b + cl + dr) | 0\n  this._b = (this._c + dl + er) | 0\n  this._c = (this._d + el + ar) | 0\n  this._d = (this._e + al + br) | 0\n  this._e = (this._a + bl + cr) | 0\n  this._a = t\n}\n\nRIPEMD160.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  buffer.writeInt32LE(this._e, 16)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fn1 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn2 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn3 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn4 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn5 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0\n}\n\nmodule.exports = RIPEMD160\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require(35)\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","!function(globals){\n'use strict'\n\n//*** UMD BEGIN\nif (typeof define !== 'undefined' && define.amd) { //require.js / AMD\n  define([], function() {\n    return secureRandom\n  })\n} else if (typeof module !== 'undefined' && module.exports) { //CommonJS\n  module.exports = secureRandom\n} else { //script / browser\n  globals.secureRandom = secureRandom\n}\n//*** UMD END\n\n//options.type is the only valid option\nfunction secureRandom(count, options) {\n  options = options || {type: 'Array'}\n  //we check for process.pid to prevent browserify from tricking us\n  if (typeof process != 'undefined' && typeof process.pid == 'number') {\n    return nodeRandom(count, options)\n  } else {\n    var crypto = window.crypto || window.msCrypto\n    if (!crypto) throw new Error(\"Your browser does not support window.crypto.\")\n    return browserRandom(count, options)\n  }\n}\n\nfunction nodeRandom(count, options) {\n  var crypto = require('crypto')\n  var buf = crypto.randomBytes(count)\n\n  switch (options.type) {\n    case 'Array':\n      return [].slice.call(buf)\n    case 'Buffer':\n      return buf\n    case 'Uint8Array':\n      var arr = new Uint8Array(count)\n      for (var i = 0; i < count; ++i) { arr[i] = buf.readUInt8(i) }\n      return arr\n    default:\n      throw new Error(options.type + \" is unsupported.\")\n  }\n}\n\nfunction browserRandom(count, options) {\n  var nativeArr = new Uint8Array(count)\n  var crypto = window.crypto || window.msCrypto\n  crypto.getRandomValues(nativeArr)\n\n  switch (options.type) {\n    case 'Array':\n      return [].slice.call(nativeArr)\n    case 'Buffer':\n      try { var b = new Buffer(1) } catch(e) { throw new Error('Buffer not supported in this environment. Use Node.js or Browserify for browser support.')}\n      return new Buffer(nativeArr)\n    case 'Uint8Array':\n      return nativeArr\n    default:\n      throw new Error(options.type + \" is unsupported.\")\n  }\n}\n\nsecureRandom.randomArray = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Array'})\n}\n\nsecureRandom.randomUint8Array = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Uint8Array'})\n}\n\nsecureRandom.randomBuffer = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Buffer'})\n}\n\n\n}(this);\n","var Buffer = require(93).Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require(97)\nexports.sha1 = require(98)\nexports.sha224 = require(99)\nexports.sha256 = require(100)\nexports.sha384 = require(101)\nexports.sha512 = require(102)\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require(65)\nvar Sha256 = require(100)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\n","var inherits = require(65)\nvar SHA512 = require(102)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","var inherits = require(65)\nvar Hash = require(95)\nvar Buffer = require(93).Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require(62).EventEmitter;\nvar inherits = require(65);\n\ninherits(Stream, EE);\nStream.Readable = require(89);\nStream.Writable = require(91);\nStream.Duplex = require(78);\nStream.Transform = require(90);\nStream.PassThrough = require(88);\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require(93).Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","var nextTick = require('process/browser.js').nextTick;\nvar apply = Function.prototype.apply;\nvar slice = Array.prototype.slice;\nvar immediateIds = {};\nvar nextImmediateId = 0;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) { timeout.close(); };\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// That's not how node.js implements it but the exposed api is the same.\nexports.setImmediate = typeof setImmediate === \"function\" ? setImmediate : function(fn) {\n  var id = nextImmediateId++;\n  var args = arguments.length < 2 ? false : slice.call(arguments, 1);\n\n  immediateIds[id] = true;\n\n  nextTick(function onNextTick() {\n    if (immediateIds[id]) {\n      // fn.call() is faster so we optimize for the common use-case\n      // @see http://jsperf.com/call-apply-segu\n      if (args) {\n        fn.apply(null, args);\n      } else {\n        fn.call(null);\n      }\n      // Prevent ids from leaking\n      exports.clearImmediate(id);\n    }\n  });\n\n  return id;\n};\n\nexports.clearImmediate = typeof clearImmediate === \"function\" ? clearImmediate : function(id) {\n  delete immediateIds[id];\n};","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","dist/browser.js","dist/chain/src/AccountLogin.js","dist/chain/src/ChainTypes.js","dist/chain/src/ObjectId.js","dist/chain/src/TransactionBuilder.js","dist/chain/src/state.js","dist/ecc/index.js","dist/ecc/src/BrainKey.js","dist/ecc/src/KeyUtils.js","dist/ecc/src/PrivateKey.js","dist/ecc/src/PublicKey.js","dist/ecc/src/address.js","dist/ecc/src/aes.js","dist/ecc/src/ecdsa.js","dist/ecc/src/ecsignature.js","dist/ecc/src/enforce_types.js","dist/ecc/src/hash.js","dist/ecc/src/signature.js","dist/serializer/index.js","dist/serializer/src/FastParser.js","dist/serializer/src/SerializerValidation.js","dist/serializer/src/error_with_cause.js","dist/serializer/src/operations.js","dist/serializer/src/serializer.js","dist/serializer/src/template.js","dist/serializer/src/types.js","node_modules/assert/assert.js","node_modules/base-x/index.js","node_modules/base64-js/index.js","node_modules/bigi/lib/bigi.js","node_modules/bigi/lib/convert.js","node_modules/bigi/lib/index.js","node_modules/bigi/package.json","node_modules/browser-resolve/empty.js","node_modules/browserify/node_modules/buffer/index.js","node_modules/browserify/node_modules/string_decoder/index.js","node_modules/bs58/index.js","node_modules/bytebuffer/dist/bytebuffer.js","node_modules/cipher-base/index.js","node_modules/core-util-is/lib/util.js","node_modules/create-hash/browser.js","node_modules/create-hash/md5.js","node_modules/create-hmac/browser.js","node_modules/create-hmac/legacy.js","node_modules/crypto-js/aes.js","node_modules/crypto-js/cipher-core.js","node_modules/crypto-js/core.js","node_modules/crypto-js/enc-base64.js","node_modules/crypto-js/enc-hex.js","node_modules/crypto-js/evpkdf.js","node_modules/crypto-js/hmac.js","node_modules/crypto-js/md5.js","node_modules/crypto-js/sha1.js","node_modules/deep-equal/index.js","node_modules/deep-equal/lib/is_arguments.js","node_modules/deep-equal/lib/keys.js","node_modules/ecurve/lib/curve.js","node_modules/ecurve/lib/curves.json","node_modules/ecurve/lib/index.js","node_modules/ecurve/lib/names.js","node_modules/ecurve/lib/point.js","node_modules/events/events.js","node_modules/hash-base/index.js","node_modules/ieee754/index.js","node_modules/inherits/inherits_browser.js","node_modules/is-buffer/index.js","node_modules/isarray/index.js","node_modules/long/dist/long.js","node_modules/md5.js/index.js","node_modules/peerplaysjs-ws/dist/index.js","node_modules/peerplaysjs-ws/dist/src/ApiInstances.js","node_modules/peerplaysjs-ws/dist/src/ChainConfig.js","node_modules/peerplaysjs-ws/dist/src/ChainWebSocket.js","node_modules/peerplaysjs-ws/dist/src/ConnectionManager.js","node_modules/peerplaysjs-ws/dist/src/GrapheneApi.js","node_modules/process-nextick-args/index.js","node_modules/process/browser.js","node_modules/readable-stream/duplex-browser.js","node_modules/readable-stream/lib/_stream_duplex.js","node_modules/readable-stream/lib/_stream_passthrough.js","node_modules/readable-stream/lib/_stream_readable.js","node_modules/readable-stream/lib/_stream_transform.js","node_modules/readable-stream/lib/_stream_writable.js","node_modules/readable-stream/lib/internal/streams/BufferList.js","node_modules/readable-stream/lib/internal/streams/destroy.js","node_modules/readable-stream/lib/internal/streams/stream-browser.js","node_modules/readable-stream/passthrough.js","node_modules/readable-stream/readable-browser.js","node_modules/readable-stream/transform.js","node_modules/readable-stream/writable-browser.js","node_modules/ripemd160/index.js","node_modules/safe-buffer/index.js","node_modules/secure-random/lib/secure-random.js","node_modules/sha.js/hash.js","node_modules/sha.js/index.js","node_modules/sha.js/sha.js","node_modules/sha.js/sha1.js","node_modules/sha.js/sha224.js","node_modules/sha.js/sha256.js","node_modules/sha.js/sha384.js","node_modules/sha.js/sha512.js","node_modules/stream-browserify/index.js","node_modules/string_decoder/lib/string_decoder.js","node_modules/timers-browserify/main.js","node_modules/util-deprecate/browser.js","node_modules/util/support/isBufferBrowser.js","node_modules/util/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9kBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACzMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACpNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC3OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACnTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC1NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACzFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1WA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpsBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC//BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1eA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACr+CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3FA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7NA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClqHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC12BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3QA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9SA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACleA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxLA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACrNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9qBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACvSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;ACn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file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","\"use strict\";\n\nmodule.exports = {\n    PrivateKey: require(\"./ecc/src/PrivateKey\"),\n    PublicKey: require(\"./ecc/src/PublicKey\"),\n    Signature: require(\"./ecc/src/signature\"),\n    key: require(\"./ecc/src/KeyUtils\"),\n    TransactionBuilder: require(\"./chain/src/TransactionBuilder\"),\n    Login: require(\"./chain/src/AccountLogin\"),\n    grapheneWS: require(\"peerplaysjs-ws\")\n};","\"use strict\";\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar PrivateKey = require(\"../../ecc/src/PrivateKey\");\nvar key = require(\"../../ecc/src/KeyUtils\");\n\nvar _require = require(\"./state\"),\n    get = _require.get,\n    set = _require.set;\n\nvar _keyCachePriv = {};\nvar _keyCachePub = {};\n\nvar AccountLogin = function () {\n    function AccountLogin() {\n        _classCallCheck(this, AccountLogin);\n\n        var state = { loggedIn: false, roles: [\"active\", \"owner\", \"memo\"] };\n        this.get = get(state);\n        this.set = set(state);\n\n        this.subs = {};\n    }\n\n    _createClass(AccountLogin, [{\n        key: \"addSubscription\",\n        value: function addSubscription(cb) {\n            this.subs[cb] = cb;\n        }\n    }, {\n        key: \"setRoles\",\n        value: function setRoles(roles) {\n            this.set(\"roles\", roles);\n        }\n    }, {\n        key: \"generateKeys\",\n        value: function generateKeys(accountName, password, roles, prefix) {\n            var start = new Date().getTime();\n            if (!accountName || !password) {\n                throw new Error(\"Account name or password required\");\n            }\n            if (password.length < 12) {\n                throw new Error(\"Password must have at least 12 characters\");\n            }\n\n            var privKeys = {};\n            var pubKeys = {};\n\n            (roles || this.get(\"roles\")).forEach(function (role) {\n                var seed = accountName + role + password;\n                var pkey = _keyCachePriv[seed] ? _keyCachePriv[seed] : PrivateKey.fromSeed(key.normalize_brainKey(seed));\n                _keyCachePriv[seed] = pkey;\n\n                privKeys[role] = pkey;\n                pubKeys[role] = _keyCachePub[seed] ? _keyCachePub[seed] : pkey.toPublicKey().toString(prefix);\n\n                _keyCachePub[seed] = pubKeys[role];\n            });\n\n            return { privKeys: privKeys, pubKeys: pubKeys };\n        }\n    }, {\n        key: \"checkKeys\",\n        value: function checkKeys(_ref) {\n            var _this = this;\n\n            var accountName = _ref.accountName,\n                password = _ref.password,\n                auths = _ref.auths;\n\n            if (!accountName || !password || !auths) {\n                throw new Error(\"checkKeys: Missing inputs\");\n            }\n            var hasKey = false;\n\n            var _loop = function _loop(role) {\n                var _generateKeys = _this.generateKeys(accountName, password, [role]),\n                    privKeys = _generateKeys.privKeys,\n                    pubKeys = _generateKeys.pubKeys;\n\n                auths[role].forEach(function (key) {\n                    if (key[0] === pubKeys[role]) {\n                        hasKey = true;\n                        _this.set(role, { priv: privKeys[role], pub: pubKeys[role] });\n                    }\n                });\n            };\n\n            for (var role in auths) {\n                _loop(role);\n            };\n\n            if (hasKey) {\n                this.set(\"name\", accountName);\n            }\n\n            this.set(\"loggedIn\", hasKey);\n\n            return hasKey;\n        }\n    }, {\n        key: \"signTransaction\",\n        value: function signTransaction(tr) {\n            var _this2 = this;\n\n            var myKeys = {};\n            var hasKey = false;\n\n            this.get(\"roles\").forEach(function (role) {\n                var myKey = _this2.get(role);\n                if (myKey) {\n                    hasKey = true;\n                    console.log(\"adding signer:\", myKey.pub);\n                    tr.add_signer(myKey.priv, myKey.pub);\n                }\n            });\n\n            if (!hasKey) {\n                throw new Error(\"You do not have any private keys to sign this transaction\");\n            }\n        }\n    }]);\n\n    return AccountLogin;\n}();\n\nvar accountLogin = new AccountLogin();\n\nmodule.exports = accountLogin;","\"use strict\";\n\nvar ChainTypes = {};\n\nChainTypes.reserved_spaces = {\n  relative_protocol_ids: 0,\n  protocol_ids: 1,\n  implementation_ids: 2\n};\n\nChainTypes.object_type = {\n  \"null\": 0,\n  base: 1,\n  account: 2,\n  asset: 3,\n  force_settlement: 4,\n  committee_member: 5,\n  witness: 6,\n  limit_order: 7,\n  call_order: 8,\n  custom: 9,\n  proposal: 10,\n  operation_history: 11,\n  withdraw_permission: 12,\n  vesting_balance: 13,\n  worker: 14,\n  balance: 15,\n  tournament: 16,\n  tournament_details: 17,\n  match_object_type: 18,\n  game: 19\n};\n\nChainTypes.impl_object_type = {\n  global_property: 0,\n  dynamic_global_property: 1,\n  index_meta: 2,\n  asset_dynamic_data: 3,\n  asset_bitasset_data: 4,\n  account_balance: 5,\n  account_statistics: 6,\n  transaction: 7,\n  block_summary: 8,\n  account_transaction_history: 9,\n  blinded_balance: 10,\n  chain_property: 11,\n  witness_schedule: 12,\n  budget_record: 13,\n  special_authority: 14,\n  buyback: 15,\n  fba_accumulator: 16,\n  asset_dividend_data: 17,\n  pending_dividend_payout_balance_for_holder: 18,\n  distributed_dividend_balance_data: 19\n};\n\nChainTypes.vote_type = {\n  committee: 0,\n  witness: 1,\n  worker: 2\n};\n\nChainTypes.operations = {\n  transfer: 0,\n  limit_order_create: 1,\n  limit_order_cancel: 2,\n  call_order_update: 3,\n  fill_order: 4,\n  account_create: 5,\n  account_update: 6,\n  account_whitelist: 7,\n  account_upgrade: 8,\n  account_transfer: 9,\n  asset_create: 10,\n  asset_update: 11,\n  asset_update_bitasset: 12,\n  asset_update_feed_producers: 13,\n  asset_issue: 14,\n  asset_reserve: 15,\n  asset_fund_fee_pool: 16,\n  asset_settle: 17,\n  asset_global_settle: 18,\n  asset_publish_feed: 19,\n  witness_create: 20,\n  witness_update: 21,\n  proposal_create: 22,\n  proposal_update: 23,\n  proposal_delete: 24,\n  withdraw_permission_create: 25,\n  withdraw_permission_update: 26,\n  withdraw_permission_claim: 27,\n  withdraw_permission_delete: 28,\n  committee_member_create: 29,\n  committee_member_update: 30,\n  committee_member_update_global_parameters: 31,\n  vesting_balance_create: 32,\n  vesting_balance_withdraw: 33,\n  worker_create: 34,\n  custom: 35,\n  assert: 36,\n  balance_claim: 37,\n  override_transfer: 38,\n  transfer_to_blind: 39,\n  blind_transfer: 40,\n  transfer_from_blind: 41,\n  asset_settle_cancel: 42,\n  asset_claim_fees: 43,\n  fba_distribute_operation: 44,\n  tournament_create: 45,\n  tournament_join: 46,\n  game_move: 47,\n  asset_update_dividend: 48,\n  asset_dividend_distribution: 49\n};\n\nmodule.exports = ChainTypes;","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _require = require('bytebuffer'),\n    Long = _require.Long;\n\nvar v = require('../../serializer/src/SerializerValidation');\n\nvar DB_MAX_INSTANCE_ID = Long.fromNumber(Math.pow(2, 48) - 1);\n\nvar ObjectId = function () {\n    function ObjectId(space, type, instance) {\n        _classCallCheck(this, ObjectId);\n\n        this.space = space;\n        this.type = type;\n        this.instance = instance;\n        var instance_string = this.instance.toString();\n        var _ObjectId = this.space + '.' + this.type + '.' + instance_string;\n        if (!v.is_digits(instance_string)) {\n            throw new ('Invalid object id ' + _ObjectId)();\n        }\n    }\n\n    _createClass(ObjectId, [{\n        key: 'toLong',\n        value: function toLong() {\n            return Long.fromNumber(this.space).shiftLeft(56).or(Long.fromNumber(this.type).shiftLeft(48).or(this.instance));\n        }\n    }, {\n        key: 'appendByteBuffer',\n        value: function appendByteBuffer(b) {\n            return b.writeUint64(this.toLong());\n        }\n    }, {\n        key: 'toString',\n        value: function toString() {\n            return this.space + '.' + this.type + '.' + this.instance.toString();\n        }\n    }], [{\n        key: 'fromString',\n        value: function fromString(value) {\n            if (value.space !== undefined && value.type !== undefined && value.instance !== undefined) {\n                return value;\n            }\n\n            var params = v.require_match(/^([0-9]+)\\.([0-9]+)\\.([0-9]+)$/, v.required(value, \"ObjectId\"), \"ObjectId\");\n            return new ObjectId(parseInt(params[1]), parseInt(params[2]), Long.fromString(params[3]));\n        }\n    }, {\n        key: 'fromLong',\n        value: function fromLong(long) {\n            var space = long.shiftRight(56).toInt();\n            var type = long.shiftRight(48).toInt() & 0x00ff;\n            var instance = long.and(DB_MAX_INSTANCE_ID);\n            return new ObjectId(space, type, instance);\n        }\n    }, {\n        key: 'fromByteBuffer',\n        value: function fromByteBuffer(b) {\n            return ObjectId.fromLong(b.readUint64());\n        }\n    }]);\n\n    return ObjectId;\n}();\n\nmodule.exports = ObjectId;","\"use strict\";\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar assert = require(\"assert\");\n\nvar _require = require(\"../../ecc\"),\n    Signature = _require.Signature,\n    PublicKey = _require.PublicKey,\n    hash = _require.hash;\n\nvar _require2 = require(\"../../serializer\"),\n    ops = _require2.ops;\n\nvar _require3 = require('peerplaysjs-ws'),\n    Apis = _require3.Apis,\n    ChainConfig = _require3.ChainConfig;\n\nvar ChainTypes = require('./ChainTypes');\nvar head_block_time_string;\n\nvar TransactionBuilder = function () {\n    function TransactionBuilder() {\n        _classCallCheck(this, TransactionBuilder);\n\n        this.ref_block_num = 0;\n        this.ref_block_prefix = 0;\n        this.expiration = 0;\n        this.operations = [];\n        this.signatures = [];\n        this.signer_private_keys = [];\n\n        // semi-private method bindings\n        this._broadcast = _broadcast.bind(this);\n    }\n\n    /**\n        @arg {string} name - like \"transfer\"\n        @arg {object} operation - JSON matchching the operation's format\n    */\n\n\n    _createClass(TransactionBuilder, [{\n        key: \"add_type_operation\",\n        value: function add_type_operation(name, operation) {\n            this.add_operation(this.get_type_operation(name, operation));\n            return;\n        }\n\n        /**\n            This does it all: set fees, finalize, sign, and broadcast (if wanted).\n             @arg {ConfidentialWallet} cwallet - must be unlocked, used to gather signing keys\n             @arg {array<string>} [signer_pubkeys = null] - Optional [\"GPHAbc9Def0...\", ...].  These are additional signing keys.  Some balance claims require propritary address formats, the witness node can't tell us which ones are needed so they must be passed in.  If the witness node can figure out a signing key (mostly all other transactions), it should not be passed in here.\n             @arg {boolean} [broadcast = false]\n        */\n\n    }, {\n        key: \"process_transaction\",\n        value: function process_transaction(cwallet) {\n            var _this = this;\n\n            var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n            var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n\n            var wallet_object = cwallet.wallet.wallet_object;\n            if (Apis.instance().chain_id !== wallet_object.get(\"chain_id\")) return Promise.reject(\"Mismatched chain_id; expecting \" + wallet_object.get(\"chain_id\") + \", but got \" + Apis.instance().chain_id);\n\n            return this.set_required_fees().then(function () {\n                var signer_pubkeys_added = {};\n                if (signer_pubkeys) {\n\n                    // Balance claims are by address, only the private\n                    // key holder can know about these additional\n                    // potential keys.\n                    var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys);\n                    if (!pubkeys.length) throw new Error(\"Missing signing key\");\n\n                    var _iteratorNormalCompletion = true;\n                    var _didIteratorError = false;\n                    var _iteratorError = undefined;\n\n                    try {\n                        for (var _iterator = pubkeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                            var pubkey_string = _step.value;\n\n                            var private_key = cwallet.getPrivateKey(pubkey_string);\n                            _this.add_signer(private_key, pubkey_string);\n                            signer_pubkeys_added[pubkey_string] = true;\n                        }\n                    } catch (err) {\n                        _didIteratorError = true;\n                        _iteratorError = err;\n                    } finally {\n                        try {\n                            if (!_iteratorNormalCompletion && _iterator.return) {\n                                _iterator.return();\n                            }\n                        } finally {\n                            if (_didIteratorError) {\n                                throw _iteratorError;\n                            }\n                        }\n                    }\n                }\n\n                return _this.get_potential_signatures().then(function (_ref) {\n                    var pubkeys = _ref.pubkeys,\n                        addys = _ref.addys;\n\n                    var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys);\n\n                    //{//Testing only, don't send All public keys!\n                    //    var pubkeys_all = PrivateKeyStore.getPubkeys() // All public keys\n                    //    this.get_required_signatures(pubkeys_all).then( required_pubkey_strings =>\n                    //        console.log('get_required_signatures all\\t',required_pubkey_strings.sort(), pubkeys_all))\n                    //    this.get_required_signatures(my_pubkeys).then( required_pubkey_strings =>\n                    //        console.log('get_required_signatures normal\\t',required_pubkey_strings.sort(), pubkeys))\n                    //}\n\n                    return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) {\n                        var _iteratorNormalCompletion2 = true;\n                        var _didIteratorError2 = false;\n                        var _iteratorError2 = undefined;\n\n                        try {\n                            for (var _iterator2 = required_pubkeys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n                                var _pubkey_string = _step2.value;\n\n                                if (signer_pubkeys_added[_pubkey_string]) continue;\n                                var private_key = cwallet.getPrivateKey(_pubkey_string);\n                                if (!private_key)\n                                    // This should not happen, get_required_signatures will only\n                                    // returned keys from my_pubkeys\n                                    throw new Error(\"Missing signing key for \" + _pubkey_string);\n                                _this.add_signer(private_key, _pubkey_string);\n                            }\n                        } catch (err) {\n                            _didIteratorError2 = true;\n                            _iteratorError2 = err;\n                        } finally {\n                            try {\n                                if (!_iteratorNormalCompletion2 && _iterator2.return) {\n                                    _iterator2.return();\n                                }\n                            } finally {\n                                if (_didIteratorError2) {\n                                    throw _iteratorError2;\n                                }\n                            }\n                        }\n                    });\n                }).then(function () {\n                    return broadcast ? _this.broadcast() : _this.serialize();\n                });\n            });\n        }\n\n        /** Typically this is called automatically just prior to signing.  Once finalized this transaction can not be changed. */\n\n    }, {\n        key: \"finalize\",\n        value: function finalize() {\n            var _this2 = this;\n\n            return new Promise(function (resolve, reject) {\n\n                if (_this2.tr_buffer) {\n                    throw new Error(\"already finalized\");\n                }\n\n                resolve(Apis.instance().db_api().exec(\"get_objects\", [[\"2.1.0\"]]).then(function (r) {\n                    head_block_time_string = r[0].time;\n                    if (_this2.expiration === 0) _this2.expiration = base_expiration_sec() + ChainConfig.expire_in_secs;\n                    _this2.ref_block_num = r[0].head_block_number & 0xFFFF;\n                    _this2.ref_block_prefix = new Buffer(r[0].head_block_id, 'hex').readUInt32LE(4);\n                    //DEBUG console.log(\"ref_block\",@ref_block_num,@ref_block_prefix,r)\n\n                    var iterable = _this2.operations;\n                    for (var i = 0, op; i < iterable.length; i++) {\n                        op = iterable[i];\n                        if (op[1][\"finalize\"]) {\n                            op[1].finalize();\n                        }\n\n                        var _type = ops.operation.st_operations[op[0]];\n                        var hexBuffer = _type.toBuffer(op[1]).toString(\"hex\");\n                        console.log(\"Operation %s: %O => %s (%d bytes)\", _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2);\n                    }\n                    _this2.tr_buffer = ops.transaction.toBuffer(_this2);\n                }));\n            });\n        }\n\n        /** @return {string} hex transaction ID */\n\n    }, {\n        key: \"id\",\n        value: function id() {\n            if (!this.tr_buffer) {\n                throw new Error(\"not finalized\");\n            }\n            return hash.sha256(this.tr_buffer).toString('hex').substring(0, 40);\n        }\n\n        /**\n            Typically one will use {@link this.add_type_operation} instead.\n            @arg {array} operation - [operation_id, operation]\n        */\n\n    }, {\n        key: \"add_operation\",\n        value: function add_operation(operation) {\n            if (this.tr_buffer) {\n                throw new Error(\"already finalized\");\n            }\n            assert(operation, \"operation\");\n            if (!Array.isArray(operation)) {\n                throw new Error(\"Expecting array [operation_id, operation]\");\n            }\n            this.operations.push(operation);\n            return;\n        }\n    }, {\n        key: \"get_type_operation\",\n        value: function get_type_operation(name, operation) {\n            if (this.tr_buffer) {\n                throw new Error(\"already finalized\");\n            }\n            assert(name, \"name\");\n            assert(operation, \"operation\");\n            var _type = ops[name];\n            assert(_type, \"Unknown operation \" + name);\n            var operation_id = ChainTypes.operations[_type.operation_name];\n            if (operation_id === undefined) {\n                throw new Error(\"unknown operation: \" + _type.operation_name);\n            }\n            if (!operation.fee) {\n                operation.fee = { amount: 0, asset_id: 0 };\n            }\n            if (name === 'proposal_create') {\n                operation.expiration_time || (operation.expiration_time = base_expiration_sec() + ChainConfig.expire_in_secs_proposal);\n            }\n            var operation_instance = _type.fromObject(operation);\n            return [operation_id, operation_instance];\n        }\n\n        /** optional: there is a deafult expiration */\n\n    }, {\n        key: \"set_expire_seconds\",\n        value: function set_expire_seconds(sec) {\n            if (this.tr_buffer) {\n                throw new Error(\"already finalized\");\n            }\n            return this.expiration = base_expiration_sec() + sec;\n        }\n\n        /* Wraps this transaction in a proposal_create transaction */\n\n    }, {\n        key: \"propose\",\n        value: function propose(proposal_create_options) {\n            if (this.tr_buffer) {\n                throw new Error(\"already finalized\");\n            }\n            if (!this.operations.length) {\n                throw new Error(\"add operation first\");\n            }\n\n            assert(proposal_create_options, \"proposal_create_options\");\n            assert(proposal_create_options.fee_paying_account, \"proposal_create_options.fee_paying_account\");\n\n            var proposed_ops = this.operations.map(function (op) {\n                return { op: op };\n            });\n\n            this.operations = [];\n            this.signatures = [];\n            this.signer_private_keys = [];\n            proposal_create_options.proposed_ops = proposed_ops;\n            this.add_type_operation(\"proposal_create\", proposal_create_options);\n            return this;\n        }\n    }, {\n        key: \"has_proposed_operation\",\n        value: function has_proposed_operation() {\n            var hasProposed = false;\n            for (var i = 0; i < this.operations.length; i++) {\n                if (\"proposed_ops\" in this.operations[i][1]) {\n                    hasProposed = true;\n                    break;\n                }\n            }\n\n            return hasProposed;\n        }\n\n        /** optional: the fees can be obtained from the witness node */\n\n    }, {\n        key: \"set_required_fees\",\n        value: function set_required_fees(asset_id) {\n            var _this3 = this;\n\n            var fee_pool;\n            if (this.tr_buffer) {\n                throw new Error(\"already finalized\");\n            }\n            if (!this.operations.length) {\n                throw new Error(\"add operations first\");\n            }\n            var operations = [];\n            for (var i = 0, op; i < this.operations.length; i++) {\n                op = this.operations[i];\n                operations.push(ops.operation.toObject(op));\n            }\n\n            if (!asset_id) {\n                var op1_fee = operations[0][1].fee;\n                if (op1_fee && op1_fee.asset_id !== null) {\n                    asset_id = op1_fee.asset_id;\n                } else {\n                    asset_id = \"1.3.0\";\n                }\n            }\n\n            var promises = [Apis.instance().db_api().exec(\"get_required_fees\", [operations, asset_id])];\n\n            var feeAssetPromise = null;\n            if (asset_id !== \"1.3.0\") {\n                // This handles the fallback to paying fees in BTS if the fee pool is empty.\n                promises.push(Apis.instance().db_api().exec(\"get_required_fees\", [operations, \"1.3.0\"]));\n                promises.push(Apis.instance().db_api().exec(\"get_objects\", [[asset_id]]));\n            }\n\n            return Promise.all(promises).then(function (results) {\n                var _results = _slicedToArray(results, 3),\n                    fees = _results[0],\n                    coreFees = _results[1],\n                    asset = _results[2];\n\n                asset = asset ? asset[0] : null;\n\n                var dynamicPromise = asset_id !== \"1.3.0\" && asset ? Apis.instance().db_api().exec(\"get_objects\", [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve, reject) {\n                    resolve();\n                });\n\n                return dynamicPromise.then(function (dynamicObject) {\n                    if (asset_id !== \"1.3.0\") {\n                        fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0;\n                        var totalFees = 0;\n                        for (var j = 0, fee; j < coreFees.length; j++) {\n                            fee = coreFees[j];\n                            totalFees += fee.amount;\n                        }\n\n                        if (totalFees > parseInt(fee_pool, 10)) {\n                            fees = coreFees;\n                            asset_id = \"1.3.0\";\n                        }\n                    }\n\n                    // Proposed transactions need to be flattened\n                    var flat_assets = [];\n                    var flatten = function flatten(obj) {\n                        if (Array.isArray(obj)) {\n                            for (var k = 0, item; k < obj.length; k++) {\n                                item = obj[k];\n                                flatten(item);\n                            }\n                        } else {\n                            flat_assets.push(obj);\n                        }\n                        return;\n                    };\n                    flatten(fees);\n\n                    var asset_index = 0;\n\n                    var set_fee = function set_fee(operation) {\n                        if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === \"0\" // Long\n                        ) {\n                                operation.fee = flat_assets[asset_index];\n                                // console.log(\"new operation.fee\", operation.fee)\n                            } else {\n                                // console.log(\"old operation.fee\", operation.fee)\n                            }\n                        asset_index++;\n                        if (operation.proposed_ops) {\n                            var result = [];\n                            for (var y = 0; y < operation.proposed_ops.length; y++) {\n                                result.push(set_fee(operation.proposed_ops[y].op[1]));\n                            }return result;\n                        }\n                    };\n                    for (var _i = 0; _i < _this3.operations.length; _i++) {\n                        set_fee(_this3.operations[_i][1]);\n                    }\n                });\n                //DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets)\n            });\n        }\n    }, {\n        key: \"get_potential_signatures\",\n        value: function get_potential_signatures() {\n            var tr_object = ops.signed_transaction.toObject(this);\n            return Promise.all([Apis.instance().db_api().exec(\"get_potential_signatures\", [tr_object]), Apis.instance().db_api().exec(\"get_potential_address_signatures\", [tr_object])]).then(function (results) {\n                return { pubkeys: results[0], addys: results[1] };\n            });\n        }\n    }, {\n        key: \"get_required_signatures\",\n        value: function get_required_signatures(available_keys) {\n            if (!available_keys.length) {\n                return Promise.resolve([]);\n            }\n            var tr_object = ops.signed_transaction.toObject(this);\n            //DEBUG console.log('... tr_object',tr_object)\n            return Apis.instance().db_api().exec(\"get_required_signatures\", [tr_object, available_keys]).then(function (required_public_keys) {\n                //DEBUG console.log('... get_required_signatures',required_public_keys)\n                return required_public_keys;\n            });\n        }\n    }, {\n        key: \"add_signer\",\n        value: function add_signer(private_key) {\n            var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey();\n\n\n            assert(private_key.d, \"required PrivateKey object\");\n\n            if (this.signed) {\n                throw new Error(\"already signed\");\n            }\n            if (!public_key.Q) {\n                public_key = PublicKey.fromPublicKeyString(public_key);\n            }\n            // prevent duplicates\n            var spHex = private_key.toHex();\n            var _iteratorNormalCompletion3 = true;\n            var _didIteratorError3 = false;\n            var _iteratorError3 = undefined;\n\n            try {\n                for (var _iterator3 = this.signer_private_keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                    var sp = _step3.value;\n\n                    if (sp[0].toHex() === spHex) return;\n                }\n            } catch (err) {\n                _didIteratorError3 = true;\n                _iteratorError3 = err;\n            } finally {\n                try {\n                    if (!_iteratorNormalCompletion3 && _iterator3.return) {\n                        _iterator3.return();\n                    }\n                } finally {\n                    if (_didIteratorError3) {\n                        throw _iteratorError3;\n                    }\n                }\n            }\n\n            this.signer_private_keys.push([private_key, public_key]);\n        }\n    }, {\n        key: \"sign\",\n        value: function sign() {\n            var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Apis.instance().chain_id;\n\n            if (!this.tr_buffer) {\n                throw new Error(\"not finalized\");\n            }\n            if (this.signed) {\n                throw new Error(\"already signed\");\n            }\n            if (!this.signer_private_keys.length) {\n                throw new Error(\"Transaction was not signed. Do you have a private key? [no_signers]\");\n            }\n            var end = this.signer_private_keys.length;\n            for (var i = 0; 0 < end ? i < end : i > end; 0 < end ? i++ : i++) {\n                var _signer_private_keys$ = _slicedToArray(this.signer_private_keys[i], 2),\n                    private_key = _signer_private_keys$[0],\n                    public_key = _signer_private_keys$[1];\n\n                var sig = Signature.signBuffer(Buffer.concat([new Buffer(chain_id, 'hex'), this.tr_buffer]), private_key, public_key);\n                this.signatures.push(sig.toBuffer());\n            }\n            this.signer_private_keys = [];\n            this.signed = true;\n            return;\n        }\n    }, {\n        key: \"serialize\",\n        value: function serialize() {\n            return ops.signed_transaction.toObject(this);\n        }\n    }, {\n        key: \"toObject\",\n        value: function toObject() {\n            return ops.signed_transaction.toObject(this);\n        }\n    }, {\n        key: \"broadcast\",\n        value: function broadcast(was_broadcast_callback) {\n            var _this4 = this;\n\n            if (this.tr_buffer) {\n                return this._broadcast(was_broadcast_callback);\n            } else {\n                return this.finalize().then(function () {\n                    return _this4._broadcast(was_broadcast_callback);\n                });\n            }\n        }\n    }]);\n\n    return TransactionBuilder;\n}();\n\nvar base_expiration_sec = function base_expiration_sec() {\n    var head_block_sec = Math.ceil(getHeadBlockDate().getTime() / 1000);\n    var now_sec = Math.ceil(Date.now() / 1000);\n    // The head block time should be updated every 3 seconds.  If it isn't\n    // then help the transaction to expire (use head_block_sec)\n    if (now_sec - head_block_sec > 30) {\n        return head_block_sec;\n    }\n    // If the user's clock is very far behind, use the head block time.\n    return Math.max(now_sec, head_block_sec);\n};\n\nfunction _broadcast(was_broadcast_callback) {\n    var _this5 = this;\n\n    return new Promise(function (resolve, reject) {\n\n        if (!_this5.signed) {\n            _this5.sign();\n        }\n        if (!_this5.tr_buffer) {\n            throw new Error(\"not finalized\");\n        }\n        if (!_this5.signatures.length) {\n            throw new Error(\"not signed\");\n        }\n        if (!_this5.operations.length) {\n            throw new Error(\"no operations\");\n        }\n\n        var tr_object = ops.signed_transaction.toObject(_this5);\n        // console.log('... broadcast_transaction_with_callback !!!')\n        Apis.instance().network_api().exec(\"broadcast_transaction_with_callback\", [function (res) {\n            return resolve(res);\n        }, tr_object]).then(function () {\n            //console.log('... broadcast success, waiting for callback')\n            if (was_broadcast_callback) was_broadcast_callback();\n            return;\n        }).catch(function (error) {\n            // console.log may be redundant for network errors, other errors could occur\n            console.log(error);\n            var message = error.message;\n            if (!message) {\n                message = \"\";\n            }\n            reject(new Error(message + \"\\n\" + 'graphene-crypto ' + ' digest ' + hash.sha256(_this5.tr_buffer).toString('hex') + ' transaction ' + _this5.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object)));\n            return;\n        });\n        return;\n    });\n}\n\nfunction getHeadBlockDate() {\n    return timeStringToDate(head_block_time_string);\n}\n\nfunction timeStringToDate(time_string) {\n    if (!time_string) return new Date(\"1970-01-01T00:00:00.000Z\");\n    if (!/Z$/.test(time_string)) //does not end in Z\n        // https://github.com/cryptonomex/graphene/issues/368\n        time_string = time_string + \"Z\";\n    return new Date(time_string);\n}\n\nmodule.exports = TransactionBuilder;","\"use strict\";\n\nfunction get(state) {\n    return function (key) {\n        return state[key] || \"\";\n    };\n}\n\nfunction set(state) {\n    return function (key, value) {\n        state[key] = value;\n        return this;\n    };\n}\n\nmodule.exports = {\n    get: get,\n    set: set\n};","\"use strict\";\n\nmodule.exports = {\n    Address: require(\"./src/address\"),\n    Aes: require(\"./src/aes\"),\n    PrivateKey: require(\"./src/PrivateKey\"),\n    PublicKey: require(\"./src/PublicKey\"),\n    Signature: require(\"./src/signature\"),\n    brainKey: require(\"./src/BrainKey\"),\n    hash: require(\"./src/hash\"),\n    key: require(\"./src/KeyUtils\")\n};","'use strict';\n\nmodule.exports = function normalize(brainKey) {\n    if (typeof brainKey !== 'string') {\n        throw new Error(\"string required for brainKey\");\n    }\n    brainKey = brainKey.trim();\n    return brainKey.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n};","'use strict';\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar key;\nvar PrivateKey = require('./PrivateKey');\nvar PublicKey = require('./PublicKey');\nvar Address = require('./address');\nvar Aes = require('./aes');\n\nvar hash = require('./hash');\n// var dictionary = require('./dictionary_en');\nvar secureRandom = require('secure-random');\n\nvar _require = require('peerplaysjs-ws'),\n    ChainConfig = _require.ChainConfig;\n\n// hash for .25 second\n\n\nvar HASH_POWER_MILLS = 250;\n\nmodule.exports = key = {\n\n    /** Uses 1 second of hashing power to create a key/password checksum.  An\n    implementation can re-call this method with the same password to re-match\n    the strength of the CPU (either after moving from a desktop to a mobile,\n    mobile to desktop, or N years from now when CPUs are presumably stronger).\n     A salt is used for all the normal reasons...\n     @return object {\n        aes_private: Aes,\n        checksum: \"{hash_iteration_count},{salt},{checksum}\"\n    }\n    */\n    aes_checksum: function aes_checksum(password) {\n        if (!(typeof password === \"string\")) {\n            throw new \"password string required\"();\n        }\n        var salt = secureRandom.randomBuffer(4).toString('hex');\n        var iterations = 0;\n        var secret = salt + password;\n        // hash for .1 second\n        var start_t = Date.now();\n        while (Date.now() - start_t < HASH_POWER_MILLS) {\n            secret = hash.sha256(secret);\n            iterations += 1;\n        }\n\n        var checksum = hash.sha256(secret);\n        var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(',');\n\n        return { aes_private: Aes.fromSeed(secret),\n            checksum: checksum_string\n        };\n    },\n\n\n    /** Provide a matching password and key_checksum.  A \"wrong password\"\n    error is thrown if the password does not match.  If this method takes\n    much more or less than 1 second to return, one should consider updating\n    all encyrpted fields using a new key.key_checksum.\n    */\n    aes_private: function aes_private(password, key_checksum) {\n        var _key_checksum$split = key_checksum.split(','),\n            _key_checksum$split2 = _slicedToArray(_key_checksum$split, 3),\n            iterations = _key_checksum$split2[0],\n            salt = _key_checksum$split2[1],\n            checksum = _key_checksum$split2[2];\n\n        var secret = salt + password;\n        for (var i = 0; 0 < iterations ? i < iterations : i > iterations; 0 < iterations ? i++ : i++) {\n            secret = hash.sha256(secret);\n        }\n        var new_checksum = hash.sha256(secret);\n        if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) {\n            throw new Error(\"wrong password\");\n        }\n        return Aes.fromSeed(secret);\n    },\n\n\n    /**\n        A week random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.\n         @param1 string entropy of at least 32 bytes\n    */\n    random32ByteBuffer: function random32ByteBuffer() {\n        var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy();\n\n\n        if (!(typeof entropy === 'string')) {\n            throw new Error(\"string required for entropy\");\n        }\n\n        if (entropy.length < 32) {\n            throw new Error(\"expecting at least 32 bytes of entropy\");\n        }\n\n        var start_t = Date.now();\n\n        while (Date.now() - start_t < HASH_POWER_MILLS) {\n            entropy = hash.sha256(entropy);\n        }var hash_array = [];\n        hash_array.push(entropy);\n\n        // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back).\n        hash_array.push(secureRandom.randomBuffer(32));\n\n        return hash.sha256(Buffer.concat(hash_array));\n    },\n\n\n    suggest_brain_key: function suggest_brain_key() {\n        var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : \",\";\n        var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy();\n\n\n        var randomBuffer = this.random32ByteBuffer(entropy);\n\n        var word_count = 16;\n        var dictionary_lines = dictionary.split(',');\n\n        if (!(dictionary_lines.length === 49744)) {\n            throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words');\n        }\n\n        var brainkey = [];\n        var end = word_count * 2;\n\n        for (var i = 0; i < end; i += 2) {\n\n            // randomBuffer has 256 bits / 16 bits per word == 16 words\n            var num = (randomBuffer[i] << 8) + randomBuffer[i + 1];\n\n            // convert into a number between 0 and 1 (inclusive)\n            var rndMultiplier = num / Math.pow(2, 16);\n            var wordIndex = Math.round(dictionary_lines.length * rndMultiplier);\n\n            brainkey.push(dictionary_lines[wordIndex]);\n        }\n        return this.normalize_brainKey(brainkey.join(' '));\n    },\n\n    get_random_key: function get_random_key(entropy) {\n        return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy));\n    },\n    get_brainPrivateKey: function get_brainPrivateKey(brainKey) {\n        var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n        if (sequence < 0) {\n            throw new Error(\"invalid sequence\");\n        }\n        brainKey = key.normalize_brainKey(brainKey);\n        return PrivateKey.fromBuffer(hash.sha256(hash.sha512(brainKey + \" \" + sequence)));\n    },\n\n\n    // Turn invisible space like characters into a single space\n    normalize_brainKey: function normalize_brainKey(brainKey) {\n        if (!(typeof brainKey === 'string')) {\n            throw new Error(\"string required for brainKey\");\n        }\n\n        brainKey = brainKey.trim();\n        return brainKey.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n    },\n    browserEntropy: function browserEntropy() {\n\n        var entropyStr = \"\";\n        try {\n            entropyStr = new Date().toString() + \" \" + window.screen.height + \" \" + window.screen.width + \" \" + window.screen.colorDepth + \" \" + \" \" + window.screen.availHeight + \" \" + window.screen.availWidth + \" \" + window.screen.pixelDepth + navigator.language + \" \" + window.location + \" \" + window.history.length;\n\n            for (var i = 0, mimeType; i < navigator.mimeTypes.length; i++) {\n                mimeType = navigator.mimeTypes[i];\n                entropyStr += mimeType.description + \" \" + mimeType.type + \" \" + mimeType.suffixes + \" \";\n            }\n            console.log(\"INFO\\tbrowserEntropy gathered\");\n        } catch (error) {\n            //nodejs:ReferenceError: window is not defined\n            entropyStr = hash.sha256(new Date().toString());\n        }\n\n        var b = new Buffer(entropyStr);\n        entropyStr += b.toString('binary') + \" \" + new Date().toString();\n        return entropyStr;\n    },\n\n\n    // @return array of 5 legacy addresses for a pubkey string parameter.\n    addresses: function addresses(pubkey) {\n        var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix;\n\n        var public_key = PublicKey.fromPublicKeyString(pubkey, address_prefix);\n        // S L O W\n        var address_string = [Address.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed\n        Address.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed\n        Address.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed\n        Address.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed\n        public_key.toAddressString(address_prefix) // bts_short, most recent format\n        ];\n        return address_string;\n    }\n};","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ecurve = require('ecurve');\n\nvar _require = require('ecurve'),\n    Point = _require.Point,\n    getCurveByName = _require.getCurveByName;\n\nvar secp256k1 = getCurveByName('secp256k1');\nvar BigInteger = require('bigi');\n\nvar _require2 = require('bs58'),\n    encode = _require2.encode,\n    decode = _require2.decode;\n\nvar assert = require('assert');\nvar hash = require('./hash');\nvar PublicKey = require('./PublicKey');\nvar deepEqual = require(\"deep-equal\");\n\nvar G = secp256k1.G,\n    n = secp256k1.n;\n\nvar PrivateKey = function () {\n\n    /**\n        @private see static functions\n        @param {BigInteger}\n    */\n    function PrivateKey(d) {\n        _classCallCheck(this, PrivateKey);\n\n        this.d = d;\n    }\n\n    _createClass(PrivateKey, [{\n        key: 'toWif',\n        value: function toWif() {\n            var private_key = this.toBuffer();\n            // checksum includes the version\n            private_key = Buffer.concat([new Buffer([0x80]), private_key]);\n            var checksum = hash.sha256(private_key);\n            checksum = hash.sha256(checksum);\n            checksum = checksum.slice(0, 4);\n            var private_wif = Buffer.concat([private_key, checksum]);\n            return encode(private_wif);\n        }\n\n        /**\n            @return {Point}\n        */\n\n    }, {\n        key: 'toPublicKeyPoint',\n        value: function toPublicKeyPoint() {\n            var Q;\n            return Q = secp256k1.G.multiply(this.d);\n        }\n    }, {\n        key: 'toPublicKey',\n        value: function toPublicKey() {\n            if (this.public_key) {\n                return this.public_key;\n            }\n            return this.public_key = PublicKey.fromPoint(this.toPublicKeyPoint());\n        }\n    }, {\n        key: 'toBuffer',\n        value: function toBuffer() {\n            return this.d.toBuffer(32);\n        }\n\n        /** ECIES */\n\n    }, {\n        key: 'get_shared_secret',\n        value: function get_shared_secret(public_key) {\n            var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n            public_key = toPublic(public_key);\n            var KB = public_key.toUncompressed().toBuffer();\n            var KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)), // x\n            BigInteger.fromBuffer(KB.slice(33, 65)) // y\n            );\n            var r = this.toBuffer();\n            var P = KBP.multiply(BigInteger.fromBuffer(r));\n            var S = P.affineX.toBuffer({ size: 32 });\n            /*\n            the input to sha512 must be exactly 32-bytes, to match the c++ implementation\n            of get_shared_secret.  Right now S will be shorter if the most significant\n            byte(s) is zero.  Pad it back to the full 32-bytes\n            */\n            if (!legacy && S.length < 32) {\n                pad = new Buffer(32 - S.length).fill(0);\n                S = Buffer.concat([pad, S]);\n            }\n\n            // SHA512 used in ECIES\n            return hash.sha512(S);\n        }\n\n        // /** ECIES (does not always match the Point.fromAffine version above) */\n        // get_shared_secret(public_key){\n        //     public_key = toPublic(public_key)\n        //     var P = public_key.Q.multiply( this.d );\n        //     var S = P.affineX.toBuffer({size: 32});\n        //     // ECIES, adds an extra sha512\n        //     return hash.sha512(S);\n        // }\n\n        /** @throws {Error} - overflow of the key could not be derived */\n\n    }, {\n        key: 'child',\n        value: function child(offset) {\n            offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);\n            offset = hash.sha256(offset);\n            var c = BigInteger.fromBuffer(offset);\n\n            if (c.compareTo(n) >= 0) throw new Error(\"Child offset went out of bounds, try again\");\n\n            var derived = this.d.add(c); //.mod(n)\n\n            if (derived.signum() === 0) throw new Error(\"Child offset derived to an invalid key, try again\");\n\n            return new PrivateKey(derived);\n        }\n\n        /* <helper_functions> */\n\n    }, {\n        key: 'toByteBuffer',\n        value: function toByteBuffer() {\n            var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n            this.appendByteBuffer(b);\n            return b.copy(0, b.offset);\n        }\n    }, {\n        key: 'toHex',\n        value: function toHex() {\n            return this.toBuffer().toString('hex');\n        }\n\n        /* </helper_functions> */\n\n    }], [{\n        key: 'fromBuffer',\n        value: function fromBuffer(buf) {\n            if (!Buffer.isBuffer(buf)) {\n                throw new Error(\"Expecting paramter to be a Buffer type\");\n            }\n            if (32 !== buf.length) {\n                console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack);\n            }\n            if (buf.length === 0) {\n                throw new Error(\"Empty buffer\");\n            }\n            return new PrivateKey(BigInteger.fromBuffer(buf));\n        }\n\n        /** @arg {string} seed - any length string.  This is private, the same seed produces the same private key every time.  */\n\n    }, {\n        key: 'fromSeed',\n        value: function fromSeed(seed) {\n            // generate_private_key\n            if (!(typeof seed === 'string')) {\n                throw new Error('seed must be of type string');\n            }\n            return PrivateKey.fromBuffer(hash.sha256(seed));\n        }\n\n        /** @return {string} Wallet Import Format (still a secret, Not encrypted) */\n\n    }, {\n        key: 'fromWif',\n        value: function fromWif(_private_wif) {\n            var private_wif = new Buffer(decode(_private_wif));\n            var version = private_wif.readUInt8(0);\n            assert.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version);\n            // checksum includes the version\n            var private_key = private_wif.slice(0, -4);\n            var checksum = private_wif.slice(-4);\n            var new_checksum = hash.sha256(private_key);\n            new_checksum = hash.sha256(new_checksum);\n            new_checksum = new_checksum.slice(0, 4);\n            var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum'\n            if (!isEqual) {\n                throw new Error(\"Checksum did not match\");\n            }\n            private_key = private_key.slice(1);\n            private_key = private_key.slice(0, 32);\n            return PrivateKey.fromBuffer(private_key);\n        }\n    }, {\n        key: 'fromHex',\n        value: function fromHex(hex) {\n            return PrivateKey.fromBuffer(new Buffer(hex, 'hex'));\n        }\n    }]);\n\n    return PrivateKey;\n}();\n\nmodule.exports = PrivateKey;\n\nvar toPublic = function toPublic(data) {\n    return data == null ? data : data.Q ? data : PublicKey.fromStringOrThrow(data);\n};","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar BigInteger = require('bigi');\n\nvar _require = require('ecurve'),\n    Point = _require.Point,\n    getCurveByName = _require.getCurveByName;\n\nvar secp256k1 = getCurveByName('secp256k1');\n\nvar _require2 = require('bs58'),\n    encode = _require2.encode,\n    decode = _require2.decode;\n\nvar hash = require('./hash');\n\nvar _require3 = require('peerplaysjs-ws'),\n    ChainConfig = _require3.ChainConfig;\n\nvar assert = require('assert');\nvar deepEqual = require(\"deep-equal\");\n\nvar G = secp256k1.G,\n    n = secp256k1.n;\n\nvar PublicKey = function () {\n\n    /** @param {Point} public key */\n    function PublicKey(Q) {\n        _classCallCheck(this, PublicKey);\n\n        this.Q = Q;\n    }\n\n    _createClass(PublicKey, [{\n        key: 'toBuffer',\n        value: function toBuffer() {\n            var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null;\n\n            if (this.Q === null) return new Buffer('000000000000000000000000000000000000000000000000000000000000000000', 'hex');\n            return this.Q.getEncoded(compressed);\n        }\n    }, {\n        key: 'toUncompressed',\n        value: function toUncompressed() {\n            var buf = this.Q.getEncoded(false);\n            var point = Point.decodeFrom(secp256k1, buf);\n            return PublicKey.fromPoint(point);\n        }\n\n        /** bts::blockchain::address (unique but not a full public key) */\n\n    }, {\n        key: 'toBlockchainAddress',\n        value: function toBlockchainAddress() {\n            var pub_buf = this.toBuffer();\n            var pub_sha = hash.sha512(pub_buf);\n            return hash.ripemd160(pub_sha);\n        }\n\n        /** Alias for {@link toPublicKeyString} */\n\n    }, {\n        key: 'toString',\n        value: function toString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix;\n\n            return this.toPublicKeyString(address_prefix);\n        }\n\n        /**\n            Full public key\n            {return} string\n        */\n\n    }, {\n        key: 'toPublicKeyString',\n        value: function toPublicKeyString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix;\n\n            var pub_buf = this.toBuffer();\n            var checksum = hash.ripemd160(pub_buf);\n            // Slice from the buffer directly, slicing from the checksum Uint8array will return the entire array each time.\n            var sliced = new Uint8Array(checksum.buffer.slice(0, 4));\n\n            // concat only accepts buffers so initialize the sliced Uint8array as a Buffer.\n            var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]);\n            return address_prefix + encode(addy);\n        }\n\n        /**\n            @arg {string} public_key - like GPHXyz...\n            @arg {string} address_prefix - like GPH\n            @return PublicKey or `null` (if the public_key string is invalid)\n        */\n\n    }, {\n        key: 'toAddressString',\n        value: function toAddressString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix;\n\n            var pub_buf = this.toBuffer();\n            var pub_sha = hash.sha512(pub_buf);\n            var addy = hash.ripemd160(pub_sha);\n            var checksum = hash.ripemd160(addy);\n            addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n            return address_prefix + encode(addy);\n        }\n    }, {\n        key: 'toPtsAddy',\n        value: function toPtsAddy() {\n            var pub_buf = this.toBuffer();\n            var pub_sha = hash.sha256(pub_buf);\n            var addy = hash.ripemd160(pub_sha);\n            addy = Buffer.concat([new Buffer([0x38]), addy]); //version 56(decimal)\n\n            var checksum = hash.sha256(addy);\n            checksum = hash.sha256(checksum);\n\n            addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n            return encode(addy);\n        }\n    }, {\n        key: 'child',\n        value: function child(offset) {\n\n            assert(Buffer.isBuffer(offset), \"Buffer required: offset\");\n            assert.equal(offset.length, 32, \"offset length\");\n\n            offset = Buffer.concat([this.toBuffer(), offset]);\n            offset = hash.sha256(offset);\n\n            var c = BigInteger.fromBuffer(offset);\n\n            if (c.compareTo(n) >= 0) throw new Error(\"Child offset went out of bounds, try again\");\n\n            var cG = G.multiply(c);\n            var Qprime = this.Q.add(cG);\n\n            if (secp256k1.isInfinity(Qprime)) throw new Error(\"Child offset derived to an invalid key, try again\");\n\n            return PublicKey.fromPoint(Qprime);\n        }\n\n        /* <HEX> */\n\n    }, {\n        key: 'toByteBuffer',\n        value: function toByteBuffer() {\n            var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n            this.appendByteBuffer(b);\n            return b.copy(0, b.offset);\n        }\n    }, {\n        key: 'toHex',\n        value: function toHex() {\n            return this.toBuffer().toString('hex');\n        }\n    }], [{\n        key: 'fromBinary',\n        value: function fromBinary(bin) {\n            return PublicKey.fromBuffer(new Buffer(bin, 'binary'));\n        }\n    }, {\n        key: 'fromBuffer',\n        value: function fromBuffer(buffer) {\n            if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') return new PublicKey(null);\n            return new PublicKey(Point.decodeFrom(secp256k1, buffer));\n        }\n    }, {\n        key: 'fromPoint',\n        value: function fromPoint(point) {\n            return new PublicKey(point);\n        }\n    }, {\n        key: 'fromPublicKeyString',\n        value: function fromPublicKeyString(public_key) {\n            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix;\n\n            try {\n                return PublicKey.fromStringOrThrow(public_key, address_prefix);\n            } catch (e) {\n                return null;\n            }\n        }\n\n        /**\n            @arg {string} public_key - like GPHXyz...\n            @arg {string} address_prefix - like GPH\n            @throws {Error} if public key is invalid\n            @return PublicKey\n        */\n\n    }, {\n        key: 'fromStringOrThrow',\n        value: function fromStringOrThrow(public_key) {\n            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix;\n\n            var prefix = public_key.slice(0, address_prefix.length);\n            assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n            public_key = public_key.slice(address_prefix.length);\n\n            public_key = new Buffer(decode(public_key), 'binary');\n            var checksum = public_key.slice(-4);\n            public_key = public_key.slice(0, -4);\n            var new_checksum = hash.ripemd160(public_key);\n            new_checksum = new_checksum.slice(0, 4);\n            var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum'\n            if (!isEqual) {\n                throw new Error(\"Checksum did not match\");\n            }\n            return PublicKey.fromBuffer(public_key);\n        }\n    }, {\n        key: 'fromHex',\n        value: function fromHex(hex) {\n            return PublicKey.fromBuffer(new Buffer(hex, 'hex'));\n        }\n    }, {\n        key: 'fromPublicKeyStringHex',\n        value: function fromPublicKeyStringHex(hex) {\n            return PublicKey.fromPublicKeyString(new Buffer(hex, 'hex'));\n        }\n\n        /* </HEX> */\n\n    }]);\n\n    return PublicKey;\n}();\n\nmodule.exports = PublicKey;","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar assert = require('assert');\n\nvar _require = require('peerplaysjs-ws'),\n    ChainConfig = _require.ChainConfig;\n\nvar hash = require('./hash');\n\nvar _require2 = require('bs58'),\n    encode = _require2.encode,\n    decode = _require2.decode;\n\nvar deepEqual = require(\"deep-equal\");\n\n/** Addresses are shortened non-reversable hashes of a public key.  The full PublicKey is preferred.\n    @deprecated\n*/\n\nvar Address = function () {\n    function Address(addy) {\n        _classCallCheck(this, Address);\n\n        this.addy = addy;\n    }\n\n    _createClass(Address, [{\n        key: 'toBuffer',\n        value: function toBuffer() {\n            return this.addy;\n        }\n    }, {\n        key: 'toString',\n        value: function toString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix;\n\n            var checksum = hash.ripemd160(this.addy);\n            var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]);\n            return address_prefix + encode(addy);\n        }\n    }], [{\n        key: 'fromBuffer',\n        value: function fromBuffer(buffer) {\n            var _hash = hash.sha512(buffer);\n            var addy = hash.ripemd160(_hash);\n            return new Address(addy);\n        }\n    }, {\n        key: 'fromString',\n        value: function fromString(string) {\n            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix;\n\n            var prefix = string.slice(0, address_prefix.length);\n            assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n            var addy = string.slice(address_prefix.length);\n            addy = new Buffer(decode(addy), 'binary');\n            var checksum = addy.slice(-4);\n            addy = addy.slice(0, -4);\n            var new_checksum = hash.ripemd160(addy);\n            new_checksum = new_checksum.slice(0, 4);\n            var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum'\n            if (!isEqual) {\n                throw new Error(\"Checksum did not match\");\n            }\n            return new Address(addy);\n        }\n    }, {\n        key: 'fromPublic',\n\n\n        /** @return Address - Compressed PTS format (by default) */\n        value: function fromPublic(public_key) {\n            var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n            var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56;\n\n            var sha2 = hash.sha256(public_key.toBuffer(compressed));\n            var rep = hash.ripemd160(sha2);\n            var versionBuffer = new Buffer(1);\n            versionBuffer.writeUInt8(0xFF & version, 0);\n            var addr = Buffer.concat([versionBuffer, rep]);\n            var check = hash.sha256(addr);\n            check = hash.sha256(check);\n            var buffer = Buffer.concat([addr, check.slice(0, 4)]);\n            return new Address(hash.ripemd160(buffer));\n        }\n    }]);\n\n    return Address;\n}();\n\nmodule.exports = Address;","\"use strict\";\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n// https://code.google.com/p/crypto-js\nvar AES = require(\"crypto-js/aes\");\nvar encHex = require(\"crypto-js/enc-hex\");\nvar encBase64 = require(\"crypto-js/enc-base64\");\nvar assert = require(\"assert\");\n\nvar _require = require(\"bytebuffer\"),\n    Long = _require.Long;\n\nvar hash = require('./hash');\n\n/** Provides symetric encrypt and decrypt via AES. */\n\nvar Aes = function () {\n\n    /** @private */\n    function Aes(iv, key) {\n        _classCallCheck(this, Aes);\n\n        this.iv = iv, this.key = key;\n    }\n\n    /** This is an excellent way to ensure that all references to Aes can not operate anymore (example: a wallet becomes locked).  An application should ensure there is only one Aes object instance for a given secret `seed`. */\n\n\n    _createClass(Aes, [{\n        key: \"clear\",\n        value: function clear() {\n            return this.iv = this.key = undefined;\n        }\n\n        /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */\n\n    }, {\n        key: \"_decrypt_word_array\",\n\n\n        /** @private */\n        value: function _decrypt_word_array(cipher) {\n            // https://code.google.com/p/crypto-js/#Custom_Key_and_IV\n            // see wallet_records.cpp master_key::decrypt_key\n            return AES.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv });\n        }\n\n        /** @private */\n\n    }, {\n        key: \"_encrypt_word_array\",\n        value: function _encrypt_word_array(plaintext) {\n            //https://code.google.com/p/crypto-js/issues/detail?id=85\n            var cipher = AES.encrypt(plaintext, this.key, { iv: this.iv });\n            return encBase64.parse(cipher.toString());\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string} ciphertext\n            @return {Buffer} binary\n        */\n\n    }, {\n        key: \"decrypt\",\n        value: function decrypt(ciphertext) {\n            if (typeof ciphertext === \"string\") {\n                ciphertext = new Buffer(ciphertext, 'binary');\n            }\n            if (!Buffer.isBuffer(ciphertext)) {\n                throw new Error(\"buffer required\");\n            }\n            assert(ciphertext, \"Missing cipher text\");\n            // hex is the only common format\n            var hex = this.decryptHex(ciphertext.toString('hex'));\n            return new Buffer(hex, 'hex');\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string} plaintext\n            @return {Buffer} binary\n        */\n\n    }, {\n        key: \"encrypt\",\n        value: function encrypt(plaintext) {\n            if (typeof plaintext === \"string\") {\n                plaintext = new Buffer(plaintext, 'binary');\n            }\n            if (!Buffer.isBuffer(plaintext)) {\n                throw new Error(\"buffer required\");\n            }\n            //assert plaintext, \"Missing plain text\"\n            // hex is the only common format\n            var hex = this.encryptHex(plaintext.toString('hex'));\n            return new Buffer(hex, 'hex');\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string|Buffer} plaintext\n            @return {string} hex\n        */\n\n    }, {\n        key: \"encryptToHex\",\n        value: function encryptToHex(plaintext) {\n            if (typeof plaintext === \"string\") {\n                plaintext = new Buffer(plaintext, 'binary');\n            }\n            if (!Buffer.isBuffer(plaintext)) {\n                throw new Error(\"buffer required\");\n            }\n            //assert plaintext, \"Missing plain text\"\n            // hex is the only common format\n            return this.encryptHex(plaintext.toString('hex'));\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string} cipher - hex\n            @return {string} binary (could easily be readable text)\n        */\n\n    }, {\n        key: \"decryptHex\",\n        value: function decryptHex(cipher) {\n            assert(cipher, \"Missing cipher text\");\n            // Convert data into word arrays (used by Crypto)\n            var cipher_array = encHex.parse(cipher);\n            var plainwords = this._decrypt_word_array(cipher_array);\n            return encHex.stringify(plainwords);\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string} cipher - hex\n            @return {Buffer} encoded as specified by the parameter\n        */\n\n    }, {\n        key: \"decryptHexToBuffer\",\n        value: function decryptHexToBuffer(cipher) {\n            assert(cipher, \"Missing cipher text\");\n            // Convert data into word arrays (used by Crypto)\n            var cipher_array = encHex.parse(cipher);\n            var plainwords = this._decrypt_word_array(cipher_array);\n            var plainhex = encHex.stringify(plainwords);\n            return new Buffer(plainhex, 'hex');\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string} cipher - hex\n            @arg {string} [encoding = 'binary'] - a valid Buffer encoding\n            @return {String} encoded as specified by the parameter\n        */\n\n    }, {\n        key: \"decryptHexToText\",\n        value: function decryptHexToText(cipher) {\n            var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary';\n\n            return this.decryptHexToBuffer(cipher).toString(encoding);\n        }\n\n        /** This method does not use a checksum, the returned data must be validated some other way.\n            @arg {string} plainhex - hex format\n            @return {String} hex\n        */\n\n    }, {\n        key: \"encryptHex\",\n        value: function encryptHex(plainhex) {\n            var plain_array = encHex.parse(plainhex);\n            var cipher_array = this._encrypt_word_array(plain_array);\n            return encHex.stringify(cipher_array);\n        }\n    }], [{\n        key: \"fromSeed\",\n        value: function fromSeed(seed) {\n            if (seed === undefined) {\n                throw new Error(\"seed is required\");\n            }\n            var _hash = hash.sha512(seed);\n            _hash = _hash.toString('hex');\n            // DEBUG console.log('... fromSeed _hash',_hash)\n            return Aes.fromSha512(_hash);\n        }\n    }, {\n        key: \"fromSha512\",\n\n\n        /** @arg {string} hash - A 128 byte hex string, typically one would call {@link fromSeed} instead. */\n        value: function fromSha512(hash) {\n            assert.equal(hash.length, 128, \"A Sha512 in HEX should be 128 characters long, instead got \" + hash.length);\n            var iv = encHex.parse(hash.substring(64, 96));\n            var key = encHex.parse(hash.substring(0, 64));\n            return new Aes(iv, key);\n        }\n    }, {\n        key: \"fromBuffer\",\n        value: function fromBuffer(buf) {\n            assert(Buffer.isBuffer(buf), \"Expecting Buffer\");\n            assert.equal(buf.length, 64, \"A Sha512 Buffer should be 64 characters long, instead got \" + buf.length);\n            return Aes.fromSha512(buf.toString(\"hex\"));\n        }\n        /**\n            @throws {Error} - \"Invalid Key, ...\"\n            @arg {PrivateKey} private_key - required and used for decryption\n            @arg {PublicKey} public_key - required and used to calcualte the shared secret\n            @arg {string} [nonce = \"\"] optional but should always be provided and be unique when re-using the same private/public keys more than once.  This nonce is not a secret.\n            @arg {string|Buffer} message - Encrypted message containing a checksum\n            @return {Buffer}\n        */\n\n    }, {\n        key: \"decrypt_with_checksum\",\n        value: function decrypt_with_checksum(private_key, public_key, nonce, message) {\n            var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n\n            // Warning: Do not put `nonce = \"\"` in the arguments, in es6 this will not convert \"null\" into an emtpy string\n            if (nonce == null) // null or undefined\n                nonce = \"\";\n\n            if (!Buffer.isBuffer(message)) {\n                message = new Buffer(message, 'hex');\n            }\n\n            var S = private_key.get_shared_secret(public_key, legacy);\n            // D E B U G\n            // console.log('decrypt_with_checksum', {\n            //     priv_to_pub: private_key.toPublicKey().toString(),\n            //     pub: public_key.toPublicKeyString(),\n            //     nonce: nonce,\n            //     message: message.length,\n            //     S: S.toString('hex')\n            // })\n\n            var aes = Aes.fromSeed(Buffer.concat([\n            // A null or empty string nonce will not effect the hash\n            new Buffer(\"\" + nonce), new Buffer(S.toString('hex'))]));\n\n            var planebuffer = aes.decrypt(message);\n            if (!(planebuffer.length >= 4)) {\n                throw new Error(\"Invalid key, could not decrypt message(1)\");\n            }\n\n            // DEBUG console.log('... planebuffer',planebuffer)\n            var checksum = planebuffer.slice(0, 4);\n            var plaintext = planebuffer.slice(4);\n\n            // console.log('... checksum',checksum.toString('hex'))\n            // console.log('... plaintext',plaintext.toString())\n\n            var new_checksum = hash.sha256(plaintext);\n            new_checksum = new_checksum.slice(0, 4);\n            new_checksum = new_checksum.toString('hex');\n\n            if (!(checksum.toString('hex') === new_checksum)) {\n                throw new Error(\"Invalid key, could not decrypt message(2)\");\n            }\n\n            return plaintext;\n        }\n    }, {\n        key: \"encrypt_with_checksum\",\n\n\n        /** Identical to {@link decrypt_with_checksum} but used to encrypt.  Should not throw an error.\n            @return {Buffer} message - Encrypted message which includes a checksum\n        */\n        value: function encrypt_with_checksum(private_key, public_key, nonce, message) {\n\n            // Warning: Do not put `nonce = \"\"` in the arguments, in es6 this will not convert \"null\" into an emtpy string\n\n            if (nonce == null) // null or undefined\n                nonce = \"\";\n\n            if (!Buffer.isBuffer(message)) {\n                message = new Buffer(message, 'binary');\n            }\n\n            var S = private_key.get_shared_secret(public_key);\n\n            // D E B U G\n            // console.log('encrypt_with_checksum', {\n            //     priv_to_pub: private_key.toPublicKey().toString()\n            //     pub: public_key.toPublicKeyString()\n            //     nonce: nonce\n            //     message: message.length\n            //     S: S.toString('hex')\n            // })\n\n            var aes = Aes.fromSeed(Buffer.concat([\n            // A null or empty string nonce will not effect the hash\n            new Buffer(\"\" + nonce), new Buffer(S.toString('hex'))]));\n            // DEBUG console.log('... S',S.toString('hex'))\n            var checksum = hash.sha256(message).slice(0, 4);\n            var payload = Buffer.concat([checksum, message]);\n            // DEBUG console.log('... payload',payload.toString())\n            return aes.encrypt(payload);\n        }\n    }]);\n\n    return Aes;\n}();\n\nmodule.exports = Aes;","'use strict';\n\nvar assert = require('assert'); // from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa\nvar crypto = require('./hash');\nvar enforceType = require('./enforce_types');\n\nvar BigInteger = require('bigi');\nvar ECSignature = require('./ecsignature');\n\n// https://tools.ietf.org/html/rfc6979#section-3.2\nfunction deterministicGenerateK(curve, hash, d, checkSig, nonce) {\n\n  enforceType('Buffer', hash);\n  enforceType(BigInteger, d);\n\n  if (nonce) {\n    hash = crypto.sha256(Buffer.concat([hash, new Buffer(nonce)]));\n  }\n\n  // sanity check\n  assert.equal(hash.length, 32, 'Hash must be 256 bit');\n\n  var x = d.toBuffer(32);\n  var k = new Buffer(32);\n  var v = new Buffer(32);\n\n  // Step B\n  v.fill(1);\n\n  // Step C\n  k.fill(0);\n\n  // Step D\n  k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0]), x, hash]), k);\n\n  // Step E\n  v = crypto.HmacSHA256(v, k);\n\n  // Step F\n  k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([1]), x, hash]), k);\n\n  // Step G\n  v = crypto.HmacSHA256(v, k);\n\n  // Step H1/H2a, ignored as tlen === qlen (256 bit)\n  // Step H2b\n  v = crypto.HmacSHA256(v, k);\n\n  var T = BigInteger.fromBuffer(v);\n\n  // Step H3, repeat until T is within the interval [1, n - 1]\n  while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) {\n    k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0])]), k);\n    v = crypto.HmacSHA256(v, k);\n\n    // Step H1/H2a, again, ignored as tlen === qlen (256 bit)\n    // Step H2b again\n    v = crypto.HmacSHA256(v, k);\n\n    T = BigInteger.fromBuffer(v);\n  }\n\n  return T;\n}\n\nfunction sign(curve, hash, d, nonce) {\n\n  var e = BigInteger.fromBuffer(hash);\n  var n = curve.n;\n  var G = curve.G;\n\n  var r, s;\n  var k = deterministicGenerateK(curve, hash, d, function (k) {\n    // find canonically valid signature\n    var Q = G.multiply(k);\n\n    if (curve.isInfinity(Q)) return false;\n\n    r = Q.affineX.mod(n);\n    if (r.signum() === 0) return false;\n\n    s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n);\n    if (s.signum() === 0) return false;\n\n    return true;\n  }, nonce);\n\n  var N_OVER_TWO = n.shiftRight(1);\n\n  // enforce low S values, see bip62: 'low s values in signatures'\n  if (s.compareTo(N_OVER_TWO) > 0) {\n    s = n.subtract(s);\n  }\n\n  return new ECSignature(r, s);\n}\n\nfunction verifyRaw(curve, e, signature, Q) {\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = signature.r;\n  var s = signature.s;\n\n  // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]\n  if (r.signum() <= 0 || r.compareTo(n) >= 0) return false;\n  if (s.signum() <= 0 || s.compareTo(n) >= 0) return false;\n\n  // c = s^-1 mod n\n  var c = s.modInverse(n);\n\n  // 1.4.4 Compute u1 = es^−1 mod n\n  //               u2 = rs^−1 mod n\n  var u1 = e.multiply(c).mod(n);\n  var u2 = r.multiply(c).mod(n);\n\n  // 1.4.5 Compute R = (xR, yR) = u1G + u2Q\n  var R = G.multiplyTwo(u1, Q, u2);\n\n  // 1.4.5 (cont.) Enforce R is not at infinity\n  if (curve.isInfinity(R)) return false;\n\n  // 1.4.6 Convert the field element R.x to an integer\n  var xR = R.affineX;\n\n  // 1.4.7 Set v = xR mod n\n  var v = xR.mod(n);\n\n  // 1.4.8 If v = r, output \"valid\", and if v != r, output \"invalid\"\n  return v.equals(r);\n}\n\nfunction verify(curve, hash, signature, Q) {\n  // 1.4.2 H = Hash(M), already done by the user\n  // 1.4.3 e = H\n  var e = BigInteger.fromBuffer(hash);\n  return verifyRaw(curve, e, signature, Q);\n}\n\n/**\n  * Recover a public key from a signature.\n  *\n  * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, \"Public\n  * Key Recovery Operation\".\n  *\n  * http://www.secg.org/download/aid-780/sec1-v2.pdf\n  */\nfunction recoverPubKey(curve, e, signature, i) {\n  assert.strictEqual(i & 3, i, 'Recovery param is more than two bits');\n\n  var n = curve.n;\n  var G = curve.G;\n\n  var r = signature.r;\n  var s = signature.s;\n\n  assert(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value');\n  assert(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value');\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = i & 1;\n\n  // The more significant bit specifies whether we should use the\n  // first or second candidate key.\n  var isSecondKey = i >> 1;\n\n  // 1.1 Let x = r + jn\n  var x = isSecondKey ? r.add(n) : r;\n  var R = curve.pointFromX(isYOdd, x);\n\n  // 1.4 Check that nR is at infinity\n  var nR = R.multiply(n);\n  assert(curve.isInfinity(nR), 'nR is not a valid curve point');\n\n  // Compute -e from e\n  var eNeg = e.negate().mod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  var rInv = r.modInverse(n);\n\n  var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv);\n  curve.validate(Q);\n\n  return Q;\n}\n\n/**\n  * Calculate pubkey extraction parameter.\n  *\n  * When extracting a pubkey from a signature, we have to\n  * distinguish four different cases. Rather than putting this\n  * burden on the verifier, Bitcoin includes a 2-bit value with the\n  * signature.\n  *\n  * This function simply tries all four cases and returns the value\n  * that resulted in a successful pubkey recovery.\n  */\nfunction calcPubKeyRecoveryParam(curve, e, signature, Q) {\n  for (var i = 0; i < 4; i++) {\n    var Qprime = recoverPubKey(curve, e, signature, i);\n\n    // 1.6.2 Verify Q\n    if (Qprime.equals(Q)) {\n      return i;\n    }\n  }\n\n  throw new Error('Unable to find valid recovery factor');\n}\n\nmodule.exports = {\n  calcPubKeyRecoveryParam: calcPubKeyRecoveryParam,\n  deterministicGenerateK: deterministicGenerateK,\n  recoverPubKey: recoverPubKey,\n  sign: sign,\n  verify: verify,\n  verifyRaw: verifyRaw\n};","'use strict';\n\nvar assert = require('assert'); // from https://github.com/bitcoinjs/bitcoinjs-lib\nvar enforceType = require('./enforce_types');\n\nvar BigInteger = require('bigi');\n\nfunction ECSignature(r, s) {\n  enforceType(BigInteger, r);\n  enforceType(BigInteger, s);\n\n  this.r = r;\n  this.s = s;\n}\n\n// Import operations\nECSignature.parseCompact = function (buffer) {\n  assert.equal(buffer.length, 65, 'Invalid signature length');\n  var i = buffer.readUInt8(0) - 27;\n\n  // At most 3 bits\n  assert.equal(i, i & 7, 'Invalid signature parameter');\n  var compressed = !!(i & 4);\n\n  // Recovery param only\n  i = i & 3;\n\n  var r = BigInteger.fromBuffer(buffer.slice(1, 33));\n  var s = BigInteger.fromBuffer(buffer.slice(33));\n\n  return {\n    compressed: compressed,\n    i: i,\n    signature: new ECSignature(r, s)\n  };\n};\n\nECSignature.fromDER = function (buffer) {\n  assert.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence');\n  assert.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length');\n  assert.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer');\n\n  var rLen = buffer.readUInt8(3);\n  assert(rLen > 0, 'R length is zero');\n\n  var offset = 4 + rLen;\n  assert.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)');\n\n  var sLen = buffer.readUInt8(offset + 1);\n  assert(sLen > 0, 'S length is zero');\n\n  var rB = buffer.slice(4, offset);\n  var sB = buffer.slice(offset + 2);\n  offset += 2 + sLen;\n\n  if (rLen > 1 && rB.readUInt8(0) === 0x00) {\n    assert(rB.readUInt8(1) & 0x80, 'R value excessively padded');\n  }\n\n  if (sLen > 1 && sB.readUInt8(0) === 0x00) {\n    assert(sB.readUInt8(1) & 0x80, 'S value excessively padded');\n  }\n\n  assert.equal(offset, buffer.length, 'Invalid DER encoding');\n  var r = BigInteger.fromDERInteger(rB);\n  var s = BigInteger.fromDERInteger(sB);\n\n  assert(r.signum() >= 0, 'R value is negative');\n  assert(s.signum() >= 0, 'S value is negative');\n\n  return new ECSignature(r, s);\n};\n\n// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, importing Transaction causes a circular dependency\nECSignature.parseScriptSignature = function (buffer) {\n  var hashType = buffer.readUInt8(buffer.length - 1);\n  var hashTypeMod = hashType & ~0x80;\n\n  assert(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType');\n\n  return {\n    signature: ECSignature.fromDER(buffer.slice(0, -1)),\n    hashType: hashType\n  };\n};\n\n// Export operations\nECSignature.prototype.toCompact = function (i, compressed) {\n  if (compressed) i += 4;\n  i += 27;\n\n  var buffer = new Buffer(65);\n  buffer.writeUInt8(i, 0);\n\n  this.r.toBuffer(32).copy(buffer, 1);\n  this.s.toBuffer(32).copy(buffer, 33);\n\n  return buffer;\n};\n\nECSignature.prototype.toDER = function () {\n  var rBa = this.r.toDERInteger();\n  var sBa = this.s.toDERInteger();\n\n  var sequence = [];\n\n  // INTEGER\n  sequence.push(0x02, rBa.length);\n  sequence = sequence.concat(rBa);\n\n  // INTEGER\n  sequence.push(0x02, sBa.length);\n  sequence = sequence.concat(sBa);\n\n  // SEQUENCE\n  sequence.unshift(0x30, sequence.length);\n\n  return new Buffer(sequence);\n};\n\nECSignature.prototype.toScriptSignature = function (hashType) {\n  var hashTypeBuffer = new Buffer(1);\n  hashTypeBuffer.writeUInt8(hashType, 0);\n\n  return Buffer.concat([this.toDER(), hashTypeBuffer]);\n};\n\nmodule.exports = ECSignature;","'use strict';\n\nmodule.exports = function enforce(type, value) {\n  // Copied from https://github.com/bitcoinjs/bitcoinjs-lib\n  switch (type) {\n    case 'Array':\n      {\n        if (Array.isArray(value)) return;\n        break;\n      }\n\n    case 'Boolean':\n      {\n        if (typeof value === 'boolean') return;\n        break;\n      }\n\n    case 'Buffer':\n      {\n        if (Buffer.isBuffer(value)) return;\n        break;\n      }\n\n    case 'Number':\n      {\n        if (typeof value === 'number') return;\n        break;\n      }\n\n    case 'String':\n      {\n        if (typeof value === 'string') return;\n        break;\n      }\n\n    default:\n      {\n        if (getName(value.constructor) === getName(type)) return;\n      }\n  }\n\n  throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value);\n};\n\nfunction getName(fn) {\n  // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property\n  var match = fn.toString().match(/function (.*?)\\(/);\n  return match ? match[1] : null;\n}","\"use strict\";\n\nvar createHash = require(\"create-hash\");\nvar createHmac = require(\"create-hmac\");\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha1(data, encoding) {\n    return createHash('sha1').update(data).digest(encoding);\n}\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha256(data, encoding) {\n    return createHash('sha256').update(data).digest(encoding);\n}\n\n/** @arg {string|Buffer} data\n    @arg {string} [digest = null] - 'hex', 'binary' or 'base64'\n    @return {string|Buffer} - Buffer when digest is null, or string\n*/\nfunction sha512(data, encoding) {\n    return createHash('sha512').update(data).digest(encoding);\n}\n\nfunction HmacSHA256(buffer, secret) {\n    return createHmac('sha256', secret).update(buffer).digest();\n}\n\nfunction ripemd160(data) {\n    return createHash('rmd160').update(data).digest();\n}\n\n// function hash160(buffer) {\n//   return ripemd160(sha256(buffer))\n// }\n//\n// function hash256(buffer) {\n//   return sha256(sha256(buffer))\n// }\n\n//\n// function HmacSHA512(buffer, secret) {\n//   return crypto.createHmac('sha512', secret).update(buffer).digest()\n// }\n\nmodule.exports = {\n    sha1: sha1,\n    sha256: sha256,\n    sha512: sha512,\n    HmacSHA256: HmacSHA256,\n    ripemd160: ripemd160\n    // hash160: hash160,\n    // hash256: hash256,\n    // HmacSHA512: HmacSHA512\n};","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ecdsa = require('./ecdsa');\nvar hash = require('./hash');\n\nvar _require = require('ecurve'),\n    getCurveByName = _require.getCurveByName;\n\nvar secp256k1 = getCurveByName('secp256k1');\nvar assert = require('assert');\nvar BigInteger = require('bigi');\nvar PublicKey = require('./PublicKey');\n\nvar Signature = function () {\n    function Signature(r1, s1, i1) {\n        _classCallCheck(this, Signature);\n\n        this.r = r1;\n        this.s = s1;\n        this.i = i1;\n        assert.equal(this.r != null, true, 'Missing parameter');\n        assert.equal(this.s != null, true, 'Missing parameter');\n        assert.equal(this.i != null, true, 'Missing parameter');\n    }\n\n    _createClass(Signature, [{\n        key: 'toBuffer',\n        value: function toBuffer() {\n            var buf;\n            buf = new Buffer(65);\n            buf.writeUInt8(this.i, 0);\n            this.r.toBuffer(32).copy(buf, 1);\n            this.s.toBuffer(32).copy(buf, 33);\n            return buf;\n        }\n    }, {\n        key: 'recoverPublicKeyFromBuffer',\n        value: function recoverPublicKeyFromBuffer(buffer) {\n            return this.recoverPublicKey(hash.sha256(buffer));\n        }\n    }, {\n        key: 'recoverPublicKey',\n\n\n        /**\n            @return {PublicKey}\n        */\n        value: function recoverPublicKey(sha256_buffer) {\n            var Q = void 0,\n                e = void 0,\n                i = void 0;\n            e = BigInteger.fromBuffer(sha256_buffer);\n            i = this.i;\n            i -= 27;\n            i = i & 3;\n            Q = ecdsa.recoverPubKey(secp256k1, e, this, i);\n            return PublicKey.fromPoint(Q);\n        }\n    }, {\n        key: 'verifyBuffer',\n\n\n        /**\n            @param {Buffer} un-hashed\n            @param {./PublicKey}\n            @return {boolean}\n        */\n        value: function verifyBuffer(buf, public_key) {\n            var _hash = hash.sha256(buf);\n            return this.verifyHash(_hash, public_key);\n        }\n    }, {\n        key: 'verifyHash',\n        value: function verifyHash(hash, public_key) {\n            assert.equal(hash.length, 32, \"A SHA 256 should be 32 bytes long, instead got \" + hash.length);\n            return ecdsa.verify(secp256k1, hash, {\n                r: this.r,\n                s: this.s\n            }, public_key.Q);\n        }\n    }, {\n        key: 'toByteBuffer',\n\n\n        /* <HEX> */\n\n        value: function toByteBuffer() {\n            var b;\n            b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n            this.appendByteBuffer(b);\n            return b.copy(0, b.offset);\n        }\n    }, {\n        key: 'toHex',\n        value: function toHex() {\n            return this.toBuffer().toString(\"hex\");\n        }\n    }, {\n        key: 'verifyHex',\n        value: function verifyHex(hex, public_key) {\n            var buf;\n            buf = new Buffer(hex, 'hex');\n            return this.verifyBuffer(buf, public_key);\n        }\n    }], [{\n        key: 'fromBuffer',\n        value: function fromBuffer(buf) {\n            var i, r, s;\n            assert.equal(buf.length, 65, 'Invalid signature length');\n            i = buf.readUInt8(0);\n            assert.equal(i - 27, i - 27 & 7, 'Invalid signature parameter');\n            r = BigInteger.fromBuffer(buf.slice(1, 33));\n            s = BigInteger.fromBuffer(buf.slice(33));\n            return new Signature(r, s, i);\n        }\n    }, {\n        key: 'signBuffer',\n\n\n        /**\n            @param {Buffer} buf\n            @param {PrivateKey} private_key\n            @return {Signature}\n        */\n        value: function signBuffer(buf, private_key) {\n            var _hash = hash.sha256(buf);\n            return Signature.signBufferSha256(_hash, private_key);\n        }\n\n        /** Sign a buffer of exactally 32 bytes in size (sha256(text))\n            @param {Buffer} buf - 32 bytes binary\n            @param {PrivateKey} private_key\n            @return {Signature}\n        */\n\n    }, {\n        key: 'signBufferSha256',\n        value: function signBufferSha256(buf_sha256, private_key) {\n            if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error(\"buf_sha256: 32 byte buffer requred\");\n            var der, e, ecsignature, i, lenR, lenS, nonce;\n            i = null;\n            nonce = 0;\n            e = BigInteger.fromBuffer(buf_sha256);\n            while (true) {\n                ecsignature = ecdsa.sign(secp256k1, buf_sha256, private_key.d, nonce++);\n                der = ecsignature.toDER();\n                lenR = der[3];\n                lenS = der[5 + lenR];\n                if (lenR === 32 && lenS === 32) {\n                    i = ecdsa.calcPubKeyRecoveryParam(secp256k1, e, ecsignature, private_key.toPublicKey().Q);\n                    i += 4; // compressed\n                    i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)\n                    break;\n                }\n                if (nonce % 10 === 0) {\n                    console.log(\"WARN: \" + nonce + \" attempts to find canonical signature\");\n                }\n            }\n            return new Signature(ecsignature.r, ecsignature.s, i);\n        }\n    }, {\n        key: 'sign',\n        value: function sign(string, private_key) {\n            return Signature.signBuffer(new Buffer(string), private_key);\n        }\n    }, {\n        key: 'fromHex',\n        value: function fromHex(hex) {\n            return Signature.fromBuffer(new Buffer(hex, \"hex\"));\n        }\n    }, {\n        key: 'signHex',\n        value: function signHex(hex, private_key) {\n            var buf;\n            buf = new Buffer(hex, 'hex');\n            return Signature.signBuffer(buf, private_key);\n        }\n    }]);\n\n    return Signature;\n}();\n\nmodule.exports = Signature;","'use strict';\n\nmodule.exports = {\n\n    // Primary class for creating operations\n    Serializer: require('./src/serializer'),\n\n    // helper functions for creating operations\n    fp: require('./src/FastParser'),\n\n    // Low level types\n    types: require('./src/types'),\n\n    // Higher level operations (made out of generic types)\n    ops: require('./src/operations'),\n\n    // Utility that generates JSON examples\n    template: require('./src/template'),\n\n    // Serializer validation\n    SerializerValidation: require('./src/SerializerValidation')\n};","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar PublicKey = require(\"../../ecc/src/PublicKey\");\n\nvar FastParser = function () {\n    function FastParser() {\n        _classCallCheck(this, FastParser);\n    }\n\n    _createClass(FastParser, null, [{\n        key: 'fixed_data',\n        value: function fixed_data(b, len, buffer) {\n            if (!b) {\n                return;\n            }\n            if (buffer) {\n                var data = buffer.slice(0, len).toString('binary');\n                b.append(data, 'binary');\n                while (len-- > data.length) {\n                    b.writeUint8(0);\n                }\n            } else {\n                var b_copy = b.copy(b.offset, b.offset + len);\n                b.skip(len);\n                return new Buffer(b_copy.toBinary(), 'binary');\n            }\n        }\n    }, {\n        key: 'public_key',\n        value: function public_key(b, _public_key) {\n            if (!b) {\n                return;\n            }\n            if (_public_key) {\n                var buffer = _public_key.toBuffer();\n                b.append(buffer.toString('binary'), 'binary');\n                return;\n            } else {\n                buffer = FastParser.fixed_data(b, 33);\n                return PublicKey.fromBuffer(buffer);\n            }\n        }\n    }, {\n        key: 'ripemd160',\n        value: function ripemd160(b, _ripemd) {\n            if (!b) {\n                return;\n            }\n            if (_ripemd) {\n                FastParser.fixed_data(b, 20, _ripemd);\n                return;\n            } else {\n                return FastParser.fixed_data(b, 20);\n            }\n        }\n    }, {\n        key: 'sha256',\n        value: function sha256(b, _sha) {\n            if (!b) {\n                return;\n            }\n            if (_sha) {\n                FastParser.fixed_data(b, 32, _sha);\n                return;\n            } else {\n                return FastParser.fixed_data(b, 32);\n            }\n        }\n    }, {\n        key: 'time_point_sec',\n        value: function time_point_sec(b, epoch) {\n            if (epoch) {\n                epoch = Math.ceil(epoch / 1000);\n                b.writeInt32(epoch);\n                return;\n            } else {\n                epoch = b.readInt32(); // fc::time_point_sec\n                return new Date(epoch * 1000);\n            }\n        }\n    }]);\n\n    return FastParser;\n}();\n\nmodule.exports = FastParser;","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _require = require('bytebuffer'),\n    Long = _require.Long;\n\nvar ChainTypes = require('../../chain/src/ChainTypes');\n\nvar MAX_SAFE_INT = 9007199254740991;\nvar MIN_SAFE_INT = -9007199254740991;\n\n/**\n    Most validations are skipped and the value returned unchanged when an empty string, null, or undefined is encountered (except \"required\").\n\n    Validations support a string format for dealing with large numbers.\n*/\nvar _my = {\n\n    is_empty: function is_empty(value) {\n        return value === null || value === undefined;\n    },\n\n    required: function required(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            throw new Error('value required ' + field_name + ' ' + value);\n        }\n        return value;\n    },\n    require_long: function require_long(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (!Long.isLong(value)) {\n            throw new Error('Long value required ' + field_name + ' ' + value);\n        }\n        return value;\n    },\n    string: function string(value) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (typeof value !== \"string\") {\n            throw new Error('string required: ' + value);\n        }\n        return value;\n    },\n    number: function number(value) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (typeof value !== \"number\") {\n            throw new Error('number required: ' + value);\n        }\n        return value;\n    },\n    whole_number: function whole_number(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (/\\./.test(value)) {\n            throw new Error('whole number required ' + field_name + ' ' + value);\n        }\n        return value;\n    },\n    unsigned: function unsigned(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (/-/.test(value)) {\n            throw new Error('unsigned required ' + field_name + ' ' + value);\n        }\n        return value;\n    },\n\n\n    is_digits: function is_digits(value) {\n        if (typeof value === \"numeric\") {\n            return true;\n        }\n        return (/^[0-9]+$/.test(value)\n        );\n    },\n\n    to_number: function to_number(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        this.no_overflow53(value, field_name);\n        var int_value = function () {\n            if (typeof value === \"number\") {\n                return value;\n            } else {\n                return parseInt(value);\n            }\n        }();\n        return int_value;\n    },\n\n    to_long: function to_long(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (Long.isLong(value)) {\n            return value;\n        }\n\n        this.no_overflow64(value, field_name);\n        if (typeof value === \"number\") {\n            value = \"\" + value;\n        }\n        return Long.fromString(value);\n    },\n    to_ulong: function to_ulong(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (Long.isLong(value)) {\n            return value;\n        }\n\n        this.no_overflow64(value, field_name, true);\n        if (typeof value === \"number\") {\n            value = \"\" + value;\n        }\n        return Long.fromString(value, true);\n    },\n    to_string: function to_string(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (typeof value === \"string\") {\n            return value;\n        }\n        if (typeof value === \"number\") {\n            this.no_overflow53(value, field_name);\n            return \"\" + value;\n        }\n        if (Long.isLong(value)) {\n            return value.toString();\n        }\n        throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value;\n    },\n    require_test: function require_test(regex, value) {\n        var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        if (!regex.test(value)) {\n            throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value);\n        }\n        return value;\n    },\n\n\n    require_match: function require_match(regex, value) {\n        var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        var match = value.match(regex);\n        if (match === null) {\n            throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value);\n        }\n        return match;\n    },\n\n    require_object_id: function require_object_id(value, field_name) {\n        return require_match(/^([0-9]+)\\.([0-9]+)\\.([0-9]+)$/, value, field_name);\n    },\n\n    // Does not support over 53 bits\n    require_range: function require_range(min, max, value) {\n        var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        var number = this.to_number(value);\n        if (value < min || value > max) {\n            throw new Error('out of range ' + value + ' ' + field_name + ' ' + value);\n        }\n        return value;\n    },\n\n\n    require_object_type: function require_object_type() {\n        var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;\n        var type = arguments[1];\n        var value = arguments[2];\n        var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : \"\";\n\n        if (this.is_empty(value)) {\n            return value;\n        }\n        var object_type = ChainTypes.object_type[type];\n        if (!object_type) {\n            throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value);\n        }\n        var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$');\n        if (!re.test(value)) {\n            throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value));\n        }\n        return value;\n    },\n\n    get_instance: function get_instance(reserve_spaces, type, value, field_name) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        this.require_object_type(reserve_spaces, type, value, field_name);\n        return this.to_number(value.split('.')[2]);\n    },\n\n    require_relative_type: function require_relative_type(type, value, field_name) {\n        this.require_object_type(0, type, value, field_name);\n        return value;\n    },\n\n    get_relative_instance: function get_relative_instance(type, value, field_name) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        this.require_object_type(0, type, value, field_name);\n        return this.to_number(value.split('.')[2]);\n    },\n\n    require_protocol_type: function require_protocol_type(type, value, field_name) {\n        this.require_object_type(1, type, value, field_name);\n        return value;\n    },\n\n    get_protocol_instance: function get_protocol_instance(type, value, field_name) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        this.require_object_type(1, type, value, field_name);\n        return this.to_number(value.split('.')[2]);\n    },\n\n    get_protocol_type: function get_protocol_type(value, field_name) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        this.require_object_id(value, field_name);\n        var values = value.split('.');\n        return this.to_number(values[1]);\n    },\n\n    get_protocol_type_name: function get_protocol_type_name(value, field_name) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        var type_id = this.get_protocol_type(value, field_name);\n        return Object.keys(ChainTypes.object_type)[type_id];\n    },\n\n\n    require_implementation_type: function require_implementation_type(type, value, field_name) {\n        this.require_object_type(2, type, value, field_name);\n        return value;\n    },\n\n    get_implementation_instance: function get_implementation_instance(type, value, field_name) {\n        if (this.is_empty(value)) {\n            return value;\n        }\n        this.require_object_type(2, type, value, field_name);\n        return this.to_number(value.split('.')[2]);\n    },\n\n    // signed / unsigned decimal\n    no_overflow53: function no_overflow53(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n\n        if (typeof value === \"number\") {\n            if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n                throw new Error('overflow ' + field_name + ' ' + value);\n            }\n            return;\n        }\n        if (typeof value === \"string\") {\n            var int = parseInt(value);\n            if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n                throw new Error('overflow ' + field_name + ' ' + value);\n            }\n            return;\n        }\n        if (Long.isLong(value)) {\n            // typeof value.toInt() is 'number'\n            this.no_overflow53(value.toInt(), field_name);\n            return;\n        }\n        throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value;\n    },\n\n\n    // signed / unsigned whole numbers only\n    no_overflow64: function no_overflow64(value) {\n        var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n        var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n        // https://github.com/dcodeIO/Long.js/issues/20\n        if (Long.isLong(value)) {\n            return;\n        }\n\n        // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20\n        if (value.t !== undefined && value.s !== undefined) {\n            this.no_overflow64(value.toString(), field_name, unsigned);\n\n            return;\n        }\n\n        if (typeof value === \"string\") {\n            // remove leading zeros, will cause a false positive\n            value = value.replace(/^0+/, '');\n            // remove trailing zeros\n            while (/0$/.test(value)) {\n                value = value.substring(0, value.length - 1);\n            }\n            if (/\\.$/.test(value)) {\n                // remove trailing dot\n                value = value.substring(0, value.length - 1);\n            }\n            if (value === \"\") {\n                value = \"0\";\n            }\n\n            var long_string = Long.fromString(value, unsigned).toString();\n\n            if (long_string !== value.trim()) {\n                throw new Error('overflow ' + field_name + ' ' + value);\n            }\n            return;\n        }\n        if (typeof value === \"number\") {\n            if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) {\n                throw new Error('overflow ' + field_name + ' ' + value);\n            }\n            return;\n        }\n\n        throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value;\n    }\n};\n\nmodule.exports = _my;","\"use strict\";\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** Exception nesting.  */\nvar ErrorWithCause = function () {\n    function ErrorWithCause(message, cause) {\n        _classCallCheck(this, ErrorWithCause);\n\n        this.message = message;\n        if (typeof cause !== \"undefined\" && cause !== null ? cause.message : undefined) {\n            this.message = \"cause\\t\" + cause.message + \"\\t\" + this.message;\n        }\n\n        var stack = \"\"; //(new Error).stack\n        if (typeof cause !== \"undefined\" && cause !== null ? cause.stack : undefined) {\n            stack = \"caused by\\n\\t\" + cause.stack + \"\\t\" + stack;\n        }\n\n        this.stack = this.message + \"\\n\" + stack;\n    }\n\n    _createClass(ErrorWithCause, null, [{\n        key: \"throw\",\n        value: function _throw(message, cause) {\n            var msg = message;\n            if (typeof cause !== \"undefined\" && cause !== null ? cause.message : undefined) {\n                msg += \"\\t cause: \" + cause.message + \" \";\n            }\n            if (typeof cause !== \"undefined\" && cause !== null ? cause.stack : undefined) {\n                msg += \"\\n stack: \" + cause.stack + \" \";\n            }\n            throw new Error(msg);\n        }\n    }]);\n\n    return ErrorWithCause;\n}();\n\nmodule.exports = ErrorWithCause;","\"use strict\";\n\nvar types = require(\"./types\");\nvar SerializerImpl = require(\"./serializer\");\n\nvar uint8 = types.uint8,\n    uint16 = types.uint16,\n    uint32 = types.uint32,\n    int64 = types.int64,\n    uint64 = types.uint64,\n    string = types.string,\n    bytes = types.bytes,\n    bool = types.bool,\n    array = types.array,\n    fixed_array = types.fixed_array,\n    protocol_id_type = types.protocol_id_type,\n    object_id_type = types.object_id_type,\n    vote_id = types.vote_id,\n    future_extensions = types.future_extensions,\n    static_variant = types.static_variant,\n    map = types.map,\n    set = types.set,\n    public_key = types.public_key,\n    address = types.address,\n    time_point_sec = types.time_point_sec,\n    optional = types.optional,\n    variant = types.variant,\n    variant_object = types.variant_object,\n    enumeration = types.enumeration,\n    sha256 = types.sha256;\n\n\nfuture_extensions = types.void;\n\n/*\nWhen updating generated code\nReplace:  operation = static_variant [\nwith:     operation.st_operations = [\n\nDelete:\npublic_key = new Serializer( \n    \"public_key\"\n    key_data: bytes 33\n)\n\n*/\n// Place-holder, their are dependencies on \"operation\" .. The final list of\n// operations is not avialble until the very end of the generated code.\n// See: operation.st_operations = ...\nvar operation = static_variant();\nmodule.exports[\"operation\"] = operation;\n\n// For module.exports\nvar Serializer = function Serializer(operation_name, serilization_types_object) {\n    var s = new SerializerImpl(operation_name, serilization_types_object);\n    return module.exports[operation_name] = s;\n};\n\n// Custom-types follow Generated code:\n\n// ##  Generated code follows\n// # programs/js_operation_serializer > npm i -g decaffeinate\n// ## -------------------------------\nvar transfer_operation_fee_parameters = new Serializer(\"transfer_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar limit_order_create_operation_fee_parameters = new Serializer(\"limit_order_create_operation_fee_parameters\", { fee: uint64 });\n\nvar limit_order_cancel_operation_fee_parameters = new Serializer(\"limit_order_cancel_operation_fee_parameters\", { fee: uint64 });\n\nvar call_order_update_operation_fee_parameters = new Serializer(\"call_order_update_operation_fee_parameters\", { fee: uint64 });\n\nvar fill_order_operation_fee_parameters = new Serializer(\"fill_order_operation_fee_parameters\");\n\nvar account_create_operation_fee_parameters = new Serializer(\"account_create_operation_fee_parameters\", { basic_fee: uint64,\n    premium_fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar account_update_operation_fee_parameters = new Serializer(\"account_update_operation_fee_parameters\", { fee: int64,\n    price_per_kbyte: uint32 });\n\nvar account_whitelist_operation_fee_parameters = new Serializer(\"account_whitelist_operation_fee_parameters\", { fee: int64 });\n\nvar account_upgrade_operation_fee_parameters = new Serializer(\"account_upgrade_operation_fee_parameters\", { membership_annual_fee: uint64,\n    membership_lifetime_fee: uint64 });\n\nvar account_transfer_operation_fee_parameters = new Serializer(\"account_transfer_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_create_operation_fee_parameters = new Serializer(\"asset_create_operation_fee_parameters\", { symbol3: uint64,\n    symbol4: uint64,\n    long_symbol: uint64,\n    price_per_kbyte: uint32 });\n\nvar asset_update_operation_fee_parameters = new Serializer(\"asset_update_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar asset_update_bitasset_operation_fee_parameters = new Serializer(\"asset_update_bitasset_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_update_feed_producers_operation_fee_parameters = new Serializer(\"asset_update_feed_producers_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_issue_operation_fee_parameters = new Serializer(\"asset_issue_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar asset_reserve_operation_fee_parameters = new Serializer(\"asset_reserve_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_fund_fee_pool_operation_fee_parameters = new Serializer(\"asset_fund_fee_pool_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_settle_operation_fee_parameters = new Serializer(\"asset_settle_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_global_settle_operation_fee_parameters = new Serializer(\"asset_global_settle_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_publish_feed_operation_fee_parameters = new Serializer(\"asset_publish_feed_operation_fee_parameters\", { fee: uint64 });\n\nvar witness_create_operation_fee_parameters = new Serializer(\"witness_create_operation_fee_parameters\", { fee: uint64 });\n\nvar witness_update_operation_fee_parameters = new Serializer(\"witness_update_operation_fee_parameters\", { fee: int64 });\n\nvar proposal_create_operation_fee_parameters = new Serializer(\"proposal_create_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar proposal_update_operation_fee_parameters = new Serializer(\"proposal_update_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar proposal_delete_operation_fee_parameters = new Serializer(\"proposal_delete_operation_fee_parameters\", { fee: uint64 });\n\nvar withdraw_permission_create_operation_fee_parameters = new Serializer(\"withdraw_permission_create_operation_fee_parameters\", { fee: uint64 });\n\nvar withdraw_permission_update_operation_fee_parameters = new Serializer(\"withdraw_permission_update_operation_fee_parameters\", { fee: uint64 });\n\nvar withdraw_permission_claim_operation_fee_parameters = new Serializer(\"withdraw_permission_claim_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar withdraw_permission_delete_operation_fee_parameters = new Serializer(\"withdraw_permission_delete_operation_fee_parameters\", { fee: uint64 });\n\nvar committee_member_create_operation_fee_parameters = new Serializer(\"committee_member_create_operation_fee_parameters\", { fee: uint64 });\n\nvar committee_member_update_operation_fee_parameters = new Serializer(\"committee_member_update_operation_fee_parameters\", { fee: uint64 });\n\nvar committee_member_update_global_parameters_operation_fee_parameters = new Serializer(\"committee_member_update_global_parameters_operation_fee_parameters\", { fee: uint64 });\n\nvar vesting_balance_create_operation_fee_parameters = new Serializer(\"vesting_balance_create_operation_fee_parameters\", { fee: uint64 });\n\nvar vesting_balance_withdraw_operation_fee_parameters = new Serializer(\"vesting_balance_withdraw_operation_fee_parameters\", { fee: uint64 });\n\nvar worker_create_operation_fee_parameters = new Serializer(\"worker_create_operation_fee_parameters\", { fee: uint64 });\n\nvar custom_operation_fee_parameters = new Serializer(\"custom_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar assert_operation_fee_parameters = new Serializer(\"assert_operation_fee_parameters\", { fee: uint64 });\n\nvar balance_claim_operation_fee_parameters = new Serializer(\"balance_claim_operation_fee_parameters\");\n\nvar override_transfer_operation_fee_parameters = new Serializer(\"override_transfer_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar transfer_to_blind_operation_fee_parameters = new Serializer(\"transfer_to_blind_operation_fee_parameters\", { fee: uint64,\n    price_per_output: uint32 });\n\nvar blind_transfer_operation_fee_parameters = new Serializer(\"blind_transfer_operation_fee_parameters\", { fee: uint64,\n    price_per_output: uint32 });\n\nvar transfer_from_blind_operation_fee_parameters = new Serializer(\"transfer_from_blind_operation_fee_parameters\", { fee: uint64 });\n\nvar asset_settle_cancel_operation_fee_parameters = new Serializer(\"asset_settle_cancel_operation_fee_parameters\");\n\nvar asset_claim_fees_operation_fee_parameters = new Serializer(\"asset_claim_fees_operation_fee_parameters\", { fee: uint64 });\n\nvar fba_distribute_operation_fee_parameters = new Serializer(\"fba_distribute_operation_fee_parameters\", {});\n\nvar tournament_create_operation_fee_parameters = new Serializer(\"tournament_create_operation_fee_parameters\", { fee: uint64,\n    price_per_kbyte: uint32 });\n\nvar tournament_join_operation_fee_parameters = new Serializer(\"tournament_join_operation_fee_parameters\", { fee: uint64 });\n\nvar fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters]);\n\nvar fee_schedule = new Serializer(\"fee_schedule\", { parameters: set(fee_parameters),\n    scale: uint32 });\n\nvar void_result = new Serializer(\"void_result\");\n\nvar asset = new Serializer(\"asset\", { amount: int64,\n    asset_id: protocol_id_type(\"asset\") });\n\nvar operation_result = static_variant([void_result, object_id_type, asset]);\n\nvar processed_transaction = new Serializer(\"processed_transaction\", { ref_block_num: uint16,\n    ref_block_prefix: uint32,\n    expiration: time_point_sec,\n    operations: array(operation),\n    extensions: set(future_extensions),\n    signatures: array(bytes(65)),\n    operation_results: array(operation_result) });\n\nvar signed_block = new Serializer(\"signed_block\", { previous: bytes(20),\n    timestamp: time_point_sec,\n    witness: protocol_id_type(\"witness\"),\n    transaction_merkle_root: bytes(20),\n    extensions: set(future_extensions),\n    witness_signature: bytes(65),\n    transactions: array(processed_transaction) });\n\nvar block_header = new Serializer(\"block_header\", { previous: bytes(20),\n    timestamp: time_point_sec,\n    witness: protocol_id_type(\"witness\"),\n    transaction_merkle_root: bytes(20),\n    extensions: set(future_extensions) });\n\nvar signed_block_header = new Serializer(\"signed_block_header\", { previous: bytes(20),\n    timestamp: time_point_sec,\n    witness: protocol_id_type(\"witness\"),\n    transaction_merkle_root: bytes(20),\n    extensions: set(future_extensions),\n    witness_signature: bytes(65) });\n\nvar memo_data = new Serializer(\"memo_data\", { from: public_key,\n    to: public_key,\n    nonce: uint64,\n    message: bytes() });\n\nvar transfer = new Serializer(\"transfer\", { fee: asset,\n    from: protocol_id_type(\"account\"),\n    to: protocol_id_type(\"account\"),\n    amount: asset,\n    memo: optional(memo_data),\n    extensions: set(future_extensions) });\n\nvar limit_order_create = new Serializer(\"limit_order_create\", { fee: asset,\n    seller: protocol_id_type(\"account\"),\n    amount_to_sell: asset,\n    min_to_receive: asset,\n    expiration: time_point_sec,\n    fill_or_kill: bool,\n    extensions: set(future_extensions) });\n\nvar limit_order_cancel = new Serializer(\"limit_order_cancel\", { fee: asset,\n    fee_paying_account: protocol_id_type(\"account\"),\n    order: protocol_id_type(\"limit_order\"),\n    extensions: set(future_extensions) });\n\nvar call_order_update = new Serializer(\"call_order_update\", { fee: asset,\n    funding_account: protocol_id_type(\"account\"),\n    delta_collateral: asset,\n    delta_debt: asset,\n    extensions: set(future_extensions) });\n\nvar fill_order = new Serializer(\"fill_order\", { fee: asset,\n    order_id: object_id_type,\n    account_id: protocol_id_type(\"account\"),\n    pays: asset,\n    receives: asset });\n\nvar authority = new Serializer(\"authority\", { weight_threshold: uint32,\n    account_auths: map(protocol_id_type(\"account\"), uint16),\n    key_auths: map(public_key, uint16),\n    address_auths: map(address, uint16) });\n\nvar account_options = new Serializer(\"account_options\", { memo_key: public_key,\n    voting_account: protocol_id_type(\"account\"),\n    num_witness: uint16,\n    num_committee: uint16,\n    votes: set(vote_id),\n    extensions: set(future_extensions) });\n\nvar account_create = new Serializer(\"account_create\", { fee: asset,\n    registrar: protocol_id_type(\"account\"),\n    referrer: protocol_id_type(\"account\"),\n    referrer_percent: uint16,\n    name: string,\n    owner: authority,\n    active: authority,\n    options: account_options,\n    extensions: set(future_extensions) });\n\nvar account_update = new Serializer(\"account_update\", { fee: asset,\n    account: protocol_id_type(\"account\"),\n    owner: optional(authority),\n    active: optional(authority),\n    new_options: optional(account_options),\n    extensions: set(future_extensions) });\n\nvar account_whitelist = new Serializer(\"account_whitelist\", { fee: asset,\n    authorizing_account: protocol_id_type(\"account\"),\n    account_to_list: protocol_id_type(\"account\"),\n    new_listing: uint8,\n    extensions: set(future_extensions) });\n\nvar account_upgrade = new Serializer(\"account_upgrade\", { fee: asset,\n    account_to_upgrade: protocol_id_type(\"account\"),\n    upgrade_to_lifetime_member: bool,\n    extensions: set(future_extensions) });\n\nvar account_transfer = new Serializer(\"account_transfer\", { fee: asset,\n    account_id: protocol_id_type(\"account\"),\n    new_owner: protocol_id_type(\"account\"),\n    extensions: set(future_extensions) });\n\nvar price = new Serializer(\"price\", { base: asset,\n    quote: asset });\n\nvar asset_options = new Serializer(\"asset_options\", { max_supply: int64,\n    market_fee_percent: uint16,\n    max_market_fee: int64,\n    issuer_permissions: uint16,\n    flags: uint16,\n    core_exchange_rate: price,\n    whitelist_authorities: set(protocol_id_type(\"account\")),\n    blacklist_authorities: set(protocol_id_type(\"account\")),\n    whitelist_markets: set(protocol_id_type(\"asset\")),\n    blacklist_markets: set(protocol_id_type(\"asset\")),\n    description: string,\n    extensions: set(future_extensions) });\n\nvar bitasset_options = new Serializer(\"bitasset_options\", { feed_lifetime_sec: uint32,\n    minimum_feeds: uint8,\n    force_settlement_delay_sec: uint32,\n    force_settlement_offset_percent: uint16,\n    maximum_force_settlement_volume: uint16,\n    short_backing_asset: protocol_id_type(\"asset\"),\n    extensions: set(future_extensions) });\n\nvar asset_create = new Serializer(\"asset_create\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    symbol: string,\n    precision: uint8,\n    common_options: asset_options,\n    bitasset_opts: optional(bitasset_options),\n    is_prediction_market: bool,\n    extensions: set(future_extensions) });\n\nvar asset_update = new Serializer(\"asset_update\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    asset_to_update: protocol_id_type(\"asset\"),\n    new_issuer: optional(protocol_id_type(\"account\")),\n    new_options: asset_options,\n    extensions: set(future_extensions) });\n\nvar asset_update_bitasset = new Serializer(\"asset_update_bitasset\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    asset_to_update: protocol_id_type(\"asset\"),\n    new_options: bitasset_options,\n    extensions: set(future_extensions) });\n\nvar asset_update_feed_producers = new Serializer(\"asset_update_feed_producers\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    asset_to_update: protocol_id_type(\"asset\"),\n    new_feed_producers: set(protocol_id_type(\"account\")),\n    extensions: set(future_extensions) });\n\nvar asset_issue = new Serializer(\"asset_issue\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    asset_to_issue: asset,\n    issue_to_account: protocol_id_type(\"account\"),\n    memo: optional(memo_data),\n    extensions: set(future_extensions) });\n\nvar asset_reserve = new Serializer(\"asset_reserve\", { fee: asset,\n    payer: protocol_id_type(\"account\"),\n    amount_to_reserve: asset,\n    extensions: set(future_extensions) });\n\nvar asset_fund_fee_pool = new Serializer(\"asset_fund_fee_pool\", { fee: asset,\n    from_account: protocol_id_type(\"account\"),\n    asset_id: protocol_id_type(\"asset\"),\n    amount: int64,\n    extensions: set(future_extensions) });\n\nvar asset_settle = new Serializer(\"asset_settle\", { fee: asset,\n    account: protocol_id_type(\"account\"),\n    amount: asset,\n    extensions: set(future_extensions) });\n\nvar asset_global_settle = new Serializer(\"asset_global_settle\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    asset_to_settle: protocol_id_type(\"asset\"),\n    settle_price: price,\n    extensions: set(future_extensions) });\n\nvar price_feed = new Serializer(\"price_feed\", { settlement_price: price,\n    maintenance_collateral_ratio: uint16,\n    maximum_short_squeeze_ratio: uint16,\n    core_exchange_rate: price });\n\nvar asset_publish_feed = new Serializer(\"asset_publish_feed\", { fee: asset,\n    publisher: protocol_id_type(\"account\"),\n    asset_id: protocol_id_type(\"asset\"),\n    feed: price_feed,\n    extensions: set(future_extensions) });\n\nvar witness_create = new Serializer(\"witness_create\", { fee: asset,\n    witness_account: protocol_id_type(\"account\"),\n    url: string,\n    block_signing_key: public_key });\n\nvar witness_update = new Serializer(\"witness_update\", { fee: asset,\n    witness: protocol_id_type(\"witness\"),\n    witness_account: protocol_id_type(\"account\"),\n    new_url: optional(string),\n    new_signing_key: optional(public_key) });\n\nvar op_wrapper = new Serializer(\"op_wrapper\", { op: operation });\n\nvar proposal_create = new Serializer(\"proposal_create\", { fee: asset,\n    fee_paying_account: protocol_id_type(\"account\"),\n    expiration_time: time_point_sec,\n    proposed_ops: array(op_wrapper),\n    review_period_seconds: optional(uint32),\n    extensions: set(future_extensions) });\n\nvar proposal_update = new Serializer(\"proposal_update\", { fee: asset,\n    fee_paying_account: protocol_id_type(\"account\"),\n    proposal: protocol_id_type(\"proposal\"),\n    active_approvals_to_add: set(protocol_id_type(\"account\")),\n    active_approvals_to_remove: set(protocol_id_type(\"account\")),\n    owner_approvals_to_add: set(protocol_id_type(\"account\")),\n    owner_approvals_to_remove: set(protocol_id_type(\"account\")),\n    key_approvals_to_add: set(public_key),\n    key_approvals_to_remove: set(public_key),\n    extensions: set(future_extensions) });\n\nvar proposal_delete = new Serializer(\"proposal_delete\", { fee: asset,\n    fee_paying_account: protocol_id_type(\"account\"),\n    using_owner_authority: bool,\n    proposal: protocol_id_type(\"proposal\"),\n    extensions: set(future_extensions) });\n\nvar withdraw_permission_create = new Serializer(\"withdraw_permission_create\", { fee: asset,\n    withdraw_from_account: protocol_id_type(\"account\"),\n    authorized_account: protocol_id_type(\"account\"),\n    withdrawal_limit: asset,\n    withdrawal_period_sec: uint32,\n    periods_until_expiration: uint32,\n    period_start_time: time_point_sec });\n\nvar withdraw_permission_update = new Serializer(\"withdraw_permission_update\", { fee: asset,\n    withdraw_from_account: protocol_id_type(\"account\"),\n    authorized_account: protocol_id_type(\"account\"),\n    permission_to_update: protocol_id_type(\"withdraw_permission\"),\n    withdrawal_limit: asset,\n    withdrawal_period_sec: uint32,\n    period_start_time: time_point_sec,\n    periods_until_expiration: uint32 });\n\nvar withdraw_permission_claim = new Serializer(\"withdraw_permission_claim\", { fee: asset,\n    withdraw_permission: protocol_id_type(\"withdraw_permission\"),\n    withdraw_from_account: protocol_id_type(\"account\"),\n    withdraw_to_account: protocol_id_type(\"account\"),\n    amount_to_withdraw: asset,\n    memo: optional(memo_data) });\n\nvar withdraw_permission_delete = new Serializer(\"withdraw_permission_delete\", { fee: asset,\n    withdraw_from_account: protocol_id_type(\"account\"),\n    authorized_account: protocol_id_type(\"account\"),\n    withdrawal_permission: protocol_id_type(\"withdraw_permission\") });\n\nvar committee_member_create = new Serializer(\"committee_member_create\", { fee: asset,\n    committee_member_account: protocol_id_type(\"account\"),\n    url: string });\n\nvar committee_member_update = new Serializer(\"committee_member_update\", { fee: asset,\n    committee_member: protocol_id_type(\"committee_member\"),\n    committee_member_account: protocol_id_type(\"account\"),\n    new_url: optional(string) });\n\nvar chain_parameters = new Serializer(\"chain_parameters\", { current_fees: fee_schedule,\n    block_interval: uint8,\n    maintenance_interval: uint32,\n    maintenance_skip_slots: uint8,\n    committee_proposal_review_period: uint32,\n    maximum_transaction_size: uint32,\n    maximum_block_size: uint32,\n    maximum_time_until_expiration: uint32,\n    maximum_proposal_lifetime: uint32,\n    maximum_asset_whitelist_authorities: uint8,\n    maximum_asset_feed_publishers: uint8,\n    maximum_witness_count: uint16,\n    maximum_committee_count: uint16,\n    maximum_authority_membership: uint16,\n    reserve_percent_of_fee: uint16,\n    network_percent_of_fee: uint16,\n    lifetime_referrer_percent_of_fee: uint16,\n    cashback_vesting_period_seconds: uint32,\n    cashback_vesting_threshold: int64,\n    count_non_member_votes: bool,\n    allow_non_member_whitelists: bool,\n    witness_pay_per_block: int64,\n    worker_budget_per_day: int64,\n    max_predicate_opcode: uint16,\n    fee_liquidation_threshold: int64,\n    accounts_per_fee_scale: uint16,\n    account_fee_scale_bitshifts: uint8,\n    max_authority_depth: uint8,\n    extensions: set(future_extensions) });\n\nvar committee_member_update_global_parameters = new Serializer(\"committee_member_update_global_parameters\", { fee: asset,\n    new_parameters: chain_parameters });\n\nvar linear_vesting_policy_initializer = new Serializer(\"linear_vesting_policy_initializer\", { begin_timestamp: time_point_sec,\n    vesting_cliff_seconds: uint32,\n    vesting_duration_seconds: uint32 });\n\nvar cdd_vesting_policy_initializer = new Serializer(\"cdd_vesting_policy_initializer\", { start_claim: time_point_sec,\n    vesting_seconds: uint32 });\n\nvar vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]);\n\nvar vesting_balance_create = new Serializer(\"vesting_balance_create\", { fee: asset,\n    creator: protocol_id_type(\"account\"),\n    owner: protocol_id_type(\"account\"),\n    amount: asset,\n    policy: vesting_policy_initializer });\n\nvar vesting_balance_withdraw = new Serializer(\"vesting_balance_withdraw\", { fee: asset,\n    vesting_balance: protocol_id_type(\"vesting_balance\"),\n    owner: protocol_id_type(\"account\"),\n    amount: asset });\n\nvar refund_worker_initializer = new Serializer(\"refund_worker_initializer\");\n\nvar vesting_balance_worker_initializer = new Serializer(\"vesting_balance_worker_initializer\", { pay_vesting_period_days: uint16 });\n\nvar burn_worker_initializer = new Serializer(\"burn_worker_initializer\");\n\nvar worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]);\n\nvar worker_create = new Serializer(\"worker_create\", { fee: asset,\n    owner: protocol_id_type(\"account\"),\n    work_begin_date: time_point_sec,\n    work_end_date: time_point_sec,\n    daily_pay: int64,\n    name: string,\n    url: string,\n    initializer: worker_initializer });\n\nvar custom = new Serializer(\"custom\", { fee: asset,\n    payer: protocol_id_type(\"account\"),\n    required_auths: set(protocol_id_type(\"account\")),\n    id: uint16,\n    data: bytes() });\n\nvar account_name_eq_lit_predicate = new Serializer(\"account_name_eq_lit_predicate\", { account_id: protocol_id_type(\"account\"),\n    name: string });\n\nvar asset_symbol_eq_lit_predicate = new Serializer(\"asset_symbol_eq_lit_predicate\", { asset_id: protocol_id_type(\"asset\"),\n    symbol: string });\n\nvar block_id_predicate = new Serializer(\"block_id_predicate\", { id: bytes(20) });\n\nvar predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]);\n\nvar assert = new Serializer(\"assert\", { fee: asset,\n    fee_paying_account: protocol_id_type(\"account\"),\n    predicates: array(predicate),\n    required_auths: set(protocol_id_type(\"account\")),\n    extensions: set(future_extensions) });\n\nvar balance_claim = new Serializer(\"balance_claim\", { fee: asset,\n    deposit_to_account: protocol_id_type(\"account\"),\n    balance_to_claim: protocol_id_type(\"balance\"),\n    balance_owner_key: public_key,\n    total_claimed: asset });\n\nvar override_transfer = new Serializer(\"override_transfer\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    from: protocol_id_type(\"account\"),\n    to: protocol_id_type(\"account\"),\n    amount: asset,\n    memo: optional(memo_data),\n    extensions: set(future_extensions) });\n\nvar stealth_confirmation = new Serializer(\"stealth_confirmation\", { one_time_key: public_key,\n    to: optional(public_key),\n    encrypted_memo: bytes() });\n\nvar blind_output = new Serializer(\"blind_output\", { commitment: bytes(33),\n    range_proof: bytes(),\n    owner: authority,\n    stealth_memo: optional(stealth_confirmation) });\n\nvar transfer_to_blind = new Serializer(\"transfer_to_blind\", { fee: asset,\n    amount: asset,\n    from: protocol_id_type(\"account\"),\n    blinding_factor: bytes(32),\n    outputs: array(blind_output) });\n\nvar blind_input = new Serializer(\"blind_input\", { commitment: bytes(33),\n    owner: authority });\n\nvar blind_transfer = new Serializer(\"blind_transfer\", { fee: asset,\n    inputs: array(blind_input),\n    outputs: array(blind_output) });\n\nvar transfer_from_blind = new Serializer(\"transfer_from_blind\", { fee: asset,\n    amount: asset,\n    to: protocol_id_type(\"account\"),\n    blinding_factor: bytes(32),\n    inputs: array(blind_input) });\n\nvar asset_settle_cancel = new Serializer(\"asset_settle_cancel\", { fee: asset,\n    settlement: protocol_id_type(\"force_settlement\"),\n    account: protocol_id_type(\"account\"),\n    amount: asset,\n    extensions: set(future_extensions) });\n\nvar asset_claim_fees = new Serializer(\"asset_claim_fees\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    amount_to_claim: asset,\n    extensions: set(future_extensions) });\n\nvar fba_distribute = new Serializer(\"fba_distribute\", { fee: asset,\n    account_id: protocol_id_type(\"account\"),\n    fba_id: protocol_id_type(\"fba_accumulator\"),\n    amount: int64 });\n\nvar dividend_asset_options = new Serializer(\"dividend_asset_options\", { next_payout_time: optional(time_point_sec),\n    payout_interval: optional(uint32),\n    minimum_fee_percentage: uint64,\n    minimum_distribution_interval: optional(uint32),\n    extensions: set(future_extensions) });\n\nvar asset_update_dividend = new Serializer(\"asset_update_dividend\", { fee: asset,\n    issuer: protocol_id_type(\"account\"),\n    asset_to_update: protocol_id_type(\"asset\"),\n    new_options: dividend_asset_options,\n    extensions: set(future_extensions) });\n\nvar rock_paper_scissors_game_options = new Serializer(\"rock_paper_scissors_game_options\", { insurance_enabled: bool,\n    time_per_commit_move: uint32,\n    time_per_reveal_move: uint32,\n    number_of_gestures: uint8 });\n\nvar game_specific_details = static_variant([rock_paper_scissors_game_options]);\n\nvar tournament_options = new Serializer(\"tournament_options\", {\n    type_of_game: uint16,\n    registration_deadline: time_point_sec,\n    number_of_players: uint32,\n    buy_in: asset,\n    whitelist: set(protocol_id_type(\"account\")),\n    start_time: optional(time_point_sec),\n    start_delay: optional(uint32),\n    round_delay: uint32,\n    number_of_wins: uint32,\n    meta: variant_object,\n    game_options: game_specific_details\n});\n\nvar tournament_create = new Serializer(\"tournament_create\", { fee: asset,\n    creator: protocol_id_type(\"account\"),\n    options: tournament_options,\n    extensions: set(future_extensions) });\n\nvar tournament_join = new Serializer(\"tournament_join\", { fee: asset,\n    payer_account_id: protocol_id_type(\"account\"),\n    player_account_id: protocol_id_type(\"account\"),\n    tournament_id: protocol_id_type(\"tournament\"),\n    buy_in: asset,\n    extensions: set(future_extensions) });\n\nvar rock_paper_scissors_gesture = enumeration([\"rock\", \"paper\", \"scissors\", \"spock\", \"lizard\"]);\n\nvar rock_paper_scissors_throw_commit = new Serializer(\"rock_paper_scissors_throw_commit\", { nonce1: uint64,\n    throw_hash: sha256 });\n\nvar rock_paper_scissors_throw_reveal = new Serializer(\"rock_paper_scissors_throw_reveal\", { nonce2: uint64,\n    gesture: rock_paper_scissors_gesture });\n\nvar game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]);\n\nvar game_move = new Serializer(\"game_move\", { fee: asset,\n    game_id: protocol_id_type(\"game\"),\n    player_account_id: protocol_id_type(\"account\"),\n    move: game_specific_moves,\n    extensions: set(future_extensions) });\n\noperation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend];\n\nvar transaction = new Serializer(\"transaction\", { ref_block_num: uint16,\n    ref_block_prefix: uint32,\n    expiration: time_point_sec,\n    operations: array(operation),\n    extensions: set(future_extensions) });\n\nvar signed_transaction = new Serializer(\"signed_transaction\", { ref_block_num: uint16,\n    ref_block_prefix: uint32,\n    expiration: time_point_sec,\n    operations: array(operation),\n    extensions: set(future_extensions),\n    signatures: array(bytes(65)) });\n//# -------------------------------\n//#  Generated code end\n//# -------------------------------\n\n// Custom Types\n\nvar stealth_memo_data = new Serializer(\"stealth_memo_data\", {\n    from: optional(public_key),\n    amount: asset,\n    blinding_factor: bytes(32),\n    commitment: bytes(33),\n    check: uint32\n});\n// var stealth_confirmation = new Serializer(\n//     \"stealth_confirmation\", {\n//     one_time_key: public_key,\n//     to: optional( public_key ),\n//     encrypted_memo: stealth_memo_data\n// })","'use strict';\n\nvar _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ByteBuffer = require('bytebuffer');\nvar EC = require('./error_with_cause');\n\nvar HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump;\n\nvar Serializer = function () {\n    function Serializer(operation_name, types) {\n        _classCallCheck(this, Serializer);\n\n        this.operation_name = operation_name;\n        this.types = types;\n        if (this.types) this.keys = Object.keys(this.types);\n\n        Serializer.printDebug = true;\n    }\n\n    _createClass(Serializer, [{\n        key: 'fromByteBuffer',\n        value: function fromByteBuffer(b) {\n            var object = {};\n            var field = null;\n            try {\n                var iterable = this.keys;\n                for (var i = 0, field; i < iterable.length; i++) {\n                    field = iterable[i];\n                    var type = this.types[field];\n                    try {\n                        if (HEX_DUMP) {\n                            if (type.operation_name) {\n                                console.error(type.operation_name);\n                            } else {\n                                var o1 = b.offset;\n                                type.fromByteBuffer(b);\n                                var o2 = b.offset;\n                                b.offset = o1;\n                                //b.reset()\n                                var _b = b.copy(o1, o2);\n                                console.error(this.operation_name + '.' + field + '\\t', _b.toHex());\n                            }\n                        }\n                        object[field] = type.fromByteBuffer(b);\n                    } catch (e) {\n                        if (Serializer.printDebug) {\n                            console.error('Error reading ' + this.operation_name + '.' + field + ' in data:');\n                            b.printDebug();\n                        }\n                        throw e;\n                    }\n                }\n            } catch (error) {\n                EC.throw(this.operation_name + '.' + field, error);\n            }\n\n            return object;\n        }\n    }, {\n        key: 'appendByteBuffer',\n        value: function appendByteBuffer(b, object) {\n            var field = null;\n            try {\n                var iterable = this.keys;\n                for (var i = 0, field; i < iterable.length; i++) {\n                    field = iterable[i];\n                    var type = this.types[field];\n                    type.appendByteBuffer(b, object[field]);\n                }\n            } catch (error) {\n                try {\n                    EC.throw(this.operation_name + '.' + field + \" = \" + JSON.stringify(object[field]), error);\n                } catch (e) {\n                    // circular ref\n                    EC.throw(this.operation_name + '.' + field + \" = \" + object[field], error);\n                }\n            }\n            return;\n        }\n    }, {\n        key: 'fromObject',\n        value: function fromObject(serialized_object) {\n            var result = {};\n            var field = null;\n            try {\n                var iterable = this.keys;\n                for (var i = 0, field; i < iterable.length; i++) {\n                    field = iterable[i];\n                    var type = this.types[field];\n                    var value = serialized_object[field];\n                    //DEBUG value = value.resolve if value.resolve\n                    //DEBUG console.log('... value',field,value)\n                    var object = type.fromObject(value);\n                    result[field] = object;\n                }\n            } catch (error) {\n                EC.throw(this.operation_name + '.' + field, error);\n            }\n\n            return result;\n        }\n\n        /**\n            @arg {boolean} [debug.use_default = false] - more template friendly\n            @arg {boolean} [debug.annotate = false] - add user-friendly information\n        */\n\n    }, {\n        key: 'toObject',\n        value: function toObject() {\n            var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false };\n\n            var result = {};\n            var field = null;\n            try {\n                if (!this.types) return result;\n\n                var iterable = this.keys;\n                for (var i = 0, field; i < iterable.length; i++) {\n                    field = iterable[i];\n                    var type = this.types[field];\n                    var object = type.toObject(typeof serialized_object !== \"undefined\" && serialized_object !== null ? serialized_object[field] : undefined, debug);\n                    result[field] = object;\n                    if (HEX_DUMP) {\n                        var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n                        type.appendByteBuffer(b, typeof serialized_object !== \"undefined\" && serialized_object !== null ? serialized_object[field] : undefined);\n                        b = b.copy(0, b.offset);\n                        console.error(this.operation_name + '.' + field, b.toHex());\n                    }\n                }\n            } catch (error) {\n                EC.throw(this.operation_name + '.' + field, error);\n            }\n\n            return result;\n        }\n\n        /** Sort by the first element in a operation */\n\n    }, {\n        key: 'compare',\n        value: function compare(a, b) {\n\n            var first_key = this.keys[0];\n            var first_type = this.types[first_key];\n\n            var valA = a[first_key];\n            var valB = b[first_key];\n\n            if (first_type.compare) return first_type.compare(valA, valB);\n\n            if (typeof valA === \"number\" && typeof valB === \"number\") return valA - valB;\n\n            var encoding = void 0;\n            if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) {\n                // A binary string compare does not work.  If localeCompare is well supported that could replace HEX.  Performanance is very good so comparing HEX works.\n                encoding = \"hex\";\n            }\n\n            var strA = valA.toString(encoding);\n            var strB = valB.toString(encoding);\n            return strA > strB ? 1 : strA < strB ? -1 : 0;\n        }\n\n        // <helper_functions>\n\n    }, {\n        key: 'fromHex',\n        value: function fromHex(hex) {\n            var b = ByteBuffer.fromHex(hex, ByteBuffer.LITTLE_ENDIAN);\n            return this.fromByteBuffer(b);\n        }\n    }, {\n        key: 'fromBuffer',\n        value: function fromBuffer(buffer) {\n            var b = ByteBuffer.fromBinary(buffer.toString(\"binary\"), ByteBuffer.LITTLE_ENDIAN);\n            return this.fromByteBuffer(b);\n        }\n    }, {\n        key: 'toHex',\n        value: function toHex(object) {\n            // return this.toBuffer(object).toString(\"hex\")\n            var b = this.toByteBuffer(object);\n            return b.toHex();\n        }\n    }, {\n        key: 'toByteBuffer',\n        value: function toByteBuffer(object) {\n            var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n            this.appendByteBuffer(b, object);\n            return b.copy(0, b.offset);\n        }\n    }, {\n        key: 'toBuffer',\n        value: function toBuffer(object) {\n            return new Buffer(this.toByteBuffer(object).toBinary(), 'binary');\n        }\n    }]);\n\n    return Serializer;\n}();\n\nmodule.exports = Serializer;","\"use strict\";\n\n/** Console print any transaction object with zero default values. */\nmodule.exports = function template(op) {\n\n    var object = op.toObject(void 0, { use_default: true, annotate: true });\n\n    // visual (with descriptions)\n    console.error(JSON.stringify(object, null, 4));\n\n    // usable in a copy-paste\n\n    object = op.toObject(void 0, { use_default: true, annotate: false });\n\n    // copy-paste one-lineer\n    console.error(JSON.stringify(object));\n};","'use strict';\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// Low-level types that make up operations\n\nvar v = require('./SerializerValidation');\nvar fp = require('./FastParser');\n\nvar ChainTypes = require(\"../../chain/src/ChainTypes\");\nvar ObjectId = require(\"../../chain/src/ObjectId\");\n\nvar _require = require(\"../../ecc\"),\n    PublicKey = _require.PublicKey,\n    Address = _require.Address;\n\nvar _require2 = require(\"peerplaysjs-ws\"),\n    ChainConfig = _require2.ChainConfig;\n\nvar Types = {};\nmodule.exports = Types;\n\nvar HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump;\n\nTypes.uint8 = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readUint8();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.require_range(0, 0xFF, object, 'uint8 ' + object);\n        b.writeUint8(object);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.require_range(0, 0xFF, object, 'uint8 ' + object);\n        return object;\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return 0;\n        }\n        v.require_range(0, 0xFF, object, 'uint8 ' + object);\n        return parseInt(object);\n    }\n};\n\nTypes.uint16 = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readUint16();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.require_range(0, 0xFFFF, object, 'uint16 ' + object);\n        b.writeUint16(object);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.require_range(0, 0xFFFF, object, 'uint16 ' + object);\n        return object;\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return 0;\n        }\n        v.require_range(0, 0xFFFF, object, 'uint16 ' + object);\n        return parseInt(object);\n    }\n};\n\nTypes.uint32 = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readUint32();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object);\n        b.writeUint32(object);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object);\n        return object;\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return 0;\n        }\n        v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object);\n        return parseInt(object);\n    }\n};\n\nvar MIN_SIGNED_32 = -1 * Math.pow(2, 31);\nvar MAX_SIGNED_32 = Math.pow(2, 31) - 1;\n\nTypes.varint32 = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readVarint32();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n        b.writeVarint32(object);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n        return object;\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return 0;\n        }\n        v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object);\n        return parseInt(object);\n    }\n};\n\nTypes.int64 = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readInt64();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.required(object);\n        b.writeInt64(v.to_long(object));\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.required(object);\n        return v.to_long(object);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return \"0\";\n        }\n        v.required(object);\n        return v.to_long(object).toString();\n    }\n};\n\nTypes.uint64 = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readUint64();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        b.writeUint64(v.to_ulong(v.unsigned(object)));\n        return;\n    },\n    fromObject: function fromObject(object) {\n        return v.to_ulong(v.unsigned(object));\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return \"0\";\n        }\n        return v.to_ulong(object).toString();\n    }\n};\n\nTypes.string = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        var b_copy;\n        var len = b.readVarint32();\n        b_copy = b.copy(b.offset, b.offset + len), b.skip(len);\n        return new Buffer(b_copy.toBinary(), 'binary');\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.required(object);\n        b.writeVarint32(object.length);\n        b.append(object.toString('binary'), 'binary');\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.required(object);\n        return new Buffer(object);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return \"\";\n        }\n        return object.toString();\n    }\n};\n\nTypes.bytes = function (size) {\n    return {\n        fromByteBuffer: function fromByteBuffer(b) {\n            if (size === undefined) {\n                var b_copy;\n                var len = b.readVarint32();\n                b_copy = b.copy(b.offset, b.offset + len), b.skip(len);\n                return new Buffer(b_copy.toBinary(), 'binary');\n            } else {\n                b_copy = b.copy(b.offset, b.offset + size), b.skip(size);\n                return new Buffer(b_copy.toBinary(), 'binary');\n            }\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            v.required(object);\n            if (typeof object === \"string\") object = new Buffer(object, \"hex\");\n\n            if (size === undefined) {\n                b.writeVarint32(object.length);\n            }\n            b.append(object.toString('binary'), 'binary');\n            return;\n        },\n        fromObject: function fromObject(object) {\n            v.required(object);\n            if (Buffer.isBuffer(object)) return object;\n\n            return new Buffer(object, 'hex');\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            if (debug.use_default && object === undefined) {\n                var zeros = function zeros(num) {\n                    return new Array(num).join(\"00\");\n                };\n                return zeros(size);\n            }\n            v.required(object);\n            return object.toString('hex');\n        }\n    };\n};\n\nTypes.bool = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readUint8() === 1;\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        // supports boolean or integer\n        b.writeUint8(JSON.parse(object) ? 1 : 0);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        return JSON.parse(object) ? true : false;\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return false;\n        }\n        return JSON.parse(object) ? true : false;\n    }\n};\n\nTypes.void = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        throw new Error(\"(void) undefined type\");\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        throw new Error(\"(void) undefined type\");\n    },\n    fromObject: function fromObject(object) {\n        throw new Error(\"(void) undefined type\");\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return undefined;\n        }\n        throw new Error(\"(void) undefined type\");\n    }\n};\n\nTypes.array = function (st_operation) {\n    return {\n        fromByteBuffer: function fromByteBuffer(b) {\n            var size = b.readVarint32();\n            if (HEX_DUMP) {\n                console.log(\"varint32 size = \" + size.toString(16));\n            }\n            var result = [];\n            for (var i = 0; 0 < size ? i < size : i > size; 0 < size ? i++ : i++) {\n                result.push(st_operation.fromByteBuffer(b));\n            }\n            return sortOperation(result, st_operation);\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            v.required(object);\n            object = sortOperation(object, st_operation);\n            b.writeVarint32(object.length);\n            for (var i = 0, o; i < object.length; i++) {\n                o = object[i];\n                st_operation.appendByteBuffer(b, o);\n            }\n        },\n        fromObject: function fromObject(object) {\n            v.required(object);\n            object = sortOperation(object, st_operation);\n            var result = [];\n            for (var i = 0, o; i < object.length; i++) {\n                o = object[i];\n                result.push(st_operation.fromObject(o));\n            }\n            return result;\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            if (debug.use_default && object === undefined) {\n                return [st_operation.toObject(object, debug)];\n            }\n            v.required(object);\n            object = sortOperation(object, st_operation);\n\n            var result = [];\n            for (var i = 0, o; i < object.length; i++) {\n                o = object[i];\n                result.push(st_operation.toObject(o, debug));\n            }\n            return result;\n        }\n    };\n};\n\nTypes.time_point_sec = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return b.readUint32();\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        if (typeof object !== \"number\") object = Types.time_point_sec.fromObject(object);\n\n        b.writeUint32(object);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.required(object);\n\n        if (typeof object === \"number\") return object;\n\n        if (object.getTime) return Math.floor(object.getTime() / 1000);\n\n        if (typeof object !== \"string\") throw new Error(\"Unknown date type: \" + object);\n\n        // if(typeof object === \"string\" && !/Z$/.test(object))\n        //     object = object + \"Z\"\n\n        return Math.floor(new Date(object).getTime() / 1000);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) return new Date(0).toISOString().split('.')[0];\n\n        v.required(object);\n\n        if (typeof object === \"string\") return object;\n\n        if (object.getTime) return object.toISOString().split('.')[0];\n\n        var int = parseInt(object);\n        v.require_range(0, 0xFFFFFFFF, int, 'uint32 ' + object);\n        return new Date(int * 1000).toISOString().split('.')[0];\n    }\n};\n\nTypes.set = function (st_operation) {\n    return {\n        validate: function validate(array) {\n            var dup_map = {};\n            for (var i = 0, o; i < array.length; i++) {\n                o = array[i];\n                var ref;\n                if (ref = typeof o === 'undefined' ? 'undefined' : _typeof(o), ['string', 'number'].indexOf(ref) >= 0) {\n                    if (dup_map[o] !== undefined) {\n                        throw new Error(\"duplicate (set)\");\n                    }\n                    dup_map[o] = true;\n                }\n            }\n            return sortOperation(array, st_operation);\n        },\n        fromByteBuffer: function fromByteBuffer(b) {\n            var size = b.readVarint32();\n            if (HEX_DUMP) {\n                console.log(\"varint32 size = \" + size.toString(16));\n            }\n            return this.validate(function () {\n                var result = [];\n                for (var i = 0; 0 < size ? i < size : i > size; 0 < size ? i++ : i++) {\n                    result.push(st_operation.fromByteBuffer(b));\n                }\n                return result;\n            }());\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            if (!object) {\n                object = [];\n            }\n            b.writeVarint32(object.length);\n            var iterable = this.validate(object);\n            for (var i = 0, o; i < iterable.length; i++) {\n                o = iterable[i];\n                st_operation.appendByteBuffer(b, o);\n            }\n            return;\n        },\n        fromObject: function fromObject(object) {\n            if (!object) {\n                object = [];\n            }\n            return this.validate(function () {\n                var result = [];\n                for (var i = 0, o; i < object.length; i++) {\n                    o = object[i];\n                    result.push(st_operation.fromObject(o));\n                }\n                return result;\n            }());\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            if (debug.use_default && object === undefined) {\n                return [st_operation.toObject(object, debug)];\n            }\n            if (!object) {\n                object = [];\n            }\n            return this.validate(function () {\n                var result = [];\n                for (var i = 0, o; i < object.length; i++) {\n                    o = object[i];\n                    result.push(st_operation.toObject(o, debug));\n                }\n                return result;\n            }());\n        }\n    };\n};\n\n// global_parameters_update_operation current_fees\nTypes.fixed_array = function (count, st_operation) {\n    return {\n        fromByteBuffer: function fromByteBuffer(b) {\n            var i, j, ref, results;\n            results = [];\n            for (i = j = 0, ref = count; j < ref; i = j += 1) {\n                results.push(st_operation.fromByteBuffer(b));\n            }\n            return sortOperation(results, st_operation);\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            var i, j, ref;\n            if (count !== 0) {\n                v.required(object);\n                object = sortOperation(object, st_operation);\n            }\n            for (i = j = 0, ref = count; j < ref; i = j += 1) {\n                st_operation.appendByteBuffer(b, object[i]);\n            }\n        },\n        fromObject: function fromObject(object) {\n            var i, j, ref, results;\n            if (count !== 0) {\n                v.required(object);\n            }\n            results = [];\n            for (i = j = 0, ref = count; j < ref; i = j += 1) {\n                results.push(st_operation.fromObject(object[i]));\n            }\n            return results;\n        },\n        toObject: function toObject(object, debug) {\n            var i, j, k, ref, ref1, results, results1;\n            if (debug == null) {\n                debug = {};\n            }\n            if (debug.use_default && object === void 0) {\n                results = [];\n                for (i = j = 0, ref = count; j < ref; i = j += 1) {\n                    results.push(st_operation.toObject(void 0, debug));\n                }\n                return results;\n            }\n            if (count !== 0) {\n                v.required(object);\n            }\n            results1 = [];\n            for (i = k = 0, ref1 = count; k < ref1; i = k += 1) {\n                results1.push(st_operation.toObject(object[i], debug));\n            }\n            return results1;\n        }\n    };\n};\n\n/* Supports instance numbers (11) or object types (1.2.11).  Object type\nValidation is enforced when an object type is used. */\nvar id_type = function id_type(reserved_spaces, object_type) {\n    v.required(reserved_spaces, \"reserved_spaces\");\n    v.required(object_type, \"object_type\");\n    return {\n        fromByteBuffer: function fromByteBuffer(b) {\n            return b.readVarint32();\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            v.required(object);\n            if (object.resolve !== undefined) {\n                object = object.resolve;\n            }\n            // convert 1.2.n into just n\n            if (/^[0-9]+\\.[0-9]+\\.[0-9]+$/.test(object)) {\n                object = v.get_instance(reserved_spaces, object_type, object);\n            }\n            b.writeVarint32(v.to_number(object));\n            return;\n        },\n        fromObject: function fromObject(object) {\n            v.required(object);\n            if (object.resolve !== undefined) {\n                object = object.resolve;\n            }\n            if (v.is_digits(object)) {\n                return v.to_number(object);\n            }\n            return v.get_instance(reserved_spaces, object_type, object);\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            var object_type_id = ChainTypes.object_type[object_type];\n            if (debug.use_default && object === undefined) {\n                return reserved_spaces + '.' + object_type_id + '.0';\n            }\n            v.required(object);\n            if (object.resolve !== undefined) {\n                object = object.resolve;\n            }\n            if (/^[0-9]+\\.[0-9]+\\.[0-9]+$/.test(object)) {\n                object = v.get_instance(reserved_spaces, object_type, object);\n            }\n\n            return reserved_spaces + '.' + object_type_id + '.' + object;\n        }\n    };\n};\n\nTypes.protocol_id_type = function (name) {\n    v.required(name, \"name\");\n    return id_type(ChainTypes.reserved_spaces.protocol_ids, name);\n};\n\nTypes.object_id_type = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        return ObjectId.fromByteBuffer(b);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.required(object);\n        if (object.resolve !== undefined) {\n            object = object.resolve;\n        }\n        object = ObjectId.fromString(object);\n        object.appendByteBuffer(b);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.required(object);\n        if (object.resolve !== undefined) {\n            object = object.resolve;\n        }\n        return ObjectId.fromString(object);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return \"0.0.0\";\n        }\n        v.required(object);\n        if (object.resolve !== undefined) {\n            object = object.resolve;\n        }\n        object = ObjectId.fromString(object);\n        return object.toString();\n    }\n};\n\nTypes.vote_id = { TYPE: 0x000000FF,\n    ID: 0xFFFFFF00,\n    fromByteBuffer: function fromByteBuffer(b) {\n        var value = b.readUint32();\n        return {\n            type: value & this.TYPE,\n            id: value & this.ID\n        };\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.required(object);\n        if (object === \"string\") object = Types.vote_id.fromObject(object);\n\n        var value = object.id << 8 | object.type;\n        b.writeUint32(value);\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.required(object, \"(type vote_id)\");\n        if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === \"object\") {\n            v.required(object.type, \"type\");\n            v.required(object.id, \"id\");\n            return object;\n        }\n        v.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object);\n\n        var _object$split = object.split(':'),\n            _object$split2 = _slicedToArray(_object$split, 2),\n            type = _object$split2[0],\n            id = _object$split2[1];\n\n        v.require_range(0, 0xff, type, 'vote type ' + object);\n        v.require_range(0, 0xffffff, id, 'vote id ' + object);\n        return { type: type, id: id };\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return \"0:0\";\n        }\n        v.required(object);\n        if (typeof object === \"string\") object = Types.vote_id.fromObject(object);\n\n        return object.type + \":\" + object.id;\n    },\n    compare: function compare(a, b) {\n        if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== \"object\") a = Types.vote_id.fromObject(a);\n        if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== \"object\") b = Types.vote_id.fromObject(b);\n        return parseInt(a.id) - parseInt(b.id);\n    }\n};\n\nTypes.optional = function (st_operation) {\n    v.required(st_operation, \"st_operation\");\n    return {\n        fromByteBuffer: function fromByteBuffer(b) {\n            if (!(b.readUint8() === 1)) {\n                return undefined;\n            }\n            return st_operation.fromByteBuffer(b);\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            if (object !== null && object !== undefined) {\n                b.writeUint8(1);\n                st_operation.appendByteBuffer(b, object);\n            } else {\n                b.writeUint8(0);\n            }\n            return;\n        },\n        fromObject: function fromObject(object) {\n            if (object === undefined) {\n                return undefined;\n            }\n            return st_operation.fromObject(object);\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            // toObject is only null save if use_default is true\n            var result_object = function () {\n                if (!debug.use_default && object === undefined) {\n                    return undefined;\n                } else {\n                    return st_operation.toObject(object, debug);\n                }\n            }();\n\n            if (debug.annotate) {\n                if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === \"object\") {\n                    result_object.__optional = \"parent is optional\";\n                } else {\n                    result_object = { __optional: result_object };\n                }\n            }\n            return result_object;\n        }\n    };\n};\n\nTypes.static_variant = function (_st_operations) {\n    return {\n        nosort: true,\n        st_operations: _st_operations,\n        fromByteBuffer: function fromByteBuffer(b) {\n            var type_id = b.readVarint32();\n            var st_operation = this.st_operations[type_id];\n            if (HEX_DUMP) {\n                console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')');\n            }\n            v.required(st_operation, 'operation ' + type_id);\n            return [type_id, st_operation.fromByteBuffer(b)];\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            v.required(object);\n            var type_id = object[0];\n            var st_operation = this.st_operations[type_id];\n            v.required(st_operation, 'operation ' + type_id);\n            b.writeVarint32(type_id);\n            st_operation.appendByteBuffer(b, object[1]);\n            return;\n        },\n        fromObject: function fromObject(object) {\n            v.required(object);\n            var type_id = object[0];\n            var st_operation = this.st_operations[type_id];\n            v.required(st_operation, 'operation ' + type_id);\n            return [type_id, st_operation.fromObject(object[1])];\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            if (debug.use_default && object === undefined) {\n                return [0, this.st_operations[0].toObject(undefined, debug)];\n            }\n            v.required(object);\n            var type_id = object[0];\n            var st_operation = this.st_operations[type_id];\n            v.required(st_operation, 'operation ' + type_id);\n            return [type_id, st_operation.toObject(object[1], debug)];\n        }\n    };\n};\n\nTypes.map = function (key_st_operation, value_st_operation) {\n    return {\n        validate: function validate(array) {\n            if (!Array.isArray(array)) {\n                throw new Error(\"expecting array\");\n            }\n            var dup_map = {};\n            for (var i = 0, o; i < array.length; i++) {\n                o = array[i];\n                var ref;\n                if (!(o.length === 2)) {\n                    throw new Error(\"expecting two elements\");\n                }\n                if (ref = _typeof(o[0]), ['number', 'string'].indexOf(ref) >= 0) {\n                    if (dup_map[o[0]] !== undefined) {\n                        throw new Error(\"duplicate (map)\");\n                    }\n                    dup_map[o[0]] = true;\n                }\n            }\n            return sortOperation(array, key_st_operation);\n        },\n        fromByteBuffer: function fromByteBuffer(b) {\n            var result = [];\n            var end = b.readVarint32();\n            for (var i = 0; 0 < end ? i < end : i > end; 0 < end ? i++ : i++) {\n                result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]);\n            }\n            return this.validate(result);\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            this.validate(object);\n            b.writeVarint32(object.length);\n            for (var i = 0, o; i < object.length; i++) {\n                o = object[i];\n                key_st_operation.appendByteBuffer(b, o[0]);\n                value_st_operation.appendByteBuffer(b, o[1]);\n            }\n            return;\n        },\n        fromObject: function fromObject(object) {\n            v.required(object);\n            var result = [];\n            for (var i = 0, o; i < object.length; i++) {\n                o = object[i];\n                result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]);\n            }\n            return this.validate(result);\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            if (debug.use_default && object === undefined) {\n                return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]];\n            }\n            v.required(object);\n            object = this.validate(object);\n            var result = [];\n            for (var i = 0, o; i < object.length; i++) {\n                o = object[i];\n                result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]);\n            }\n            return result;\n        }\n    };\n};\n\nTypes.public_key = {\n    toPublic: function toPublic(object) {\n        if (object.resolve !== undefined) {\n            object = object.resolve;\n        }\n\n        if (object instanceof PublicKey) {\n            return object;\n        }\n\n        return object == null ? object : object.Q ? object : PublicKey.fromStringOrThrow(object);\n    },\n    fromByteBuffer: function fromByteBuffer(b) {\n        return fp.public_key(b);\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        v.required(object);\n        fp.public_key(b, Types.public_key.toPublic(object));\n        return;\n    },\n    fromObject: function fromObject(object) {\n        v.required(object);\n        if (object.Q) {\n            return object;\n        }\n        return Types.public_key.toPublic(object);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return ChainConfig.address_prefix + \"859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM\";\n        }\n        v.required(object);\n        return object.toString();\n    },\n    compare: function compare(a, b) {\n        return strCmp(a.toAddressString(), b.toAddressString());\n    }\n};\n\nTypes.address = {\n    _to_address: function _to_address(object) {\n        v.required(object);\n        if (object.addy) {\n            return object;\n        }\n        return Address.fromString(object);\n    },\n    fromByteBuffer: function fromByteBuffer(b) {\n        return new Address(fp.ripemd160(b));\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        fp.ripemd160(b, Types.address._to_address(object).toBuffer());\n        return;\n    },\n    fromObject: function fromObject(object) {\n        return Types.address._to_address(object);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return ChainConfig.address_prefix + \"664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S\";\n        }\n        return Types.address._to_address(object).toString();\n    },\n    compare: function compare(a, b) {\n        return strCmp(a.toString(), b.toString());\n    }\n};\n\nTypes.variant = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        var type = b.readUint8();\n        switch (type) {\n            case 0:\n                return null;\n            case 1:\n                return Types.int64.fromByteBuffer(b);\n            case 2:\n                return Types.uint64.fromByteBuffer(b);\n            case 3:\n                return b.readDouble();\n            case 4:\n                return Types.bool.fromByteBuffer(b);\n            case 5:\n                return Types.string.fromByteBuffer(b);\n            case 6:\n                return Types.array(Types.variant).fromByteBuffer(b);\n            case 7:\n            default:\n                return Types.variant_object.fromByteBuffer(b);\n        };\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        if (typeof object == 'number') {\n            if (Number.isInteger(object)) {\n                if (object >= 0) {\n                    b.writeUint8(2);\n                    Types.uint64.appendByteBuffer(b, object);\n                } else {\n                    b.writeUint8(1);\n                    Types.int64.appendByteBuffer(b, object);\n                }\n            } else {\n                b.writeUint8(3);\n                b.writeDouble(Number.parseFloat(object));\n            }\n        } else if (typeof object == 'boolean') {\n            b.writeUint8(4);\n            Types.bool.appendByteBuffer(b, object);\n        } else if (typeof object == 'string') {\n            b.writeUint8(5);\n            Types.string.appendByteBuffer(b, object);\n        } else if (typeof object == 'array') {\n            b.writeUint8(6);\n            Types.array(Types.variant).appendByteBuffer(b, object);\n        } else {\n            b.writeUint8(7);\n            Types.variant_object.appendByteBuffer(b, object);\n        }\n    },\n    fromObject: function fromObject(object) {\n        return JSON.parse(object);\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        if (debug.use_default && object === undefined) {\n            return null;\n        }\n        return JSON.parse(object);\n    }\n};\n\nTypes.variant_object = {\n    fromByteBuffer: function fromByteBuffer(b) {\n        var count = b.readVarint32();\n        var result = {};\n        for (var i = 0; i < count; ++i) {\n            var key = Types.string.fromByteBuffer(b);\n            result[key] = Types.variant.fromByteBuffer(b);\n        }\n        return result;\n    },\n    appendByteBuffer: function appendByteBuffer(b, object) {\n        var count = 0;\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) ++count;\n        }b.writeVarint32(count); // number of key/value pairs\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) {\n                Types.string.appendByteBuffer(b, key);\n                Types.variant.appendByteBuffer(b, object[key]);\n            }\n        }return;\n    },\n    fromObject: function fromObject(object) {\n        var newObject = {};\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) newObject[key] = object[key];\n        }return newObject;\n    },\n    toObject: function toObject(object) {\n        var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        var newObject = {};\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) newObject[key] = object[key];\n        }return newObject;\n    }\n};\n\nTypes.enumeration = function (values) {\n    return {\n        fromByteBuffer: function fromByteBuffer(b) {\n            return values[b.readVarint32ZigZag()];\n        },\n        appendByteBuffer: function appendByteBuffer(b, object) {\n            b.writeVarint32ZigZag(values.indexOf(object));\n            return;\n        },\n        fromObject: function fromObject(object) {\n            return object;\n        },\n        toObject: function toObject(object) {\n            var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            if (debug.use_default && object === undefined) {\n                values[0];\n            }\n            return object;\n        }\n    };\n};\n\nTypes.sha256 = Types.bytes(32);\n\nvar strCmp = function strCmp(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n};\nvar firstEl = function firstEl(el) {\n    return Array.isArray(el) ? el[0] : el;\n};\nvar sortOperation = function sortOperation(array, st_operation) {\n    return st_operation.nosort ? array : st_operation.compare ? array.sort(function (a, b) {\n        return st_operation.compare(firstEl(a), firstEl(b));\n    }) : // custom compare operation\n    array.sort(function (a, b) {\n        return typeof firstEl(a) === \"number\" && typeof firstEl(b) === \"number\" ? firstEl(a) - firstEl(b) :\n        // A binary string compare does not work. Performanance is very good so HEX is used..  localeCompare is another option.\n        Buffer.isBuffer(firstEl(a)) && Buffer.isBuffer(firstEl(b)) ? strCmp(firstEl(a).toString(\"hex\"), firstEl(b).toString(\"hex\")) : strCmp(firstEl(a).toString(), firstEl(b).toString());\n    });\n};","'use strict';\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","// base-x encoding\n// Forked from https://github.com/cryptocoinjs/bs58\n// Originally written by Mike Hearn for BitcoinJ\n// Copyright (c) 2011 Google Inc\n// Ported to JavaScript by Stefan Thomas\n// Merged Buffer refactorings from base58-native by Stephen Pair\n// Copyright (c) 2013 BitPay Inc\n\nmodule.exports = function base (ALPHABET) {\n  var ALPHABET_MAP = {}\n  var BASE = ALPHABET.length\n  var LEADER = ALPHABET.charAt(0)\n\n  // pre-compute lookup table\n  for (var i = 0; i < ALPHABET.length; i++) {\n    ALPHABET_MAP[ALPHABET.charAt(i)] = i\n  }\n\n  function encode (source) {\n    if (source.length === 0) return ''\n\n    var digits = [0]\n    for (var i = 0; i < source.length; ++i) {\n      for (var j = 0, carry = source[i]; j < digits.length; ++j) {\n        carry += digits[j] << 8\n        digits[j] = carry % BASE\n        carry = (carry / BASE) | 0\n      }\n\n      while (carry > 0) {\n        digits.push(carry % BASE)\n        carry = (carry / BASE) | 0\n      }\n    }\n\n    var string = ''\n\n    // deal with leading zeros\n    for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) string += ALPHABET[0]\n    // convert digits to a string\n    for (var q = digits.length - 1; q >= 0; --q) string += ALPHABET[digits[q]]\n\n    return string\n  }\n\n  function decodeUnsafe (string) {\n    if (string.length === 0) return []\n\n    var bytes = [0]\n    for (var i = 0; i < string.length; i++) {\n      var value = ALPHABET_MAP[string[i]]\n      if (value === undefined) return\n\n      for (var j = 0, carry = value; j < bytes.length; ++j) {\n        carry += bytes[j] * BASE\n        bytes[j] = carry & 0xff\n        carry >>= 8\n      }\n\n      while (carry > 0) {\n        bytes.push(carry & 0xff)\n        carry >>= 8\n      }\n    }\n\n    // deal with leading zeros\n    for (var k = 0; string[k] === LEADER && k < string.length - 1; ++k) {\n      bytes.push(0)\n    }\n\n    return bytes.reverse()\n  }\n\n  function decode (string) {\n    var array = decodeUnsafe(string)\n    if (array) return array\n\n    throw new Error('Non-base' + BASE + ' character')\n  }\n\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","// (public) Constructor\nfunction BigInteger(a, b, c) {\n  if (!(this instanceof BigInteger))\n    return new BigInteger(a, b, c)\n\n  if (a != null) {\n    if (\"number\" == typeof a) this.fromNumber(a, b, c)\n    else if (b == null && \"string\" != typeof a) this.fromString(a, 256)\n    else this.fromString(a, b)\n  }\n}\n\nvar proto = BigInteger.prototype\n\n// duck-typed isBigInteger\nproto.__bigi = require('../package.json').version\nBigInteger.isBigInteger = function (obj, check_ver) {\n  return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi)\n}\n\n// Bits per digit\nvar dbits\n\n// am: Compute w_j += (x*this_i), propagate carries,\n// c is initial carry, returns final carry.\n// c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n// We need to select the fastest one that works in this environment.\n\n// am1: use a single mult and divide to get the high bits,\n// max digit bits should be 26 because\n// max internal value = 2*dvalue^2-2*dvalue (< 2^53)\nfunction am1(i, x, w, j, c, n) {\n  while (--n >= 0) {\n    var v = x * this[i++] + w[j] + c\n    c = Math.floor(v / 0x4000000)\n    w[j++] = v & 0x3ffffff\n  }\n  return c\n}\n// am2 avoids a big mult-and-extract completely.\n// Max digit bits should be <= 30 because we do bitwise ops\n// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\nfunction am2(i, x, w, j, c, n) {\n  var xl = x & 0x7fff,\n    xh = x >> 15\n  while (--n >= 0) {\n    var l = this[i] & 0x7fff\n    var h = this[i++] >> 15\n    var m = xh * l + h * xl\n    l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)\n    c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)\n    w[j++] = l & 0x3fffffff\n  }\n  return c\n}\n// Alternately, set max digit bits to 28 since some\n// browsers slow down when dealing with 32-bit numbers.\nfunction am3(i, x, w, j, c, n) {\n  var xl = x & 0x3fff,\n    xh = x >> 14\n  while (--n >= 0) {\n    var l = this[i] & 0x3fff\n    var h = this[i++] >> 14\n    var m = xh * l + h * xl\n    l = xl * l + ((m & 0x3fff) << 14) + w[j] + c\n    c = (l >> 28) + (m >> 14) + xh * h\n    w[j++] = l & 0xfffffff\n  }\n  return c\n}\n\n// wtf?\nBigInteger.prototype.am = am1\ndbits = 26\n\nBigInteger.prototype.DB = dbits\nBigInteger.prototype.DM = ((1 << dbits) - 1)\nvar DV = BigInteger.prototype.DV = (1 << dbits)\n\nvar BI_FP = 52\nBigInteger.prototype.FV = Math.pow(2, BI_FP)\nBigInteger.prototype.F1 = BI_FP - dbits\nBigInteger.prototype.F2 = 2 * dbits - BI_FP\n\n// Digit conversions\nvar BI_RM = \"0123456789abcdefghijklmnopqrstuvwxyz\"\nvar BI_RC = new Array()\nvar rr, vv\nrr = \"0\".charCodeAt(0)\nfor (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv\nrr = \"a\".charCodeAt(0)\nfor (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv\nrr = \"A\".charCodeAt(0)\nfor (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv\n\nfunction int2char(n) {\n  return BI_RM.charAt(n)\n}\n\nfunction intAt(s, i) {\n  var c = BI_RC[s.charCodeAt(i)]\n  return (c == null) ? -1 : c\n}\n\n// (protected) copy this to r\nfunction bnpCopyTo(r) {\n  for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]\n  r.t = this.t\n  r.s = this.s\n}\n\n// (protected) set from integer value x, -DV <= x < DV\nfunction bnpFromInt(x) {\n  this.t = 1\n  this.s = (x < 0) ? -1 : 0\n  if (x > 0) this[0] = x\n  else if (x < -1) this[0] = x + DV\n  else this.t = 0\n}\n\n// return bigint initialized to value\nfunction nbv(i) {\n  var r = new BigInteger()\n  r.fromInt(i)\n  return r\n}\n\n// (protected) set from string and radix\nfunction bnpFromString(s, b) {\n  var self = this\n\n  var k\n  if (b == 16) k = 4\n  else if (b == 8) k = 3\n  else if (b == 256) k = 8; // byte array\n  else if (b == 2) k = 1\n  else if (b == 32) k = 5\n  else if (b == 4) k = 2\n  else {\n    self.fromRadix(s, b)\n    return\n  }\n  self.t = 0\n  self.s = 0\n  var i = s.length,\n    mi = false,\n    sh = 0\n  while (--i >= 0) {\n    var x = (k == 8) ? s[i] & 0xff : intAt(s, i)\n    if (x < 0) {\n      if (s.charAt(i) == \"-\") mi = true\n      continue\n    }\n    mi = false\n    if (sh == 0)\n      self[self.t++] = x\n    else if (sh + k > self.DB) {\n      self[self.t - 1] |= (x & ((1 << (self.DB - sh)) - 1)) << sh\n      self[self.t++] = (x >> (self.DB - sh))\n    } else\n      self[self.t - 1] |= x << sh\n    sh += k\n    if (sh >= self.DB) sh -= self.DB\n  }\n  if (k == 8 && (s[0] & 0x80) != 0) {\n    self.s = -1\n    if (sh > 0) self[self.t - 1] |= ((1 << (self.DB - sh)) - 1) << sh\n  }\n  self.clamp()\n  if (mi) BigInteger.ZERO.subTo(self, self)\n}\n\n// (protected) clamp off excess high words\nfunction bnpClamp() {\n  var c = this.s & this.DM\n  while (this.t > 0 && this[this.t - 1] == c)--this.t\n}\n\n// (public) return string representation in given radix\nfunction bnToString(b) {\n  var self = this\n  if (self.s < 0) return \"-\" + self.negate()\n    .toString(b)\n  var k\n  if (b == 16) k = 4\n  else if (b == 8) k = 3\n  else if (b == 2) k = 1\n  else if (b == 32) k = 5\n  else if (b == 4) k = 2\n  else return self.toRadix(b)\n  var km = (1 << k) - 1,\n    d, m = false,\n    r = \"\",\n    i = self.t\n  var p = self.DB - (i * self.DB) % k\n  if (i-- > 0) {\n    if (p < self.DB && (d = self[i] >> p) > 0) {\n      m = true\n      r = int2char(d)\n    }\n    while (i >= 0) {\n      if (p < k) {\n        d = (self[i] & ((1 << p) - 1)) << (k - p)\n        d |= self[--i] >> (p += self.DB - k)\n      } else {\n        d = (self[i] >> (p -= k)) & km\n        if (p <= 0) {\n          p += self.DB\n          --i\n        }\n      }\n      if (d > 0) m = true\n      if (m) r += int2char(d)\n    }\n  }\n  return m ? r : \"0\"\n}\n\n// (public) -this\nfunction bnNegate() {\n  var r = new BigInteger()\n  BigInteger.ZERO.subTo(this, r)\n  return r\n}\n\n// (public) |this|\nfunction bnAbs() {\n  return (this.s < 0) ? this.negate() : this\n}\n\n// (public) return + if this > a, - if this < a, 0 if equal\nfunction bnCompareTo(a) {\n  var r = this.s - a.s\n  if (r != 0) return r\n  var i = this.t\n  r = i - a.t\n  if (r != 0) return (this.s < 0) ? -r : r\n  while (--i >= 0)\n    if ((r = this[i] - a[i]) != 0) return r\n  return 0\n}\n\n// returns bit length of the integer x\nfunction nbits(x) {\n  var r = 1,\n    t\n  if ((t = x >>> 16) != 0) {\n    x = t\n    r += 16\n  }\n  if ((t = x >> 8) != 0) {\n    x = t\n    r += 8\n  }\n  if ((t = x >> 4) != 0) {\n    x = t\n    r += 4\n  }\n  if ((t = x >> 2) != 0) {\n    x = t\n    r += 2\n  }\n  if ((t = x >> 1) != 0) {\n    x = t\n    r += 1\n  }\n  return r\n}\n\n// (public) return the number of bits in \"this\"\nfunction bnBitLength() {\n  if (this.t <= 0) return 0\n  return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))\n}\n\n// (public) return the number of bytes in \"this\"\nfunction bnByteLength() {\n  return this.bitLength() >> 3\n}\n\n// (protected) r = this << n*DB\nfunction bnpDLShiftTo(n, r) {\n  var i\n  for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]\n  for (i = n - 1; i >= 0; --i) r[i] = 0\n  r.t = this.t + n\n  r.s = this.s\n}\n\n// (protected) r = this >> n*DB\nfunction bnpDRShiftTo(n, r) {\n  for (var i = n; i < this.t; ++i) r[i - n] = this[i]\n  r.t = Math.max(this.t - n, 0)\n  r.s = this.s\n}\n\n// (protected) r = this << n\nfunction bnpLShiftTo(n, r) {\n  var self = this\n  var bs = n % self.DB\n  var cbs = self.DB - bs\n  var bm = (1 << cbs) - 1\n  var ds = Math.floor(n / self.DB),\n    c = (self.s << bs) & self.DM,\n    i\n  for (i = self.t - 1; i >= 0; --i) {\n    r[i + ds + 1] = (self[i] >> cbs) | c\n    c = (self[i] & bm) << bs\n  }\n  for (i = ds - 1; i >= 0; --i) r[i] = 0\n  r[ds] = c\n  r.t = self.t + ds + 1\n  r.s = self.s\n  r.clamp()\n}\n\n// (protected) r = this >> n\nfunction bnpRShiftTo(n, r) {\n  var self = this\n  r.s = self.s\n  var ds = Math.floor(n / self.DB)\n  if (ds >= self.t) {\n    r.t = 0\n    return\n  }\n  var bs = n % self.DB\n  var cbs = self.DB - bs\n  var bm = (1 << bs) - 1\n  r[0] = self[ds] >> bs\n  for (var i = ds + 1; i < self.t; ++i) {\n    r[i - ds - 1] |= (self[i] & bm) << cbs\n    r[i - ds] = self[i] >> bs\n  }\n  if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs\n  r.t = self.t - ds\n  r.clamp()\n}\n\n// (protected) r = this - a\nfunction bnpSubTo(a, r) {\n  var self = this\n  var i = 0,\n    c = 0,\n    m = Math.min(a.t, self.t)\n  while (i < m) {\n    c += self[i] - a[i]\n    r[i++] = c & self.DM\n    c >>= self.DB\n  }\n  if (a.t < self.t) {\n    c -= a.s\n    while (i < self.t) {\n      c += self[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += self.s\n  } else {\n    c += self.s\n    while (i < a.t) {\n      c -= a[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c -= a.s\n  }\n  r.s = (c < 0) ? -1 : 0\n  if (c < -1) r[i++] = self.DV + c\n  else if (c > 0) r[i++] = c\n  r.t = i\n  r.clamp()\n}\n\n// (protected) r = this * a, r != this,a (HAC 14.12)\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyTo(a, r) {\n  var x = this.abs(),\n    y = a.abs()\n  var i = x.t\n  r.t = i + y.t\n  while (--i >= 0) r[i] = 0\n  for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)\n  r.s = 0\n  r.clamp()\n  if (this.s != a.s) BigInteger.ZERO.subTo(r, r)\n}\n\n// (protected) r = this^2, r != this (HAC 14.16)\nfunction bnpSquareTo(r) {\n  var x = this.abs()\n  var i = r.t = 2 * x.t\n  while (--i >= 0) r[i] = 0\n  for (i = 0; i < x.t - 1; ++i) {\n    var c = x.am(i, x[i], r, 2 * i, 0, 1)\n    if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {\n      r[i + x.t] -= x.DV\n      r[i + x.t + 1] = 1\n    }\n  }\n  if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)\n  r.s = 0\n  r.clamp()\n}\n\n// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n// r != q, this != m.  q or r may be null.\nfunction bnpDivRemTo(m, q, r) {\n  var self = this\n  var pm = m.abs()\n  if (pm.t <= 0) return\n  var pt = self.abs()\n  if (pt.t < pm.t) {\n    if (q != null) q.fromInt(0)\n    if (r != null) self.copyTo(r)\n    return\n  }\n  if (r == null) r = new BigInteger()\n  var y = new BigInteger(),\n    ts = self.s,\n    ms = m.s\n  var nsh = self.DB - nbits(pm[pm.t - 1]); // normalize modulus\n  if (nsh > 0) {\n    pm.lShiftTo(nsh, y)\n    pt.lShiftTo(nsh, r)\n  } else {\n    pm.copyTo(y)\n    pt.copyTo(r)\n  }\n  var ys = y.t\n  var y0 = y[ys - 1]\n  if (y0 == 0) return\n  var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0)\n  var d1 = self.FV / yt,\n    d2 = (1 << self.F1) / yt,\n    e = 1 << self.F2\n  var i = r.t,\n    j = i - ys,\n    t = (q == null) ? new BigInteger() : q\n  y.dlShiftTo(j, t)\n  if (r.compareTo(t) >= 0) {\n    r[r.t++] = 1\n    r.subTo(t, r)\n  }\n  BigInteger.ONE.dlShiftTo(ys, t)\n  t.subTo(y, y); // \"negative\" y so we can replace sub with am later\n  while (y.t < ys) y[y.t++] = 0\n  while (--j >= 0) {\n    // Estimate quotient digit\n    var qd = (r[--i] == y0) ? self.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)\n    if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out\n      y.dlShiftTo(j, t)\n      r.subTo(t, r)\n      while (r[i] < --qd) r.subTo(t, r)\n    }\n  }\n  if (q != null) {\n    r.drShiftTo(ys, q)\n    if (ts != ms) BigInteger.ZERO.subTo(q, q)\n  }\n  r.t = ys\n  r.clamp()\n  if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder\n  if (ts < 0) BigInteger.ZERO.subTo(r, r)\n}\n\n// (public) this mod a\nfunction bnMod(a) {\n  var r = new BigInteger()\n  this.abs()\n    .divRemTo(a, null, r)\n  if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r)\n  return r\n}\n\n// Modular reduction using \"classic\" algorithm\nfunction Classic(m) {\n  this.m = m\n}\n\nfunction cConvert(x) {\n  if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m)\n  else return x\n}\n\nfunction cRevert(x) {\n  return x\n}\n\nfunction cReduce(x) {\n  x.divRemTo(this.m, null, x)\n}\n\nfunction cMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nfunction cSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\nClassic.prototype.convert = cConvert\nClassic.prototype.revert = cRevert\nClassic.prototype.reduce = cReduce\nClassic.prototype.mulTo = cMulTo\nClassic.prototype.sqrTo = cSqrTo\n\n// (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n// justification:\n//         xy == 1 (mod m)\n//         xy =  1+km\n//   xy(2-xy) = (1+km)(1-km)\n// x[y(2-xy)] = 1-k^2m^2\n// x[y(2-xy)] == 1 (mod m^2)\n// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n// JS multiply \"overflows\" differently from C/C++, so care is needed here.\nfunction bnpInvDigit() {\n  if (this.t < 1) return 0\n  var x = this[0]\n  if ((x & 1) == 0) return 0\n  var y = x & 3; // y == 1/x mod 2^2\n  y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4\n  y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8\n  y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16\n  // last step - calculate inverse mod DV directly\n  // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n  y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits\n  // we really want the negative inverse, and -DV < y < DV\n  return (y > 0) ? this.DV - y : -y\n}\n\n// Montgomery reduction\nfunction Montgomery(m) {\n  this.m = m\n  this.mp = m.invDigit()\n  this.mpl = this.mp & 0x7fff\n  this.mph = this.mp >> 15\n  this.um = (1 << (m.DB - 15)) - 1\n  this.mt2 = 2 * m.t\n}\n\n// xR mod m\nfunction montConvert(x) {\n  var r = new BigInteger()\n  x.abs()\n    .dlShiftTo(this.m.t, r)\n  r.divRemTo(this.m, null, r)\n  if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)\n  return r\n}\n\n// x/R mod m\nfunction montRevert(x) {\n  var r = new BigInteger()\n  x.copyTo(r)\n  this.reduce(r)\n  return r\n}\n\n// x = x/R mod m (HAC 14.32)\nfunction montReduce(x) {\n  while (x.t <= this.mt2) // pad x so am has enough room later\n    x[x.t++] = 0\n  for (var i = 0; i < this.m.t; ++i) {\n    // faster way of calculating u0 = x[i]*mp mod DV\n    var j = x[i] & 0x7fff\n    var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM\n    // use am to combine the multiply-shift-add into one call\n    j = i + this.m.t\n    x[j] += this.m.am(0, u0, x, i, 0, this.m.t)\n    // propagate carry\n    while (x[j] >= x.DV) {\n      x[j] -= x.DV\n      x[++j]++\n    }\n  }\n  x.clamp()\n  x.drShiftTo(this.m.t, x)\n  if (x.compareTo(this.m) >= 0) x.subTo(this.m, x)\n}\n\n// r = \"x^2/R mod m\"; x != r\nfunction montSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\n// r = \"xy/R mod m\"; x,y != r\nfunction montMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nMontgomery.prototype.convert = montConvert\nMontgomery.prototype.revert = montRevert\nMontgomery.prototype.reduce = montReduce\nMontgomery.prototype.mulTo = montMulTo\nMontgomery.prototype.sqrTo = montSqrTo\n\n// (protected) true iff this is even\nfunction bnpIsEven() {\n  return ((this.t > 0) ? (this[0] & 1) : this.s) == 0\n}\n\n// (protected) this^e, e < 2^32, doing sqr and mul with \"r\" (HAC 14.79)\nfunction bnpExp(e, z) {\n  if (e > 0xffffffff || e < 1) return BigInteger.ONE\n  var r = new BigInteger(),\n    r2 = new BigInteger(),\n    g = z.convert(this),\n    i = nbits(e) - 1\n  g.copyTo(r)\n  while (--i >= 0) {\n    z.sqrTo(r, r2)\n    if ((e & (1 << i)) > 0) z.mulTo(r2, g, r)\n    else {\n      var t = r\n      r = r2\n      r2 = t\n    }\n  }\n  return z.revert(r)\n}\n\n// (public) this^e % m, 0 <= e < 2^32\nfunction bnModPowInt(e, m) {\n  var z\n  if (e < 256 || m.isEven()) z = new Classic(m)\n  else z = new Montgomery(m)\n  return this.exp(e, z)\n}\n\n// protected\nproto.copyTo = bnpCopyTo\nproto.fromInt = bnpFromInt\nproto.fromString = bnpFromString\nproto.clamp = bnpClamp\nproto.dlShiftTo = bnpDLShiftTo\nproto.drShiftTo = bnpDRShiftTo\nproto.lShiftTo = bnpLShiftTo\nproto.rShiftTo = bnpRShiftTo\nproto.subTo = bnpSubTo\nproto.multiplyTo = bnpMultiplyTo\nproto.squareTo = bnpSquareTo\nproto.divRemTo = bnpDivRemTo\nproto.invDigit = bnpInvDigit\nproto.isEven = bnpIsEven\nproto.exp = bnpExp\n\n// public\nproto.toString = bnToString\nproto.negate = bnNegate\nproto.abs = bnAbs\nproto.compareTo = bnCompareTo\nproto.bitLength = bnBitLength\nproto.byteLength = bnByteLength\nproto.mod = bnMod\nproto.modPowInt = bnModPowInt\n\n// (public)\nfunction bnClone() {\n  var r = new BigInteger()\n  this.copyTo(r)\n  return r\n}\n\n// (public) return value as integer\nfunction bnIntValue() {\n  if (this.s < 0) {\n    if (this.t == 1) return this[0] - this.DV\n    else if (this.t == 0) return -1\n  } else if (this.t == 1) return this[0]\n  else if (this.t == 0) return 0\n  // assumes 16 < DB < 32\n  return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]\n}\n\n// (public) return value as byte\nfunction bnByteValue() {\n  return (this.t == 0) ? this.s : (this[0] << 24) >> 24\n}\n\n// (public) return value as short (assumes DB>=16)\nfunction bnShortValue() {\n  return (this.t == 0) ? this.s : (this[0] << 16) >> 16\n}\n\n// (protected) return x s.t. r^x < DV\nfunction bnpChunkSize(r) {\n  return Math.floor(Math.LN2 * this.DB / Math.log(r))\n}\n\n// (public) 0 if this == 0, 1 if this > 0\nfunction bnSigNum() {\n  if (this.s < 0) return -1\n  else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0\n  else return 1\n}\n\n// (protected) convert to radix string\nfunction bnpToRadix(b) {\n  if (b == null) b = 10\n  if (this.signum() == 0 || b < 2 || b > 36) return \"0\"\n  var cs = this.chunkSize(b)\n  var a = Math.pow(b, cs)\n  var d = nbv(a),\n    y = new BigInteger(),\n    z = new BigInteger(),\n    r = \"\"\n  this.divRemTo(d, y, z)\n  while (y.signum() > 0) {\n    r = (a + z.intValue())\n      .toString(b)\n      .substr(1) + r\n    y.divRemTo(d, y, z)\n  }\n  return z.intValue()\n    .toString(b) + r\n}\n\n// (protected) convert from radix string\nfunction bnpFromRadix(s, b) {\n  var self = this\n  self.fromInt(0)\n  if (b == null) b = 10\n  var cs = self.chunkSize(b)\n  var d = Math.pow(b, cs),\n    mi = false,\n    j = 0,\n    w = 0\n  for (var i = 0; i < s.length; ++i) {\n    var x = intAt(s, i)\n    if (x < 0) {\n      if (s.charAt(i) == \"-\" && self.signum() == 0) mi = true\n      continue\n    }\n    w = b * w + x\n    if (++j >= cs) {\n      self.dMultiply(d)\n      self.dAddOffset(w, 0)\n      j = 0\n      w = 0\n    }\n  }\n  if (j > 0) {\n    self.dMultiply(Math.pow(b, j))\n    self.dAddOffset(w, 0)\n  }\n  if (mi) BigInteger.ZERO.subTo(self, self)\n}\n\n// (protected) alternate constructor\nfunction bnpFromNumber(a, b, c) {\n  var self = this\n  if (\"number\" == typeof b) {\n    // new BigInteger(int,int,RNG)\n    if (a < 2) self.fromInt(1)\n    else {\n      self.fromNumber(a, c)\n      if (!self.testBit(a - 1)) // force MSB set\n        self.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, self)\n      if (self.isEven()) self.dAddOffset(1, 0); // force odd\n      while (!self.isProbablePrime(b)) {\n        self.dAddOffset(2, 0)\n        if (self.bitLength() > a) self.subTo(BigInteger.ONE.shiftLeft(a - 1), self)\n      }\n    }\n  } else {\n    // new BigInteger(int,RNG)\n    var x = new Array(),\n      t = a & 7\n    x.length = (a >> 3) + 1\n    b.nextBytes(x)\n    if (t > 0) x[0] &= ((1 << t) - 1)\n    else x[0] = 0\n    self.fromString(x, 256)\n  }\n}\n\n// (public) convert to bigendian byte array\nfunction bnToByteArray() {\n  var self = this\n  var i = self.t,\n    r = new Array()\n  r[0] = self.s\n  var p = self.DB - (i * self.DB) % 8,\n    d, k = 0\n  if (i-- > 0) {\n    if (p < self.DB && (d = self[i] >> p) != (self.s & self.DM) >> p)\n      r[k++] = d | (self.s << (self.DB - p))\n    while (i >= 0) {\n      if (p < 8) {\n        d = (self[i] & ((1 << p) - 1)) << (8 - p)\n        d |= self[--i] >> (p += self.DB - 8)\n      } else {\n        d = (self[i] >> (p -= 8)) & 0xff\n        if (p <= 0) {\n          p += self.DB\n          --i\n        }\n      }\n      if ((d & 0x80) != 0) d |= -256\n      if (k === 0 && (self.s & 0x80) != (d & 0x80))++k\n      if (k > 0 || d != self.s) r[k++] = d\n    }\n  }\n  return r\n}\n\nfunction bnEquals(a) {\n  return (this.compareTo(a) == 0)\n}\n\nfunction bnMin(a) {\n  return (this.compareTo(a) < 0) ? this : a\n}\n\nfunction bnMax(a) {\n  return (this.compareTo(a) > 0) ? this : a\n}\n\n// (protected) r = this op a (bitwise)\nfunction bnpBitwiseTo(a, op, r) {\n  var self = this\n  var i, f, m = Math.min(a.t, self.t)\n  for (i = 0; i < m; ++i) r[i] = op(self[i], a[i])\n  if (a.t < self.t) {\n    f = a.s & self.DM\n    for (i = m; i < self.t; ++i) r[i] = op(self[i], f)\n    r.t = self.t\n  } else {\n    f = self.s & self.DM\n    for (i = m; i < a.t; ++i) r[i] = op(f, a[i])\n    r.t = a.t\n  }\n  r.s = op(self.s, a.s)\n  r.clamp()\n}\n\n// (public) this & a\nfunction op_and(x, y) {\n  return x & y\n}\n\nfunction bnAnd(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_and, r)\n  return r\n}\n\n// (public) this | a\nfunction op_or(x, y) {\n  return x | y\n}\n\nfunction bnOr(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_or, r)\n  return r\n}\n\n// (public) this ^ a\nfunction op_xor(x, y) {\n  return x ^ y\n}\n\nfunction bnXor(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_xor, r)\n  return r\n}\n\n// (public) this & ~a\nfunction op_andnot(x, y) {\n  return x & ~y\n}\n\nfunction bnAndNot(a) {\n  var r = new BigInteger()\n  this.bitwiseTo(a, op_andnot, r)\n  return r\n}\n\n// (public) ~this\nfunction bnNot() {\n  var r = new BigInteger()\n  for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i]\n  r.t = this.t\n  r.s = ~this.s\n  return r\n}\n\n// (public) this << n\nfunction bnShiftLeft(n) {\n  var r = new BigInteger()\n  if (n < 0) this.rShiftTo(-n, r)\n  else this.lShiftTo(n, r)\n  return r\n}\n\n// (public) this >> n\nfunction bnShiftRight(n) {\n  var r = new BigInteger()\n  if (n < 0) this.lShiftTo(-n, r)\n  else this.rShiftTo(n, r)\n  return r\n}\n\n// return index of lowest 1-bit in x, x < 2^31\nfunction lbit(x) {\n  if (x == 0) return -1\n  var r = 0\n  if ((x & 0xffff) == 0) {\n    x >>= 16\n    r += 16\n  }\n  if ((x & 0xff) == 0) {\n    x >>= 8\n    r += 8\n  }\n  if ((x & 0xf) == 0) {\n    x >>= 4\n    r += 4\n  }\n  if ((x & 3) == 0) {\n    x >>= 2\n    r += 2\n  }\n  if ((x & 1) == 0)++r\n  return r\n}\n\n// (public) returns index of lowest 1-bit (or -1 if none)\nfunction bnGetLowestSetBit() {\n  for (var i = 0; i < this.t; ++i)\n    if (this[i] != 0) return i * this.DB + lbit(this[i])\n  if (this.s < 0) return this.t * this.DB\n  return -1\n}\n\n// return number of 1 bits in x\nfunction cbit(x) {\n  var r = 0\n  while (x != 0) {\n    x &= x - 1\n    ++r\n  }\n  return r\n}\n\n// (public) return number of set bits\nfunction bnBitCount() {\n  var r = 0,\n    x = this.s & this.DM\n  for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x)\n  return r\n}\n\n// (public) true iff nth bit is set\nfunction bnTestBit(n) {\n  var j = Math.floor(n / this.DB)\n  if (j >= this.t) return (this.s != 0)\n  return ((this[j] & (1 << (n % this.DB))) != 0)\n}\n\n// (protected) this op (1<<n)\nfunction bnpChangeBit(n, op) {\n  var r = BigInteger.ONE.shiftLeft(n)\n  this.bitwiseTo(r, op, r)\n  return r\n}\n\n// (public) this | (1<<n)\nfunction bnSetBit(n) {\n  return this.changeBit(n, op_or)\n}\n\n// (public) this & ~(1<<n)\nfunction bnClearBit(n) {\n  return this.changeBit(n, op_andnot)\n}\n\n// (public) this ^ (1<<n)\nfunction bnFlipBit(n) {\n  return this.changeBit(n, op_xor)\n}\n\n// (protected) r = this + a\nfunction bnpAddTo(a, r) {\n  var self = this\n\n  var i = 0,\n    c = 0,\n    m = Math.min(a.t, self.t)\n  while (i < m) {\n    c += self[i] + a[i]\n    r[i++] = c & self.DM\n    c >>= self.DB\n  }\n  if (a.t < self.t) {\n    c += a.s\n    while (i < self.t) {\n      c += self[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += self.s\n  } else {\n    c += self.s\n    while (i < a.t) {\n      c += a[i]\n      r[i++] = c & self.DM\n      c >>= self.DB\n    }\n    c += a.s\n  }\n  r.s = (c < 0) ? -1 : 0\n  if (c > 0) r[i++] = c\n  else if (c < -1) r[i++] = self.DV + c\n  r.t = i\n  r.clamp()\n}\n\n// (public) this + a\nfunction bnAdd(a) {\n  var r = new BigInteger()\n  this.addTo(a, r)\n  return r\n}\n\n// (public) this - a\nfunction bnSubtract(a) {\n  var r = new BigInteger()\n  this.subTo(a, r)\n  return r\n}\n\n// (public) this * a\nfunction bnMultiply(a) {\n  var r = new BigInteger()\n  this.multiplyTo(a, r)\n  return r\n}\n\n// (public) this^2\nfunction bnSquare() {\n  var r = new BigInteger()\n  this.squareTo(r)\n  return r\n}\n\n// (public) this / a\nfunction bnDivide(a) {\n  var r = new BigInteger()\n  this.divRemTo(a, r, null)\n  return r\n}\n\n// (public) this % a\nfunction bnRemainder(a) {\n  var r = new BigInteger()\n  this.divRemTo(a, null, r)\n  return r\n}\n\n// (public) [this/a,this%a]\nfunction bnDivideAndRemainder(a) {\n  var q = new BigInteger(),\n    r = new BigInteger()\n  this.divRemTo(a, q, r)\n  return new Array(q, r)\n}\n\n// (protected) this *= n, this >= 0, 1 < n < DV\nfunction bnpDMultiply(n) {\n  this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)\n  ++this.t\n  this.clamp()\n}\n\n// (protected) this += n << w words, this >= 0\nfunction bnpDAddOffset(n, w) {\n  if (n == 0) return\n  while (this.t <= w) this[this.t++] = 0\n  this[w] += n\n  while (this[w] >= this.DV) {\n    this[w] -= this.DV\n    if (++w >= this.t) this[this.t++] = 0\n    ++this[w]\n  }\n}\n\n// A \"null\" reducer\nfunction NullExp() {}\n\nfunction nNop(x) {\n  return x\n}\n\nfunction nMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n}\n\nfunction nSqrTo(x, r) {\n  x.squareTo(r)\n}\n\nNullExp.prototype.convert = nNop\nNullExp.prototype.revert = nNop\nNullExp.prototype.mulTo = nMulTo\nNullExp.prototype.sqrTo = nSqrTo\n\n// (public) this^e\nfunction bnPow(e) {\n  return this.exp(e, new NullExp())\n}\n\n// (protected) r = lower n words of \"this * a\", a.t <= n\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyLowerTo(a, n, r) {\n  var i = Math.min(this.t + a.t, n)\n  r.s = 0; // assumes a,this >= 0\n  r.t = i\n  while (i > 0) r[--i] = 0\n  var j\n  for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t)\n  for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i)\n  r.clamp()\n}\n\n// (protected) r = \"this * a\" without lower n words, n > 0\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyUpperTo(a, n, r) {\n  --n\n  var i = r.t = this.t + a.t - n\n  r.s = 0; // assumes a,this >= 0\n  while (--i >= 0) r[i] = 0\n  for (i = Math.max(n - this.t, 0); i < a.t; ++i)\n    r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n)\n  r.clamp()\n  r.drShiftTo(1, r)\n}\n\n// Barrett modular reduction\nfunction Barrett(m) {\n  // setup Barrett\n  this.r2 = new BigInteger()\n  this.q3 = new BigInteger()\n  BigInteger.ONE.dlShiftTo(2 * m.t, this.r2)\n  this.mu = this.r2.divide(m)\n  this.m = m\n}\n\nfunction barrettConvert(x) {\n  if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m)\n  else if (x.compareTo(this.m) < 0) return x\n  else {\n    var r = new BigInteger()\n    x.copyTo(r)\n    this.reduce(r)\n    return r\n  }\n}\n\nfunction barrettRevert(x) {\n  return x\n}\n\n// x = x mod m (HAC 14.42)\nfunction barrettReduce(x) {\n  var self = this\n  x.drShiftTo(self.m.t - 1, self.r2)\n  if (x.t > self.m.t + 1) {\n    x.t = self.m.t + 1\n    x.clamp()\n  }\n  self.mu.multiplyUpperTo(self.r2, self.m.t + 1, self.q3)\n  self.m.multiplyLowerTo(self.q3, self.m.t + 1, self.r2)\n  while (x.compareTo(self.r2) < 0) x.dAddOffset(1, self.m.t + 1)\n  x.subTo(self.r2, x)\n  while (x.compareTo(self.m) >= 0) x.subTo(self.m, x)\n}\n\n// r = x^2 mod m; x != r\nfunction barrettSqrTo(x, r) {\n  x.squareTo(r)\n  this.reduce(r)\n}\n\n// r = x*y mod m; x,y != r\nfunction barrettMulTo(x, y, r) {\n  x.multiplyTo(y, r)\n  this.reduce(r)\n}\n\nBarrett.prototype.convert = barrettConvert\nBarrett.prototype.revert = barrettRevert\nBarrett.prototype.reduce = barrettReduce\nBarrett.prototype.mulTo = barrettMulTo\nBarrett.prototype.sqrTo = barrettSqrTo\n\n// (public) this^e % m (HAC 14.85)\nfunction bnModPow(e, m) {\n  var i = e.bitLength(),\n    k, r = nbv(1),\n    z\n  if (i <= 0) return r\n  else if (i < 18) k = 1\n  else if (i < 48) k = 3\n  else if (i < 144) k = 4\n  else if (i < 768) k = 5\n  else k = 6\n  if (i < 8)\n    z = new Classic(m)\n  else if (m.isEven())\n    z = new Barrett(m)\n  else\n    z = new Montgomery(m)\n\n  // precomputation\n  var g = new Array(),\n    n = 3,\n    k1 = k - 1,\n    km = (1 << k) - 1\n  g[1] = z.convert(this)\n  if (k > 1) {\n    var g2 = new BigInteger()\n    z.sqrTo(g[1], g2)\n    while (n <= km) {\n      g[n] = new BigInteger()\n      z.mulTo(g2, g[n - 2], g[n])\n      n += 2\n    }\n  }\n\n  var j = e.t - 1,\n    w, is1 = true,\n    r2 = new BigInteger(),\n    t\n  i = nbits(e[j]) - 1\n  while (j >= 0) {\n    if (i >= k1) w = (e[j] >> (i - k1)) & km\n    else {\n      w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)\n      if (j > 0) w |= e[j - 1] >> (this.DB + i - k1)\n    }\n\n    n = k\n    while ((w & 1) == 0) {\n      w >>= 1\n      --n\n    }\n    if ((i -= n) < 0) {\n      i += this.DB\n      --j\n    }\n    if (is1) { // ret == 1, don't bother squaring or multiplying it\n      g[w].copyTo(r)\n      is1 = false\n    } else {\n      while (n > 1) {\n        z.sqrTo(r, r2)\n        z.sqrTo(r2, r)\n        n -= 2\n      }\n      if (n > 0) z.sqrTo(r, r2)\n      else {\n        t = r\n        r = r2\n        r2 = t\n      }\n      z.mulTo(r2, g[w], r)\n    }\n\n    while (j >= 0 && (e[j] & (1 << i)) == 0) {\n      z.sqrTo(r, r2)\n      t = r\n      r = r2\n      r2 = t\n      if (--i < 0) {\n        i = this.DB - 1\n        --j\n      }\n    }\n  }\n  return z.revert(r)\n}\n\n// (public) gcd(this,a) (HAC 14.54)\nfunction bnGCD(a) {\n  var x = (this.s < 0) ? this.negate() : this.clone()\n  var y = (a.s < 0) ? a.negate() : a.clone()\n  if (x.compareTo(y) < 0) {\n    var t = x\n    x = y\n    y = t\n  }\n  var i = x.getLowestSetBit(),\n    g = y.getLowestSetBit()\n  if (g < 0) return x\n  if (i < g) g = i\n  if (g > 0) {\n    x.rShiftTo(g, x)\n    y.rShiftTo(g, y)\n  }\n  while (x.signum() > 0) {\n    if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x)\n    if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y)\n    if (x.compareTo(y) >= 0) {\n      x.subTo(y, x)\n      x.rShiftTo(1, x)\n    } else {\n      y.subTo(x, y)\n      y.rShiftTo(1, y)\n    }\n  }\n  if (g > 0) y.lShiftTo(g, y)\n  return y\n}\n\n// (protected) this % n, n < 2^26\nfunction bnpModInt(n) {\n  if (n <= 0) return 0\n  var d = this.DV % n,\n    r = (this.s < 0) ? n - 1 : 0\n  if (this.t > 0)\n    if (d == 0) r = this[0] % n\n    else\n      for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n\n  return r\n}\n\n// (public) 1/this % m (HAC 14.61)\nfunction bnModInverse(m) {\n  var ac = m.isEven()\n  if (this.signum() === 0) throw new Error('division by zero')\n  if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO\n  var u = m.clone(),\n    v = this.clone()\n  var a = nbv(1),\n    b = nbv(0),\n    c = nbv(0),\n    d = nbv(1)\n  while (u.signum() != 0) {\n    while (u.isEven()) {\n      u.rShiftTo(1, u)\n      if (ac) {\n        if (!a.isEven() || !b.isEven()) {\n          a.addTo(this, a)\n          b.subTo(m, b)\n        }\n        a.rShiftTo(1, a)\n      } else if (!b.isEven()) b.subTo(m, b)\n      b.rShiftTo(1, b)\n    }\n    while (v.isEven()) {\n      v.rShiftTo(1, v)\n      if (ac) {\n        if (!c.isEven() || !d.isEven()) {\n          c.addTo(this, c)\n          d.subTo(m, d)\n        }\n        c.rShiftTo(1, c)\n      } else if (!d.isEven()) d.subTo(m, d)\n      d.rShiftTo(1, d)\n    }\n    if (u.compareTo(v) >= 0) {\n      u.subTo(v, u)\n      if (ac) a.subTo(c, a)\n      b.subTo(d, b)\n    } else {\n      v.subTo(u, v)\n      if (ac) c.subTo(a, c)\n      d.subTo(b, d)\n    }\n  }\n  if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO\n  while (d.compareTo(m) >= 0) d.subTo(m, d)\n  while (d.signum() < 0) d.addTo(m, d)\n  return d\n}\n\nvar lowprimes = [\n  2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,\n  73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,\n  157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,\n  239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,\n  331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,\n  421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,\n  509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,\n  613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,\n  709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,\n  821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,\n  919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997\n]\n\nvar lplim = (1 << 26) / lowprimes[lowprimes.length - 1]\n\n// (public) test primality with certainty >= 1-.5^t\nfunction bnIsProbablePrime(t) {\n  var i, x = this.abs()\n  if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {\n    for (i = 0; i < lowprimes.length; ++i)\n      if (x[0] == lowprimes[i]) return true\n    return false\n  }\n  if (x.isEven()) return false\n  i = 1\n  while (i < lowprimes.length) {\n    var m = lowprimes[i],\n      j = i + 1\n    while (j < lowprimes.length && m < lplim) m *= lowprimes[j++]\n    m = x.modInt(m)\n    while (i < j) if (m % lowprimes[i++] == 0) return false\n  }\n  return x.millerRabin(t)\n}\n\n// (protected) true if probably prime (HAC 4.24, Miller-Rabin)\nfunction bnpMillerRabin(t) {\n  var n1 = this.subtract(BigInteger.ONE)\n  var k = n1.getLowestSetBit()\n  if (k <= 0) return false\n  var r = n1.shiftRight(k)\n  t = (t + 1) >> 1\n  if (t > lowprimes.length) t = lowprimes.length\n  var a = new BigInteger(null)\n  var j, bases = []\n  for (var i = 0; i < t; ++i) {\n    for (;;) {\n      j = lowprimes[Math.floor(Math.random() * lowprimes.length)]\n      if (bases.indexOf(j) == -1) break\n    }\n    bases.push(j)\n    a.fromInt(j)\n    var y = a.modPow(r, this)\n    if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {\n      var j = 1\n      while (j++ < k && y.compareTo(n1) != 0) {\n        y = y.modPowInt(2, this)\n        if (y.compareTo(BigInteger.ONE) == 0) return false\n      }\n      if (y.compareTo(n1) != 0) return false\n    }\n  }\n  return true\n}\n\n// protected\nproto.chunkSize = bnpChunkSize\nproto.toRadix = bnpToRadix\nproto.fromRadix = bnpFromRadix\nproto.fromNumber = bnpFromNumber\nproto.bitwiseTo = bnpBitwiseTo\nproto.changeBit = bnpChangeBit\nproto.addTo = bnpAddTo\nproto.dMultiply = bnpDMultiply\nproto.dAddOffset = bnpDAddOffset\nproto.multiplyLowerTo = bnpMultiplyLowerTo\nproto.multiplyUpperTo = bnpMultiplyUpperTo\nproto.modInt = bnpModInt\nproto.millerRabin = bnpMillerRabin\n\n// public\nproto.clone = bnClone\nproto.intValue = bnIntValue\nproto.byteValue = bnByteValue\nproto.shortValue = bnShortValue\nproto.signum = bnSigNum\nproto.toByteArray = bnToByteArray\nproto.equals = bnEquals\nproto.min = bnMin\nproto.max = bnMax\nproto.and = bnAnd\nproto.or = bnOr\nproto.xor = bnXor\nproto.andNot = bnAndNot\nproto.not = bnNot\nproto.shiftLeft = bnShiftLeft\nproto.shiftRight = bnShiftRight\nproto.getLowestSetBit = bnGetLowestSetBit\nproto.bitCount = bnBitCount\nproto.testBit = bnTestBit\nproto.setBit = bnSetBit\nproto.clearBit = bnClearBit\nproto.flipBit = bnFlipBit\nproto.add = bnAdd\nproto.subtract = bnSubtract\nproto.multiply = bnMultiply\nproto.divide = bnDivide\nproto.remainder = bnRemainder\nproto.divideAndRemainder = bnDivideAndRemainder\nproto.modPow = bnModPow\nproto.modInverse = bnModInverse\nproto.pow = bnPow\nproto.gcd = bnGCD\nproto.isProbablePrime = bnIsProbablePrime\n\n// JSBN-specific extension\nproto.square = bnSquare\n\n// constants\nBigInteger.ZERO = nbv(0)\nBigInteger.ONE = nbv(1)\nBigInteger.valueOf = nbv\n\nmodule.exports = BigInteger\n","// FIXME: Kind of a weird way to throw exceptions, consider removing\nvar assert = require('assert')\nvar BigInteger = require('./bigi')\n\n/**\n * Turns a byte array into a big integer.\n *\n * This function will interpret a byte array as a big integer in big\n * endian notation.\n */\nBigInteger.fromByteArrayUnsigned = function(byteArray) {\n  // BigInteger expects a DER integer conformant byte array\n  if (byteArray[0] & 0x80) {\n    return new BigInteger([0].concat(byteArray))\n  }\n\n  return new BigInteger(byteArray)\n}\n\n/**\n * Returns a byte array representation of the big integer.\n *\n * This returns the absolute of the contained value in big endian\n * form. A value of zero results in an empty array.\n */\nBigInteger.prototype.toByteArrayUnsigned = function() {\n  var byteArray = this.toByteArray()\n  return byteArray[0] === 0 ? byteArray.slice(1) : byteArray\n}\n\nBigInteger.fromDERInteger = function(byteArray) {\n  return new BigInteger(byteArray)\n}\n\n/*\n * Converts BigInteger to a DER integer representation.\n *\n * The format for this value uses the most significant bit as a sign\n * bit.  If the most significant bit is already set and the integer is\n * positive, a 0x00 is prepended.\n *\n * Examples:\n *\n *      0 =>     0x00\n *      1 =>     0x01\n *     -1 =>     0xff\n *    127 =>     0x7f\n *   -127 =>     0x81\n *    128 =>   0x0080\n *   -128 =>     0x80\n *    255 =>   0x00ff\n *   -255 =>   0xff01\n *  16300 =>   0x3fac\n * -16300 =>   0xc054\n *  62300 => 0x00f35c\n * -62300 => 0xff0ca4\n*/\nBigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray\n\nBigInteger.fromBuffer = function(buffer) {\n  // BigInteger expects a DER integer conformant byte array\n  if (buffer[0] & 0x80) {\n    var byteArray = Array.prototype.slice.call(buffer)\n\n    return new BigInteger([0].concat(byteArray))\n  }\n\n  return new BigInteger(buffer)\n}\n\nBigInteger.fromHex = function(hex) {\n  if (hex === '') return BigInteger.ZERO\n\n  assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')\n  assert.equal(hex.length % 2, 0, 'Incomplete hex')\n  return new BigInteger(hex, 16)\n}\n\nBigInteger.prototype.toBuffer = function(size) {\n  var byteArray = this.toByteArrayUnsigned()\n  var zeros = []\n\n  var padding = size - byteArray.length\n  while (zeros.length < padding) zeros.push(0)\n\n  return new Buffer(zeros.concat(byteArray))\n}\n\nBigInteger.prototype.toHex = function(size) {\n  return this.toBuffer(size).toString('hex')\n}\n","var BigInteger = require('./bigi')\n\n//addons\nrequire('./convert')\n\nmodule.exports = BigInteger","module.exports={\n  \"_from\": \"bigi@^1.4.1\",\n  \"_id\": \"bigi@1.4.2\",\n  \"_inBundle\": false,\n  \"_integrity\": \"sha1-nGZalfiLiwj8Bc/XMfVhhZ1yWCU=\",\n  \"_location\": \"/peerplaysjs-lib/bigi\",\n  \"_phantomChildren\": {},\n  \"_requested\": {\n    \"type\": \"range\",\n    \"registry\": true,\n    \"raw\": \"bigi@^1.4.1\",\n    \"name\": \"bigi\",\n    \"escapedName\": \"bigi\",\n    \"rawSpec\": \"^1.4.1\",\n    \"saveSpec\": null,\n    \"fetchSpec\": \"^1.4.1\"\n  },\n  \"_requiredBy\": [\n    \"/peerplaysjs-lib\",\n    \"/peerplaysjs-lib/ecurve\"\n  ],\n  \"_resolved\": \"https://registry.npmjs.org/bigi/-/bigi-1.4.2.tgz\",\n  \"_shasum\": \"9c665a95f88b8b08fc05cfd731f561859d725825\",\n  \"_spec\": \"bigi@^1.4.1\",\n  \"_where\": \"/Users/mseaward/Documents/code/peerplaysjs-lib\",\n  \"bugs\": {\n    \"url\": \"https://github.com/cryptocoinjs/bigi/issues\"\n  },\n  \"bundleDependencies\": false,\n  \"dependencies\": {},\n  \"deprecated\": false,\n  \"description\": \"Big integers.\",\n  \"devDependencies\": {\n    \"coveralls\": \"^2.11.2\",\n    \"istanbul\": \"^0.3.5\",\n    \"jshint\": \"^2.5.1\",\n    \"mocha\": \"^2.1.0\",\n    \"mochify\": \"^2.1.0\"\n  },\n  \"homepage\": \"https://github.com/cryptocoinjs/bigi#readme\",\n  \"keywords\": [\n    \"cryptography\",\n    \"math\",\n    \"bitcoin\",\n    \"arbitrary\",\n    \"precision\",\n    \"arithmetic\",\n    \"big\",\n    \"integer\",\n    \"int\",\n    \"number\",\n    \"biginteger\",\n    \"bigint\",\n    \"bignumber\",\n    \"decimal\",\n    \"float\"\n  ],\n  \"main\": \"./lib/index.js\",\n  \"name\": \"bigi\",\n  \"repository\": {\n    \"url\": \"git+https://github.com/cryptocoinjs/bigi.git\",\n    \"type\": \"git\"\n  },\n  \"scripts\": {\n    \"browser-test\": \"mochify --wd -R spec\",\n    \"coverage\": \"istanbul cover ./node_modules/.bin/_mocha -- --reporter list test/*.js\",\n    \"coveralls\": \"npm run-script coverage && node ./node_modules/.bin/coveralls < coverage/lcov.info\",\n    \"jshint\": \"jshint --config jshint.json lib/*.js ; true\",\n    \"test\": \"_mocha -- test/*.js\",\n    \"unit\": \"mocha\"\n  },\n  \"testling\": {\n    \"files\": \"test/*.js\",\n    \"harness\": \"mocha\",\n    \"browsers\": [\n      \"ie/9..latest\",\n      \"firefox/latest\",\n      \"chrome/latest\",\n      \"safari/6.0..latest\",\n      \"iphone/6.0..latest\",\n      \"android-browser/4.2..latest\"\n    ]\n  },\n  \"version\": \"1.4.2\"\n}\n","","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar Buffer = require('buffer').Buffer;\n\nvar isBufferEncoding = Buffer.isEncoding\n  || function(encoding) {\n       switch (encoding && encoding.toLowerCase()) {\n         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;\n         default: return false;\n       }\n     }\n\n\nfunction assertEncoding(encoding) {\n  if (encoding && !isBufferEncoding(encoding)) {\n    throw new Error('Unknown encoding: ' + encoding);\n  }\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters. CESU-8 is handled as part of the UTF-8 encoding.\n//\n// @TODO Handling all encodings inside a single object makes it very difficult\n// to reason about this code, so it should be split up in the future.\n// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code\n// points as used by CESU-8.\nvar StringDecoder = exports.StringDecoder = function(encoding) {\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\n  assertEncoding(encoding);\n  switch (this.encoding) {\n    case 'utf8':\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\n      this.surrogateSize = 3;\n      break;\n    case 'ucs2':\n    case 'utf16le':\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\n      this.surrogateSize = 2;\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\n      break;\n    case 'base64':\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\n      this.surrogateSize = 3;\n      this.detectIncompleteChar = base64DetectIncompleteChar;\n      break;\n    default:\n      this.write = passThroughWrite;\n      return;\n  }\n\n  // Enough space to store all bytes of a single character. UTF-8 needs 4\n  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).\n  this.charBuffer = new Buffer(6);\n  // Number of bytes received for the current incomplete multi-byte character.\n  this.charReceived = 0;\n  // Number of bytes expected for the current incomplete multi-byte character.\n  this.charLength = 0;\n};\n\n\n// write decodes the given buffer and returns it as JS string that is\n// guaranteed to not contain any partial multi-byte characters. Any partial\n// character found at the end of the buffer is buffered up, and will be\n// returned when calling write again with the remaining bytes.\n//\n// Note: Converting a Buffer containing an orphan surrogate to a String\n// currently works, but converting a String to a Buffer (via `new Buffer`, or\n// Buffer#write) will replace incomplete surrogates with the unicode\n// replacement character. See https://codereview.chromium.org/121173009/ .\nStringDecoder.prototype.write = function(buffer) {\n  var charStr = '';\n  // if our last write ended with an incomplete multibyte character\n  while (this.charLength) {\n    // determine how many remaining bytes this buffer has to offer for this char\n    var available = (buffer.length >= this.charLength - this.charReceived) ?\n        this.charLength - this.charReceived :\n        buffer.length;\n\n    // add the new bytes to the char buffer\n    buffer.copy(this.charBuffer, this.charReceived, 0, available);\n    this.charReceived += available;\n\n    if (this.charReceived < this.charLength) {\n      // still not enough chars in this buffer? wait for more ...\n      return '';\n    }\n\n    // remove bytes belonging to the current character from the buffer\n    buffer = buffer.slice(available, buffer.length);\n\n    // get the character that was split\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\n\n    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n    var charCode = charStr.charCodeAt(charStr.length - 1);\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n      this.charLength += this.surrogateSize;\n      charStr = '';\n      continue;\n    }\n    this.charReceived = this.charLength = 0;\n\n    // if there are no more bytes in this buffer, just emit our char\n    if (buffer.length === 0) {\n      return charStr;\n    }\n    break;\n  }\n\n  // determine and set charLength / charReceived\n  this.detectIncompleteChar(buffer);\n\n  var end = buffer.length;\n  if (this.charLength) {\n    // buffer the incomplete character bytes we got\n    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);\n    end -= this.charReceived;\n  }\n\n  charStr += buffer.toString(this.encoding, 0, end);\n\n  var end = charStr.length - 1;\n  var charCode = charStr.charCodeAt(end);\n  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n    var size = this.surrogateSize;\n    this.charLength += size;\n    this.charReceived += size;\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\n    buffer.copy(this.charBuffer, 0, 0, size);\n    return charStr.substring(0, end);\n  }\n\n  // or just emit the charStr\n  return charStr;\n};\n\n// detectIncompleteChar determines if there is an incomplete UTF-8 character at\n// the end of the given buffer. If so, it sets this.charLength to the byte\n// length that character, and sets this.charReceived to the number of bytes\n// that are available for this character.\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\n  // determine how many bytes we have to check at the end of this buffer\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\n\n  // Figure out if one of the last i bytes of our buffer announces an\n  // incomplete char.\n  for (; i > 0; i--) {\n    var c = buffer[buffer.length - i];\n\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\n\n    // 110XXXXX\n    if (i == 1 && c >> 5 == 0x06) {\n      this.charLength = 2;\n      break;\n    }\n\n    // 1110XXXX\n    if (i <= 2 && c >> 4 == 0x0E) {\n      this.charLength = 3;\n      break;\n    }\n\n    // 11110XXX\n    if (i <= 3 && c >> 3 == 0x1E) {\n      this.charLength = 4;\n      break;\n    }\n  }\n  this.charReceived = i;\n};\n\nStringDecoder.prototype.end = function(buffer) {\n  var res = '';\n  if (buffer && buffer.length)\n    res = this.write(buffer);\n\n  if (this.charReceived) {\n    var cr = this.charReceived;\n    var buf = this.charBuffer;\n    var enc = this.encoding;\n    res += buf.slice(0, cr).toString(enc);\n  }\n\n  return res;\n};\n\nfunction passThroughWrite(buffer) {\n  return buffer.toString(this.encoding);\n}\n\nfunction utf16DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 2;\n  this.charLength = this.charReceived ? 2 : 0;\n}\n\nfunction base64DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 3;\n  this.charLength = this.charReceived ? 3 : 0;\n}\n","var basex = require('base-x')\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","/*\r\n Copyright 2013-2014 Daniel Wirtz <dcode@dcode.io>\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license bytebuffer.js (c) 2015 Daniel Wirtz <dcode@dcode.io>\r\n * Backing buffer: ArrayBuffer, Accessor: Uint8Array\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/bytebuffer.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([\"long\"], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module['exports'] = (function() {\r\n            var Long; try { Long = require(\"long\"); } catch (e) {}\r\n            return factory(Long);\r\n        })();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"ByteBuffer\"] = factory(global[\"dcodeIO\"][\"Long\"]);\r\n\r\n})(this, function(Long) {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a new ByteBuffer.\r\n     * @class The swiss army knife for binary data in JavaScript.\r\n     * @exports ByteBuffer\r\n     * @constructor\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @expose\r\n     */\r\n    var ByteBuffer = function(capacity, littleEndian, noAssert) {\r\n        if (typeof capacity === 'undefined')\r\n            capacity = ByteBuffer.DEFAULT_CAPACITY;\r\n        if (typeof littleEndian === 'undefined')\r\n            littleEndian = ByteBuffer.DEFAULT_ENDIAN;\r\n        if (typeof noAssert === 'undefined')\r\n            noAssert = ByteBuffer.DEFAULT_NOASSERT;\r\n        if (!noAssert) {\r\n            capacity = capacity | 0;\r\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity\");\r\n            littleEndian = !!littleEndian;\r\n            noAssert = !!noAssert;\r\n        }\r\n\r\n        /**\r\n         * Backing ArrayBuffer.\r\n         * @type {!ArrayBuffer}\r\n         * @expose\r\n         */\r\n        this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);\r\n\r\n        /**\r\n         * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.\r\n         * @type {?Uint8Array}\r\n         * @expose\r\n         */\r\n        this.view = capacity === 0 ? null : new Uint8Array(this.buffer);\r\n\r\n        /**\r\n         * Absolute read/write offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.offset = 0;\r\n\r\n        /**\r\n         * Marked offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#mark\r\n         * @see ByteBuffer#reset\r\n         */\r\n        this.markedOffset = -1;\r\n\r\n        /**\r\n         * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.limit = capacity;\r\n\r\n        /**\r\n         * Whether to use little endian byte order, defaults to `false` for big endian.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.littleEndian = littleEndian;\r\n\r\n        /**\r\n         * Whether to skip assertions of offsets and values, defaults to `false`.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.noAssert = noAssert;\r\n    };\r\n\r\n    /**\r\n     * ByteBuffer version.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.VERSION = \"5.0.1\";\r\n\r\n    /**\r\n     * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.LITTLE_ENDIAN = true;\r\n\r\n    /**\r\n     * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.BIG_ENDIAN = false;\r\n\r\n    /**\r\n     * Default initial capacity of `16`.\r\n     * @type {number}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_CAPACITY = 16;\r\n\r\n    /**\r\n     * Default endianess of `false` for big endian.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;\r\n\r\n    /**\r\n     * Default no assertions flag of `false`.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_NOASSERT = false;\r\n\r\n    /**\r\n     * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded\r\n     *  and int64 support is not available.\r\n     * @type {?Long}\r\n     * @const\r\n     * @see https://github.com/dcodeIO/long.js\r\n     * @expose\r\n     */\r\n    ByteBuffer.Long = Long || null;\r\n\r\n    /**\r\n     * @alias ByteBuffer.prototype\r\n     * @inner\r\n     */\r\n    var ByteBufferPrototype = ByteBuffer.prototype;\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a ByteBuffer or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     * @private\r\n     */\r\n    ByteBufferPrototype.__isByteBuffer__;\r\n\r\n    Object.defineProperty(ByteBufferPrototype, \"__isByteBuffer__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    // helpers\r\n\r\n    /**\r\n     * @type {!ArrayBuffer}\r\n     * @inner\r\n     */\r\n    var EMPTY_BUFFER = new ArrayBuffer(0);\r\n\r\n    /**\r\n     * String.fromCharCode reference for compile-time renaming.\r\n     * @type {function(...number):string}\r\n     * @inner\r\n     */\r\n    var stringFromCharCode = String.fromCharCode;\r\n\r\n    /**\r\n     * Creates a source function for a string.\r\n     * @param {string} s String to read from\r\n     * @returns {function():number|null} Source function returning the next char code respectively `null` if there are\r\n     *  no more characters left.\r\n     * @throws {TypeError} If the argument is invalid\r\n     * @inner\r\n     */\r\n    function stringSource(s) {\r\n        var i=0; return function() {\r\n            return i < s.length ? s.charCodeAt(i++) : null;\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Creates a destination function for a string.\r\n     * @returns {function(number=):undefined|string} Destination function successively called with the next char code.\r\n     *  Returns the final string when called without arguments.\r\n     * @inner\r\n     */\r\n    function stringDestination() {\r\n        var cs = [], ps = []; return function() {\r\n            if (arguments.length === 0)\r\n                return ps.join('')+stringFromCharCode.apply(String, cs);\r\n            if (cs.length + arguments.length > 1024)\r\n                ps.push(stringFromCharCode.apply(String, cs)),\r\n                    cs.length = 0;\r\n            Array.prototype.push.apply(cs, arguments);\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Gets the accessor type.\r\n     * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.accessor = function() {\r\n        return Uint8Array;\r\n    };\r\n    /**\r\n     * Allocates a new ByteBuffer backed by a buffer of the specified capacity.\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {\r\n        return new ByteBuffer(capacity, littleEndian, noAssert);\r\n    };\r\n\r\n    /**\r\n     * Concatenates multiple ByteBuffers into one.\r\n     * @param {!Array.<!ByteBuffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate\r\n     * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string (\"base64\", \"hex\", \"binary\",\r\n     *  defaults to \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults\r\n     *  to {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} Concatenated ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding === 'boolean' || typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var capacity = 0;\r\n        for (var i=0, k=buffers.length, length; i<k; ++i) {\r\n            if (!ByteBuffer.isByteBuffer(buffers[i]))\r\n                buffers[i] = ByteBuffer.wrap(buffers[i], encoding);\r\n            length = buffers[i].limit - buffers[i].offset;\r\n            if (length > 0) capacity += length;\r\n        }\r\n        if (capacity === 0)\r\n            return new ByteBuffer(0, littleEndian, noAssert);\r\n        var bb = new ByteBuffer(capacity, littleEndian, noAssert),\r\n            bi;\r\n        i=0; while (i<k) {\r\n            bi = buffers[i++];\r\n            length = bi.limit - bi.offset;\r\n            if (length <= 0) continue;\r\n            bb.view.set(bi.view.subarray(bi.offset, bi.limit), bb.offset);\r\n            bb.offset += length;\r\n        }\r\n        bb.limit = bb.offset;\r\n        bb.offset = 0;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Tests if the specified type is a ByteBuffer.\r\n     * @param {*} bb ByteBuffer to test\r\n     * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`\r\n     * @expose\r\n     */\r\n    ByteBuffer.isByteBuffer = function(bb) {\r\n        return (bb && bb[\"__isByteBuffer__\"]) === true;\r\n    };\r\n    /**\r\n     * Gets the backing buffer type.\r\n     * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.type = function() {\r\n        return ArrayBuffer;\r\n    };\r\n    /**\r\n     * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its\r\n     *  {@link ByteBuffer#limit} to the length of the wrapped data.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped\r\n     * @param {(string|boolean)=} encoding String encoding if `buffer` is a string (\"base64\", \"hex\", \"binary\", defaults to\r\n     *  \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`\r\n     * @expose\r\n     */\r\n    ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        if (typeof buffer === 'string') {\r\n            if (typeof encoding === 'undefined')\r\n                encoding = \"utf8\";\r\n            switch (encoding) {\r\n                case \"base64\":\r\n                    return ByteBuffer.fromBase64(buffer, littleEndian);\r\n                case \"hex\":\r\n                    return ByteBuffer.fromHex(buffer, littleEndian);\r\n                case \"binary\":\r\n                    return ByteBuffer.fromBinary(buffer, littleEndian);\r\n                case \"utf8\":\r\n                    return ByteBuffer.fromUTF8(buffer, littleEndian);\r\n                case \"debug\":\r\n                    return ByteBuffer.fromDebug(buffer, littleEndian);\r\n                default:\r\n                    throw Error(\"Unsupported encoding: \"+encoding);\r\n            }\r\n        }\r\n        if (buffer === null || typeof buffer !== 'object')\r\n            throw TypeError(\"Illegal buffer\");\r\n        var bb;\r\n        if (ByteBuffer.isByteBuffer(buffer)) {\r\n            bb = ByteBufferPrototype.clone.call(buffer);\r\n            bb.markedOffset = -1;\r\n            return bb;\r\n        }\r\n        if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER\r\n                bb.buffer = buffer.buffer;\r\n                bb.offset = buffer.byteOffset;\r\n                bb.limit = buffer.byteOffset + buffer.byteLength;\r\n                bb.view = new Uint8Array(buffer.buffer);\r\n            }\r\n        } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.byteLength > 0) {\r\n                bb.buffer = buffer;\r\n                bb.offset = 0;\r\n                bb.limit = buffer.byteLength;\r\n                bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null;\r\n            }\r\n        } else if (Object.prototype.toString.call(buffer) === \"[object Array]\") { // Create from octets\r\n            bb = new ByteBuffer(buffer.length, littleEndian, noAssert);\r\n            bb.limit = buffer.length;\r\n            for (var i=0; i<buffer.length; ++i)\r\n                bb.view[i] = buffer[i];\r\n        } else\r\n            throw TypeError(\"Illegal buffer\"); // Otherwise fail\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Writes the array as a bitset.\r\n     * @param {Array<boolean>} value Array of booleans to write\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBitSet = function(value, offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n      if (!this.noAssert) {\r\n        if (!(value instanceof Array))\r\n          throw TypeError(\"Illegal BitSet: Not an array\");\r\n        if (typeof offset !== 'number' || offset % 1 !== 0)\n            throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n        offset >>>= 0;\n        if (offset < 0 || offset + 0 > this.buffer.byteLength)\n            throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n      }\r\n\r\n      var start = offset,\r\n          bits = value.length,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          k;\r\n\r\n      offset += this.writeVarint32(bits,offset);\r\n\r\n      while(bytes--) {\r\n        k = (!!value[bit++] & 1) |\r\n            ((!!value[bit++] & 1) << 1) |\r\n            ((!!value[bit++] & 1) << 2) |\r\n            ((!!value[bit++] & 1) << 3) |\r\n            ((!!value[bit++] & 1) << 4) |\r\n            ((!!value[bit++] & 1) << 5) |\r\n            ((!!value[bit++] & 1) << 6) |\r\n            ((!!value[bit++] & 1) << 7);\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0; k = 0;\r\n        while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n        return this;\r\n      }\r\n      return offset - start;\r\n    }\r\n\r\n    /**\r\n     * Reads a BitSet as an array of booleans.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {Array<boolean>\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBitSet = function(offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n\r\n      var ret = this.readVarint32(offset),\r\n          bits = ret.value,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          value = [],\r\n          k;\r\n\r\n      offset += ret.length;\r\n\r\n      while(bytes--) {\r\n        k = this.readByte(offset++);\r\n        value[bit++] = !!(k & 0x01);\r\n        value[bit++] = !!(k & 0x02);\r\n        value[bit++] = !!(k & 0x04);\r\n        value[bit++] = !!(k & 0x08);\r\n        value[bit++] = !!(k & 0x10);\r\n        value[bit++] = !!(k & 0x20);\r\n        value[bit++] = !!(k & 0x40);\r\n        value[bit++] = !!(k & 0x80);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0;\r\n        k = this.readByte(offset++);\r\n        while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n      }\r\n      return value;\r\n    }\r\n    /**\r\n     * Reads the specified number of bytes.\r\n     * @param {number} length Number of bytes to read\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBytes = function(length, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + length > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n        }\r\n        var slice = this.slice(offset, offset + length);\r\n        if (relative) this.offset += length;\n        return slice;\r\n    };\r\n\r\n    /**\r\n     * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.\r\n     * @function\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;\r\n\r\n    // types/ints/int8\r\n\r\n    /**\r\n     * Writes an 8bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity0 = this.buffer.byteLength;\n        if (offset > capacity0)\n            this.resize((capacity0 *= 2) > offset ? capacity0 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;\r\n\r\n    /**\r\n     * Reads an 8bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity1 = this.buffer.byteLength;\n        if (offset > capacity1)\n            this.resize((capacity1 *= 2) > offset ? capacity1 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;\r\n\r\n    // types/ints/int16\r\n\r\n    /**\r\n     * Writes a 16bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity2 = this.buffer.byteLength;\n        if (offset > capacity2)\n            this.resize((capacity2 *= 2) > offset ? capacity2 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;\r\n\r\n    /**\r\n     * Reads a 16bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity3 = this.buffer.byteLength;\n        if (offset > capacity3)\n            this.resize((capacity3 *= 2) > offset ? capacity3 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;\r\n\r\n    // types/ints/int32\r\n\r\n    /**\r\n     * Writes a 32bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity4 = this.buffer.byteLength;\n        if (offset > capacity4)\n            this.resize((capacity4 *= 2) > offset ? capacity4 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;\r\n\r\n    /**\r\n     * Reads a 32bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        value |= 0; // Cast to signed\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity5 = this.buffer.byteLength;\n        if (offset > capacity5)\n            this.resize((capacity5 *= 2) > offset ? capacity5 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;\r\n\r\n    // types/ints/int64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Writes a 64bit signed integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeInt64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity6 = this.buffer.byteLength;\n            if (offset > capacity6)\n                this.resize((capacity6 *= 2) > offset ? capacity6 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;\r\n\r\n        /**\r\n         * Reads a 64bit signed integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readInt64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, false);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity7 = this.buffer.byteLength;\n            if (offset > capacity7)\n                this.resize((capacity7 *= 2) > offset ? capacity7 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.\r\n         * @function\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, true);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.\r\n         * @function\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;\r\n\r\n    } // Long\r\n\r\n\r\n    // types/floats/float32\r\n\r\n    /*\r\n     ieee754 - https://github.com/feross/ieee754\r\n\r\n     The MIT License (MIT)\r\n\r\n     Copyright (c) Feross Aboukhadijeh\r\n\r\n     Permission is hereby granted, free of charge, to any person obtaining a copy\r\n     of this software and associated documentation files (the \"Software\"), to deal\r\n     in the Software without restriction, including without limitation the rights\r\n     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n     copies of the Software, and to permit persons to whom the Software is\r\n     furnished to do so, subject to the following conditions:\r\n\r\n     The above copyright notice and this permission notice shall be included in\r\n     all copies or substantial portions of the Software.\r\n\r\n     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n     THE SOFTWARE.\r\n    */\r\n\r\n    /**\r\n     * Reads an IEEE754 float from a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    function ieee754_read(buffer, offset, isLE, mLen, nBytes) {\r\n        var e, m,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            nBits = -7,\r\n            i = isLE ? (nBytes - 1) : 0,\r\n            d = isLE ? -1 : 1,\r\n            s = buffer[offset + i];\r\n\r\n        i += d;\r\n\r\n        e = s & ((1 << (-nBits)) - 1);\r\n        s >>= (-nBits);\r\n        nBits += eLen;\r\n        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        m = e & ((1 << (-nBits)) - 1);\r\n        e >>= (-nBits);\r\n        nBits += mLen;\r\n        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        if (e === 0) {\r\n            e = 1 - eBias;\r\n        } else if (e === eMax) {\r\n            return m ? NaN : ((s ? -1 : 1) * Infinity);\r\n        } else {\r\n            m = m + Math.pow(2, mLen);\r\n            e = e - eBias;\r\n        }\r\n        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\r\n    }\r\n\r\n    /**\r\n     * Writes an IEEE754 float to a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} value\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @inner\r\n     */\r\n    function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) {\r\n        var e, m, c,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),\r\n            i = isLE ? 0 : (nBytes - 1),\r\n            d = isLE ? 1 : -1,\r\n            s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\r\n\r\n        value = Math.abs(value);\r\n\r\n        if (isNaN(value) || value === Infinity) {\r\n            m = isNaN(value) ? 1 : 0;\r\n            e = eMax;\r\n        } else {\r\n            e = Math.floor(Math.log(value) / Math.LN2);\r\n            if (value * (c = Math.pow(2, -e)) < 1) {\r\n                e--;\r\n                c *= 2;\r\n            }\r\n            if (e + eBias >= 1) {\r\n                value += rt / c;\r\n            } else {\r\n                value += rt * Math.pow(2, 1 - eBias);\r\n            }\r\n            if (value * c >= 2) {\r\n                e++;\r\n                c /= 2;\r\n            }\r\n\r\n            if (e + eBias >= eMax) {\r\n                m = 0;\r\n                e = eMax;\r\n            } else if (e + eBias >= 1) {\r\n                m = (value * c - 1) * Math.pow(2, mLen);\r\n                e = e + eBias;\r\n            } else {\r\n                m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\r\n                e = 0;\r\n            }\r\n        }\r\n\r\n        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\r\n\r\n        e = (e << mLen) | m;\r\n        eLen += mLen;\r\n        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\r\n\r\n        buffer[offset + i - d] |= s * 128;\r\n    }\r\n\r\n    /**\r\n     * Writes a 32bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity8 = this.buffer.byteLength;\n        if (offset > capacity8)\n            this.resize((capacity8 *= 2) > offset ? capacity8 : offset);\n        offset -= 4;\n        ieee754_write(this.view, value, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;\r\n\r\n    /**\r\n     * Reads a 32bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;\r\n\r\n    // types/floats/float64\r\n\r\n    /**\r\n     * Writes a 64bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat64 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 8;\n        var capacity9 = this.buffer.byteLength;\n        if (offset > capacity9)\n            this.resize((capacity9 *= 2) > offset ? capacity9 : offset);\n        offset -= 8;\n        ieee754_write(this.view, value, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64;\r\n\r\n    /**\r\n     * Reads a 64bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat64 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;\r\n\r\n\r\n    // types/varints/varint32\r\n\r\n    /**\r\n     * Maximum number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @type {number}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.MAX_VARINT32_BYTES = 5;\r\n\r\n    /**\r\n     * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to encode\r\n     * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateVarint32 = function(value) {\r\n        // ref: src/google/protobuf/io/coded_stream.cc\r\n        value = value >>> 0;\r\n             if (value < 1 << 7 ) return 1;\r\n        else if (value < 1 << 14) return 2;\r\n        else if (value < 1 << 21) return 3;\r\n        else if (value < 1 << 28) return 4;\r\n        else                      return 5;\r\n    };\r\n\r\n    /**\r\n     * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.\r\n     * @param {number} n Signed 32bit integer\r\n     * @returns {number} Unsigned zigzag encoded 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagEncode32 = function(n) {\r\n        return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Decodes a zigzag encoded signed 32bit integer.\r\n     * @param {number} n Unsigned zigzag encoded 32bit integer\r\n     * @returns {number} Signed 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagDecode32 = function(n) {\r\n        return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var size = ByteBuffer.calculateVarint32(value),\r\n            b;\r\n        offset += size;\n        var capacity10 = this.buffer.byteLength;\n        if (offset > capacity10)\n            this.resize((capacity10 *= 2) > offset ? capacity10 : offset);\n        offset -= size;\n        value >>>= 0;\r\n        while (value >= 0x80) {\r\n            b = (value & 0x7f) | 0x80;\r\n            this.view[offset++] = b;\r\n            value >>>= 7;\r\n        }\r\n        this.view[offset++] = value;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return size;\r\n    };\r\n\r\n    /**\r\n     * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {\r\n        return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available\r\n     *  to fully decode the varint.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var c = 0,\r\n            value = 0 >>> 0,\r\n            b;\r\n        do {\r\n            if (!this.noAssert && offset > this.limit) {\r\n                var err = Error(\"Truncated\");\r\n                err['truncated'] = true;\r\n                throw err;\r\n            }\r\n            b = this.view[offset++];\r\n            if (c < 5)\r\n                value |= (b & 0x7f) << (7*c);\r\n            ++c;\r\n        } while ((b & 0x80) !== 0);\r\n        value |= 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return value;\r\n        }\r\n        return {\r\n            \"value\": value,\r\n            \"length\": c\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32ZigZag = function(offset) {\r\n        var val = this.readVarint32(offset);\r\n        if (typeof val === 'object')\r\n            val[\"value\"] = ByteBuffer.zigZagDecode32(val[\"value\"]);\r\n        else\r\n            val = ByteBuffer.zigZagDecode32(val);\r\n        return val;\r\n    };\r\n\r\n    // types/varints/varint64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Maximum number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @type {number}\r\n         * @const\r\n         * @expose\r\n         */\r\n        ByteBuffer.MAX_VARINT64_BYTES = 10;\r\n\r\n        /**\r\n         * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @param {number|!Long} value Value to encode\r\n         * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}\r\n         * @expose\r\n         */\r\n        ByteBuffer.calculateVarint64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            if (part2 == 0) {\r\n                if (part1 == 0) {\r\n                    if (part0 < 1 << 14)\r\n                        return part0 < 1 << 7 ? 1 : 2;\r\n                    else\r\n                        return part0 < 1 << 21 ? 3 : 4;\r\n                } else {\r\n                    if (part1 < 1 << 14)\r\n                        return part1 < 1 << 7 ? 5 : 6;\r\n                    else\r\n                        return part1 < 1 << 21 ? 7 : 8;\r\n                }\r\n            } else\r\n                return part2 < 1 << 7 ? 9 : 10;\r\n        };\r\n\r\n        /**\r\n         * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.\r\n         * @param {number|!Long} value Signed long\r\n         * @returns {!Long} Unsigned zigzag encoded long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagEncode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();\r\n        };\r\n\r\n        /**\r\n         * Decodes a zigzag encoded signed 64bit integer.\r\n         * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number\r\n         * @returns {!Long} Signed long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagDecode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            var size = ByteBuffer.calculateVarint64(value),\r\n                part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            offset += size;\n            var capacity11 = this.buffer.byteLength;\n            if (offset > capacity11)\n                this.resize((capacity11 *= 2) > offset ? capacity11 : offset);\n            offset -= size;\n            switch (size) {\r\n                case 10: this.view[offset+9] = (part2 >>>  7) & 0x01;\r\n                case 9 : this.view[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;\r\n                case 8 : this.view[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;\r\n                case 7 : this.view[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;\r\n                case 6 : this.view[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;\r\n                case 5 : this.view[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;\r\n                case 4 : this.view[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;\r\n                case 3 : this.view[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;\r\n                case 2 : this.view[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;\r\n                case 1 : this.view[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;\r\n            }\r\n            if (relative) {\r\n                this.offset += size;\r\n                return this;\r\n            } else {\r\n                return size;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Writes a zig-zag encoded 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {\r\n            return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n            }\r\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var start = offset,\r\n                part0 = 0,\r\n                part1 = 0,\r\n                part2 = 0,\r\n                b  = 0;\r\n            b = this.view[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            throw Error(\"Buffer overrun\"); }}}}}}}}}}\r\n            var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return value;\r\n            } else {\r\n                return {\r\n                    'value': value,\r\n                    'length': offset-start\r\n                };\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64ZigZag = function(offset) {\r\n            var val = this.readVarint64(offset);\r\n            if (val && val['value'] instanceof Long)\r\n                val[\"value\"] = ByteBuffer.zigZagDecode64(val[\"value\"]);\r\n            else\r\n                val = ByteBuffer.zigZagDecode64(val);\r\n            return val;\r\n        };\r\n\r\n    } // Long\r\n\r\n\r\n    // types/strings/cstring\r\n\r\n    /**\r\n     * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL\r\n     *  characters itself.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  contained in `str` + 1 if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeCString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        var i,\r\n            k = str.length;\r\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            for (i=0; i<k; ++i) {\r\n                if (str.charCodeAt(i) === 0)\r\n                    throw RangeError(\"Illegal str: Contains NULL-characters\");\r\n            }\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character, so:\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k+1;\n        var capacity12 = this.buffer.byteLength;\n        if (offset > capacity12)\n            this.resize((capacity12 *= 2) > offset ? capacity12 : offset);\n        offset -= k+1;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        this.view[offset++] = 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return k;\r\n    };\r\n\r\n    /**\r\n     * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters\r\n     *  itself.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readCString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            temp;\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:\r\n        var sd, b = -1;\r\n        utfx.decodeUTF8toUTF16(function() {\r\n            if (b === 0) return null;\r\n            if (offset >= this.limit)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" < \"+this.limit);\r\n            b = this.view[offset++];\r\n            return b === 0 ? null : b;\r\n        }.bind(this), sd = stringDestination(), true);\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return sd();\r\n        } else {\r\n            return {\r\n                \"string\": sd(),\r\n                \"length\": offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/istring\r\n\r\n    /**\r\n     * Writes a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeIString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        offset += 4+k;\n        var capacity13 = this.buffer.byteLength;\n        if (offset > capacity13)\n            this.resize((capacity13 *= 2) > offset ? capacity13 : offset);\n        offset -= 4+k;\n        if (this.littleEndian) {\n            this.view[offset+3] = (k >>> 24) & 0xFF;\n            this.view[offset+2] = (k >>> 16) & 0xFF;\n            this.view[offset+1] = (k >>>  8) & 0xFF;\n            this.view[offset  ] =  k         & 0xFF;\n        } else {\n            this.view[offset  ] = (k >>> 24) & 0xFF;\n            this.view[offset+1] = (k >>> 16) & 0xFF;\n            this.view[offset+2] = (k >>>  8) & 0xFF;\n            this.view[offset+3] =  k         & 0xFF;\n        }\n        offset += 4;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start + 4 + k)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+4+k));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readIString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readUint32(offset);\r\n        var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/utf8string\r\n\r\n    /**\r\n     * Metrics representing number of UTF8 characters. Evaluates to `c`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_CHARS = 'c';\r\n\r\n    /**\r\n     * Metrics representing number of bytes. Evaluates to `b`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_BYTES = 'b';\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUTF8String = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var k;\r\n        var start = offset;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k;\n        var capacity14 = this.buffer.byteLength;\n        if (offset > capacity14)\n            this.resize((capacity14 *= 2) > offset ? capacity14 : offset);\n        offset -= k;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.\r\n     * @function\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;\r\n\r\n    /**\r\n     * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's\r\n     *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 characters\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Chars = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[0];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Bytes = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.\r\n     * @function\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string.\r\n     * @param {number} length Number of characters or bytes to read.\r\n     * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {\r\n        if (typeof metrics === 'number') {\r\n            offset = metrics;\r\n            metrics = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var i = 0,\r\n            start = offset,\r\n            sd;\r\n        if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser\r\n            sd = stringDestination();\r\n            utfx.decodeUTF8(function() {\r\n                return i < length && offset < this.limit ? this.view[offset++] : null;\r\n            }.bind(this), function(cp) {\r\n                ++i; utfx.UTF8toUTF16(cp, sd);\r\n            });\r\n            if (i !== length)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+i+\" == \"+length);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    \"string\": sd(),\r\n                    \"length\": offset - start\r\n                };\r\n            }\r\n        } else if (metrics === ByteBuffer.METRICS_BYTES) {\r\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + length > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n            }\r\n            var k = offset + length;\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return offset < k ? this.view[offset++] : null;\r\n            }.bind(this), sd = stringDestination(), this.noAssert);\r\n            if (offset !== k)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+k);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    'string': sd(),\r\n                    'length': offset - start\r\n                };\r\n            }\r\n        } else\r\n            throw TypeError(\"Unsupported metrics: \"+metrics);\r\n    };\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.\r\n     * @function\r\n     * @param {number} length Number of characters or bytes to read\r\n     * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;\r\n\r\n    // types/strings/vstring\r\n\r\n    /**\r\n     * Writes a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeVString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k, l;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        l = ByteBuffer.calculateVarint32(k);\r\n        offset += l+k;\n        var capacity15 = this.buffer.byteLength;\n        if (offset > capacity15)\n            this.resize((capacity15 *= 2) > offset ? capacity15 : offset);\n        offset -= l+k;\n        offset += this.writeVarint32(k, offset);\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start+k+l)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+k+l));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readVString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readVarint32(offset);\r\n        var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n\r\n    /**\r\n     * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended\r\n     *  data's length.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`\r\n     * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`\r\n     */\r\n    ByteBufferPrototype.append = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var length = source.limit - source.offset;\r\n        if (length <= 0) return this; // Nothing to append\r\n        offset += length;\n        var capacity16 = this.buffer.byteLength;\n        if (offset > capacity16)\n            this.resize((capacity16 *= 2) > offset ? capacity16 : offset);\n        offset -= length;\n        this.view.set(source.view.subarray(source.offset, source.limit), offset);\r\n        source.offset += length;\r\n        if (relative) this.offset += length;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the\r\n        specified offset up to the length of this ByteBuffer's data.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#append\r\n     */\r\n    ByteBufferPrototype.appendTo = function(target, offset) {\r\n        target.append(this, offset);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to\r\n     *  disable them if your code already makes sure that everything is valid.\r\n     * @param {boolean} assert `true` to enable assertions, otherwise `false`\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.assert = function(assert) {\r\n        this.noAssert = !assert;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Gets the capacity of this ByteBuffer's backing buffer.\r\n     * @returns {number} Capacity of the backing buffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.capacity = function() {\r\n        return this.buffer.byteLength;\r\n    };\r\n    /**\r\n     * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the\r\n     *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clear = function() {\r\n        this.offset = 0;\r\n        this.limit = this.buffer.byteLength;\r\n        this.markedOffset = -1;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},\r\n     *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`\r\n     * @returns {!ByteBuffer} Cloned instance\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clone = function(copy) {\r\n        var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        if (copy) {\r\n            bb.buffer = new ArrayBuffer(this.buffer.byteLength);\r\n            bb.view = new Uint8Array(bb.buffer);\r\n        } else {\r\n            bb.buffer = this.buffer;\r\n            bb.view = this.view;\r\n        }\r\n        bb.offset = this.offset;\r\n        bb.markedOffset = this.markedOffset;\r\n        bb.limit = this.limit;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes\r\n     *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and\r\n     *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.compact = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === 0 && end === this.buffer.byteLength)\r\n            return this; // Already compacted\r\n        var len = end - begin;\r\n        if (len === 0) {\r\n            this.buffer = EMPTY_BUFFER;\r\n            this.view = null;\r\n            if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n            this.offset = 0;\r\n            this.limit = 0;\r\n            return this;\r\n        }\r\n        var buffer = new ArrayBuffer(len);\r\n        var view = new Uint8Array(buffer);\r\n        view.set(this.view.subarray(begin, end));\r\n        this.buffer = buffer;\r\n        this.view = view;\r\n        if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n        this.offset = 0;\r\n        this.limit = len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Copy\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copy = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        var capacity = end - begin,\r\n            bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);\r\n        bb.offset = 0;\r\n        bb.limit = capacity;\r\n        if (bb.markedOffset >= 0) bb.markedOffset -= begin;\r\n        this.copyTo(bb, 0, begin, end);\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}\r\n     *  by the number of bytes copied if omitted.\r\n     * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the\r\n     *  number of bytes copied if omitted.\r\n     * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {\r\n        var relative,\r\n            targetRelative;\r\n        if (!this.noAssert) {\r\n            if (!ByteBuffer.isByteBuffer(target))\r\n                throw TypeError(\"Illegal target: Not a ByteBuffer\");\r\n        }\r\n        targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;\r\n        sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;\r\n        sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;\r\n\r\n        if (targetOffset < 0 || targetOffset > target.buffer.byteLength)\r\n            throw RangeError(\"Illegal target range: 0 <= \"+targetOffset+\" <= \"+target.buffer.byteLength);\r\n        if (sourceOffset < 0 || sourceLimit > this.buffer.byteLength)\r\n            throw RangeError(\"Illegal source range: 0 <= \"+sourceOffset+\" <= \"+this.buffer.byteLength);\r\n\r\n        var len = sourceLimit - sourceOffset;\r\n        if (len === 0)\r\n            return target; // Nothing to copy\r\n\r\n        target.ensureCapacity(targetOffset + len);\r\n\r\n        target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset);\r\n\r\n        if (relative) this.offset += len;\r\n        if (targetRelative) target.offset += len;\r\n\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the\r\n     *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,\r\n     *  the required capacity will be used instead.\r\n     * @param {number} capacity Required capacity\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.ensureCapacity = function(capacity) {\r\n        var current = this.buffer.byteLength;\r\n        if (current < capacity)\r\n            return this.resize((current *= 2) > capacity ? current : capacity);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {number|string} value Byte value to fill with. If given as a string, the first character is used.\r\n     * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted. defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes\r\n     */\r\n    ByteBufferPrototype.fill = function(value, begin, end) {\r\n        var relative = typeof begin === 'undefined';\n        if (relative) begin = this.offset;\n        if (typeof value === 'string' && value.length > 0)\r\n            value = value.charCodeAt(0);\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin >= end)\r\n            return this; // Nothing to fill\r\n        while (begin < end) this.view[begin++] = value;\r\n        if (relative) this.offset = begin;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and\r\n     *  `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.flip = function() {\r\n        this.limit = this.offset;\r\n        this.offset = 0;\r\n        return this;\r\n    };\r\n    /**\r\n     * Marks an offset on this ByteBuffer to be used later.\r\n     * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @see ByteBuffer#reset\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.mark = function(offset) {\r\n        offset = typeof offset === 'undefined' ? this.offset : offset;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        this.markedOffset = offset;\r\n        return this;\r\n    };\r\n    /**\r\n     * Sets the byte order.\r\n     * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.order = function(littleEndian) {\r\n        if (!this.noAssert) {\r\n            if (typeof littleEndian !== 'boolean')\r\n                throw TypeError(\"Illegal littleEndian: Not a boolean\");\r\n        }\r\n        this.littleEndian = !!littleEndian;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) little endian byte order.\r\n     * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.LE = function(littleEndian) {\r\n        this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) big endian byte order.\r\n     * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.BE = function(bigEndian) {\r\n        this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false;\r\n        return this;\r\n    };\r\n    /**\r\n     * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer|string|!ArrayBuffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be\r\n     *  modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|`\r\n     * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|`\r\n     */\r\n    ByteBufferPrototype.prepend = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var len = source.limit - source.offset;\r\n        if (len <= 0) return this; // Nothing to prepend\r\n        var diff = len - offset;\r\n        if (diff > 0) { // Not enough space before offset, so resize + move\r\n            var buffer = new ArrayBuffer(this.buffer.byteLength + diff);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view.subarray(offset, this.buffer.byteLength), len);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n            this.offset += diff;\r\n            if (this.markedOffset >= 0) this.markedOffset += diff;\r\n            this.limit += diff;\r\n            offset += diff;\r\n        } else {\r\n            var arrayView = new Uint8Array(this.buffer);\r\n        }\r\n        this.view.set(source.view.subarray(source.offset, source.limit), offset - len);\r\n\r\n        source.offset = source.limit;\r\n        if (relative)\r\n            this.offset -= len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#prepend\r\n     */\r\n    ByteBufferPrototype.prependTo = function(target, offset) {\r\n        target.prepend(this, offset);\r\n        return this;\r\n    };\r\n    /**\r\n     * Prints debug information about this ByteBuffer's contents.\r\n     * @param {function(string)=} out Output function to call, defaults to console.log\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.printDebug = function(out) {\r\n        if (typeof out !== 'function') out = console.log.bind(console);\r\n        out(\r\n            this.toString()+\"\\n\"+\r\n            \"-------------------------------------------------------------------\\n\"+\r\n            this.toDebug(/* columns */ true)\r\n        );\r\n    };\r\n\r\n    /**\r\n     * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}, so this returns `limit - offset`.\r\n     * @returns {number} Remaining readable bytes. May be negative if `offset > limit`.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.remaining = function() {\r\n        return this.limit - this.offset;\r\n    };\r\n    /**\r\n     * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark}\r\n     *  before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been\r\n     *  marked, sets `offset = 0`.\r\n     * @returns {!ByteBuffer} this\r\n     * @see ByteBuffer#mark\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reset = function() {\r\n        if (this.markedOffset >= 0) {\r\n            this.offset = this.markedOffset;\r\n            this.markedOffset = -1;\r\n        } else {\r\n            this.offset = 0;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that\r\n     *  large or larger.\r\n     * @param {number} capacity Capacity required\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `capacity` is not a number\r\n     * @throws {RangeError} If `capacity < 0`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.resize = function(capacity) {\r\n        if (!this.noAssert) {\r\n            if (typeof capacity !== 'number' || capacity % 1 !== 0)\n                throw TypeError(\"Illegal capacity: \"+capacity+\" (not an integer)\");\n            capacity |= 0;\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity: 0 <= \"+capacity);\r\n        }\r\n        if (this.buffer.byteLength < capacity) {\r\n            var buffer = new ArrayBuffer(capacity);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Reverses this ByteBuffer's contents.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reverse = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return this; // Nothing to reverse\r\n        Array.prototype.reverse.call(this.view.subarray(begin, end));\r\n        return this;\r\n    };\r\n    /**\r\n     * Skips the next `length` bytes. This will just advance\r\n     * @param {number} length Number of bytes to skip. May also be negative to move the offset back.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.skip = function(length) {\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n        }\r\n        var offset = this.offset + length;\r\n        if (!this.noAssert) {\r\n            if (offset < 0 || offset > this.buffer.byteLength)\r\n                throw RangeError(\"Illegal length: 0 <= \"+this.offset+\" + \"+length+\" <= \"+this.buffer.byteLength);\r\n        }\r\n        this.offset = offset;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.slice = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var bb = this.clone();\r\n        bb.offset = begin;\r\n        bb.limit = end;\r\n        return bb;\r\n    };\r\n    /**\r\n     * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if\r\n     *  possible. Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBuffer = function(forceCopy) {\r\n        var offset = this.offset,\r\n            limit = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: Not an integer\");\n            offset >>>= 0;\n            if (typeof limit !== 'number' || limit % 1 !== 0)\n                throw TypeError(\"Illegal limit: Not an integer\");\n            limit >>>= 0;\n            if (offset < 0 || offset > limit || limit > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+offset+\" <= \"+limit+\" <= \"+this.buffer.byteLength);\n        }\r\n        // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is\r\n        // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So:\r\n        if (!forceCopy && offset === 0 && limit === this.buffer.byteLength)\r\n            return this.buffer;\r\n        if (offset === limit)\r\n            return EMPTY_BUFFER;\r\n        var buffer = new ArrayBuffer(limit - offset);\r\n        new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0);\r\n        return buffer;\r\n    };\r\n\r\n    /**\r\n     * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}.\r\n     * @function\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory.\r\n     *  Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer;\r\n\r\n    /**\r\n     * Converts the ByteBuffer's contents to a string.\r\n     * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows\r\n     *  direct conversion to \"utf8\", \"hex\", \"base64\" and \"binary\" encoding. \"debug\" returns a hex representation with\r\n     *  highlighted offsets.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {string} String representation\r\n     * @throws {Error} If `encoding` is invalid\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toString = function(encoding, begin, end) {\r\n        if (typeof encoding === 'undefined')\r\n            return \"ByteBufferAB(offset=\"+this.offset+\",markedOffset=\"+this.markedOffset+\",limit=\"+this.limit+\",capacity=\"+this.capacity()+\")\";\r\n        if (typeof encoding === 'number')\r\n            encoding = \"utf8\",\r\n            begin = encoding,\r\n            end = begin;\r\n        switch (encoding) {\r\n            case \"utf8\":\r\n                return this.toUTF8(begin, end);\r\n            case \"base64\":\r\n                return this.toBase64(begin, end);\r\n            case \"hex\":\r\n                return this.toHex(begin, end);\r\n            case \"binary\":\r\n                return this.toBinary(begin, end);\r\n            case \"debug\":\r\n                return this.toDebug();\r\n            case \"columns\":\r\n                return this.toColumns();\r\n            default:\r\n                throw Error(\"Unsupported encoding: \"+encoding);\r\n        }\r\n    };\r\n\r\n    // lxiv-embeddable\r\n\r\n    /**\r\n     * lxiv-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/lxiv for details\r\n     */\r\n    var lxiv = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * lxiv namespace.\r\n         * @type {!Object.<string,*>}\r\n         * @exports lxiv\r\n         */\r\n        var lxiv = {};\r\n\r\n        /**\r\n         * Character codes for output.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var aout = [\r\n            65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,\r\n            81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102,\r\n            103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,\r\n            119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47\r\n        ];\r\n\r\n        /**\r\n         * Character codes for input.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var ain = [];\r\n        for (var i=0, k=aout.length; i<k; ++i)\r\n            ain[aout[i]] = i;\r\n\r\n        /**\r\n         * Encodes bytes to base64 char codes.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if\r\n         *  there are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each encoded char\r\n         *  code.\r\n         */\r\n        lxiv.encode = function(src, dst) {\r\n            var b, t;\r\n            while ((b = src()) !== null) {\r\n                dst(aout[(b>>2)&0x3f]);\r\n                t = (b&0x3)<<4;\r\n                if ((b = src()) !== null) {\r\n                    t |= (b>>4)&0xf;\r\n                    dst(aout[(t|((b>>4)&0xf))&0x3f]);\r\n                    t = (b&0xf)<<2;\r\n                    if ((b = src()) !== null)\r\n                        dst(aout[(t|((b>>6)&0x3))&0x3f]),\r\n                        dst(aout[b&0x3f]);\r\n                    else\r\n                        dst(aout[t&0x3f]),\r\n                        dst(61);\r\n                } else\r\n                    dst(aout[t&0x3f]),\r\n                    dst(61),\r\n                    dst(61);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes base64 char codes to bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         * @throws {Error} If a character code is invalid\r\n         */\r\n        lxiv.decode = function(src, dst) {\r\n            var c, t1, t2;\r\n            function fail(c) {\r\n                throw Error(\"Illegal character code: \"+c);\r\n            }\r\n            while ((c = src()) !== null) {\r\n                t1 = ain[c];\r\n                if (typeof t1 === 'undefined') fail(c);\r\n                if ((c = src()) !== null) {\r\n                    t2 = ain[c];\r\n                    if (typeof t2 === 'undefined') fail(c);\r\n                    dst((t1<<2)>>>0|(t2&0x30)>>4);\r\n                    if ((c = src()) !== null) {\r\n                        t1 = ain[c];\r\n                        if (typeof t1 === 'undefined')\r\n                            if (c === 61) break; else fail(c);\r\n                        dst(((t2&0xf)<<4)>>>0|(t1&0x3c)>>2);\r\n                        if ((c = src()) !== null) {\r\n                            t2 = ain[c];\r\n                            if (typeof t2 === 'undefined')\r\n                                if (c === 61) break; else fail(c);\r\n                            dst(((t1&0x3)<<6)>>>0|t2);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Tests if a string is valid base64.\r\n         * @param {string} str String to test\r\n         * @returns {boolean} `true` if valid, otherwise `false`\r\n         */\r\n        lxiv.test = function(str) {\r\n            return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(str);\r\n        };\r\n\r\n        return lxiv;\r\n    }();\r\n\r\n    // encodings/base64\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a base64 encoded string.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Base64 encoded string\r\n     * @throws {RangeError} If `begin` or `end` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBase64 = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin = begin | 0; end = end | 0;\r\n        if (begin < 0 || end > this.capacity || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        var sd; lxiv.encode(function() {\r\n            return begin < end ? this.view[begin++] : null;\r\n        }.bind(this), sd = stringDestination());\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBase64 = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var bb = new ByteBuffer(str.length/4*3, littleEndian),\r\n            i = 0;\r\n        lxiv.decode(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Encodes a binary string to base64 like `window.btoa` does.\r\n     * @param {string} str Binary string\r\n     * @returns {string} Base64 encoded string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa\r\n     * @expose\r\n     */\r\n    ByteBuffer.btoa = function(str) {\r\n        return ByteBuffer.fromBinary(str).toBase64();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to binary like `window.atob` does.\r\n     * @param {string} b64 Base64 encoded string\r\n     * @returns {string} Binary string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob\r\n     * @expose\r\n     */\r\n    ByteBuffer.atob = function(b64) {\r\n        return ByteBuffer.fromBase64(b64).toBinary();\r\n    };\r\n\r\n    // encodings/binary\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Binary encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBinary = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin |= 0; end |= 0;\r\n        if (begin < 0 || end > this.capacity() || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        if (begin === end)\r\n            return \"\";\r\n        var chars = [],\r\n            parts = [];\r\n        while (begin < end) {\r\n            chars.push(this.view[begin++]);\r\n            if (chars.length >= 1024)\r\n                parts.push(String.fromCharCode.apply(String, chars)),\r\n                chars = [];\r\n        }\r\n        return parts.join('') + String.fromCharCode.apply(String, chars);\r\n    };\r\n\r\n    /**\r\n     * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBinary = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var i = 0,\r\n            k = str.length,\r\n            charCode,\r\n            bb = new ByteBuffer(k, littleEndian);\r\n        while (i<k) {\r\n            charCode = str.charCodeAt(i);\r\n            if (charCode > 0xff)\r\n                throw RangeError(\"illegal char code: \"+charCode);\r\n            bb.view[i++] = charCode;\r\n        }\r\n        bb.limit = k;\r\n        return bb;\r\n    };\r\n\r\n    // encodings/debug\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are:\r\n     * * `<` : offset,\r\n     * * `'` : markedOffset,\r\n     * * `>` : limit,\r\n     * * `|` : offset and limit,\r\n     * * `[` : offset and markedOffset,\r\n     * * `]` : markedOffset and limit,\r\n     * * `!` : offset, markedOffset and limit\r\n     * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false`\r\n     * @returns {string|!Array.<string>} Debug string or array of lines if `asArray = true`\r\n     * @expose\r\n     * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3`\r\n     * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4`\r\n     * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1`\r\n     * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1`\r\n     */\r\n    ByteBufferPrototype.toDebug = function(columns) {\r\n        var i = -1,\r\n            k = this.buffer.byteLength,\r\n            b,\r\n            hex = \"\",\r\n            asc = \"\",\r\n            out = \"\";\r\n        while (i<k) {\r\n            if (i !== -1) {\r\n                b = this.view[i];\r\n                if (b < 0x10) hex += \"0\"+b.toString(16).toUpperCase();\r\n                else hex += b.toString(16).toUpperCase();\r\n                if (columns)\r\n                    asc += b > 32 && b < 127 ? String.fromCharCode(b) : '.';\r\n            }\r\n            ++i;\r\n            if (columns) {\r\n                if (i > 0 && i % 16 === 0 && i !== k) {\r\n                    while (hex.length < 3*16+3) hex += \" \";\r\n                    out += hex+asc+\"\\n\";\r\n                    hex = asc = \"\";\r\n                }\r\n            }\r\n            if (i === this.offset && i === this.limit)\r\n                hex += i === this.markedOffset ? \"!\" : \"|\";\r\n            else if (i === this.offset)\r\n                hex += i === this.markedOffset ? \"[\" : \"<\";\r\n            else if (i === this.limit)\r\n                hex += i === this.markedOffset ? \"]\" : \">\";\r\n            else\r\n                hex += i === this.markedOffset ? \"'\" : (columns || (i !== 0 && i !== k) ? \" \" : \"\");\r\n        }\r\n        if (columns && hex !== \" \") {\r\n            while (hex.length < 3*16+3)\r\n                hex += \" \";\r\n            out += hex + asc + \"\\n\";\r\n        }\r\n        return columns ? out : hex;\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string with marked offsets to a ByteBuffer.\r\n     * @param {string} str Debug string to decode (not be generated with `columns = true`)\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     * @see ByteBuffer#toDebug\r\n     */\r\n    ByteBuffer.fromDebug = function(str, littleEndian, noAssert) {\r\n        var k = str.length,\r\n            bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert);\r\n        var i = 0, j = 0, ch, b,\r\n            rs = false, // Require symbol next\r\n            ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)?\r\n            fail = false;\r\n        while (i<k) {\r\n            switch (ch = str.charAt(i++)) {\r\n                case '!':\r\n                    if (!noAssert) {\r\n                        if (ho || hm || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = hl = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '|':\r\n                    if (!noAssert) {\r\n                        if (ho || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hl = true;\r\n                    }\r\n                    bb.offset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '[':\r\n                    if (!noAssert) {\r\n                        if (ho || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '<':\r\n                    if (!noAssert) {\r\n                        if (ho) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = true;\r\n                    }\r\n                    bb.offset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ']':\r\n                    if (!noAssert) {\r\n                        if (hl || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = hm = true;\r\n                    }\r\n                    bb.limit = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '>':\r\n                    if (!noAssert) {\r\n                        if (hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = true;\r\n                    }\r\n                    bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case \"'\":\r\n                    if (!noAssert) {\r\n                        if (hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hm = true;\r\n                    }\r\n                    bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ' ':\r\n                    rs = false;\r\n                    break;\r\n                default:\r\n                    if (!noAssert) {\r\n                        if (rs) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                    }\r\n                    b = parseInt(ch+str.charAt(i++), 16);\r\n                    if (!noAssert) {\r\n                        if (isNaN(b) || b < 0 || b > 255)\r\n                            throw TypeError(\"Illegal str: Not a debug encoded string\");\r\n                    }\r\n                    bb.view[j++] = b;\r\n                    rs = true;\r\n            }\r\n            if (fail)\r\n                throw TypeError(\"Illegal str: Invalid symbol at \"+i);\r\n        }\r\n        if (!noAssert) {\r\n            if (!ho || !hl)\r\n                throw TypeError(\"Illegal str: Missing offset or limit\");\r\n            if (j<bb.buffer.byteLength)\r\n                throw TypeError(\"Illegal str: Not a debug encoded string (is it hex?) \"+j+\" < \"+k);\r\n        }\r\n        return bb;\r\n    };\r\n\r\n    // encodings/hex\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a hex encoded string.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Hex encoded string\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toHex = function(begin, end) {\r\n        begin = typeof begin === 'undefined' ? this.offset : begin;\r\n        end = typeof end === 'undefined' ? this.limit : end;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var out = new Array(end - begin),\r\n            b;\r\n        while (begin < end) {\r\n            b = this.view[begin++];\r\n            if (b < 0x10)\r\n                out.push(\"0\", b.toString(16));\r\n            else out.push(b.toString(16));\r\n        }\r\n        return out.join('');\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromHex = function(str, littleEndian, noAssert) {\r\n        if (!noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (str.length % 2 !== 0)\r\n                throw TypeError(\"Illegal str: Length not a multiple of 2\");\r\n        }\r\n        var k = str.length,\r\n            bb = new ByteBuffer((k / 2) | 0, littleEndian),\r\n            b;\r\n        for (var i=0, j=0; i<k; i+=2) {\r\n            b = parseInt(str.substring(i, i+2), 16);\r\n            if (!noAssert)\r\n                if (!isFinite(b) || b < 0 || b > 255)\r\n                    throw TypeError(\"Illegal str: Contains non-hex characters\");\r\n            bb.view[j++] = b;\r\n        }\r\n        bb.limit = j;\r\n        return bb;\r\n    };\r\n\r\n    // utfx-embeddable\r\n\r\n    /**\r\n     * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/utfx for details\r\n     */\r\n    var utfx = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * utfx namespace.\r\n         * @inner\r\n         * @type {!Object.<string,*>}\r\n         */\r\n        var utfx = {};\r\n\r\n        /**\r\n         * Maximum valid code point.\r\n         * @type {number}\r\n         * @const\r\n         */\r\n        utfx.MAX_CODEPOINT = 0x10FFFF;\r\n\r\n        /**\r\n         * Encodes UTF8 code points to UTF8 bytes.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte\r\n         */\r\n        utfx.encodeUTF8 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src,\r\n                src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp < 0x80)\r\n                    dst(cp&0x7F);\r\n                else if (cp < 0x800)\r\n                    dst(((cp>>6)&0x1F)|0xC0),\r\n                    dst((cp&0x3F)|0x80);\r\n                else if (cp < 0x10000)\r\n                    dst(((cp>>12)&0x0F)|0xE0),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                else\r\n                    dst(((cp>>18)&0x07)|0xF0),\r\n                    dst(((cp>>12)&0x3F)|0x80),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes UTF8 bytes to UTF8 code points.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the\r\n         *  remaining bytes.\r\n         */\r\n        utfx.decodeUTF8 = function(src, dst) {\r\n            var a, b, c, d, fail = function(b) {\r\n                b = b.slice(0, b.indexOf(null));\r\n                var err = Error(b.toString());\r\n                err.name = \"TruncatedError\";\r\n                err['bytes'] = b;\r\n                throw err;\r\n            };\r\n            while ((a = src()) !== null) {\r\n                if ((a&0x80) === 0)\r\n                    dst(a);\r\n                else if ((a&0xE0) === 0xC0)\r\n                    ((b = src()) === null) && fail([a, b]),\r\n                    dst(((a&0x1F)<<6) | (b&0x3F));\r\n                else if ((a&0xF0) === 0xE0)\r\n                    ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),\r\n                    dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));\r\n                else if ((a&0xF8) === 0xF0)\r\n                    ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),\r\n                    dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));\r\n                else throw RangeError(\"Illegal starting byte: \"+a);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts UTF16 characters to UTF8 code points.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each converted code\r\n         *  point.\r\n         */\r\n        utfx.UTF16toUTF8 = function(src, dst) {\r\n            var c1, c2 = null;\r\n            while (true) {\r\n                if ((c1 = c2 !== null ? c2 : src()) === null)\r\n                    break;\r\n                if (c1 >= 0xD800 && c1 <= 0xDFFF) {\r\n                    if ((c2 = src()) !== null) {\r\n                        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {\r\n                            dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);\r\n                            c2 = null; continue;\r\n                        }\r\n                    }\r\n                }\r\n                dst(c1);\r\n            }\r\n            if (c2 !== null) dst(c2);\r\n        };\r\n\r\n        /**\r\n         * Converts UTF8 code points to UTF16 characters.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a code point is out of range\r\n         */\r\n        utfx.UTF8toUTF16 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src, src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp <= 0xFFFF)\r\n                    dst(cp);\r\n                else\r\n                    cp -= 0x10000,\r\n                    dst((cp>>10)+0xD800),\r\n                    dst((cp%0x400)+0xDC00);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts and encodes UTF16 characters to UTF8 bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`\r\n         *  if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         */\r\n        utfx.encodeUTF16toUTF8 = function(src, dst) {\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                utfx.encodeUTF8(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Decodes and converts UTF8 bytes to UTF16 characters.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.\r\n         */\r\n        utfx.decodeUTF8toUTF16 = function(src, dst) {\r\n            utfx.decodeUTF8(src, function(cp) {\r\n                utfx.UTF8toUTF16(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Calculates the byte length of an UTF8 code point.\r\n         * @param {number} cp UTF8 code point\r\n         * @returns {number} Byte length\r\n         */\r\n        utfx.calculateCodePoint = function(cp) {\r\n            return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 bytes required to store UTF8 code points.\r\n         * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively\r\n         *  `null` if there are no more code points left.\r\n         * @returns {number} The number of UTF8 bytes required\r\n         */\r\n        utfx.calculateUTF8 = function(src) {\r\n            var cp, l=0;\r\n            while ((cp = src()) !== null)\r\n                l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            return l;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.\r\n         * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.\r\n         */\r\n        utfx.calculateUTF16asUTF8 = function(src) {\r\n            var n=0, l=0;\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            });\r\n            return [n,l];\r\n        };\r\n\r\n        return utfx;\r\n    }();\r\n\r\n    // encodings/utf8\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded\r\n     *  string.\r\n     * @returns {string} Hex encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toUTF8 = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var sd; try {\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return begin < end ? this.view[begin++] : null;\r\n            }.bind(this), sd = stringDestination());\r\n        } catch (e) {\r\n            if (begin !== end)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+begin+\" != \"+end);\r\n        }\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes an UTF8 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) {\r\n        if (!noAssert)\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n        var bb = new ByteBuffer(utfx.calculateUTF16asUTF8(stringSource(str), true)[1], littleEndian, noAssert),\r\n            i = 0;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    return ByteBuffer;\r\n});\r\n","var Buffer = require('safe-buffer').Buffer\nvar Transform = require('stream').Transform\nvar StringDecoder = require('string_decoder').StringDecoder\nvar inherits = require('inherits')\n\nfunction CipherBase (hashMode) {\n  Transform.call(this)\n  this.hashMode = typeof hashMode === 'string'\n  if (this.hashMode) {\n    this[hashMode] = this._finalOrDigest\n  } else {\n    this.final = this._finalOrDigest\n  }\n  if (this._final) {\n    this.__final = this._final\n    this._final = null\n  }\n  this._decoder = null\n  this._encoding = null\n}\ninherits(CipherBase, Transform)\n\nCipherBase.prototype.update = function (data, inputEnc, outputEnc) {\n  if (typeof data === 'string') {\n    data = Buffer.from(data, inputEnc)\n  }\n\n  var outData = this._update(data)\n  if (this.hashMode) return this\n\n  if (outputEnc) {\n    outData = this._toString(outData, outputEnc)\n  }\n\n  return outData\n}\n\nCipherBase.prototype.setAutoPadding = function () {}\nCipherBase.prototype.getAuthTag = function () {\n  throw new Error('trying to get auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAuthTag = function () {\n  throw new Error('trying to set auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAAD = function () {\n  throw new Error('trying to set aad in unsupported state')\n}\n\nCipherBase.prototype._transform = function (data, _, next) {\n  var err\n  try {\n    if (this.hashMode) {\n      this._update(data)\n    } else {\n      this.push(this._update(data))\n    }\n  } catch (e) {\n    err = e\n  } finally {\n    next(err)\n  }\n}\nCipherBase.prototype._flush = function (done) {\n  var err\n  try {\n    this.push(this.__final())\n  } catch (e) {\n    err = e\n  }\n\n  done(err)\n}\nCipherBase.prototype._finalOrDigest = function (outputEnc) {\n  var outData = this.__final() || Buffer.alloc(0)\n  if (outputEnc) {\n    outData = this._toString(outData, outputEnc, true)\n  }\n  return outData\n}\n\nCipherBase.prototype._toString = function (value, enc, fin) {\n  if (!this._decoder) {\n    this._decoder = new StringDecoder(enc)\n    this._encoding = enc\n  }\n\n  if (this._encoding !== enc) throw new Error('can\\'t switch encodings')\n\n  var out = this._decoder.write(value)\n  if (fin) {\n    out += this._decoder.end()\n  }\n\n  return out\n}\n\nmodule.exports = CipherBase\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","'use strict'\nvar inherits = require('inherits')\nvar MD5 = require('md5.js')\nvar RIPEMD160 = require('ripemd160')\nvar sha = require('sha.js')\nvar Base = require('cipher-base')\n\nfunction Hash (hash) {\n  Base.call(this, 'digest')\n\n  this._hash = hash\n}\n\ninherits(Hash, Base)\n\nHash.prototype._update = function (data) {\n  this._hash.update(data)\n}\n\nHash.prototype._final = function () {\n  return this._hash.digest()\n}\n\nmodule.exports = function createHash (alg) {\n  alg = alg.toLowerCase()\n  if (alg === 'md5') return new MD5()\n  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()\n\n  return new Hash(sha(alg))\n}\n","var MD5 = require('md5.js')\n\nmodule.exports = function (buffer) {\n  return new MD5().update(buffer).digest()\n}\n","'use strict'\nvar inherits = require('inherits')\nvar Legacy = require('./legacy')\nvar Base = require('cipher-base')\nvar Buffer = require('safe-buffer').Buffer\nvar md5 = require('create-hash/md5')\nvar RIPEMD160 = require('ripemd160')\n\nvar sha = require('sha.js')\n\nvar ZEROS = Buffer.alloc(128)\n\nfunction Hmac (alg, key) {\n  Base.call(this, 'digest')\n  if (typeof key === 'string') {\n    key = Buffer.from(key)\n  }\n\n  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64\n\n  this._alg = alg\n  this._key = key\n  if (key.length > blocksize) {\n    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n    key = hash.update(key).digest()\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n  var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n  this._hash.update(ipad)\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n  this._hash.update(data)\n}\n\nHmac.prototype._final = function () {\n  var h = this._hash.digest()\n  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)\n  return hash.update(this._opad).update(h).digest()\n}\n\nmodule.exports = function createHmac (alg, key) {\n  alg = alg.toLowerCase()\n  if (alg === 'rmd160' || alg === 'ripemd160') {\n    return new Hmac('rmd160', key)\n  }\n  if (alg === 'md5') {\n    return new Legacy(md5, key)\n  }\n  return new Hmac(alg, key)\n}\n","'use strict'\nvar inherits = require('inherits')\nvar Buffer = require('safe-buffer').Buffer\n\nvar Base = require('cipher-base')\n\nvar ZEROS = Buffer.alloc(128)\nvar blocksize = 64\n\nfunction Hmac (alg, key) {\n  Base.call(this, 'digest')\n  if (typeof key === 'string') {\n    key = Buffer.from(key)\n  }\n\n  this._alg = alg\n  this._key = key\n\n  if (key.length > blocksize) {\n    key = alg(key)\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n  var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n\n  this._hash = [ipad]\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n  this._hash.push(data)\n}\n\nHmac.prototype._final = function () {\n  var h = this._alg(Buffer.concat(this._hash))\n  return this._alg(Buffer.concat([this._opad, h]))\n}\nmodule.exports = Hmac\n",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"), require(\"./enc-base64\"), require(\"./md5\"), require(\"./evpkdf\"), require(\"./cipher-core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./enc-base64\", \"./md5\", \"./evpkdf\", \"./cipher-core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var BlockCipher = C_lib.BlockCipher;\n\t    var C_algo = C.algo;\n\n\t    // Lookup tables\n\t    var SBOX = [];\n\t    var INV_SBOX = [];\n\t    var SUB_MIX_0 = [];\n\t    var SUB_MIX_1 = [];\n\t    var SUB_MIX_2 = [];\n\t    var SUB_MIX_3 = [];\n\t    var INV_SUB_MIX_0 = [];\n\t    var INV_SUB_MIX_1 = [];\n\t    var INV_SUB_MIX_2 = [];\n\t    var INV_SUB_MIX_3 = [];\n\n\t    // Compute lookup tables\n\t    (function () {\n\t        // Compute double table\n\t        var d = [];\n\t        for (var i = 0; i < 256; i++) {\n\t            if (i < 128) {\n\t                d[i] = i << 1;\n\t            } else {\n\t                d[i] = (i << 1) ^ 0x11b;\n\t            }\n\t        }\n\n\t        // Walk GF(2^8)\n\t        var x = 0;\n\t        var xi = 0;\n\t        for (var i = 0; i < 256; i++) {\n\t            // Compute sbox\n\t            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);\n\t            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;\n\t            SBOX[x] = sx;\n\t            INV_SBOX[sx] = x;\n\n\t            // Compute multiplication\n\t            var x2 = d[x];\n\t            var x4 = d[x2];\n\t            var x8 = d[x4];\n\n\t            // Compute sub bytes, mix columns tables\n\t            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);\n\t            SUB_MIX_0[x] = (t << 24) | (t >>> 8);\n\t            SUB_MIX_1[x] = (t << 16) | (t >>> 16);\n\t            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);\n\t            SUB_MIX_3[x] = t;\n\n\t            // Compute inv sub bytes, inv mix columns tables\n\t            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);\n\t            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);\n\t            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);\n\t            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);\n\t            INV_SUB_MIX_3[sx] = t;\n\n\t            // Compute next counter\n\t            if (!x) {\n\t                x = xi = 1;\n\t            } else {\n\t                x = x2 ^ d[d[d[x8 ^ x2]]];\n\t                xi ^= d[d[xi]];\n\t            }\n\t        }\n\t    }());\n\n\t    // Precomputed Rcon lookup\n\t    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];\n\n\t    /**\n\t     * AES block cipher algorithm.\n\t     */\n\t    var AES = C_algo.AES = BlockCipher.extend({\n\t        _doReset: function () {\n\t            // Skip reset of nRounds has been set before and key did not change\n\t            if (this._nRounds && this._keyPriorReset === this._key) {\n\t                return;\n\t            }\n\n\t            // Shortcuts\n\t            var key = this._keyPriorReset = this._key;\n\t            var keyWords = key.words;\n\t            var keySize = key.sigBytes / 4;\n\n\t            // Compute number of rounds\n\t            var nRounds = this._nRounds = keySize + 6;\n\n\t            // Compute number of key schedule rows\n\t            var ksRows = (nRounds + 1) * 4;\n\n\t            // Compute key schedule\n\t            var keySchedule = this._keySchedule = [];\n\t            for (var ksRow = 0; ksRow < ksRows; ksRow++) {\n\t                if (ksRow < keySize) {\n\t                    keySchedule[ksRow] = keyWords[ksRow];\n\t                } else {\n\t                    var t = keySchedule[ksRow - 1];\n\n\t                    if (!(ksRow % keySize)) {\n\t                        // Rot word\n\t                        t = (t << 8) | (t >>> 24);\n\n\t                        // Sub word\n\t                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\n\t                        // Mix Rcon\n\t                        t ^= RCON[(ksRow / keySize) | 0] << 24;\n\t                    } else if (keySize > 6 && ksRow % keySize == 4) {\n\t                        // Sub word\n\t                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\t                    }\n\n\t                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;\n\t                }\n\t            }\n\n\t            // Compute inv key schedule\n\t            var invKeySchedule = this._invKeySchedule = [];\n\t            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {\n\t                var ksRow = ksRows - invKsRow;\n\n\t                if (invKsRow % 4) {\n\t                    var t = keySchedule[ksRow];\n\t                } else {\n\t                    var t = keySchedule[ksRow - 4];\n\t                }\n\n\t                if (invKsRow < 4 || ksRow <= 4) {\n\t                    invKeySchedule[invKsRow] = t;\n\t                } else {\n\t                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^\n\t                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];\n\t                }\n\t            }\n\t        },\n\n\t        encryptBlock: function (M, offset) {\n\t            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);\n\t        },\n\n\t        decryptBlock: function (M, offset) {\n\t            // Swap 2nd and 4th rows\n\t            var t = M[offset + 1];\n\t            M[offset + 1] = M[offset + 3];\n\t            M[offset + 3] = t;\n\n\t            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);\n\n\t            // Inv swap 2nd and 4th rows\n\t            var t = M[offset + 1];\n\t            M[offset + 1] = M[offset + 3];\n\t            M[offset + 3] = t;\n\t        },\n\n\t        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {\n\t            // Shortcut\n\t            var nRounds = this._nRounds;\n\n\t            // Get input, add round key\n\t            var s0 = M[offset]     ^ keySchedule[0];\n\t            var s1 = M[offset + 1] ^ keySchedule[1];\n\t            var s2 = M[offset + 2] ^ keySchedule[2];\n\t            var s3 = M[offset + 3] ^ keySchedule[3];\n\n\t            // Key schedule row counter\n\t            var ksRow = 4;\n\n\t            // Rounds\n\t            for (var round = 1; round < nRounds; round++) {\n\t                // Shift rows, sub bytes, mix columns, add round key\n\t                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];\n\t                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];\n\t                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];\n\t                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];\n\n\t                // Update state\n\t                s0 = t0;\n\t                s1 = t1;\n\t                s2 = t2;\n\t                s3 = t3;\n\t            }\n\n\t            // Shift rows, sub bytes, add round key\n\t            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];\n\t            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];\n\n\t            // Set output\n\t            M[offset]     = t0;\n\t            M[offset + 1] = t1;\n\t            M[offset + 2] = t2;\n\t            M[offset + 3] = t3;\n\t        },\n\n\t        keySize: 256/32\n\t    });\n\n\t    /**\n\t     * Shortcut functions to the cipher's object interface.\n\t     *\n\t     * @example\n\t     *\n\t     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);\n\t     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);\n\t     */\n\t    C.AES = BlockCipher._createHelper(AES);\n\t}());\n\n\n\treturn CryptoJS.AES;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t/**\n\t * Cipher core components.\n\t */\n\tCryptoJS.lib.Cipher || (function (undefined) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var WordArray = C_lib.WordArray;\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;\n\t    var C_enc = C.enc;\n\t    var Utf8 = C_enc.Utf8;\n\t    var Base64 = C_enc.Base64;\n\t    var C_algo = C.algo;\n\t    var EvpKDF = C_algo.EvpKDF;\n\n\t    /**\n\t     * Abstract base cipher template.\n\t     *\n\t     * @property {number} keySize This cipher's key size. Default: 4 (128 bits)\n\t     * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)\n\t     * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.\n\t     * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.\n\t     */\n\t    var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {WordArray} iv The IV to use for this operation.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Creates this cipher in encryption mode.\n\t         *\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {Cipher} A cipher instance.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });\n\t         */\n\t        createEncryptor: function (key, cfg) {\n\t            return this.create(this._ENC_XFORM_MODE, key, cfg);\n\t        },\n\n\t        /**\n\t         * Creates this cipher in decryption mode.\n\t         *\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {Cipher} A cipher instance.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });\n\t         */\n\t        createDecryptor: function (key, cfg) {\n\t            return this.create(this._DEC_XFORM_MODE, key, cfg);\n\t        },\n\n\t        /**\n\t         * Initializes a newly created cipher.\n\t         *\n\t         * @param {number} xformMode Either the encryption or decryption transormation mode constant.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });\n\t         */\n\t        init: function (xformMode, key, cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Store transform mode and key\n\t            this._xformMode = xformMode;\n\t            this._key = key;\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this cipher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     cipher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-cipher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Adds data to be encrypted or decrypted.\n\t         *\n\t         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.\n\t         *\n\t         * @return {WordArray} The data after processing.\n\t         *\n\t         * @example\n\t         *\n\t         *     var encrypted = cipher.process('data');\n\t         *     var encrypted = cipher.process(wordArray);\n\t         */\n\t        process: function (dataUpdate) {\n\t            // Append\n\t            this._append(dataUpdate);\n\n\t            // Process available blocks\n\t            return this._process();\n\t        },\n\n\t        /**\n\t         * Finalizes the encryption or decryption process.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.\n\t         *\n\t         * @return {WordArray} The data after final processing.\n\t         *\n\t         * @example\n\t         *\n\t         *     var encrypted = cipher.finalize();\n\t         *     var encrypted = cipher.finalize('data');\n\t         *     var encrypted = cipher.finalize(wordArray);\n\t         */\n\t        finalize: function (dataUpdate) {\n\t            // Final data update\n\t            if (dataUpdate) {\n\t                this._append(dataUpdate);\n\t            }\n\n\t            // Perform concrete-cipher logic\n\t            var finalProcessedData = this._doFinalize();\n\n\t            return finalProcessedData;\n\t        },\n\n\t        keySize: 128/32,\n\n\t        ivSize: 128/32,\n\n\t        _ENC_XFORM_MODE: 1,\n\n\t        _DEC_XFORM_MODE: 2,\n\n\t        /**\n\t         * Creates shortcut functions to a cipher's object interface.\n\t         *\n\t         * @param {Cipher} cipher The cipher to create a helper for.\n\t         *\n\t         * @return {Object} An object with encrypt and decrypt shortcut functions.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);\n\t         */\n\t        _createHelper: (function () {\n\t            function selectCipherStrategy(key) {\n\t                if (typeof key == 'string') {\n\t                    return PasswordBasedCipher;\n\t                } else {\n\t                    return SerializableCipher;\n\t                }\n\t            }\n\n\t            return function (cipher) {\n\t                return {\n\t                    encrypt: function (message, key, cfg) {\n\t                        return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);\n\t                    },\n\n\t                    decrypt: function (ciphertext, key, cfg) {\n\t                        return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);\n\t                    }\n\t                };\n\t            };\n\t        }())\n\t    });\n\n\t    /**\n\t     * Abstract base stream cipher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)\n\t     */\n\t    var StreamCipher = C_lib.StreamCipher = Cipher.extend({\n\t        _doFinalize: function () {\n\t            // Process partial blocks\n\t            var finalProcessedBlocks = this._process(!!'flush');\n\n\t            return finalProcessedBlocks;\n\t        },\n\n\t        blockSize: 1\n\t    });\n\n\t    /**\n\t     * Mode namespace.\n\t     */\n\t    var C_mode = C.mode = {};\n\n\t    /**\n\t     * Abstract base block cipher mode template.\n\t     */\n\t    var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({\n\t        /**\n\t         * Creates this mode for encryption.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);\n\t         */\n\t        createEncryptor: function (cipher, iv) {\n\t            return this.Encryptor.create(cipher, iv);\n\t        },\n\n\t        /**\n\t         * Creates this mode for decryption.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);\n\t         */\n\t        createDecryptor: function (cipher, iv) {\n\t            return this.Decryptor.create(cipher, iv);\n\t        },\n\n\t        /**\n\t         * Initializes a newly created mode.\n\t         *\n\t         * @param {Cipher} cipher A block cipher instance.\n\t         * @param {Array} iv The IV words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);\n\t         */\n\t        init: function (cipher, iv) {\n\t            this._cipher = cipher;\n\t            this._iv = iv;\n\t        }\n\t    });\n\n\t    /**\n\t     * Cipher Block Chaining mode.\n\t     */\n\t    var CBC = C_mode.CBC = (function () {\n\t        /**\n\t         * Abstract base CBC mode.\n\t         */\n\t        var CBC = BlockCipherMode.extend();\n\n\t        /**\n\t         * CBC encryptor.\n\t         */\n\t        CBC.Encryptor = CBC.extend({\n\t            /**\n\t             * Processes the data block at offset.\n\t             *\n\t             * @param {Array} words The data words to operate on.\n\t             * @param {number} offset The offset where the block starts.\n\t             *\n\t             * @example\n\t             *\n\t             *     mode.processBlock(data.words, offset);\n\t             */\n\t            processBlock: function (words, offset) {\n\t                // Shortcuts\n\t                var cipher = this._cipher;\n\t                var blockSize = cipher.blockSize;\n\n\t                // XOR and encrypt\n\t                xorBlock.call(this, words, offset, blockSize);\n\t                cipher.encryptBlock(words, offset);\n\n\t                // Remember this block to use with next block\n\t                this._prevBlock = words.slice(offset, offset + blockSize);\n\t            }\n\t        });\n\n\t        /**\n\t         * CBC decryptor.\n\t         */\n\t        CBC.Decryptor = CBC.extend({\n\t            /**\n\t             * Processes the data block at offset.\n\t             *\n\t             * @param {Array} words The data words to operate on.\n\t             * @param {number} offset The offset where the block starts.\n\t             *\n\t             * @example\n\t             *\n\t             *     mode.processBlock(data.words, offset);\n\t             */\n\t            processBlock: function (words, offset) {\n\t                // Shortcuts\n\t                var cipher = this._cipher;\n\t                var blockSize = cipher.blockSize;\n\n\t                // Remember this block to use with next block\n\t                var thisBlock = words.slice(offset, offset + blockSize);\n\n\t                // Decrypt and XOR\n\t                cipher.decryptBlock(words, offset);\n\t                xorBlock.call(this, words, offset, blockSize);\n\n\t                // This block becomes the previous block\n\t                this._prevBlock = thisBlock;\n\t            }\n\t        });\n\n\t        function xorBlock(words, offset, blockSize) {\n\t            // Shortcut\n\t            var iv = this._iv;\n\n\t            // Choose mixing block\n\t            if (iv) {\n\t                var block = iv;\n\n\t                // Remove IV for subsequent blocks\n\t                this._iv = undefined;\n\t            } else {\n\t                var block = this._prevBlock;\n\t            }\n\n\t            // XOR blocks\n\t            for (var i = 0; i < blockSize; i++) {\n\t                words[offset + i] ^= block[i];\n\t            }\n\t        }\n\n\t        return CBC;\n\t    }());\n\n\t    /**\n\t     * Padding namespace.\n\t     */\n\t    var C_pad = C.pad = {};\n\n\t    /**\n\t     * PKCS #5/7 padding strategy.\n\t     */\n\t    var Pkcs7 = C_pad.Pkcs7 = {\n\t        /**\n\t         * Pads data using the algorithm defined in PKCS #5/7.\n\t         *\n\t         * @param {WordArray} data The data to pad.\n\t         * @param {number} blockSize The multiple that the data should be padded to.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);\n\t         */\n\t        pad: function (data, blockSize) {\n\t            // Shortcut\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count padding bytes\n\t            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;\n\n\t            // Create padding word\n\t            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;\n\n\t            // Create padding\n\t            var paddingWords = [];\n\t            for (var i = 0; i < nPaddingBytes; i += 4) {\n\t                paddingWords.push(paddingWord);\n\t            }\n\t            var padding = WordArray.create(paddingWords, nPaddingBytes);\n\n\t            // Add padding\n\t            data.concat(padding);\n\t        },\n\n\t        /**\n\t         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.\n\t         *\n\t         * @param {WordArray} data The data to unpad.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     CryptoJS.pad.Pkcs7.unpad(wordArray);\n\t         */\n\t        unpad: function (data) {\n\t            // Get number of padding bytes from last byte\n\t            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;\n\n\t            // Remove padding\n\t            data.sigBytes -= nPaddingBytes;\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract base block cipher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)\n\t     */\n\t    var BlockCipher = C_lib.BlockCipher = Cipher.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {Mode} mode The block mode to use. Default: CBC\n\t         * @property {Padding} padding The padding strategy to use. Default: Pkcs7\n\t         */\n\t        cfg: Cipher.cfg.extend({\n\t            mode: CBC,\n\t            padding: Pkcs7\n\t        }),\n\n\t        reset: function () {\n\t            // Reset cipher\n\t            Cipher.reset.call(this);\n\n\t            // Shortcuts\n\t            var cfg = this.cfg;\n\t            var iv = cfg.iv;\n\t            var mode = cfg.mode;\n\n\t            // Reset block mode\n\t            if (this._xformMode == this._ENC_XFORM_MODE) {\n\t                var modeCreator = mode.createEncryptor;\n\t            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n\t                var modeCreator = mode.createDecryptor;\n\n\t                // Keep at least one block in the buffer for unpadding\n\t                this._minBufferSize = 1;\n\t            }\n\t            this._mode = modeCreator.call(mode, this, iv && iv.words);\n\t        },\n\n\t        _doProcessBlock: function (words, offset) {\n\t            this._mode.processBlock(words, offset);\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcut\n\t            var padding = this.cfg.padding;\n\n\t            // Finalize\n\t            if (this._xformMode == this._ENC_XFORM_MODE) {\n\t                // Pad data\n\t                padding.pad(this._data, this.blockSize);\n\n\t                // Process final blocks\n\t                var finalProcessedBlocks = this._process(!!'flush');\n\t            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n\t                // Process final blocks\n\t                var finalProcessedBlocks = this._process(!!'flush');\n\n\t                // Unpad data\n\t                padding.unpad(finalProcessedBlocks);\n\t            }\n\n\t            return finalProcessedBlocks;\n\t        },\n\n\t        blockSize: 128/32\n\t    });\n\n\t    /**\n\t     * A collection of cipher parameters.\n\t     *\n\t     * @property {WordArray} ciphertext The raw ciphertext.\n\t     * @property {WordArray} key The key to this ciphertext.\n\t     * @property {WordArray} iv The IV used in the ciphering operation.\n\t     * @property {WordArray} salt The salt used with a key derivation function.\n\t     * @property {Cipher} algorithm The cipher algorithm.\n\t     * @property {Mode} mode The block mode used in the ciphering operation.\n\t     * @property {Padding} padding The padding scheme used in the ciphering operation.\n\t     * @property {number} blockSize The block size of the cipher.\n\t     * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.\n\t     */\n\t    var CipherParams = C_lib.CipherParams = Base.extend({\n\t        /**\n\t         * Initializes a newly created cipher params object.\n\t         *\n\t         * @param {Object} cipherParams An object with any of the possible cipher parameters.\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipherParams = CryptoJS.lib.CipherParams.create({\n\t         *         ciphertext: ciphertextWordArray,\n\t         *         key: keyWordArray,\n\t         *         iv: ivWordArray,\n\t         *         salt: saltWordArray,\n\t         *         algorithm: CryptoJS.algo.AES,\n\t         *         mode: CryptoJS.mode.CBC,\n\t         *         padding: CryptoJS.pad.PKCS7,\n\t         *         blockSize: 4,\n\t         *         formatter: CryptoJS.format.OpenSSL\n\t         *     });\n\t         */\n\t        init: function (cipherParams) {\n\t            this.mixIn(cipherParams);\n\t        },\n\n\t        /**\n\t         * Converts this cipher params object to a string.\n\t         *\n\t         * @param {Format} formatter (Optional) The formatting strategy to use.\n\t         *\n\t         * @return {string} The stringified cipher params.\n\t         *\n\t         * @throws Error If neither the formatter nor the default formatter is set.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = cipherParams + '';\n\t         *     var string = cipherParams.toString();\n\t         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);\n\t         */\n\t        toString: function (formatter) {\n\t            return (formatter || this.formatter).stringify(this);\n\t        }\n\t    });\n\n\t    /**\n\t     * Format namespace.\n\t     */\n\t    var C_format = C.format = {};\n\n\t    /**\n\t     * OpenSSL formatting strategy.\n\t     */\n\t    var OpenSSLFormatter = C_format.OpenSSL = {\n\t        /**\n\t         * Converts a cipher params object to an OpenSSL-compatible string.\n\t         *\n\t         * @param {CipherParams} cipherParams The cipher params object.\n\t         *\n\t         * @return {string} The OpenSSL-compatible string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);\n\t         */\n\t        stringify: function (cipherParams) {\n\t            // Shortcuts\n\t            var ciphertext = cipherParams.ciphertext;\n\t            var salt = cipherParams.salt;\n\n\t            // Format\n\t            if (salt) {\n\t                var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);\n\t            } else {\n\t                var wordArray = ciphertext;\n\t            }\n\n\t            return wordArray.toString(Base64);\n\t        },\n\n\t        /**\n\t         * Converts an OpenSSL-compatible string to a cipher params object.\n\t         *\n\t         * @param {string} openSSLStr The OpenSSL-compatible string.\n\t         *\n\t         * @return {CipherParams} The cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);\n\t         */\n\t        parse: function (openSSLStr) {\n\t            // Parse base64\n\t            var ciphertext = Base64.parse(openSSLStr);\n\n\t            // Shortcut\n\t            var ciphertextWords = ciphertext.words;\n\n\t            // Test for salt\n\t            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {\n\t                // Extract salt\n\t                var salt = WordArray.create(ciphertextWords.slice(2, 4));\n\n\t                // Remove salt from ciphertext\n\t                ciphertextWords.splice(0, 4);\n\t                ciphertext.sigBytes -= 16;\n\t            }\n\n\t            return CipherParams.create({ ciphertext: ciphertext, salt: salt });\n\t        }\n\t    };\n\n\t    /**\n\t     * A cipher wrapper that returns ciphertext as a serializable cipher params object.\n\t     */\n\t    var SerializableCipher = C_lib.SerializableCipher = Base.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL\n\t         */\n\t        cfg: Base.extend({\n\t            format: OpenSSLFormatter\n\t        }),\n\n\t        /**\n\t         * Encrypts a message.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {WordArray|string} message The message to encrypt.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {CipherParams} A cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         */\n\t        encrypt: function (cipher, message, key, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Encrypt\n\t            var encryptor = cipher.createEncryptor(key, cfg);\n\t            var ciphertext = encryptor.finalize(message);\n\n\t            // Shortcut\n\t            var cipherCfg = encryptor.cfg;\n\n\t            // Create and return serializable cipher params\n\t            return CipherParams.create({\n\t                ciphertext: ciphertext,\n\t                key: key,\n\t                iv: cipherCfg.iv,\n\t                algorithm: cipher,\n\t                mode: cipherCfg.mode,\n\t                padding: cipherCfg.padding,\n\t                blockSize: cipher.blockSize,\n\t                formatter: cfg.format\n\t            });\n\t        },\n\n\t        /**\n\t         * Decrypts serialized ciphertext.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n\t         * @param {WordArray} key The key.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {WordArray} The plaintext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n\t         */\n\t        decrypt: function (cipher, ciphertext, key, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Convert string to CipherParams\n\t            ciphertext = this._parse(ciphertext, cfg.format);\n\n\t            // Decrypt\n\t            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);\n\n\t            return plaintext;\n\t        },\n\n\t        /**\n\t         * Converts serialized ciphertext to CipherParams,\n\t         * else assumed CipherParams already and returns ciphertext unchanged.\n\t         *\n\t         * @param {CipherParams|string} ciphertext The ciphertext.\n\t         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.\n\t         *\n\t         * @return {CipherParams} The unserialized ciphertext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);\n\t         */\n\t        _parse: function (ciphertext, format) {\n\t            if (typeof ciphertext == 'string') {\n\t                return format.parse(ciphertext, this);\n\t            } else {\n\t                return ciphertext;\n\t            }\n\t        }\n\t    });\n\n\t    /**\n\t     * Key derivation function namespace.\n\t     */\n\t    var C_kdf = C.kdf = {};\n\n\t    /**\n\t     * OpenSSL key derivation function.\n\t     */\n\t    var OpenSSLKdf = C_kdf.OpenSSL = {\n\t        /**\n\t         * Derives a key and IV from a password.\n\t         *\n\t         * @param {string} password The password to derive from.\n\t         * @param {number} keySize The size in words of the key to generate.\n\t         * @param {number} ivSize The size in words of the IV to generate.\n\t         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.\n\t         *\n\t         * @return {CipherParams} A cipher params object with the key, IV, and salt.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);\n\t         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');\n\t         */\n\t        execute: function (password, keySize, ivSize, salt) {\n\t            // Generate random salt\n\t            if (!salt) {\n\t                salt = WordArray.random(64/8);\n\t            }\n\n\t            // Derive key and IV\n\t            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);\n\n\t            // Separate key and IV\n\t            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);\n\t            key.sigBytes = keySize * 4;\n\n\t            // Return params\n\t            return CipherParams.create({ key: key, iv: iv, salt: salt });\n\t        }\n\t    };\n\n\t    /**\n\t     * A serializable cipher wrapper that derives the key from a password,\n\t     * and returns ciphertext as a serializable cipher params object.\n\t     */\n\t    var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL\n\t         */\n\t        cfg: SerializableCipher.cfg.extend({\n\t            kdf: OpenSSLKdf\n\t        }),\n\n\t        /**\n\t         * Encrypts a message using a password.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {WordArray|string} message The message to encrypt.\n\t         * @param {string} password The password.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {CipherParams} A cipher params object.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');\n\t         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });\n\t         */\n\t        encrypt: function (cipher, message, password, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Derive key and other params\n\t            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);\n\n\t            // Add IV to config\n\t            cfg.iv = derivedParams.iv;\n\n\t            // Encrypt\n\t            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);\n\n\t            // Mix in derived params\n\t            ciphertext.mixIn(derivedParams);\n\n\t            return ciphertext;\n\t        },\n\n\t        /**\n\t         * Decrypts serialized ciphertext using a password.\n\t         *\n\t         * @param {Cipher} cipher The cipher algorithm to use.\n\t         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n\t         * @param {string} password The password.\n\t         * @param {Object} cfg (Optional) The configuration options to use for this operation.\n\t         *\n\t         * @return {WordArray} The plaintext.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });\n\t         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });\n\t         */\n\t        decrypt: function (cipher, ciphertext, password, cfg) {\n\t            // Apply config defaults\n\t            cfg = this.cfg.extend(cfg);\n\n\t            // Convert string to CipherParams\n\t            ciphertext = this._parse(ciphertext, cfg.format);\n\n\t            // Derive key and other params\n\t            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);\n\n\t            // Add IV to config\n\t            cfg.iv = derivedParams.iv;\n\n\t            // Decrypt\n\t            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);\n\n\t            return plaintext;\n\t        }\n\t    });\n\t}());\n\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory();\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\troot.CryptoJS = factory();\n\t}\n}(this, function () {\n\n\t/**\n\t * CryptoJS core components.\n\t */\n\tvar CryptoJS = CryptoJS || (function (Math, undefined) {\n\t    /*\n\t     * Local polyfil of Object.create\n\t     */\n\t    var create = Object.create || (function () {\n\t        function F() {};\n\n\t        return function (obj) {\n\t            var subtype;\n\n\t            F.prototype = obj;\n\n\t            subtype = new F();\n\n\t            F.prototype = null;\n\n\t            return subtype;\n\t        };\n\t    }())\n\n\t    /**\n\t     * CryptoJS namespace.\n\t     */\n\t    var C = {};\n\n\t    /**\n\t     * Library namespace.\n\t     */\n\t    var C_lib = C.lib = {};\n\n\t    /**\n\t     * Base object for prototypal inheritance.\n\t     */\n\t    var Base = C_lib.Base = (function () {\n\n\n\t        return {\n\t            /**\n\t             * Creates a new object that inherits from this object.\n\t             *\n\t             * @param {Object} overrides Properties to copy into the new object.\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         field: 'value',\n\t             *\n\t             *         method: function () {\n\t             *         }\n\t             *     });\n\t             */\n\t            extend: function (overrides) {\n\t                // Spawn\n\t                var subtype = create(this);\n\n\t                // Augment\n\t                if (overrides) {\n\t                    subtype.mixIn(overrides);\n\t                }\n\n\t                // Create default initializer\n\t                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n\t                    subtype.init = function () {\n\t                        subtype.$super.init.apply(this, arguments);\n\t                    };\n\t                }\n\n\t                // Initializer's prototype is the subtype object\n\t                subtype.init.prototype = subtype;\n\n\t                // Reference supertype\n\t                subtype.$super = this;\n\n\t                return subtype;\n\t            },\n\n\t            /**\n\t             * Extends this object and runs the init method.\n\t             * Arguments to create() will be passed to init().\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var instance = MyType.create();\n\t             */\n\t            create: function () {\n\t                var instance = this.extend();\n\t                instance.init.apply(instance, arguments);\n\n\t                return instance;\n\t            },\n\n\t            /**\n\t             * Initializes a newly created object.\n\t             * Override this method to add some logic when your objects are created.\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         init: function () {\n\t             *             // ...\n\t             *         }\n\t             *     });\n\t             */\n\t            init: function () {\n\t            },\n\n\t            /**\n\t             * Copies properties into this object.\n\t             *\n\t             * @param {Object} properties The properties to mix in.\n\t             *\n\t             * @example\n\t             *\n\t             *     MyType.mixIn({\n\t             *         field: 'value'\n\t             *     });\n\t             */\n\t            mixIn: function (properties) {\n\t                for (var propertyName in properties) {\n\t                    if (properties.hasOwnProperty(propertyName)) {\n\t                        this[propertyName] = properties[propertyName];\n\t                    }\n\t                }\n\n\t                // IE won't copy toString using the loop above\n\t                if (properties.hasOwnProperty('toString')) {\n\t                    this.toString = properties.toString;\n\t                }\n\t            },\n\n\t            /**\n\t             * Creates a copy of this object.\n\t             *\n\t             * @return {Object} The clone.\n\t             *\n\t             * @example\n\t             *\n\t             *     var clone = instance.clone();\n\t             */\n\t            clone: function () {\n\t                return this.init.prototype.extend(this);\n\t            }\n\t        };\n\t    }());\n\n\t    /**\n\t     * An array of 32-bit words.\n\t     *\n\t     * @property {Array} words The array of 32-bit words.\n\t     * @property {number} sigBytes The number of significant bytes in this word array.\n\t     */\n\t    var WordArray = C_lib.WordArray = Base.extend({\n\t        /**\n\t         * Initializes a newly created word array.\n\t         *\n\t         * @param {Array} words (Optional) An array of 32-bit words.\n\t         * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.create();\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n\t         */\n\t        init: function (words, sigBytes) {\n\t            words = this.words = words || [];\n\n\t            if (sigBytes != undefined) {\n\t                this.sigBytes = sigBytes;\n\t            } else {\n\t                this.sigBytes = words.length * 4;\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts this word array to a string.\n\t         *\n\t         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n\t         *\n\t         * @return {string} The stringified word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = wordArray + '';\n\t         *     var string = wordArray.toString();\n\t         *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n\t         */\n\t        toString: function (encoder) {\n\t            return (encoder || Hex).stringify(this);\n\t        },\n\n\t        /**\n\t         * Concatenates a word array to this word array.\n\t         *\n\t         * @param {WordArray} wordArray The word array to append.\n\t         *\n\t         * @return {WordArray} This word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray1.concat(wordArray2);\n\t         */\n\t        concat: function (wordArray) {\n\t            // Shortcuts\n\t            var thisWords = this.words;\n\t            var thatWords = wordArray.words;\n\t            var thisSigBytes = this.sigBytes;\n\t            var thatSigBytes = wordArray.sigBytes;\n\n\t            // Clamp excess bits\n\t            this.clamp();\n\n\t            // Concat\n\t            if (thisSigBytes % 4) {\n\t                // Copy one byte at a time\n\t                for (var i = 0; i < thatSigBytes; i++) {\n\t                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n\t                }\n\t            } else {\n\t                // Copy one word at a time\n\t                for (var i = 0; i < thatSigBytes; i += 4) {\n\t                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n\t                }\n\t            }\n\t            this.sigBytes += thatSigBytes;\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Removes insignificant bits.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray.clamp();\n\t         */\n\t        clamp: function () {\n\t            // Shortcuts\n\t            var words = this.words;\n\t            var sigBytes = this.sigBytes;\n\n\t            // Clamp\n\t            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n\t            words.length = Math.ceil(sigBytes / 4);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this word array.\n\t         *\n\t         * @return {WordArray} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = wordArray.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone.words = this.words.slice(0);\n\n\t            return clone;\n\t        },\n\n\t        /**\n\t         * Creates a word array filled with random bytes.\n\t         *\n\t         * @param {number} nBytes The number of random bytes to generate.\n\t         *\n\t         * @return {WordArray} The random word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.random(16);\n\t         */\n\t        random: function (nBytes) {\n\t            var words = [];\n\n\t            var r = (function (m_w) {\n\t                var m_w = m_w;\n\t                var m_z = 0x3ade68b1;\n\t                var mask = 0xffffffff;\n\n\t                return function () {\n\t                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;\n\t                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;\n\t                    var result = ((m_z << 0x10) + m_w) & mask;\n\t                    result /= 0x100000000;\n\t                    result += 0.5;\n\t                    return result * (Math.random() > .5 ? 1 : -1);\n\t                }\n\t            });\n\n\t            for (var i = 0, rcache; i < nBytes; i += 4) {\n\t                var _r = r((rcache || Math.random()) * 0x100000000);\n\n\t                rcache = _r() * 0x3ade67b7;\n\t                words.push((_r() * 0x100000000) | 0);\n\t            }\n\n\t            return new WordArray.init(words, nBytes);\n\t        }\n\t    });\n\n\t    /**\n\t     * Encoder namespace.\n\t     */\n\t    var C_enc = C.enc = {};\n\n\t    /**\n\t     * Hex encoding strategy.\n\t     */\n\t    var Hex = C_enc.Hex = {\n\t        /**\n\t         * Converts a word array to a hex string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The hex string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var hexChars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                hexChars.push((bite >>> 4).toString(16));\n\t                hexChars.push((bite & 0x0f).toString(16));\n\t            }\n\n\t            return hexChars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a hex string to a word array.\n\t         *\n\t         * @param {string} hexStr The hex string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n\t         */\n\t        parse: function (hexStr) {\n\t            // Shortcut\n\t            var hexStrLength = hexStr.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < hexStrLength; i += 2) {\n\t                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n\t            }\n\n\t            return new WordArray.init(words, hexStrLength / 2);\n\t        }\n\t    };\n\n\t    /**\n\t     * Latin1 encoding strategy.\n\t     */\n\t    var Latin1 = C_enc.Latin1 = {\n\t        /**\n\t         * Converts a word array to a Latin1 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Latin1 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var latin1Chars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                latin1Chars.push(String.fromCharCode(bite));\n\t            }\n\n\t            return latin1Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Latin1 string to a word array.\n\t         *\n\t         * @param {string} latin1Str The Latin1 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n\t         */\n\t        parse: function (latin1Str) {\n\t            // Shortcut\n\t            var latin1StrLength = latin1Str.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < latin1StrLength; i++) {\n\t                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n\t            }\n\n\t            return new WordArray.init(words, latin1StrLength);\n\t        }\n\t    };\n\n\t    /**\n\t     * UTF-8 encoding strategy.\n\t     */\n\t    var Utf8 = C_enc.Utf8 = {\n\t        /**\n\t         * Converts a word array to a UTF-8 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The UTF-8 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            try {\n\t                return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n\t            } catch (e) {\n\t                throw new Error('Malformed UTF-8 data');\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts a UTF-8 string to a word array.\n\t         *\n\t         * @param {string} utf8Str The UTF-8 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n\t         */\n\t        parse: function (utf8Str) {\n\t            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract buffered block algorithm template.\n\t     *\n\t     * The property blockSize must be implemented in a concrete subtype.\n\t     *\n\t     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n\t     */\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\t        /**\n\t         * Resets this block algorithm's data buffer to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm.reset();\n\t         */\n\t        reset: function () {\n\t            // Initial values\n\t            this._data = new WordArray.init();\n\t            this._nDataBytes = 0;\n\t        },\n\n\t        /**\n\t         * Adds new data to this block algorithm's buffer.\n\t         *\n\t         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm._append('data');\n\t         *     bufferedBlockAlgorithm._append(wordArray);\n\t         */\n\t        _append: function (data) {\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof data == 'string') {\n\t                data = Utf8.parse(data);\n\t            }\n\n\t            // Append\n\t            this._data.concat(data);\n\t            this._nDataBytes += data.sigBytes;\n\t        },\n\n\t        /**\n\t         * Processes available data blocks.\n\t         *\n\t         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n\t         *\n\t         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n\t         *\n\t         * @return {WordArray} The processed data.\n\t         *\n\t         * @example\n\t         *\n\t         *     var processedData = bufferedBlockAlgorithm._process();\n\t         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n\t         */\n\t        _process: function (doFlush) {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\t            var dataSigBytes = data.sigBytes;\n\t            var blockSize = this.blockSize;\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count blocks ready\n\t            var nBlocksReady = dataSigBytes / blockSizeBytes;\n\t            if (doFlush) {\n\t                // Round up to include partial blocks\n\t                nBlocksReady = Math.ceil(nBlocksReady);\n\t            } else {\n\t                // Round down to include only full blocks,\n\t                // less the number of blocks that must remain in the buffer\n\t                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n\t            }\n\n\t            // Count words ready\n\t            var nWordsReady = nBlocksReady * blockSize;\n\n\t            // Count bytes ready\n\t            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n\t            // Process blocks\n\t            if (nWordsReady) {\n\t                for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n\t                    // Perform concrete-algorithm logic\n\t                    this._doProcessBlock(dataWords, offset);\n\t                }\n\n\t                // Remove processed words\n\t                var processedWords = dataWords.splice(0, nWordsReady);\n\t                data.sigBytes -= nBytesReady;\n\t            }\n\n\t            // Return processed words\n\t            return new WordArray.init(processedWords, nBytesReady);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this object.\n\t         *\n\t         * @return {Object} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = bufferedBlockAlgorithm.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone._data = this._data.clone();\n\n\t            return clone;\n\t        },\n\n\t        _minBufferSize: 0\n\t    });\n\n\t    /**\n\t     * Abstract hasher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n\t     */\n\t    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Initializes a newly created hasher.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hasher = CryptoJS.algo.SHA256.create();\n\t         */\n\t        init: function (cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this hasher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-hasher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Updates this hasher with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {Hasher} This hasher.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.update('message');\n\t         *     hasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            // Append\n\t            this._append(messageUpdate);\n\n\t            // Update the hash\n\t            this._process();\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the hash computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The hash.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hash = hasher.finalize();\n\t         *     var hash = hasher.finalize('message');\n\t         *     var hash = hasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Final message update\n\t            if (messageUpdate) {\n\t                this._append(messageUpdate);\n\t            }\n\n\t            // Perform concrete-hasher logic\n\t            var hash = this._doFinalize();\n\n\t            return hash;\n\t        },\n\n\t        blockSize: 512/32,\n\n\t        /**\n\t         * Creates a shortcut function to a hasher's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to create a helper for.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHelper: function (hasher) {\n\t            return function (message, cfg) {\n\t                return new hasher.init(cfg).finalize(message);\n\t            };\n\t        },\n\n\t        /**\n\t         * Creates a shortcut function to the HMAC's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to use in this HMAC helper.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHmacHelper: function (hasher) {\n\t            return function (message, key) {\n\t                return new C_algo.HMAC.init(hasher, key).finalize(message);\n\t            };\n\t        }\n\t    });\n\n\t    /**\n\t     * Algorithm namespace.\n\t     */\n\t    var C_algo = C.algo = {};\n\n\t    return C;\n\t}(Math));\n\n\n\treturn CryptoJS;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var C_enc = C.enc;\n\n\t    /**\n\t     * Base64 encoding strategy.\n\t     */\n\t    var Base64 = C_enc.Base64 = {\n\t        /**\n\t         * Converts a word array to a Base64 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Base64 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\t            var map = this._map;\n\n\t            // Clamp excess bits\n\t            wordArray.clamp();\n\n\t            // Convert\n\t            var base64Chars = [];\n\t            for (var i = 0; i < sigBytes; i += 3) {\n\t                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;\n\t                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n\t                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n\t                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n\t                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {\n\t                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n\t                }\n\t            }\n\n\t            // Add padding\n\t            var paddingChar = map.charAt(64);\n\t            if (paddingChar) {\n\t                while (base64Chars.length % 4) {\n\t                    base64Chars.push(paddingChar);\n\t                }\n\t            }\n\n\t            return base64Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Base64 string to a word array.\n\t         *\n\t         * @param {string} base64Str The Base64 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);\n\t         */\n\t        parse: function (base64Str) {\n\t            // Shortcuts\n\t            var base64StrLength = base64Str.length;\n\t            var map = this._map;\n\t            var reverseMap = this._reverseMap;\n\n\t            if (!reverseMap) {\n\t                    reverseMap = this._reverseMap = [];\n\t                    for (var j = 0; j < map.length; j++) {\n\t                        reverseMap[map.charCodeAt(j)] = j;\n\t                    }\n\t            }\n\n\t            // Ignore padding\n\t            var paddingChar = map.charAt(64);\n\t            if (paddingChar) {\n\t                var paddingIndex = base64Str.indexOf(paddingChar);\n\t                if (paddingIndex !== -1) {\n\t                    base64StrLength = paddingIndex;\n\t                }\n\t            }\n\n\t            // Convert\n\t            return parseLoop(base64Str, base64StrLength, reverseMap);\n\n\t        },\n\n\t        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='\n\t    };\n\n\t    function parseLoop(base64Str, base64StrLength, reverseMap) {\n\t      var words = [];\n\t      var nBytes = 0;\n\t      for (var i = 0; i < base64StrLength; i++) {\n\t          if (i % 4) {\n\t              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);\n\t              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);\n\t              words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);\n\t              nBytes++;\n\t          }\n\t      }\n\t      return WordArray.create(words, nBytes);\n\t    }\n\t}());\n\n\n\treturn CryptoJS.enc.Base64;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\treturn CryptoJS.enc.Hex;\n\n}));",";(function (root, factory, undef) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"), require(\"./sha1\"), require(\"./hmac\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\", \"./sha1\", \"./hmac\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var WordArray = C_lib.WordArray;\n\t    var C_algo = C.algo;\n\t    var MD5 = C_algo.MD5;\n\n\t    /**\n\t     * This key derivation function is meant to conform with EVP_BytesToKey.\n\t     * www.openssl.org/docs/crypto/EVP_BytesToKey.html\n\t     */\n\t    var EvpKDF = C_algo.EvpKDF = Base.extend({\n\t        /**\n\t         * Configuration options.\n\t         *\n\t         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\n\t         * @property {Hasher} hasher The hash algorithm to use. Default: MD5\n\t         * @property {number} iterations The number of iterations to perform. Default: 1\n\t         */\n\t        cfg: Base.extend({\n\t            keySize: 128/32,\n\t            hasher: MD5,\n\t            iterations: 1\n\t        }),\n\n\t        /**\n\t         * Initializes a newly created key derivation function.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for the derivation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create();\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });\n\t         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });\n\t         */\n\t        init: function (cfg) {\n\t            this.cfg = this.cfg.extend(cfg);\n\t        },\n\n\t        /**\n\t         * Derives a key from a password.\n\t         *\n\t         * @param {WordArray|string} password The password.\n\t         * @param {WordArray|string} salt A salt.\n\t         *\n\t         * @return {WordArray} The derived key.\n\t         *\n\t         * @example\n\t         *\n\t         *     var key = kdf.compute(password, salt);\n\t         */\n\t        compute: function (password, salt) {\n\t            // Shortcut\n\t            var cfg = this.cfg;\n\n\t            // Init hasher\n\t            var hasher = cfg.hasher.create();\n\n\t            // Initial values\n\t            var derivedKey = WordArray.create();\n\n\t            // Shortcuts\n\t            var derivedKeyWords = derivedKey.words;\n\t            var keySize = cfg.keySize;\n\t            var iterations = cfg.iterations;\n\n\t            // Generate key\n\t            while (derivedKeyWords.length < keySize) {\n\t                if (block) {\n\t                    hasher.update(block);\n\t                }\n\t                var block = hasher.update(password).finalize(salt);\n\t                hasher.reset();\n\n\t                // Iterations\n\t                for (var i = 1; i < iterations; i++) {\n\t                    block = hasher.finalize(block);\n\t                    hasher.reset();\n\t                }\n\n\t                derivedKey.concat(block);\n\t            }\n\t            derivedKey.sigBytes = keySize * 4;\n\n\t            return derivedKey;\n\t        }\n\t    });\n\n\t    /**\n\t     * Derives a key from a password.\n\t     *\n\t     * @param {WordArray|string} password The password.\n\t     * @param {WordArray|string} salt A salt.\n\t     * @param {Object} cfg (Optional) The configuration options to use for this computation.\n\t     *\n\t     * @return {WordArray} The derived key.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var key = CryptoJS.EvpKDF(password, salt);\n\t     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });\n\t     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });\n\t     */\n\t    C.EvpKDF = function (password, salt, cfg) {\n\t        return EvpKDF.create(cfg).compute(password, salt);\n\t    };\n\t}());\n\n\n\treturn CryptoJS.EvpKDF;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var Base = C_lib.Base;\n\t    var C_enc = C.enc;\n\t    var Utf8 = C_enc.Utf8;\n\t    var C_algo = C.algo;\n\n\t    /**\n\t     * HMAC algorithm.\n\t     */\n\t    var HMAC = C_algo.HMAC = Base.extend({\n\t        /**\n\t         * Initializes a newly created HMAC.\n\t         *\n\t         * @param {Hasher} hasher The hash algorithm to use.\n\t         * @param {WordArray|string} key The secret key.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);\n\t         */\n\t        init: function (hasher, key) {\n\t            // Init hasher\n\t            hasher = this._hasher = new hasher.init();\n\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof key == 'string') {\n\t                key = Utf8.parse(key);\n\t            }\n\n\t            // Shortcuts\n\t            var hasherBlockSize = hasher.blockSize;\n\t            var hasherBlockSizeBytes = hasherBlockSize * 4;\n\n\t            // Allow arbitrary length keys\n\t            if (key.sigBytes > hasherBlockSizeBytes) {\n\t                key = hasher.finalize(key);\n\t            }\n\n\t            // Clamp excess bits\n\t            key.clamp();\n\n\t            // Clone key for inner and outer pads\n\t            var oKey = this._oKey = key.clone();\n\t            var iKey = this._iKey = key.clone();\n\n\t            // Shortcuts\n\t            var oKeyWords = oKey.words;\n\t            var iKeyWords = iKey.words;\n\n\t            // XOR keys with pad constants\n\t            for (var i = 0; i < hasherBlockSize; i++) {\n\t                oKeyWords[i] ^= 0x5c5c5c5c;\n\t                iKeyWords[i] ^= 0x36363636;\n\t            }\n\t            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this HMAC to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hmacHasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Shortcut\n\t            var hasher = this._hasher;\n\n\t            // Reset\n\t            hasher.reset();\n\t            hasher.update(this._iKey);\n\t        },\n\n\t        /**\n\t         * Updates this HMAC with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {HMAC} This HMAC instance.\n\t         *\n\t         * @example\n\t         *\n\t         *     hmacHasher.update('message');\n\t         *     hmacHasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            this._hasher.update(messageUpdate);\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the HMAC computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The HMAC.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hmac = hmacHasher.finalize();\n\t         *     var hmac = hmacHasher.finalize('message');\n\t         *     var hmac = hmacHasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Shortcut\n\t            var hasher = this._hasher;\n\n\t            // Compute HMAC\n\t            var innerHash = hasher.finalize(messageUpdate);\n\t            hasher.reset();\n\t            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));\n\n\t            return hmac;\n\t        }\n\t    });\n\t}());\n\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function (Math) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Constants table\n\t    var T = [];\n\n\t    // Compute constants\n\t    (function () {\n\t        for (var i = 0; i < 64; i++) {\n\t            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n\t        }\n\t    }());\n\n\t    /**\n\t     * MD5 hash algorithm.\n\t     */\n\t    var MD5 = C_algo.MD5 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Swap endian\n\t            for (var i = 0; i < 16; i++) {\n\t                // Shortcuts\n\t                var offset_i = offset + i;\n\t                var M_offset_i = M[offset_i];\n\n\t                M[offset_i] = (\n\t                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |\n\t                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)\n\t                );\n\t            }\n\n\t            // Shortcuts\n\t            var H = this._hash.words;\n\n\t            var M_offset_0  = M[offset + 0];\n\t            var M_offset_1  = M[offset + 1];\n\t            var M_offset_2  = M[offset + 2];\n\t            var M_offset_3  = M[offset + 3];\n\t            var M_offset_4  = M[offset + 4];\n\t            var M_offset_5  = M[offset + 5];\n\t            var M_offset_6  = M[offset + 6];\n\t            var M_offset_7  = M[offset + 7];\n\t            var M_offset_8  = M[offset + 8];\n\t            var M_offset_9  = M[offset + 9];\n\t            var M_offset_10 = M[offset + 10];\n\t            var M_offset_11 = M[offset + 11];\n\t            var M_offset_12 = M[offset + 12];\n\t            var M_offset_13 = M[offset + 13];\n\t            var M_offset_14 = M[offset + 14];\n\t            var M_offset_15 = M[offset + 15];\n\n\t            // Working varialbes\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\n\t            // Computation\n\t            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);\n\t            d = FF(d, a, b, c, M_offset_1,  12, T[1]);\n\t            c = FF(c, d, a, b, M_offset_2,  17, T[2]);\n\t            b = FF(b, c, d, a, M_offset_3,  22, T[3]);\n\t            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);\n\t            d = FF(d, a, b, c, M_offset_5,  12, T[5]);\n\t            c = FF(c, d, a, b, M_offset_6,  17, T[6]);\n\t            b = FF(b, c, d, a, M_offset_7,  22, T[7]);\n\t            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);\n\t            d = FF(d, a, b, c, M_offset_9,  12, T[9]);\n\t            c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n\t            b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n\t            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);\n\t            d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n\t            c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n\t            b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\n\t            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);\n\t            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);\n\t            c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n\t            b = GG(b, c, d, a, M_offset_0,  20, T[19]);\n\t            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);\n\t            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);\n\t            c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n\t            b = GG(b, c, d, a, M_offset_4,  20, T[23]);\n\t            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);\n\t            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);\n\t            c = GG(c, d, a, b, M_offset_3,  14, T[26]);\n\t            b = GG(b, c, d, a, M_offset_8,  20, T[27]);\n\t            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);\n\t            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);\n\t            c = GG(c, d, a, b, M_offset_7,  14, T[30]);\n\t            b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\n\t            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);\n\t            d = HH(d, a, b, c, M_offset_8,  11, T[33]);\n\t            c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n\t            b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n\t            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);\n\t            d = HH(d, a, b, c, M_offset_4,  11, T[37]);\n\t            c = HH(c, d, a, b, M_offset_7,  16, T[38]);\n\t            b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n\t            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);\n\t            d = HH(d, a, b, c, M_offset_0,  11, T[41]);\n\t            c = HH(c, d, a, b, M_offset_3,  16, T[42]);\n\t            b = HH(b, c, d, a, M_offset_6,  23, T[43]);\n\t            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);\n\t            d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n\t            c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n\t            b = HH(b, c, d, a, M_offset_2,  23, T[47]);\n\n\t            a = II(a, b, c, d, M_offset_0,  6,  T[48]);\n\t            d = II(d, a, b, c, M_offset_7,  10, T[49]);\n\t            c = II(c, d, a, b, M_offset_14, 15, T[50]);\n\t            b = II(b, c, d, a, M_offset_5,  21, T[51]);\n\t            a = II(a, b, c, d, M_offset_12, 6,  T[52]);\n\t            d = II(d, a, b, c, M_offset_3,  10, T[53]);\n\t            c = II(c, d, a, b, M_offset_10, 15, T[54]);\n\t            b = II(b, c, d, a, M_offset_1,  21, T[55]);\n\t            a = II(a, b, c, d, M_offset_8,  6,  T[56]);\n\t            d = II(d, a, b, c, M_offset_15, 10, T[57]);\n\t            c = II(c, d, a, b, M_offset_6,  15, T[58]);\n\t            b = II(b, c, d, a, M_offset_13, 21, T[59]);\n\t            a = II(a, b, c, d, M_offset_4,  6,  T[60]);\n\t            d = II(d, a, b, c, M_offset_11, 10, T[61]);\n\t            c = II(c, d, a, b, M_offset_2,  15, T[62]);\n\t            b = II(b, c, d, a, M_offset_9,  21, T[63]);\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\n\t            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n\t            var nBitsTotalL = nBitsTotal;\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n\t                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)\n\t            );\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n\t                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)\n\t            );\n\n\t            data.sigBytes = (dataWords.length + 1) * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Shortcuts\n\t            var hash = this._hash;\n\t            var H = hash.words;\n\n\t            // Swap endian\n\t            for (var i = 0; i < 4; i++) {\n\t                // Shortcut\n\t                var H_i = H[i];\n\n\t                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |\n\t                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);\n\t            }\n\n\t            // Return final computed hash\n\t            return hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    function FF(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & c) | (~b & d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function GG(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & d) | (c & ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function HH(a, b, c, d, x, s, t) {\n\t        var n = a + (b ^ c ^ d) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function II(a, b, c, d, x, s, t) {\n\t        var n = a + (c ^ (b | ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.MD5('message');\n\t     *     var hash = CryptoJS.MD5(wordArray);\n\t     */\n\t    C.MD5 = Hasher._createHelper(MD5);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacMD5(message, key);\n\t     */\n\t    C.HmacMD5 = Hasher._createHmacHelper(MD5);\n\t}(Math));\n\n\n\treturn CryptoJS.MD5;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function () {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Reusable object\n\t    var W = [];\n\n\t    /**\n\t     * SHA-1 hash algorithm.\n\t     */\n\t    var SHA1 = C_algo.SHA1 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476,\n\t                0xc3d2e1f0\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Shortcut\n\t            var H = this._hash.words;\n\n\t            // Working variables\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\t            var e = H[4];\n\n\t            // Computation\n\t            for (var i = 0; i < 80; i++) {\n\t                if (i < 16) {\n\t                    W[i] = M[offset + i] | 0;\n\t                } else {\n\t                    var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n\t                    W[i] = (n << 1) | (n >>> 31);\n\t                }\n\n\t                var t = ((a << 5) | (a >>> 27)) + e + W[i];\n\t                if (i < 20) {\n\t                    t += ((b & c) | (~b & d)) + 0x5a827999;\n\t                } else if (i < 40) {\n\t                    t += (b ^ c ^ d) + 0x6ed9eba1;\n\t                } else if (i < 60) {\n\t                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;\n\t                } else /* if (i < 80) */ {\n\t                    t += (b ^ c ^ d) - 0x359d3e2a;\n\t                }\n\n\t                e = d;\n\t                d = c;\n\t                c = (b << 30) | (b >>> 2);\n\t                b = a;\n\t                a = t;\n\t            }\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t            H[4] = (H[4] + e) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n\t            data.sigBytes = dataWords.length * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Return final computed hash\n\t            return this._hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.SHA1('message');\n\t     *     var hash = CryptoJS.SHA1(wordArray);\n\t     */\n\t    C.SHA1 = Hasher._createHelper(SHA1);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacSHA1(message, key);\n\t     */\n\t    C.HmacSHA1 = Hasher._createHmacHelper(SHA1);\n\t}());\n\n\n\treturn CryptoJS.SHA1;\n\n}));","var pSlice = Array.prototype.slice;\nvar objectKeys = require('./lib/keys.js');\nvar isArguments = require('./lib/is_arguments.js');\n\nvar deepEqual = module.exports = function (actual, expected, opts) {\n  if (!opts) opts = {};\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n\n  } else if (actual instanceof Date && expected instanceof Date) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {\n    return opts.strict ? actual === expected : actual == expected;\n\n  // 7.4. For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else {\n    return objEquiv(actual, expected, opts);\n  }\n}\n\nfunction isUndefinedOrNull(value) {\n  return value === null || value === undefined;\n}\n\nfunction isBuffer (x) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false;\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') return false;\n  return true;\n}\n\nfunction objEquiv(a, b, opts) {\n  var i, key;\n  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))\n    return false;\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) return false;\n  //~~~I've managed to break Object.keys through screwy arguments passing.\n  //   Converting to array solves the problem.\n  if (isArguments(a)) {\n    if (!isArguments(b)) {\n      return false;\n    }\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return deepEqual(a, b, opts);\n  }\n  if (isBuffer(a)) {\n    if (!isBuffer(b)) {\n      return false;\n    }\n    if (a.length !== b.length) return false;\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) return false;\n    }\n    return true;\n  }\n  try {\n    var ka = objectKeys(a),\n        kb = objectKeys(b);\n  } catch (e) {//happens when one is a string literal and the other isn't\n    return false;\n  }\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length != kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], opts)) return false;\n  }\n  return typeof a === typeof b;\n}\n","var supportsArgumentsClass = (function(){\n  return Object.prototype.toString.call(arguments)\n})() == '[object Arguments]';\n\nexports = module.exports = supportsArgumentsClass ? supported : unsupported;\n\nexports.supported = supported;\nfunction supported(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n};\n\nexports.unsupported = unsupported;\nfunction unsupported(object){\n  return object &&\n    typeof object == 'object' &&\n    typeof object.length == 'number' &&\n    Object.prototype.hasOwnProperty.call(object, 'callee') &&\n    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||\n    false;\n};\n","exports = module.exports = typeof Object.keys === 'function'\n  ? Object.keys : shim;\n\nexports.shim = shim;\nfunction shim (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n}\n","var assert = require('assert')\nvar BigInteger = require('bigi')\n\nvar Point = require('./point')\n\nfunction Curve (p, a, b, Gx, Gy, n, h) {\n  this.p = p\n  this.a = a\n  this.b = b\n  this.G = Point.fromAffine(this, Gx, Gy)\n  this.n = n\n  this.h = h\n\n  this.infinity = new Point(this, null, null, BigInteger.ZERO)\n\n  // result caching\n  this.pOverFour = p.add(BigInteger.ONE).shiftRight(2)\n\n  // determine size of p in bytes\n  this.pLength = Math.floor((this.p.bitLength() + 7) / 8)\n}\n\nCurve.prototype.pointFromX = function (isOdd, x) {\n  var alpha = x.pow(3).add(this.a.multiply(x)).add(this.b).mod(this.p)\n  var beta = alpha.modPow(this.pOverFour, this.p) // XXX: not compatible with all curves\n\n  var y = beta\n  if (beta.isEven() ^ !isOdd) {\n    y = this.p.subtract(y) // -y % p\n  }\n\n  return Point.fromAffine(this, x, y)\n}\n\nCurve.prototype.isInfinity = function (Q) {\n  if (Q === this.infinity) return true\n\n  return Q.z.signum() === 0 && Q.y.signum() !== 0\n}\n\nCurve.prototype.isOnCurve = function (Q) {\n  if (this.isInfinity(Q)) return true\n\n  var x = Q.affineX\n  var y = Q.affineY\n  var a = this.a\n  var b = this.b\n  var p = this.p\n\n  // Check that xQ and yQ are integers in the interval [0, p - 1]\n  if (x.signum() < 0 || x.compareTo(p) >= 0) return false\n  if (y.signum() < 0 || y.compareTo(p) >= 0) return false\n\n  // and check that y^2 = x^3 + ax + b (mod p)\n  var lhs = y.square().mod(p)\n  var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p)\n  return lhs.equals(rhs)\n}\n\n/**\n * Validate an elliptic curve point.\n *\n * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive\n */\nCurve.prototype.validate = function (Q) {\n  // Check Q != O\n  assert(!this.isInfinity(Q), 'Point is at infinity')\n  assert(this.isOnCurve(Q), 'Point is not on the curve')\n\n  // Check nQ = O (where Q is a scalar multiple of G)\n  var nQ = Q.multiply(this.n)\n  assert(this.isInfinity(nQ), 'Point is not a scalar multiple of G')\n\n  return true\n}\n\nmodule.exports = Curve\n","module.exports={\n  \"secp128r1\": {\n    \"p\": \"fffffffdffffffffffffffffffffffff\",\n    \"a\": \"fffffffdfffffffffffffffffffffffc\",\n    \"b\": \"e87579c11079f43dd824993c2cee5ed3\",\n    \"n\": \"fffffffe0000000075a30d1b9038a115\",\n    \"h\": \"01\",\n    \"Gx\": \"161ff7528b899b2d0c28607ca52c5b86\",\n    \"Gy\": \"cf5ac8395bafeb13c02da292dded7a83\"\n  },\n  \"secp160k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffeffffac73\",\n    \"a\": \"00\",\n    \"b\": \"07\",\n    \"n\": \"0100000000000000000001b8fa16dfab9aca16b6b3\",\n    \"h\": \"01\",\n    \"Gx\": \"3b4c382ce37aa192a4019e763036f4f5dd4d7ebb\",\n    \"Gy\": \"938cf935318fdced6bc28286531733c3f03c4fee\"\n  },\n  \"secp160r1\": {\n    \"p\": \"ffffffffffffffffffffffffffffffff7fffffff\",\n    \"a\": \"ffffffffffffffffffffffffffffffff7ffffffc\",\n    \"b\": \"1c97befc54bd7a8b65acf89f81d4d4adc565fa45\",\n    \"n\": \"0100000000000000000001f4c8f927aed3ca752257\",\n    \"h\": \"01\",\n    \"Gx\": \"4a96b5688ef573284664698968c38bb913cbfc82\",\n    \"Gy\": \"23a628553168947d59dcc912042351377ac5fb32\"\n  },\n  \"secp192k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffffffffffeffffee37\",\n    \"a\": \"00\",\n    \"b\": \"03\",\n    \"n\": \"fffffffffffffffffffffffe26f2fc170f69466a74defd8d\",\n    \"h\": \"01\",\n    \"Gx\": \"db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d\",\n    \"Gy\": \"9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d\"\n  },\n  \"secp192r1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffeffffffffffffffff\",\n    \"a\": \"fffffffffffffffffffffffffffffffefffffffffffffffc\",\n    \"b\": \"64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1\",\n    \"n\": \"ffffffffffffffffffffffff99def836146bc9b1b4d22831\",\n    \"h\": \"01\",\n    \"Gx\": \"188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012\",\n    \"Gy\": \"07192b95ffc8da78631011ed6b24cdd573f977a11e794811\"\n  },\n  \"secp256k1\": {\n    \"p\": \"fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f\",\n    \"a\": \"00\",\n    \"b\": \"07\",\n    \"n\": \"fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141\",\n    \"h\": \"01\",\n    \"Gx\": \"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\n    \"Gy\": \"483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8\"\n  },\n  \"secp256r1\": {\n    \"p\": \"ffffffff00000001000000000000000000000000ffffffffffffffffffffffff\",\n    \"a\": \"ffffffff00000001000000000000000000000000fffffffffffffffffffffffc\",\n    \"b\": \"5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b\",\n    \"n\": \"ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551\",\n    \"h\": \"01\",\n    \"Gx\": \"6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296\",\n    \"Gy\": \"4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5\"\n  }\n}\n","var Point = require('./point')\nvar Curve = require('./curve')\n\nvar getCurveByName = require('./names')\n\nmodule.exports = {\n  Curve: Curve,\n  Point: Point,\n  getCurveByName: getCurveByName\n}\n","var BigInteger = require('bigi')\n\nvar curves = require('./curves.json')\nvar Curve = require('./curve')\n\nfunction getCurveByName (name) {\n  var curve = curves[name]\n  if (!curve) return null\n\n  var p = new BigInteger(curve.p, 16)\n  var a = new BigInteger(curve.a, 16)\n  var b = new BigInteger(curve.b, 16)\n  var n = new BigInteger(curve.n, 16)\n  var h = new BigInteger(curve.h, 16)\n  var Gx = new BigInteger(curve.Gx, 16)\n  var Gy = new BigInteger(curve.Gy, 16)\n\n  return new Curve(p, a, b, Gx, Gy, n, h)\n}\n\nmodule.exports = getCurveByName\n","var assert = require('assert')\nvar Buffer = require('safe-buffer').Buffer\nvar BigInteger = require('bigi')\n\nvar THREE = BigInteger.valueOf(3)\n\nfunction Point (curve, x, y, z) {\n  assert.notStrictEqual(z, undefined, 'Missing Z coordinate')\n\n  this.curve = curve\n  this.x = x\n  this.y = y\n  this.z = z\n  this._zInv = null\n\n  this.compressed = true\n}\n\nObject.defineProperty(Point.prototype, 'zInv', {\n  get: function () {\n    if (this._zInv === null) {\n      this._zInv = this.z.modInverse(this.curve.p)\n    }\n\n    return this._zInv\n  }\n})\n\nObject.defineProperty(Point.prototype, 'affineX', {\n  get: function () {\n    return this.x.multiply(this.zInv).mod(this.curve.p)\n  }\n})\n\nObject.defineProperty(Point.prototype, 'affineY', {\n  get: function () {\n    return this.y.multiply(this.zInv).mod(this.curve.p)\n  }\n})\n\nPoint.fromAffine = function (curve, x, y) {\n  return new Point(curve, x, y, BigInteger.ONE)\n}\n\nPoint.prototype.equals = function (other) {\n  if (other === this) return true\n  if (this.curve.isInfinity(this)) return this.curve.isInfinity(other)\n  if (this.curve.isInfinity(other)) return this.curve.isInfinity(this)\n\n  // u = Y2 * Z1 - Y1 * Z2\n  var u = other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p)\n\n  if (u.signum() !== 0) return false\n\n  // v = X2 * Z1 - X1 * Z2\n  var v = other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p)\n\n  return v.signum() === 0\n}\n\nPoint.prototype.negate = function () {\n  var y = this.curve.p.subtract(this.y)\n\n  return new Point(this.curve, this.x, y, this.z)\n}\n\nPoint.prototype.add = function (b) {\n  if (this.curve.isInfinity(this)) return b\n  if (this.curve.isInfinity(b)) return this\n\n  var x1 = this.x\n  var y1 = this.y\n  var x2 = b.x\n  var y2 = b.y\n\n  // u = Y2 * Z1 - Y1 * Z2\n  var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p)\n  // v = X2 * Z1 - X1 * Z2\n  var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p)\n\n  if (v.signum() === 0) {\n    if (u.signum() === 0) {\n      return this.twice() // this == b, so double\n    }\n\n    return this.curve.infinity // this = -b, so infinity\n  }\n\n  var v2 = v.square()\n  var v3 = v2.multiply(v)\n  var x1v2 = x1.multiply(v2)\n  var zu2 = u.square().multiply(this.z)\n\n  // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)\n  var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.p)\n  // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3\n  var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.p)\n  // z3 = v^3 * z1 * z2\n  var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.p)\n\n  return new Point(this.curve, x3, y3, z3)\n}\n\nPoint.prototype.twice = function () {\n  if (this.curve.isInfinity(this)) return this\n  if (this.y.signum() === 0) return this.curve.infinity\n\n  var x1 = this.x\n  var y1 = this.y\n\n  var y1z1 = y1.multiply(this.z).mod(this.curve.p)\n  var y1sqz1 = y1z1.multiply(y1).mod(this.curve.p)\n  var a = this.curve.a\n\n  // w = 3 * x1^2 + a * z1^2\n  var w = x1.square().multiply(THREE)\n\n  if (a.signum() !== 0) {\n    w = w.add(this.z.square().multiply(a))\n  }\n\n  w = w.mod(this.curve.p)\n  // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)\n  var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.p)\n  // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3\n  var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.pow(3)).mod(this.curve.p)\n  // z3 = 8 * (y1 * z1)^3\n  var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.p)\n\n  return new Point(this.curve, x3, y3, z3)\n}\n\n// Simple NAF (Non-Adjacent Form) multiplication algorithm\n// TODO: modularize the multiplication algorithm\nPoint.prototype.multiply = function (k) {\n  if (this.curve.isInfinity(this)) return this\n  if (k.signum() === 0) return this.curve.infinity\n\n  var e = k\n  var h = e.multiply(THREE)\n\n  var neg = this.negate()\n  var R = this\n\n  for (var i = h.bitLength() - 2; i > 0; --i) {\n    var hBit = h.testBit(i)\n    var eBit = e.testBit(i)\n\n    R = R.twice()\n\n    if (hBit !== eBit) {\n      R = R.add(hBit ? this : neg)\n    }\n  }\n\n  return R\n}\n\n// Compute this*j + x*k (simultaneous multiplication)\nPoint.prototype.multiplyTwo = function (j, x, k) {\n  var i = Math.max(j.bitLength(), k.bitLength()) - 1\n  var R = this.curve.infinity\n  var both = this.add(x)\n\n  while (i >= 0) {\n    var jBit = j.testBit(i)\n    var kBit = k.testBit(i)\n\n    R = R.twice()\n\n    if (jBit) {\n      if (kBit) {\n        R = R.add(both)\n      } else {\n        R = R.add(this)\n      }\n    } else if (kBit) {\n      R = R.add(x)\n    }\n    --i\n  }\n\n  return R\n}\n\nPoint.prototype.getEncoded = function (compressed) {\n  if (compressed == null) compressed = this.compressed\n  if (this.curve.isInfinity(this)) return Buffer.alloc(1, 0) // Infinity point encoded is simply '00'\n\n  var x = this.affineX\n  var y = this.affineY\n  var byteLength = this.curve.pLength\n  var buffer\n\n  // 0x02/0x03 | X\n  if (compressed) {\n    buffer = Buffer.allocUnsafe(1 + byteLength)\n    buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0)\n\n  // 0x04 | X | Y\n  } else {\n    buffer = Buffer.allocUnsafe(1 + byteLength + byteLength)\n    buffer.writeUInt8(0x04, 0)\n\n    y.toBuffer(byteLength).copy(buffer, 1 + byteLength)\n  }\n\n  x.toBuffer(byteLength).copy(buffer, 1)\n\n  return buffer\n}\n\nPoint.decodeFrom = function (curve, buffer) {\n  var type = buffer.readUInt8(0)\n  var compressed = (type !== 4)\n\n  var byteLength = Math.floor((curve.p.bitLength() + 7) / 8)\n  var x = BigInteger.fromBuffer(buffer.slice(1, 1 + byteLength))\n\n  var Q\n  if (compressed) {\n    assert.equal(buffer.length, byteLength + 1, 'Invalid sequence length')\n    assert(type === 0x02 || type === 0x03, 'Invalid sequence tag')\n\n    var isOdd = (type === 0x03)\n    Q = curve.pointFromX(isOdd, x)\n  } else {\n    assert.equal(buffer.length, 1 + byteLength + byteLength, 'Invalid sequence length')\n\n    var y = BigInteger.fromBuffer(buffer.slice(1 + byteLength))\n    Q = Point.fromAffine(curve, x, y)\n  }\n\n  Q.compressed = compressed\n  return Q\n}\n\nPoint.prototype.toString = function () {\n  if (this.curve.isInfinity(this)) return '(INFINITY)'\n\n  return '(' + this.affineX.toString() + ',' + this.affineY.toString() + ')'\n}\n\nmodule.exports = Point\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","'use strict'\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('stream').Transform\nvar inherits = require('inherits')\n\nfunction throwIfNotStringOrBuffer (val, prefix) {\n  if (!Buffer.isBuffer(val) && typeof val !== 'string') {\n    throw new TypeError(prefix + ' must be a string or a buffer')\n  }\n}\n\nfunction HashBase (blockSize) {\n  Transform.call(this)\n\n  this._block = Buffer.allocUnsafe(blockSize)\n  this._blockSize = blockSize\n  this._blockOffset = 0\n  this._length = [0, 0, 0, 0]\n\n  this._finalized = false\n}\n\ninherits(HashBase, Transform)\n\nHashBase.prototype._transform = function (chunk, encoding, callback) {\n  var error = null\n  try {\n    this.update(chunk, encoding)\n  } catch (err) {\n    error = err\n  }\n\n  callback(error)\n}\n\nHashBase.prototype._flush = function (callback) {\n  var error = null\n  try {\n    this.push(this.digest())\n  } catch (err) {\n    error = err\n  }\n\n  callback(error)\n}\n\nHashBase.prototype.update = function (data, encoding) {\n  throwIfNotStringOrBuffer(data, 'Data')\n  if (this._finalized) throw new Error('Digest already called')\n  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n  // consume data\n  var block = this._block\n  var offset = 0\n  while (this._blockOffset + data.length - offset >= this._blockSize) {\n    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]\n    this._update()\n    this._blockOffset = 0\n  }\n  while (offset < data.length) block[this._blockOffset++] = data[offset++]\n\n  // update length\n  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {\n    this._length[j] += carry\n    carry = (this._length[j] / 0x0100000000) | 0\n    if (carry > 0) this._length[j] -= 0x0100000000 * carry\n  }\n\n  return this\n}\n\nHashBase.prototype._update = function () {\n  throw new Error('_update is not implemented')\n}\n\nHashBase.prototype.digest = function (encoding) {\n  if (this._finalized) throw new Error('Digest already called')\n  this._finalized = true\n\n  var digest = this._digest()\n  if (encoding !== undefined) digest = digest.toString(encoding)\n\n  // reset state\n  this._block.fill(0)\n  this._blockOffset = 0\n  for (var i = 0; i < 4; ++i) this._length[i] = 0\n\n  return digest\n}\n\nHashBase.prototype._digest = function () {\n  throw new Error('_digest is not implemented')\n}\n\nmodule.exports = HashBase\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\r\n Copyright 2013 Daniel Wirtz <dcode@dcode.io>\r\n Copyright 2009 The Closure Library Authors. All Rights Reserved.\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS-IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/long.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module[\"exports\"] = factory();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"Long\"] = factory();\r\n\r\n})(this, function() {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n     *  See the from* functions below for more convenient ways of constructing Longs.\r\n     * @exports Long\r\n     * @class A Long class for representing a 64 bit two's-complement integer value.\r\n     * @param {number} low The low (signed) 32 bits of the long\r\n     * @param {number} high The high (signed) 32 bits of the long\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @constructor\r\n     */\r\n    function Long(low, high, unsigned) {\r\n\r\n        /**\r\n         * The low 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.low = low | 0;\r\n\r\n        /**\r\n         * The high 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.high = high | 0;\r\n\r\n        /**\r\n         * Whether unsigned or not.\r\n         * @type {boolean}\r\n         */\r\n        this.unsigned = !!unsigned;\r\n    }\r\n\r\n    // The internal representation of a long is the two given signed, 32-bit values.\r\n    // We use 32-bit pieces because these are the size of integers on which\r\n    // Javascript performs bit-operations.  For operations like addition and\r\n    // multiplication, we split each number into 16 bit pieces, which can easily be\r\n    // multiplied within Javascript's floating-point representation without overflow\r\n    // or change in sign.\r\n    //\r\n    // In the algorithms below, we frequently reduce the negative case to the\r\n    // positive case by negating the input(s) and then post-processing the result.\r\n    // Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n    // a positive number, it overflows back into a negative).  Not handling this\r\n    // case would often result in infinite recursion.\r\n    //\r\n    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n    // methods on which they depend.\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a Long or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @private\r\n     */\r\n    Long.prototype.__isLong__;\r\n\r\n    Object.defineProperty(Long.prototype, \"__isLong__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    /**\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     * @inner\r\n     */\r\n    function isLong(obj) {\r\n        return (obj && obj[\"__isLong__\"]) === true;\r\n    }\r\n\r\n    /**\r\n     * Tests if the specified object is a Long.\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     */\r\n    Long.isLong = isLong;\r\n\r\n    /**\r\n     * A cache of the Long representations of small integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var INT_CACHE = {};\r\n\r\n    /**\r\n     * A cache of the Long representations of small unsigned integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var UINT_CACHE = {};\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromInt(value, unsigned) {\r\n        var obj, cachedObj, cache;\r\n        if (unsigned) {\r\n            value >>>= 0;\r\n            if (cache = (0 <= value && value < 256)) {\r\n                cachedObj = UINT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n            if (cache)\r\n                UINT_CACHE[value] = obj;\r\n            return obj;\r\n        } else {\r\n            value |= 0;\r\n            if (cache = (-128 <= value && value < 128)) {\r\n                cachedObj = INT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n            if (cache)\r\n                INT_CACHE[value] = obj;\r\n            return obj;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given 32 bit integer value.\r\n     * @function\r\n     * @param {number} value The 32 bit integer in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromInt = fromInt;\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromNumber(value, unsigned) {\r\n        if (isNaN(value) || !isFinite(value))\r\n            return unsigned ? UZERO : ZERO;\r\n        if (unsigned) {\r\n            if (value < 0)\r\n                return UZERO;\r\n            if (value >= TWO_PWR_64_DBL)\r\n                return MAX_UNSIGNED_VALUE;\r\n        } else {\r\n            if (value <= -TWO_PWR_63_DBL)\r\n                return MIN_VALUE;\r\n            if (value + 1 >= TWO_PWR_63_DBL)\r\n                return MAX_VALUE;\r\n        }\r\n        if (value < 0)\r\n            return fromNumber(-value, unsigned).neg();\r\n        return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n     * @function\r\n     * @param {number} value The number in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromNumber = fromNumber;\r\n\r\n    /**\r\n     * @param {number} lowBits\r\n     * @param {number} highBits\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromBits(lowBits, highBits, unsigned) {\r\n        return new Long(lowBits, highBits, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n     *  assumed to use 32 bits.\r\n     * @function\r\n     * @param {number} lowBits The low 32 bits\r\n     * @param {number} highBits The high 32 bits\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromBits = fromBits;\r\n\r\n    /**\r\n     * @function\r\n     * @param {number} base\r\n     * @param {number} exponent\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n    /**\r\n     * @param {string} str\r\n     * @param {(boolean|number)=} unsigned\r\n     * @param {number=} radix\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromString(str, unsigned, radix) {\r\n        if (str.length === 0)\r\n            throw Error('empty string');\r\n        if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n            return ZERO;\r\n        if (typeof unsigned === 'number') {\r\n            // For goog.math.long compatibility\r\n            radix = unsigned,\r\n            unsigned = false;\r\n        } else {\r\n            unsigned = !! unsigned;\r\n        }\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n\r\n        var p;\r\n        if ((p = str.indexOf('-')) > 0)\r\n            throw Error('interior hyphen');\r\n        else if (p === 0) {\r\n            return fromString(str.substring(1), unsigned, radix).neg();\r\n        }\r\n\r\n        // Do several (8) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n        var result = ZERO;\r\n        for (var i = 0; i < str.length; i += 8) {\r\n            var size = Math.min(8, str.length - i),\r\n                value = parseInt(str.substring(i, i + size), radix);\r\n            if (size < 8) {\r\n                var power = fromNumber(pow_dbl(radix, size));\r\n                result = result.mul(power).add(fromNumber(value));\r\n            } else {\r\n                result = result.mul(radixToPower);\r\n                result = result.add(fromNumber(value));\r\n            }\r\n        }\r\n        result.unsigned = unsigned;\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representation of the given string, written using the specified radix.\r\n     * @function\r\n     * @param {string} str The textual representation of the Long\r\n     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromString = fromString;\r\n\r\n    /**\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromValue(val) {\r\n        if (val /* is compatible */ instanceof Long)\r\n            return val;\r\n        if (typeof val === 'number')\r\n            return fromNumber(val);\r\n        if (typeof val === 'string')\r\n            return fromString(val);\r\n        // Throws for non-objects, converts non-instanceof Long:\r\n        return fromBits(val.low, val.high, val.unsigned);\r\n    }\r\n\r\n    /**\r\n     * Converts the specified value to a Long.\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n     * @returns {!Long}\r\n     */\r\n    Long.fromValue = fromValue;\r\n\r\n    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n    // no runtime penalty for these.\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_16_DBL = 1 << 16;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24_DBL = 1 << 24;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ZERO = fromInt(0);\r\n\r\n    /**\r\n     * Signed zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.ZERO = ZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UZERO = fromInt(0, true);\r\n\r\n    /**\r\n     * Unsigned zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.UZERO = UZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ONE = fromInt(1);\r\n\r\n    /**\r\n     * Signed one.\r\n     * @type {!Long}\r\n     */\r\n    Long.ONE = ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UONE = fromInt(1, true);\r\n\r\n    /**\r\n     * Unsigned one.\r\n     * @type {!Long}\r\n     */\r\n    Long.UONE = UONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var NEG_ONE = fromInt(-1);\r\n\r\n    /**\r\n     * Signed negative one.\r\n     * @type {!Long}\r\n     */\r\n    Long.NEG_ONE = NEG_ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n    /**\r\n     * Maximum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_VALUE = MAX_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n    /**\r\n     * Maximum unsigned value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n    /**\r\n     * Minimum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MIN_VALUE = MIN_VALUE;\r\n\r\n    /**\r\n     * @alias Long.prototype\r\n     * @inner\r\n     */\r\n    var LongPrototype = Long.prototype;\r\n\r\n    /**\r\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toInt = function toInt() {\r\n        return this.unsigned ? this.low >>> 0 : this.low;\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toNumber = function toNumber() {\r\n        if (this.unsigned)\r\n            return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a string written in the specified radix.\r\n     * @param {number=} radix Radix (2-36), defaults to 10\r\n     * @returns {string}\r\n     * @override\r\n     * @throws {RangeError} If `radix` is out of range\r\n     */\r\n    LongPrototype.toString = function toString(radix) {\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n        if (this.isZero())\r\n            return '0';\r\n        if (this.isNegative()) { // Unsigned Longs are never negative\r\n            if (this.eq(MIN_VALUE)) {\r\n                // We need to change the Long value before it can be negated, so we remove\r\n                // the bottom-most digit in this base and then recurse to do the rest.\r\n                var radixLong = fromNumber(radix),\r\n                    div = this.div(radixLong),\r\n                    rem1 = div.mul(radixLong).sub(this);\r\n                return div.toString(radix) + rem1.toInt().toString(radix);\r\n            } else\r\n                return '-' + this.neg().toString(radix);\r\n        }\r\n\r\n        // Do several (6) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n            rem = this;\r\n        var result = '';\r\n        while (true) {\r\n            var remDiv = rem.div(radixToPower),\r\n                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n                digits = intval.toString(radix);\r\n            rem = remDiv;\r\n            if (rem.isZero())\r\n                return digits + result;\r\n            else {\r\n                while (digits.length < 6)\r\n                    digits = '0' + digits;\r\n                result = '' + digits + result;\r\n            }\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as a signed integer.\r\n     * @returns {number} Signed high bits\r\n     */\r\n    LongPrototype.getHighBits = function getHighBits() {\r\n        return this.high;\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned high bits\r\n     */\r\n    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n        return this.high >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as a signed integer.\r\n     * @returns {number} Signed low bits\r\n     */\r\n    LongPrototype.getLowBits = function getLowBits() {\r\n        return this.low;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned low bits\r\n     */\r\n    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n        return this.low >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the number of bits needed to represent the absolute value of this Long.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n        if (this.isNegative()) // Unsigned Longs are never negative\r\n            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n        var val = this.high != 0 ? this.high : this.low;\r\n        for (var bit = 31; bit > 0; bit--)\r\n            if ((val & (1 << bit)) != 0)\r\n                break;\r\n        return this.high != 0 ? bit + 33 : bit + 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals zero.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isZero = function isZero() {\r\n        return this.high === 0 && this.low === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is negative.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isNegative = function isNegative() {\r\n        return !this.unsigned && this.high < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is positive.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isPositive = function isPositive() {\r\n        return this.unsigned || this.high >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is odd.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isOdd = function isOdd() {\r\n        return (this.low & 1) === 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is even.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isEven = function isEven() {\r\n        return (this.low & 1) === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.equals = function equals(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n            return false;\r\n        return this.high === other.high && this.low === other.low;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.eq = LongPrototype.equals;\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.notEquals = function notEquals(other) {\r\n        return !this.eq(/* validates */ other);\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.neq = LongPrototype.notEquals;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThan = function lessThan(other) {\r\n        return this.comp(/* validates */ other) < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lt = LongPrototype.lessThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) <= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThan = function greaterThan(other) {\r\n        return this.comp(/* validates */ other) > 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.compare = function compare(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.eq(other))\r\n            return 0;\r\n        var thisNeg = this.isNegative(),\r\n            otherNeg = other.isNegative();\r\n        if (thisNeg && !otherNeg)\r\n            return -1;\r\n        if (!thisNeg && otherNeg)\r\n            return 1;\r\n        // At this point the sign bits are the same\r\n        if (!this.unsigned)\r\n            return this.sub(other).isNegative() ? -1 : 1;\r\n        // Both are positive if at least one is unsigned\r\n        return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n    };\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.comp = LongPrototype.compare;\r\n\r\n    /**\r\n     * Negates this Long's value.\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.negate = function negate() {\r\n        if (!this.unsigned && this.eq(MIN_VALUE))\r\n            return MIN_VALUE;\r\n        return this.not().add(ONE);\r\n    };\r\n\r\n    /**\r\n     * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n     * @function\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.neg = LongPrototype.negate;\r\n\r\n    /**\r\n     * Returns the sum of this and the specified Long.\r\n     * @param {!Long|number|string} addend Addend\r\n     * @returns {!Long} Sum\r\n     */\r\n    LongPrototype.add = function add(addend) {\r\n        if (!isLong(addend))\r\n            addend = fromValue(addend);\r\n\r\n        // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = addend.high >>> 16;\r\n        var b32 = addend.high & 0xFFFF;\r\n        var b16 = addend.low >>> 16;\r\n        var b00 = addend.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 + b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 + b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 + b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 + b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long.\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.subtract = function subtract(subtrahend) {\r\n        if (!isLong(subtrahend))\r\n            subtrahend = fromValue(subtrahend);\r\n        return this.add(subtrahend.neg());\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n     * @function\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.sub = LongPrototype.subtract;\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long.\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.multiply = function multiply(multiplier) {\r\n        if (this.isZero())\r\n            return ZERO;\r\n        if (!isLong(multiplier))\r\n            multiplier = fromValue(multiplier);\r\n        if (multiplier.isZero())\r\n            return ZERO;\r\n        if (this.eq(MIN_VALUE))\r\n            return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n        if (multiplier.eq(MIN_VALUE))\r\n            return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n        if (this.isNegative()) {\r\n            if (multiplier.isNegative())\r\n                return this.neg().mul(multiplier.neg());\r\n            else\r\n                return this.neg().mul(multiplier).neg();\r\n        } else if (multiplier.isNegative())\r\n            return this.mul(multiplier.neg()).neg();\r\n\r\n        // If both longs are small, use float multiplication\r\n        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n            return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n        // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n        // We can skip products that would overflow.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = multiplier.high >>> 16;\r\n        var b32 = multiplier.high & 0xFFFF;\r\n        var b16 = multiplier.low >>> 16;\r\n        var b00 = multiplier.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 * b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 * b00;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c16 += a00 * b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 * b00;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a16 * b16;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a00 * b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n     * @function\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.mul = LongPrototype.multiply;\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n     *  unsigned if this Long is unsigned.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.divide = function divide(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        if (divisor.isZero())\r\n            throw Error('division by zero');\r\n        if (this.isZero())\r\n            return this.unsigned ? UZERO : ZERO;\r\n        var approx, rem, res;\r\n        if (!this.unsigned) {\r\n            // This section is only relevant for signed longs and is derived from the\r\n            // closure library as a whole.\r\n            if (this.eq(MIN_VALUE)) {\r\n                if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                    return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n                else if (divisor.eq(MIN_VALUE))\r\n                    return ONE;\r\n                else {\r\n                    // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                    var halfThis = this.shr(1);\r\n                    approx = halfThis.div(divisor).shl(1);\r\n                    if (approx.eq(ZERO)) {\r\n                        return divisor.isNegative() ? ONE : NEG_ONE;\r\n                    } else {\r\n                        rem = this.sub(divisor.mul(approx));\r\n                        res = approx.add(rem.div(divisor));\r\n                        return res;\r\n                    }\r\n                }\r\n            } else if (divisor.eq(MIN_VALUE))\r\n                return this.unsigned ? UZERO : ZERO;\r\n            if (this.isNegative()) {\r\n                if (divisor.isNegative())\r\n                    return this.neg().div(divisor.neg());\r\n                return this.neg().div(divisor).neg();\r\n            } else if (divisor.isNegative())\r\n                return this.div(divisor.neg()).neg();\r\n            res = ZERO;\r\n        } else {\r\n            // The algorithm below has not been made for unsigned longs. It's therefore\r\n            // required to take special care of the MSB prior to running it.\r\n            if (!divisor.unsigned)\r\n                divisor = divisor.toUnsigned();\r\n            if (divisor.gt(this))\r\n                return UZERO;\r\n            if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n                return UONE;\r\n            res = UZERO;\r\n        }\r\n\r\n        // Repeat the following until the remainder is less than other:  find a\r\n        // floating-point that approximates remainder / other *from below*, add this\r\n        // into the result, and subtract it from the remainder.  It is critical that\r\n        // the approximate value is less than or equal to the real value so that the\r\n        // remainder never becomes negative.\r\n        rem = this;\r\n        while (rem.gte(divisor)) {\r\n            // Approximate the result of division. This may be a little greater or\r\n            // smaller than the actual value.\r\n            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n            // We will tweak the approximate result by changing it in the 48-th digit or\r\n            // the smallest non-fractional digit, whichever is larger.\r\n            var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n                delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n            // Decrease the approximation until it is smaller than the remainder.  Note\r\n            // that if it is too large, the product overflows and is negative.\r\n                approxRes = fromNumber(approx),\r\n                approxRem = approxRes.mul(divisor);\r\n            while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n                approx -= delta;\r\n                approxRes = fromNumber(approx, this.unsigned);\r\n                approxRem = approxRes.mul(divisor);\r\n            }\r\n\r\n            // We know the answer can't be zero... and actually, zero would cause\r\n            // infinite recursion since we would make no progress.\r\n            if (approxRes.isZero())\r\n                approxRes = ONE;\r\n\r\n            res = res.add(approxRes);\r\n            rem = rem.sub(approxRem);\r\n        }\r\n        return res;\r\n    };\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.div = LongPrototype.divide;\r\n\r\n    /**\r\n     * Returns this Long modulo the specified.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.modulo = function modulo(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        return this.sub(this.div(divisor).mul(divisor));\r\n    };\r\n\r\n    /**\r\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.mod = LongPrototype.modulo;\r\n\r\n    /**\r\n     * Returns the bitwise NOT of this Long.\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.not = function not() {\r\n        return fromBits(~this.low, ~this.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise AND of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.and = function and(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise OR of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.or = function or(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise XOR of this Long and the given one.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.xor = function xor(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n        else\r\n            return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRight = function shiftRight(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n        else\r\n            return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        numBits &= 63;\r\n        if (numBits === 0)\r\n            return this;\r\n        else {\r\n            var high = this.high;\r\n            if (numBits < 32) {\r\n                var low = this.low;\r\n                return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n            } else if (numBits === 32)\r\n                return fromBits(high, 0, this.unsigned);\r\n            else\r\n                return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n    /**\r\n     * Converts this Long to signed.\r\n     * @returns {!Long} Signed long\r\n     */\r\n    LongPrototype.toSigned = function toSigned() {\r\n        if (!this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, false);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to unsigned.\r\n     * @returns {!Long} Unsigned long\r\n     */\r\n    LongPrototype.toUnsigned = function toUnsigned() {\r\n        if (this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, true);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to its byte representation.\r\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n     * @returns {!Array.<number>} Byte representation\r\n     */\r\n    LongPrototype.toBytes = function(le) {\r\n        return le ? this.toBytesLE() : this.toBytesBE();\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its little endian byte representation.\r\n     * @returns {!Array.<number>} Little endian byte representation\r\n     */\r\n    LongPrototype.toBytesLE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n             lo         & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n             hi         & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>> 24) & 0xff\r\n        ];\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its big endian byte representation.\r\n     * @returns {!Array.<number>} Big endian byte representation\r\n     */\r\n    LongPrototype.toBytesBE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n            (hi >>> 24) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n             hi         & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n             lo         & 0xff\r\n        ];\r\n    }\r\n\r\n    return Long;\r\n});\r\n","'use strict'\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n  var M = ARRAY16\n  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n  var a = this._a\n  var b = this._b\n  var c = this._c\n  var d = this._d\n\n  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n  c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n  c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n  b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n  a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n  a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n  d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n  c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n  b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n  d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n  d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n  d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n  b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n  a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n  d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n  c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n  this._a = (this._a + a) | 0\n  this._b = (this._b + b) | 0\n  this._c = (this._c + c) | 0\n  this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = new Buffer(16)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n  return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n","'use strict';\n\nexports.__esModule = true;\nexports.Manager = exports.ChainConfig = exports.Apis = undefined;\n\nvar _ApiInstances = require('./src/ApiInstances');\n\nvar _ApiInstances2 = _interopRequireDefault(_ApiInstances);\n\nvar _ConnectionManager = require('./src/ConnectionManager');\n\nvar _ConnectionManager2 = _interopRequireDefault(_ConnectionManager);\n\nvar _ChainConfig = require('./src/ChainConfig');\n\nvar _ChainConfig2 = _interopRequireDefault(_ChainConfig);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.Apis = _ApiInstances2.default;\nexports.ChainConfig = _ChainConfig2.default;\nexports.Manager = _ConnectionManager2.default;","'use strict';\n\nexports.__esModule = true;\n\nvar _ChainWebSocket = require('./ChainWebSocket');\n\nvar _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket);\n\nvar _GrapheneApi = require('./GrapheneApi');\n\nvar _GrapheneApi2 = _interopRequireDefault(_GrapheneApi);\n\nvar _ChainConfig = require('./ChainConfig');\n\nvar _ChainConfig2 = _interopRequireDefault(_ChainConfig);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar inst = void 0;\n\nvar ApisInstance = function () {\n  function ApisInstance() {\n    _classCallCheck(this, ApisInstance);\n  }\n\n  /** @arg {string} connection .. */\n  ApisInstance.prototype.connect = function connect(cs, connectTimeout) {\n    var _this = this;\n\n    var rpc_user = '';\n    var rpc_password = '';\n\n    if (typeof window !== 'undefined' && window.location && window.location.protocol === 'https:' && cs.indexOf('wss://') < 0) {\n      throw new Error('Secure domains require wss connection');\n    }\n\n    this.ws_rpc = new _ChainWebSocket2.default(cs, this.statusCb, connectTimeout);\n\n    this.init_promise = this.ws_rpc.login(rpc_user, rpc_password).then(function () {\n      console.log('Connected to API node:', cs);\n      _this._db = new _GrapheneApi2.default(_this.ws_rpc, 'database');\n      _this._net = new _GrapheneApi2.default(_this.ws_rpc, 'network_broadcast');\n      _this._hist = new _GrapheneApi2.default(_this.ws_rpc, 'history');\n      _this._crypto = new _GrapheneApi2.default(_this.ws_rpc, 'crypto');\n      _this._bookie = new _GrapheneApi2.default(_this.ws_rpc, 'bookie');\n      var db_promise = _this._db.init().then(function () {\n        return _this._db.exec('get_chain_id', []).then(function (_chain_id) {\n          _this.chain_id = _chain_id;\n          return _ChainConfig2.default.setChainId(_chain_id);\n        });\n      });\n\n      _this.ws_rpc.on_reconnect = function () {\n        _this.ws_rpc.login('', '').then(function () {\n          _this._db.init().then(function () {\n            if (_this.statusCb) {\n              _this.statusCb(_ChainWebSocket2.default.status.RECONNECTED);\n            }\n          });\n          _this._net.init();\n          _this._hist.init();\n          _this._crypto.init();\n          _this._bookie.init();\n        });\n      };\n\n      return Promise.all([db_promise, _this._net.init(), _this._hist.init(),\n      // Temporary squash crypto API error until the API is upgraded everywhere\n      _this._crypto.init().catch(function (e) {\n        return console.error('ApiInstance\\tCrypto API Error', e);\n      }), _this._bookie.init()]);\n    });\n  };\n\n  ApisInstance.prototype.close = function close() {\n    if (this.ws_rpc) {\n      this.ws_rpc.close();\n    }\n\n    this.ws_rpc = null;\n  };\n\n  ApisInstance.prototype.db_api = function db_api() {\n    return this._db;\n  };\n\n  ApisInstance.prototype.network_api = function network_api() {\n    return this._net;\n  };\n\n  ApisInstance.prototype.history_api = function history_api() {\n    return this._hist;\n  };\n\n  ApisInstance.prototype.crypto_api = function crypto_api() {\n    return this._crypto;\n  };\n\n  ApisInstance.prototype.bookie_api = function bookie_api() {\n    return this._bookie;\n  };\n\n  ApisInstance.prototype.setRpcConnectionStatusCallback = function setRpcConnectionStatusCallback(callback) {\n    this.statusCb = callback;\n  };\n\n  return ApisInstance;\n}();\n\n/**\n    Configure: configure as follows `Apis.instance(\"ws://localhost:8090\").init_promise`.  This\n    returns a promise, once resolved the connection is ready.\n\n    Import: import { Apis } from \"@graphene/chain\"\n\n    Short-hand: Apis.db(\"method\", \"parm1\", 2, 3, ...).  Returns a promise with results.\n\n    Additional usage: Apis.instance().db_api().exec(\"method\", [\"method\", \"parm1\", 2, 3, ...]).\n    Returns a promise with results.\n*/\n\nexports.default = {\n  setRpcConnectionStatusCallback: function setRpcConnectionStatusCallback(callback) {\n    this.statusCb = callback;\n\n    if (inst) {\n      inst.setRpcConnectionStatusCallback(callback);\n    }\n  },\n\n  /**\n        @arg {string} cs is only provided in the first call\n        @return {Apis} singleton .. Check Apis.instance().init_promise to\n        know when the connection is established\n    */\n  reset: function reset() {\n    var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090';\n    var connect = arguments[1];\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;\n\n    if (inst) {\n      inst.close();\n      inst = null;\n    }\n\n    inst = new ApisInstance();\n    inst.setRpcConnectionStatusCallback(this.statusCb);\n\n    if (inst && connect) {\n      inst.connect(cs, connectTimeout);\n    }\n\n    return inst;\n  },\n  instance: function instance() {\n    var cs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ws://localhost:8090';\n    var connect = arguments[1];\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;\n\n    if (!inst) {\n      inst = new ApisInstance();\n      inst.setRpcConnectionStatusCallback(this.statusCb);\n    }\n\n    if (inst && connect) {\n      inst.connect(cs, connectTimeout);\n    }\n\n    return inst;\n  },\n  chainId: function chainId() {\n    return this.instance().chain_id;\n  },\n  close: function close() {\n    if (inst) {\n      inst.close();\n      inst = null;\n    }\n  }\n  // db: (method, ...args) => Apis.instance().db_api().exec(method, toStrings(args)),\n  // network: (method, ...args) => Apis.instance().network_api().exec(method, toStrings(args)),\n  // history: (method, ...args) => Apis.instance().history_api().exec(method, toStrings(args)),\n  // crypto: (method, ...args) => Apis.instance().crypto_api().exec(method, toStrings(args))\n\n};","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar defaults = {\n  core_asset: 'PPY',\n  address_prefix: 'PPY',\n  expire_in_secs: 15,\n  expire_in_secs_proposal: 24 * 60 * 60,\n  review_in_secs_committee: 24 * 60 * 60\n};\n\nvar networks = {\n  networks: {\n    Peerplays: {\n      core_asset: 'PPY',\n      address_prefix: 'PPY',\n      chain_id: '6b6b5f0ce7a36d323768e534f3edb41c6d6332a541a95725b98e28d140850134'\n    },\n    PeerplaysTestnet: {\n      core_asset: 'PPYTEST',\n      address_prefix: 'PPYTEST',\n      chain_id: 'be6b79295e728406cbb7494bcb626e62ad278fa4018699cf8f75739f4c1a81fd'\n    }\n  }\n};\n\nvar ChainConfig = function () {\n  function ChainConfig() {\n    _classCallCheck(this, ChainConfig);\n\n    this.reset();\n  }\n\n  ChainConfig.prototype.reset = function reset() {\n    Object.assign(this, defaults);\n  };\n\n  ChainConfig.prototype.setChainId = function setChainId(chainID) {\n    var ref = Object.keys(networks);\n\n    for (var i = 0, len = ref.length; i < len; i++) {\n      var network_name = ref[i];\n      var network = networks[network_name];\n\n      if (network.chain_id === chainID) {\n        this.network_name = network_name;\n\n        if (network.address_prefix) {\n          this.address_prefix = network.address_prefix;\n        }\n\n        return {\n          network_name: network_name,\n          network: network\n        };\n      }\n    }\n\n    if (!this.network_name) {\n      console.log('Unknown chain id (this may be a testnet)', chainID);\n    }\n  };\n\n  ChainConfig.prototype.setPrefix = function setPrefix() {\n    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'PPY';\n\n    this.address_prefix = prefix;\n  };\n\n  return ChainConfig;\n}();\n\nexports.default = new ChainConfig();","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar SOCKET_DEBUG = false;\nvar WebSocketClient = null;\n\nif (typeof WebSocket !== 'undefined') {\n  WebSocketClient = WebSocket;\n} else {\n  WebSocketClient = require('ws'); // eslint-disable-line global-require\n}\n\nvar SUBSCRIBE_OPERATIONS = ['set_subscribe_callback', 'subscribe_to_market', 'broadcast_transaction_with_callback', 'set_pending_transaction_callback'];\n\nvar UNSUBSCRIBE_OPERATIONS = ['unsubscribe_from_market', 'unsubscribe_from_accounts'];\n\nvar HEALTH_CHECK_INTERVAL = 10000;\n\nvar ChainWebSocket = function () {\n  /**\n   *Creates an instance of ChainWebSocket.\n   * @param {string}    serverAddress           The address of the websocket to connect to.\n   * @param {function}  statusCb                Called when status events occur.\n   * @param {number}    [connectTimeout=10000]  The time for a connection attempt to complete.\n   * @memberof ChainWebSocket\n   */\n  function ChainWebSocket(serverAddress, statusCb) {\n    var connectTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10000;\n\n    _classCallCheck(this, ChainWebSocket);\n\n    this.statusCb = statusCb;\n    this.serverAddress = serverAddress;\n    this.timeoutInterval = connectTimeout;\n\n    // The currenct connection state of the websocket.\n    this.connected = false;\n    this.reconnectTimeout = null;\n\n    // Callback to execute when the websocket is reconnected.\n    this.on_reconnect = null;\n\n    // An incrementing ID for each request so that we can pair it with the\n    // response from the websocket.\n    this.cbId = 0;\n\n    // Objects to store key/value pairs for callbacks, subscription callbacks\n    // and unsubscribe callbacks.\n    this.cbs = {};\n    this.subs = {};\n    this.unsub = {};\n\n    // Current connection promises' rejection\n    this.currentResolve = null;\n    this.currentReject = null;\n\n    // Health check for the connection to the BlockChain.\n    this.healthCheck = null;\n\n    // Copy the constants to this instance.\n    this.status = ChainWebSocket.status;\n\n    // Bind the functions to the instance.\n    this.onConnectionOpen = this.onConnectionOpen.bind(this);\n    this.onConnectionClose = this.onConnectionClose.bind(this);\n    this.onConnectionTerminate = this.onConnectionTerminate.bind(this);\n    this.onConnectionError = this.onConnectionError.bind(this);\n    this.onConnectionTimeout = this.onConnectionTimeout.bind(this);\n    this.createConnection = this.createConnection.bind(this);\n    this.createConnectionPromise = this.createConnectionPromise.bind(this);\n    this.listener = this.listener.bind(this);\n\n    // Create the initial connection the blockchain.\n    this.createConnection();\n  }\n\n  /**\n   * Create the connection to the Blockchain.\n   *\n   * @returns\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.createConnection = function createConnection() {\n    this.debug('!!! ChainWebSocket create connection');\n\n    // Clear any possible reconnect timers.\n    this.reconnectTimeout = null;\n\n    // Create the promise for this connection\n    if (!this.connect_promise) {\n      this.connect_promise = new Promise(this.createConnectionPromise);\n    }\n\n    // Attempt to create the websocket\n    try {\n      this.ws = new WebSocketClient(this.serverAddress);\n    } catch (error) {\n      // Set a timeout to try and reconnect here.\n      return this.resetConnection();\n    }\n\n    this.addEventListeners();\n\n    // Handle timeouts to the websocket's initial connection.\n    this.connectionTimeout = setTimeout(this.onConnectionTimeout, this.timeoutInterval);\n  };\n\n  /**\n   * Reset the connection to the BlockChain.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.resetConnection = function resetConnection() {\n    // Close the Websocket if its still 'half-open'\n    this.close();\n\n    // Make sure we only ever have one timeout running to reconnect.\n    if (!this.reconnectTimeout) {\n      this.debug('!!! ChainWebSocket reset connection', this.timeoutInterval);\n      this.reconnectTimeout = setTimeout(this.createConnection, this.timeoutInterval);\n    }\n\n    // Reject the current promise if there is one.\n    if (this.currentReject) {\n      this.currentReject(new Error('Connection attempt failed: ' + this.serverAddress));\n    }\n  };\n\n  /**\n   * Add event listeners to the WebSocket.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.addEventListeners = function addEventListeners() {\n    this.debug('!!! ChainWebSocket add event listeners');\n    this.ws.addEventListener('open', this.onConnectionOpen);\n    this.ws.addEventListener('close', this.onConnectionClose);\n    this.ws.addEventListener('error', this.onConnectionError);\n    this.ws.addEventListener('message', this.listener);\n  };\n\n  /**\n   * Remove the event listers from the WebSocket. Its important to remove the event listerers\n   * for garbaage collection. Because we are creating a new WebSocket on each connection attempt\n   * any listeners that are still attached could prevent the old sockets from\n   * being garbage collected.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.removeEventListeners = function removeEventListeners() {\n    this.debug('!!! ChainWebSocket remove event listeners');\n    this.ws.removeEventListener('open', this.onConnectionOpen);\n    this.ws.removeEventListener('close', this.onConnectionClose);\n    this.ws.removeEventListener('error', this.onConnectionError);\n    this.ws.removeEventListener('message', this.listener);\n  };\n\n  /**\n   * A function that is passed to a new promise that stores the resolve and reject callbacks\n   * in the state.\n   *\n   * @param {function} resolve A callback to be executed when the promise is resolved.\n   * @param {function} reject A callback to be executed when the promise is rejected.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.createConnectionPromise = function createConnectionPromise(resolve, reject) {\n    this.debug('!!! ChainWebSocket createPromise');\n    this.currentResolve = resolve;\n    this.currentReject = reject;\n  };\n\n  /**\n   * Called when a new Websocket connection is opened.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionOpen = function onConnectionOpen() {\n    this.debug('!!! ChainWebSocket Connected ');\n\n    this.connected = true;\n\n    clearTimeout(this.connectionTimeout);\n    this.connectionTimeout = null;\n\n    // This will trigger the login process as well as some additional setup in ApiInstances\n    if (this.on_reconnect) {\n      this.on_reconnect();\n    }\n\n    if (this.currentResolve) {\n      this.currentResolve();\n    }\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.OPEN);\n    }\n  };\n\n  /**\n   * called when the connection attempt times out.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionTimeout = function onConnectionTimeout() {\n    this.debug('!!! ChainWebSocket timeout');\n    this.onConnectionClose(new Error('Connection timed out.'));\n  };\n\n  /**\n   * Called when the Websocket is not responding to the health checks.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionTerminate = function onConnectionTerminate() {\n    this.debug('!!! ChainWebSocket terminate');\n    this.onConnectionClose(new Error('Connection was terminated.'));\n  };\n\n  /**\n   * Called when the connection to the Blockchain is closed.\n   *\n   * @param {*} error\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionClose = function onConnectionClose(error) {\n    this.debug('!!! ChainWebSocket Close ', error);\n\n    this.resetConnection();\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.CLOSED);\n    }\n  };\n\n  /**\n   * Called when the Websocket encounters an error.\n   *\n   * @param {*} error\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.onConnectionError = function onConnectionError(error) {\n    this.debug('!!! ChainWebSocket On Connection Error ', error);\n\n    this.resetConnection();\n\n    if (this.statusCb) {\n      this.statusCb(ChainWebSocket.status.ERROR);\n    }\n  };\n\n  /**\n   * Entry point to make RPC calls on the BlockChain.\n   *\n   * @param {array} params An array of params to be passed to the rpc call. [method, ...params]\n   * @returns A new promise for this specific call.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.call = function call(params) {\n    var _this = this;\n\n    if (!this.connected) {\n      this.debug('!!! ChainWebSocket Call not connected. ');\n      return Promise.reject(new Error('Disconnected from the BlockChain.'));\n    }\n\n    this.debug('!!! ChainWebSocket Call connected. ', params);\n\n    var request = {\n      method: params[1],\n      params: params,\n      id: this.cbId + 1\n    };\n\n    this.cbId = request.id;\n\n    if (SUBSCRIBE_OPERATIONS.includes(request.method)) {\n      // Store callback in subs map\n      this.subs[request.id] = {\n        callback: request.params[2][0]\n      };\n\n      // Replace callback with the callback id\n      request.params[2][0] = request.id;\n    }\n\n    if (UNSUBSCRIBE_OPERATIONS.includes(request.method)) {\n      if (typeof request.params[2][0] !== 'function') {\n        throw new Error('First parameter of unsub must be the original callback');\n      }\n\n      var unSubCb = request.params[2].splice(0, 1)[0];\n\n      // Find the corresponding subscription\n      for (var id in this.subs) {\n        // eslint-disable-line\n        if (this.subs[id].callback === unSubCb) {\n          this.unsub[request.id] = id;\n          break;\n        }\n      }\n    }\n\n    if (!this.healthCheck) {\n      this.healthCheck = setTimeout(this.onConnectionTerminate.bind(this), HEALTH_CHECK_INTERVAL);\n    }\n\n    return new Promise(function (resolve, reject) {\n      _this.cbs[request.id] = {\n        time: new Date(),\n        resolve: resolve,\n        reject: reject\n      };\n\n      // Set all requests to be 'call' methods.\n      request.method = 'call';\n\n      try {\n        _this.ws.send(JSON.stringify(request));\n      } catch (error) {\n        _this.debug('Caught a nasty error : ', error);\n      }\n    });\n  };\n\n  /**\n   * Called when messages are received on the Websocket.\n   *\n   * @param {*} response The message received.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.listener = function listener(response) {\n    var responseJSON = null;\n\n    try {\n      responseJSON = JSON.parse(response.data);\n    } catch (error) {\n      responseJSON.error = 'Error parsing response: ' + error.stack;\n      this.debug('Error parsing response: ', response);\n    }\n\n    // Clear the health check timeout, we've just received a healthy response from the server.\n    if (this.healthCheck) {\n      clearTimeout(this.healthCheck);\n      this.healthCheck = null;\n    }\n\n    var sub = false;\n    var callback = null;\n\n    if (responseJSON.method === 'notice') {\n      sub = true;\n      responseJSON.id = responseJSON.params[0];\n    }\n\n    if (!sub) {\n      callback = this.cbs[responseJSON.id];\n    } else {\n      callback = this.subs[responseJSON.id].callback;\n    }\n\n    if (callback && !sub) {\n      if (responseJSON.error) {\n        this.debug('----> responseJSON : ', responseJSON);\n        callback.reject(responseJSON.error);\n      } else {\n        callback.resolve(responseJSON.result);\n      }\n\n      delete this.cbs[responseJSON.id];\n\n      if (this.unsub[responseJSON.id]) {\n        delete this.subs[this.unsub[responseJSON.id]];\n        delete this.unsub[responseJSON.id];\n      }\n    } else if (callback && sub) {\n      callback(responseJSON.params[1]);\n    } else {\n      this.debug('Warning: unknown websocket responseJSON: ', responseJSON);\n    }\n  };\n\n  /**\n   * Login to the Blockchain.\n   *\n   * @param {string} user Username\n   * @param {string} password Password\n   * @returns A promise that is fulfilled after login.\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.login = function login(user, password) {\n    var _this2 = this;\n\n    this.debug('!!! ChainWebSocket login.', user, password);\n    return this.connect_promise.then(function () {\n      return _this2.call([1, 'login', [user, password]]);\n    });\n  };\n\n  /**\n   * Close the connection to the Blockchain.\n   *\n   * @memberof ChainWebSocket\n   */\n\n\n  ChainWebSocket.prototype.close = function close() {\n    if (this.ws) {\n      this.removeEventListeners();\n\n      // Try and fire close on the connection.\n      this.ws.close();\n\n      // Clear our references so that it can be garbage collected.\n      this.ws = null;\n    }\n\n    // Clear our timeouts for connection timeout and health check.\n    clearTimeout(this.connectionTimeout);\n    this.connectionTimeout = null;\n\n    clearTimeout(this.healthCheck);\n    this.healthCheck = null;\n\n    clearTimeout(this.reconnectTimeout);\n    this.reconnectTimeout = null;\n\n    // Toggle the connected flag.\n    this.connected = false;\n  };\n\n  ChainWebSocket.prototype.debug = function debug() {\n    if (SOCKET_DEBUG) {\n      for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) {\n        params[_key] = arguments[_key];\n      }\n\n      console.log.apply(null, params);\n    }\n  };\n\n  return ChainWebSocket;\n}();\n\n// Constants for STATE\n\n\nChainWebSocket.status = {\n  RECONNECTED: 'reconnected',\n  OPEN: 'open',\n  CLOSED: 'closed',\n  ERROR: 'error'\n};\n\nexports.default = ChainWebSocket;","'use strict';\n\nexports.__esModule = true;\n\nvar _ApiInstances = require('./ApiInstances');\n\nvar _ApiInstances2 = _interopRequireDefault(_ApiInstances);\n\nvar _ChainWebSocket = require('./ChainWebSocket');\n\nvar _ChainWebSocket2 = _interopRequireDefault(_ChainWebSocket);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Manager = function () {\n  function Manager(_ref) {\n    var url = _ref.url,\n        urls = _ref.urls;\n\n    _classCallCheck(this, Manager);\n\n    this.url = url;\n    this.urls = urls.filter(function (a) {\n      return a !== url;\n    });\n  }\n\n  Manager.prototype.logFailure = function logFailure(url) {\n    console.error('Unable to connect to', url + ', skipping to next full node API server');\n  };\n\n  Manager.prototype.connect = function connect() {\n    var _connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n    var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url;\n\n    return new Promise(function (resolve, reject) {\n      _ApiInstances2.default.instance(url, _connect).init_promise.then(resolve).catch(function (error) {\n        _ApiInstances2.default.instance().close();\n        reject(error);\n      });\n    });\n  };\n\n  Manager.prototype.connectWithFallback = function connectWithFallback() {\n    var connect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n    var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.url;\n    var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n\n    var _this = this;\n\n    var resolve = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    var reject = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n\n    if (reject && index > this.urls.length - 1) {\n      return reject(new Error('Tried ' + (index + 1) + ' connections, none of which worked: ' + JSON.stringify(this.urls.concat(this.url))));\n    }\n\n    var fallback = function fallback(resolve, reject) {\n      _this.logFailure(url);\n      return _this.connectWithFallback(connect, _this.urls[index], index + 1, resolve, reject);\n    };\n\n    if (resolve && reject) {\n      return this.connect(connect, url).then(resolve).catch(function () {\n        fallback(resolve, reject);\n      });\n    }\n\n    return new Promise(function (resolve, reject) {\n      _this.connect(connect).then(resolve).catch(function () {\n        fallback(resolve, reject);\n      });\n    });\n  };\n\n  Manager.prototype.checkConnections = function checkConnections() {\n    var rpc_user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    var rpc_password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n    var _this2 = this;\n\n    var resolve = arguments[2];\n    var reject = arguments[3];\n\n    var connectionStartTimes = {};\n\n    var checkFunction = function checkFunction(resolve, reject) {\n      var fullList = _this2.urls.concat(_this2.url);\n      var connectionPromises = [];\n\n      fullList.forEach(function (url) {\n        var conn = new _ChainWebSocket2.default(url, function () {});\n        connectionStartTimes[url] = new Date().getTime();\n        connectionPromises.push(function () {\n          return conn.login(rpc_user, rpc_password).then(function () {\n            var _ref2;\n\n            conn.close();\n            return _ref2 = {}, _ref2[url] = new Date().getTime() - connectionStartTimes[url], _ref2;\n          }).catch(function () {\n            if (url === _this2.url) {\n              _this2.url = _this2.urls[0];\n            } else {\n              _this2.urls = _this2.urls.filter(function (a) {\n                return a !== url;\n              });\n            }\n\n            conn.close();\n            return null;\n          });\n        });\n      });\n\n      Promise.all(connectionPromises.map(function (a) {\n        return a();\n      })).then(function (res) {\n        resolve(res.filter(function (a) {\n          return !!a;\n        }).reduce(function (f, a) {\n          var key = Object.keys(a)[0];\n          f[key] = a[key];\n          return f;\n        }, {}));\n      }).catch(function () {\n        return _this2.checkConnections(rpc_user, rpc_password, resolve, reject);\n      });\n    };\n\n    if (resolve && reject) {\n      checkFunction(resolve, reject);\n    } else {\n      return new Promise(checkFunction);\n    }\n  };\n\n  return Manager;\n}();\n\nexports.default = Manager;","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar GrapheneApi = function () {\n  function GrapheneApi(ws_rpc, api_name) {\n    _classCallCheck(this, GrapheneApi);\n\n    this.ws_rpc = ws_rpc;\n    this.api_name = api_name;\n  }\n\n  GrapheneApi.prototype.init = function init() {\n    var _this = this;\n\n    return this.ws_rpc.call([1, this.api_name, []]).then(function (response) {\n      _this.api_id = response;\n      return _this;\n    });\n  };\n\n  GrapheneApi.prototype.exec = function exec(method, params) {\n    return this.ws_rpc.call([this.api_id, method, params]).catch(function (error) {\n      console.log('!!! GrapheneApi error: ', method, params, error, JSON.stringify(error));\n      throw error;\n    });\n  };\n\n  return GrapheneApi;\n}();\n\nexports.default = GrapheneApi;","'use strict';\n\nif (!process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // 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\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // 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.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = require('./lib/_stream_duplex.js');\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  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]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    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);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  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);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","module.exports = require('events').EventEmitter;\n","module.exports = require('./readable').PassThrough\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","module.exports = require('./readable').Transform\n","module.exports = require('./lib/_stream_writable.js');\n","'use strict'\nvar Buffer = require('buffer').Buffer\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nvar zl = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n]\n\nvar zr = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n]\n\nvar sl = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n]\n\nvar sr = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n]\n\nvar hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]\nvar hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]\n\nfunction RIPEMD160 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n}\n\ninherits(RIPEMD160, HashBase)\n\nRIPEMD160.prototype._update = function () {\n  var words = ARRAY16\n  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)\n\n  var al = this._a | 0\n  var bl = this._b | 0\n  var cl = this._c | 0\n  var dl = this._d | 0\n  var el = this._e | 0\n\n  var ar = this._a | 0\n  var br = this._b | 0\n  var cr = this._c | 0\n  var dr = this._d | 0\n  var er = this._e | 0\n\n  // computation\n  for (var i = 0; i < 80; i += 1) {\n    var tl\n    var tr\n    if (i < 16) {\n      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])\n      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])\n    } else if (i < 32) {\n      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])\n      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])\n    } else if (i < 48) {\n      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])\n      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])\n    } else if (i < 64) {\n      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])\n      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])\n    } else { // if (i<80) {\n      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])\n      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])\n    }\n\n    al = el\n    el = dl\n    dl = rotl(cl, 10)\n    cl = bl\n    bl = tl\n\n    ar = er\n    er = dr\n    dr = rotl(cr, 10)\n    cr = br\n    br = tr\n  }\n\n  // update state\n  var t = (this._b + cl + dr) | 0\n  this._b = (this._c + dl + er) | 0\n  this._c = (this._d + el + ar) | 0\n  this._d = (this._e + al + br) | 0\n  this._e = (this._a + bl + cr) | 0\n  this._a = t\n}\n\nRIPEMD160.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  buffer.writeInt32LE(this._e, 16)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fn1 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn2 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn3 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn4 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn5 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0\n}\n\nmodule.exports = RIPEMD160\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","!function(globals){\n'use strict'\n\n//*** UMD BEGIN\nif (typeof define !== 'undefined' && define.amd) { //require.js / AMD\n  define([], function() {\n    return secureRandom\n  })\n} else if (typeof module !== 'undefined' && module.exports) { //CommonJS\n  module.exports = secureRandom\n} else { //script / browser\n  globals.secureRandom = secureRandom\n}\n//*** UMD END\n\n//options.type is the only valid option\nfunction secureRandom(count, options) {\n  options = options || {type: 'Array'}\n  //we check for process.pid to prevent browserify from tricking us\n  if (typeof process != 'undefined' && typeof process.pid == 'number') {\n    return nodeRandom(count, options)\n  } else {\n    var crypto = window.crypto || window.msCrypto\n    if (!crypto) throw new Error(\"Your browser does not support window.crypto.\")\n    return browserRandom(count, options)\n  }\n}\n\nfunction nodeRandom(count, options) {\n  var crypto = require('crypto')\n  var buf = crypto.randomBytes(count)\n\n  switch (options.type) {\n    case 'Array':\n      return [].slice.call(buf)\n    case 'Buffer':\n      return buf\n    case 'Uint8Array':\n      var arr = new Uint8Array(count)\n      for (var i = 0; i < count; ++i) { arr[i] = buf.readUInt8(i) }\n      return arr\n    default:\n      throw new Error(options.type + \" is unsupported.\")\n  }\n}\n\nfunction browserRandom(count, options) {\n  var nativeArr = new Uint8Array(count)\n  var crypto = window.crypto || window.msCrypto\n  crypto.getRandomValues(nativeArr)\n\n  switch (options.type) {\n    case 'Array':\n      return [].slice.call(nativeArr)\n    case 'Buffer':\n      try { var b = new Buffer(1) } catch(e) { throw new Error('Buffer not supported in this environment. Use Node.js or Browserify for browser support.')}\n      return new Buffer(nativeArr)\n    case 'Uint8Array':\n      return nativeArr\n    default:\n      throw new Error(options.type + \" is unsupported.\")\n  }\n}\n\nsecureRandom.randomArray = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Array'})\n}\n\nsecureRandom.randomUint8Array = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Uint8Array'})\n}\n\nsecureRandom.randomBuffer = function(byteCount) {\n  return secureRandom(byteCount, {type: 'Buffer'})\n}\n\n\n}(this);\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require('./sha')\nexports.sha1 = require('./sha1')\nexports.sha224 = require('./sha224')\nexports.sha256 = require('./sha256')\nexports.sha384 = require('./sha384')\nexports.sha512 = require('./sha512')\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Sha256 = require('./sha256')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\n","var inherits = require('inherits')\nvar SHA512 = require('./sha512')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","var inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","var nextTick = require('process/browser.js').nextTick;\nvar apply = Function.prototype.apply;\nvar slice = Array.prototype.slice;\nvar immediateIds = {};\nvar nextImmediateId = 0;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) { timeout.close(); };\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// That's not how node.js implements it but the exposed api is the same.\nexports.setImmediate = typeof setImmediate === \"function\" ? setImmediate : function(fn) {\n  var id = nextImmediateId++;\n  var args = arguments.length < 2 ? false : slice.call(arguments, 1);\n\n  immediateIds[id] = true;\n\n  nextTick(function onNextTick() {\n    if (immediateIds[id]) {\n      // fn.call() is faster so we optimize for the common use-case\n      // @see http://jsperf.com/call-apply-segu\n      if (args) {\n        fn.apply(null, args);\n      } else {\n        fn.call(null);\n      }\n      // Prevent ids from leaking\n      exports.clearImmediate(id);\n    }\n  });\n\n  return id;\n};\n\nexports.clearImmediate = typeof clearImmediate === \"function\" ? clearImmediate : function(id) {\n  delete immediateIds[id];\n};","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n"]} diff --git a/build/peerplaysjs-lib.min.js b/build/peerplaysjs-lib.min.js index 2af404d..e69d03f 100644 --- a/build/peerplaysjs-lib.min.js +++ b/build/peerplaysjs-lib.min.js @@ -1 +1 @@ -!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).peerplays_js=e()}}(function(){return function o(s,a,f){function u(t,e){if(!a[t]){if(!s[t]){var r="function"==typeof require&&require;if(!e&&r)return r(t,!0);if(c)return c(t,!0);var n=new Error("Cannot find module '"+t+"'");throw n.code="MODULE_NOT_FOUND",n}var i=a[t]={exports:{}};s[t][0].call(i.exports,function(e){return u(s[t][1][e]||e)},i,i.exports,o,s,a,f)}return a[t].exports}for(var c="function"==typeof require&&require,e=0;e %s (%d bytes)",o.operation_name,i[1],s,s.length/2)}a.tr_buffer=p.ops.transaction.toBuffer(a)}))})},e.prototype.id=function(){if(!this.tr_buffer)throw new Error("not finalized");return a.hash.sha256(this.tr_buffer).toString("hex").substring(0,40)},e.prototype.add_operation=function(e){if(this.tr_buffer)throw new Error("already finalized");if((0,u.default)(e,"operation"),!Array.isArray(e))throw new Error("Expecting array [operation_id, operation]");this.operations.push(e)},e.prototype.get_type_operation=function(e,t){if(this.tr_buffer)throw new Error("already finalized");(0,u.default)(e,"name"),(0,u.default)(t,"operation");var r=p.ops[e];(0,u.default)(r,"Unknown operation "+e);var n=c.default.operations[r.operation_name];if(void 0===n)throw new Error("unknown operation: "+r.operation_name);if(t.fee||(t.fee={amount:0,asset_id:0}),"proposal_create"===e){var i=!1,o=0;if(t.proposed_ops.forEach(function(e){var t=void 0;switch(e.op[0]){case 0:t="from";break;case 6:case 17:t="account";break;case 10:case 11:case 12:case 13:case 14:case 18:case 43:t="issuer";break;case 15:t="payer";break;case 16:t="from_account";break;case 22:case 23:case 24:t="fee_paying_account";break;case 31:i=!0,o=1123200}t in e.op[1]&&0===e.op[1][t]&&(i=!0)}),!t.expiration_time){var s=this.base_expiration_sec();t.expiration_time=s+l.ChainConfig.expire_in_secs_proposal}if(i){var a=Math.max(this.commitee_min_review,86400,l.ChainConfig.review_in_secs_committee);t.review_period_seconds=o+a,t.expiration_time+=3600+o}}return[n,r.fromObject(t)]},e.prototype.update_head_block=function(){var n=this;return l.Apis.instance().db_api().exec("get_objects",[["2.0.0","2.1.0"]]).then(function(e){var t=e[0],r=e[1];n.head_block_time_string=r[0].time,n.committee_min_review=t[0].parameters.committee_proposal_review_period})},e.prototype.set_expire_seconds=function(e){if(this.tr_buffer)throw new Error("already finalized");return this.expiration=this.base_expiration_sec()+e,this.expiration},e.prototype.propose=function(e){if(this.tr_buffer)throw new Error("already finalized");if(!this.operations.length)throw new Error("add operation first");(0,u.default)(e,"proposal_create_options"),(0,u.default)(e.fee_paying_account,"proposal_create_options.fee_paying_account");var t=this.operations.map(function(e){return{op:e}});return this.operations=[],this.signatures=[],this.signer_private_keys=[],e.proposed_ops=t,this.add_type_operation("proposal_create",e),this},e.prototype.has_proposed_operation=function(){for(var e=!1,t=0;tparseInt(h,10)&&(a=f,u="1.3.0")}var i=[];!function e(t){if(Array.isArray(t))for(var r=0,n=t.length;r>1?s.add(i):s,c=e.pointFromX(f,u),h=c.multiply(i);(0,_.default)(e.isInfinity(h),"nR is not a valid curve point");var l=t.negate().mod(i),p=s.modInverse(i),d=c.multiplyTwo(a,o,l).multiply(p);return e.validate(d),d}r.calcPubKeyRecoveryParam=function(e,t,r,n){for(var i=0;i<4;i++)if(o(e,t,r,i).equals(n))return i;throw new Error("Unable to find valid recovery factor")},r.deterministicGenerateK=d,r.recoverPubKey=o,r.sign=function(r,e,n,t){var i=c.default.fromBuffer(e),o=r.n,s=r.G,a=void 0,f=void 0;d(r,e,n,function(e){var t=s.multiply(e);return!r.isInfinity(t)&&0!==(a=t.affineX.mod(o)).signum()&&0!==(f=e.modInverse(o).multiply(i.add(n.multiply(a))).mod(o)).signum()},t);var u=o.shiftRight(1);return 0i.length;)e.writeUint8(0)}},n.public_key=function(e,t){var r=void 0;if(e)return t?(r=t.toBuffer(),void e.append(r.toString("binary"),"binary")):(r=n.fixed_data(e,33),i.default.fromBuffer(r))},n.ripemd160=function(e,t){if(e)return t?void n.fixed_data(e,20,t):n.fixed_data(e,20)},n.sha256=function(e,t){if(e)return t?void n.fixed_data(e,32,t):n.fixed_data(e,32)},n.time_point_sec=function(e,t){if(!t)return t=e.readInt32(),new Date(1e3*t);t=Math.ceil(t/1e3),e.writeInt32(t)},n}();a.default=r,s.exports=a.default}).call(this,n(35).Buffer)},{11:11,35:35}],21:[function(e,t,r){"use strict";r.__esModule=!0;var n,i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},o=e(38),s=e(3),a=(n=s)&&n.__esModule?n:{default:n};var f=9007199254740991,u=-9007199254740991,c={is_empty:function(e){return null==e},required:function(e){var t=1>=8;for(;0>=8}for(var s=0;e[s]===c&&s>16&255,o[s++]=t>>8&255,o[s++]=255&t;var u,c;2===i&&(t=h[e.charCodeAt(f)]<<2|h[e.charCodeAt(f+1)]>>4,o[s++]=255&t);1===i&&(t=h[e.charCodeAt(f)]<<10|h[e.charCodeAt(f+1)]<<4|h[e.charCodeAt(f+2)]>>2,o[s++]=t>>8&255,o[s++]=255&t);return o},r.fromByteArray=function(e){for(var t,r=e.length,n=r%3,i=[],o=0,s=r-n;o>2]+a[t<<4&63]+"==")):2===n&&(t=(e[r-2]<<8)+e[r-1],i.push(a[t>>10]+a[t>>4&63]+a[t<<2&63]+"="));return i.join("")};for(var a=[],h=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,o=n.length;i>18&63]+a[i>>12&63]+a[i>>6&63]+a[63&i]);return o.join("")}h["-".charCodeAt(0)]=62,h["_".charCodeAt(0)]=63},{}],30:[function(e,t,r){function b(e,t,r){if(!(this instanceof b))return new b(e,t,r);null!=e&&("number"==typeof e?this.fromNumber(e,t,r):null==t&&"string"!=typeof e?this.fromString(e,256):this.fromString(e,t))}var n=b.prototype;n.__bigi=e(33).version,b.isBigInteger=function(e,t){return e&&e.__bigi&&(!t||e.__bigi===n.__bigi)},b.prototype.am=function(e,t,r,n,i,o){for(;0<=--o;){var s=t*this[e++]+r[n]+i;i=Math.floor(s/67108864),r[n++]=67108863&s}return i},b.prototype.DB=26,b.prototype.DM=67108863;var i=b.prototype.DV=1<<26;b.prototype.FV=Math.pow(2,52),b.prototype.F1=26,b.prototype.F2=0;var o,s,a="0123456789abcdefghijklmnopqrstuvwxyz",f=new Array;for(o="0".charCodeAt(0),s=0;s<=9;++s)f[o++]=s;for(o="a".charCodeAt(0),s=10;s<36;++s)f[o++]=s;for(o="A".charCodeAt(0),s=10;s<36;++s)f[o++]=s;function u(e){return a.charAt(e)}function c(e,t){var r=f[e.charCodeAt(t)];return null==r?-1:r}function g(e){var t=new b;return t.fromInt(e),t}function w(e){var t,r=1;return 0!=(t=e>>>16)&&(e=t,r+=16),0!=(t=e>>8)&&(e=t,r+=8),0!=(t=e>>4)&&(e=t,r+=4),0!=(t=e>>2)&&(e=t,r+=2),0!=(t=e>>1)&&(e=t,r+=1),r}function m(e){this.m=e}function v(e){this.m=e,this.mp=e.invDigit(),this.mpl=32767&this.mp,this.mph=this.mp>>15,this.um=(1<>=16,t+=16),0==(255&e)&&(e>>=8,t+=8),0==(15&e)&&(e>>=4,t+=4),0==(3&e)&&(e>>=2,t+=2),0==(1&e)&&++t,t}function y(e){for(var t=0;0!=e;)e&=e-1,++t;return t}function E(){}function B(e){return e}function k(e){this.r2=new b,this.q3=new b,b.ONE.dlShiftTo(2*e.t,this.r2),this.mu=this.r2.divide(e),this.m=e}m.prototype.convert=function(e){return e.s<0||0<=e.compareTo(this.m)?e.mod(this.m):e},m.prototype.revert=function(e){return e},m.prototype.reduce=function(e){e.divRemTo(this.m,null,e)},m.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},m.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)},v.prototype.convert=function(e){var t=new b;return e.abs().dlShiftTo(this.m.t,t),t.divRemTo(this.m,null,t),e.s<0&&0>15)*this.mpl&this.um)<<15)&e.DM;for(e[r=t+this.m.t]+=this.m.am(0,n,e,t,0,this.m.t);e[r]>=e.DV;)e[r]-=e.DV,e[++r]++}e.clamp(),e.drShiftTo(this.m.t,e),0<=e.compareTo(this.m)&&e.subTo(this.m,e)},v.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},v.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)},n.copyTo=function(e){for(var t=this.t-1;0<=t;--t)e[t]=this[t];e.t=this.t,e.s=this.s},n.fromInt=function(e){this.t=1,this.s=e<0?-1:0,0n.DB?(n[n.t-1]|=(a&(1<>n.DB-s):n[n.t-1]|=a<=n.DB&&(s-=n.DB))}8==r&&0!=(128&e[0])&&(n.s=-1,0>o|f,f=(n[r]&s)<=r.t)t.t=0;else{var i=e%r.DB,o=r.DB-i,s=(1<>i;for(var a=n+1;a>i;0>=r.DB;if(e.t>=r.DB;i+=r.s}else{for(i+=r.s;n>=r.DB;i-=e.s}t.s=i<0?-1:0,i<-1?t[n++]=r.DV+i:0=t.DV&&(e[r+t.t]-=t.DV,e[r+t.t+1]=1)}0>n.F2:0),p=n.FV/l,d=(1<>f)&&(o=!0,s=u(n));0<=a;)f>(f+=r.DB-t)):(n=r[a]>>(f-=t)&i,f<=0&&(f+=r.DB,--a)),0>3},n.mod=function(e){var t=new b;return this.abs().divRemTo(e,null,t),this.s<0&&02*this.m.t)return e.mod(this.m);if(e.compareTo(this.m)<0)return e;var t=new b;return e.copyTo(t),this.reduce(t),t},k.prototype.revert=function(e){return e},k.prototype.reduce=function(e){var t=this;for(e.drShiftTo(t.m.t-1,t.r2),e.t>t.m.t+1&&(e.t=t.m.t+1,e.clamp()),t.mu.multiplyUpperTo(t.r2,t.m.t+1,t.q3),t.m.multiplyLowerTo(t.q3,t.m.t+1,t.r2);e.compareTo(t.r2)<0;)e.dAddOffset(1,t.m.t+1);for(e.subTo(t.r2,e);0<=e.compareTo(t.m);)e.subTo(t.m,e)},k.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},k.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)};var T=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997],S=(1<<26)/T[T.length-1];n.chunkSize=function(e){return Math.floor(Math.LN2*this.DB/Math.log(e))},n.toRadix=function(e){if(null==e&&(e=10),0==this.signum()||e<2||36=n&&(r.dMultiply(i),r.dAddOffset(a,0),a=s=0))}0e&&n.subTo(b.ONE.shiftLeft(e-1),n);else{var i=new Array,o=7&e;i.length=1+(e>>3),t.nextBytes(i),0>=r.DB;if(e.t>=r.DB;i+=r.s}else{for(i+=r.s;n>=r.DB;i+=e.s}t.s=i<0?-1:0,0=this.DV;)this[t]-=this.DV,++t>=this.t&&(this[this.t++]=0),++this[t]}},n.multiplyLowerTo=function(e,t,r){var n,i=Math.min(this.t+e.t,t);for(r.s=0,r.t=i;0>1)&&(e=T.length);for(var i=new b(null),o=[],s=0;s>24},n.shortValue=function(){return 0==this.t?this.s:this[0]<<16>>16},n.signum=function(){return this.s<0?-1:this.t<=0||1==this.t&&this[0]<=0?0:1},n.toByteArray=function(){var e=this,t=e.t,r=new Array;r[0]=e.s;var n,i=e.DB-t*e.DB%8,o=0;if(0>i)!=(e.s&e.DM)>>i&&(r[o++]=n|e.s<>(i+=e.DB-8)):(n=e[t]>>(i-=8)&255,i<=0&&(i+=e.DB,--t)),0!=(128&n)&&(n|=-256),0===o&&(128&e.s)!=(128&n)&&++o,(0=this.t?0!=this.s:0!=(this[t]&1<>i-f&u:(h=(e[p]&(1<>this.DB+i-f)),a=r;0==(1&h);)h>>=1,--a;if((i-=a)<0&&(i+=this.DB,--p),d)s[h].copyTo(o),d=!1;else{for(;1=r())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+r().toString(16)+" bytes");return 0|e}function p(e,t){if(h.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return j(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return M(e).length;default:if(n)return j(e).length;t=(""+t).toLowerCase(),n=!0}}function d(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function _(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):2147483647=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=h.from(t,n)),h.isBuffer(t))return 0===t.length?-1:g(e,t,r,n,i);if("number"==typeof t)return t&=255,h.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):g(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function g(e,t,r,n,i){var o,s=1,a=e.length,f=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;a/=s=2,f/=2,r/=2}function u(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var c=-1;for(o=r;o>>10&1023|55296),c=56320|1023&c),n.push(c),i+=h}return function(e){var t=e.length;if(t<=w)return String.fromCharCode.apply(String,e);var r="",n=0;for(;nthis.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return k(this,t,r);case"utf8":case"utf-8":return b(this,t,r);case"ascii":return E(this,t,r);case"latin1":case"binary":return B(this,t,r);case"base64":return y(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return T(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}.apply(this,arguments)},h.prototype.equals=function(e){if(!h.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===h.compare(this,e)},h.prototype.inspect=function(){var e="",t=q.INSPECT_MAX_BYTES;return 0t&&(e+=" ... ")),""},h.prototype.compare=function(e,t,r,n,i){if(!h.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(i<=n&&r<=t)return 0;if(i<=n)return-1;if(r<=t)return 1;if(this===e)return 0;for(var o=(i>>>=0)-(n>>>=0),s=(r>>>=0)-(t>>>=0),a=Math.min(o,s),f=this.slice(n,i),u=e.slice(t,r),c=0;cthis.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var o,s,a,f,u,c,h,l,p,d=!1;;)switch(n){case"hex":return m(this,e,t,r);case"utf8":case"utf-8":return l=t,p=r,D(j(e,(h=this).length-l),h,l,p);case"ascii":return v(this,e,t,r);case"latin1":case"binary":return v(this,e,t,r);case"base64":return f=this,u=t,c=r,D(M(e),f,u,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return s=t,a=r,D(function(e,t){for(var r,n,i,o=[],s=0;s>8,i=r%256,o.push(i),o.push(n);return o}(e,(o=this).length-s),o,s,a);default:if(d)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),d=!0}},h.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var w=4096;function E(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;ie.length)throw new RangeError("Index out of range")}function I(e,t,r,n){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-r,2);i>>8*(n?i:1-i)}function A(e,t,r,n){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-r,4);i>>8*(n?i:3-i)&255}function O(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function L(e,t,r,n,i){return i||O(e,0,r,4),o.write(e,t,r,n,23,4),r+4}function C(e,t,r,n,i){return i||O(e,0,r,8),o.write(e,t,r,n,52,8),r+8}h.prototype.slice=function(e,t){var r,n=this.length;if((e=~~e)<0?(e+=n)<0&&(e=0):n>>8):I(this,e,t,!0),t+2},h.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,2,65535,0),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):I(this,e,t,!1),t+2},h.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,4294967295,0),h.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):A(this,e,t,!0),t+4},h.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,4294967295,0),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):A(this,e,t,!1),t+4},h.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);x(this,e,t,r,i-1,-i)}var o=0,s=1,a=0;for(this[t]=255&e;++o>0)-a&255;return t+r},h.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);x(this,e,t,r,i-1,-i)}var o=r-1,s=1,a=0;for(this[t+o]=255&e;0<=--o&&(s*=256);)e<0&&0===a&&0!==this[t+o+1]&&(a=1),this[t+o]=(e/s>>0)-a&255;return t+r},h.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,1,127,-128),h.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},h.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,2,32767,-32768),h.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):I(this,e,t,!0),t+2},h.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,2,32767,-32768),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):I(this,e,t,!1),t+2},h.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,2147483647,-2147483648),h.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):A(this,e,t,!0),t+4},h.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||x(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),h.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):A(this,e,t,!1),t+4},h.prototype.writeFloatLE=function(e,t,r){return L(this,e,t,!0,r)},h.prototype.writeFloatBE=function(e,t,r){return L(this,e,t,!1,r)},h.prototype.writeDoubleLE=function(e,t,r){return C(this,e,t,!0,r)},h.prototype.writeDoubleBE=function(e,t,r){return C(this,e,t,!1,r)},h.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),0=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(o=t;o>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function M(e){return n.toByteArray(function(e){var t;if((e=(t=e,t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")).replace(R,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function D(e,t,r,n){for(var i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{29:29,64:64,67:67}],36:[function(e,t,r){var n=e(35).Buffer,i=n.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};var o=r.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),function(e){if(e&&!i(e))throw new Error("Unknown encoding: "+e)}(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=a;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=f;break;default:return void(this.write=s)}this.charBuffer=new n(6),this.charReceived=0,this.charLength=0};function s(e){return e.toString(this.encoding)}function a(e){this.charReceived=e.length%2,this.charLength=this.charReceived?2:0}function f(e){this.charReceived=e.length%3,this.charLength=this.charReceived?3:0}o.prototype.write=function(e){for(var t="";this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived>5==6){this.charLength=2;break}if(t<=2&&r>>4==14){this.charLength=3;break}if(t<=3&&r>>3==30){this.charLength=4;break}}this.charReceived=t},o.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;t+=n.slice(0,r).toString(i)}return t}},{35:35}],37:[function(e,t,r){var n=e(28);t.exports=n("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")},{28:28}],38:[function(t,e,r){var n,i;n=this,i=function(f){"use strict";var d=function(e,t,r){if(void 0===e&&(e=d.DEFAULT_CAPACITY),void 0===t&&(t=d.DEFAULT_ENDIAN),void 0===r&&(r=d.DEFAULT_NOASSERT),!r){if((e|=0)<0)throw RangeError("Illegal capacity");t=!!t,r=!!r}this.buffer=0===e?o:new ArrayBuffer(e),this.view=0===e?null:new Uint8Array(this.buffer),this.offset=0,this.markedOffset=-1,this.limit=e,this.littleEndian=t,this.noAssert=r};d.VERSION="5.0.1",d.LITTLE_ENDIAN=!0,d.BIG_ENDIAN=!1,d.DEFAULT_CAPACITY=16,d.DEFAULT_ENDIAN=d.BIG_ENDIAN,d.DEFAULT_NOASSERT=!1,d.Long=f||null;var s=d.prototype;s.__isByteBuffer__,Object.defineProperty(s,"__isByteBuffer__",{value:!0,enumerable:!1,configurable:!1});var o=new ArrayBuffer(0),r=String.fromCharCode;function a(e){var t=0;return function(){return t>1,c=-7,h=r?i-1:0,l=r?-1:1,p=e[t+h];for(h+=l,o=p&(1<<-c)-1,p>>=-c,c+=a;0>=-c,c+=n;0>1,l=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,_=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(f=Math.pow(2,-s))<1&&(s--,f*=2),2<=(t+=1<=s+h?l/f:l*Math.pow(2,1-h))*f&&(s++,f/=2),c<=s+h?(a=0,s=c):1<=s+h?(a=(t*f-1)*Math.pow(2,i),s+=h):(a=t*Math.pow(2,h-1)*Math.pow(2,i),s=0));8<=i;e[r+p]=255&a,p+=d,a/=256,i-=8);for(s=s<>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=t,o=e.length,s=o>>3,a=0;for(t+=this.writeVarint32(o,t);s--;)n=1&!!e[a++]|(1&!!e[a++])<<1|(1&!!e[a++])<<2|(1&!!e[a++])<<3|(1&!!e[a++])<<4|(1&!!e[a++])<<5|(1&!!e[a++])<<6|(1&!!e[a++])<<7,this.writeByte(n,t++);if(a>3,s=0,a=[];for(e+=n.length;o--;)r=this.readByte(e++),a[s++]=!!(1&r),a[s++]=!!(2&r),a[s++]=!!(4&r),a[s++]=!!(8&r),a[s++]=!!(16&r),a[s++]=!!(32&r),a[s++]=!!(64&r),a[s++]=!!(128&r);if(s>f++&1)}return t&&(this.offset=e),a},s.readBytes=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+e>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+"+e+") <= "+this.buffer.byteLength)}var n=this.slice(t,t+e);return r&&(this.offset+=e),n},s.writeBytes=s.append,s.writeInt8=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=1;var n=this.buffer.byteLength;return nt?n:t),t-=1,this.view[t]=e,r&&(this.offset+=1),this},s.writeByte=s.writeInt8,s.readInt8=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=this.view[e];return 128==(128&r)&&(r=-(255-r+1)),t&&(this.offset+=1),r},s.readByte=s.readInt8,s.writeUint8=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=1;var n=this.buffer.byteLength;return nt?n:t),t-=1,this.view[t]=e,r&&(this.offset+=1),this},s.writeUInt8=s.writeUint8,s.readUint8=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=this.view[e];return t&&(this.offset+=1),r},s.readUInt8=s.readUint8,s.writeInt16=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=2;var n=this.buffer.byteLength;return nt?n:t),t-=2,this.littleEndian?(this.view[t+1]=(65280&e)>>>8,this.view[t]=255&e):(this.view[t]=(65280&e)>>>8,this.view[t+1]=255&e),r&&(this.offset+=2),this},s.writeShort=s.writeInt16,s.readInt16=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+2>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+2) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e],r|=this.view[e+1]<<8):(r=this.view[e]<<8,r|=this.view[e+1]),32768==(32768&r)&&(r=-(65535-r+1)),t&&(this.offset+=2),r},s.readShort=s.readInt16,s.writeUint16=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=2;var n=this.buffer.byteLength;return nt?n:t),t-=2,this.littleEndian?(this.view[t+1]=(65280&e)>>>8,this.view[t]=255&e):(this.view[t]=(65280&e)>>>8,this.view[t+1]=255&e),r&&(this.offset+=2),this},s.writeUInt16=s.writeUint16,s.readUint16=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+2>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+2) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e],r|=this.view[e+1]<<8):(r=this.view[e]<<8,r|=this.view[e+1]),t&&(this.offset+=2),r},s.readUInt16=s.readUint16,s.writeInt32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,this.littleEndian?(this.view[t+3]=e>>>24&255,this.view[t+2]=e>>>16&255,this.view[t+1]=e>>>8&255,this.view[t]=255&e):(this.view[t]=e>>>24&255,this.view[t+1]=e>>>16&255,this.view[t+2]=e>>>8&255,this.view[t+3]=255&e),r&&(this.offset+=4),this},s.writeInt=s.writeInt32,s.readInt32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0):(r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0),r|=0,t&&(this.offset+=4),r},s.readInt=s.readInt32,s.writeUint32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,this.littleEndian?(this.view[t+3]=e>>>24&255,this.view[t+2]=e>>>16&255,this.view[t+1]=e>>>8&255,this.view[t]=255&e):(this.view[t]=e>>>24&255,this.view[t+1]=e>>>16&255,this.view[t+2]=e>>>8&255,this.view[t+3]=255&e),r&&(this.offset+=4),this},s.writeUInt32=s.writeUint32,s.readUint32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0):(r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0),t&&(this.offset+=4),r},s.readUInt32=s.readUint32,f&&(s.writeInt64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e)),t+=8;var n=this.buffer.byteLength;nt?n:t),t-=8;var i=e.low,o=e.high;return this.littleEndian?(this.view[t+3]=i>>>24&255,this.view[t+2]=i>>>16&255,this.view[t+1]=i>>>8&255,this.view[t]=255&i,t+=4,this.view[t+3]=o>>>24&255,this.view[t+2]=o>>>16&255,this.view[t+1]=o>>>8&255,this.view[t]=255&o):(this.view[t]=o>>>24&255,this.view[t+1]=o>>>16&255,this.view[t+2]=o>>>8&255,this.view[t+3]=255&o,t+=4,this.view[t]=i>>>24&255,this.view[t+1]=i>>>16&255,this.view[t+2]=i>>>8&255,this.view[t+3]=255&i),r&&(this.offset+=8),this},s.writeLong=s.writeInt64,s.readInt64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=0,n=0;this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0,e+=4,n=this.view[e+2]<<16,n|=this.view[e+1]<<8,n|=this.view[e],n+=this.view[e+3]<<24>>>0):(n=this.view[e+1]<<16,n|=this.view[e+2]<<8,n|=this.view[e+3],n+=this.view[e]<<24>>>0,e+=4,r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0);var i=new f(r,n,!1);return t&&(this.offset+=8),i},s.readLong=s.readInt64,s.writeUint64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e)),t+=8;var n=this.buffer.byteLength;nt?n:t),t-=8;var i=e.low,o=e.high;return this.littleEndian?(this.view[t+3]=i>>>24&255,this.view[t+2]=i>>>16&255,this.view[t+1]=i>>>8&255,this.view[t]=255&i,t+=4,this.view[t+3]=o>>>24&255,this.view[t+2]=o>>>16&255,this.view[t+1]=o>>>8&255,this.view[t]=255&o):(this.view[t]=o>>>24&255,this.view[t+1]=o>>>16&255,this.view[t+2]=o>>>8&255,this.view[t+3]=255&o,t+=4,this.view[t]=i>>>24&255,this.view[t+1]=i>>>16&255,this.view[t+2]=i>>>8&255,this.view[t+3]=255&i),r&&(this.offset+=8),this},s.writeUInt64=s.writeUint64,s.readUint64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=0,n=0;this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0,e+=4,n=this.view[e+2]<<16,n|=this.view[e+1]<<8,n|=this.view[e],n+=this.view[e+3]<<24>>>0):(n=this.view[e+1]<<16,n|=this.view[e+2]<<8,n|=this.view[e+3],n+=this.view[e]<<24>>>0,e+=4,r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0);var i=new f(r,n,!0);return t&&(this.offset+=8),i},s.readUInt64=s.readUint64),s.writeFloat32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e)throw TypeError("Illegal value: "+e+" (not a number)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,i(this.view,e,t,this.littleEndian,23,4),r&&(this.offset+=4),this},s.writeFloat=s.writeFloat32,s.readFloat32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=n(this.view,e,this.littleEndian,23,4);return t&&(this.offset+=4),r},s.readFloat=s.readFloat32,s.writeFloat64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e)throw TypeError("Illegal value: "+e+" (not a number)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=8;var n=this.buffer.byteLength;return nt?n:t),t-=8,i(this.view,e,t,this.littleEndian,52,8),r&&(this.offset+=8),this},s.writeDouble=s.writeFloat64,s.readFloat64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=n(this.view,e,this.littleEndian,52,8);return t&&(this.offset+=8),r},s.readDouble=s.readFloat64,d.MAX_VARINT32_BYTES=5,d.calculateVarint32=function(e){return(e>>>=0)<128?1:e<16384?2:e<1<<21?3:e<1<<28?4:5},d.zigZagEncode32=function(e){return((e|=0)<<1^e>>31)>>>0},d.zigZagDecode32=function(e){return e>>>1^-(1&e)|0},s.writeVarint32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=d.calculateVarint32(e);t+=i;var o=this.buffer.byteLength;for(ot?o:t),t-=i,e>>>=0;128<=e;)n=127&e|128,this.view[t++]=n,e>>>=7;return this.view[t++]=e,r?(this.offset=t,this):i},s.writeVarint32ZigZag=function(e,t){return this.writeVarint32(d.zigZagEncode32(e),t)},s.readVarint32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r,n=0,i=0;do{if(!this.noAssert&&e>this.limit){var o=Error("Truncated");throw o.truncated=!0,o}r=this.view[e++],n<5&&(i|=(127&r)<<7*n),++n}while(0!=(128&r));return i|=0,t?(this.offset=e,i):{value:i,length:n}},s.readVarint32ZigZag=function(e){var t=this.readVarint32(e);return"object"==typeof t?t.value=d.zigZagDecode32(t.value):t=d.zigZagDecode32(t),t},f&&(d.MAX_VARINT64_BYTES=10,d.calculateVarint64=function(e){"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e));var t=e.toInt()>>>0,r=e.shiftRightUnsigned(28).toInt()>>>0,n=e.shiftRightUnsigned(56).toInt()>>>0;return 0==n?0==r?t<16384?t<128?1:2:t<1<<21?3:4:r<16384?r<128?5:6:r<1<<21?7:8:n<128?9:10},d.zigZagEncode64=function(e){return"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned()),e.shiftLeft(1).xor(e.shiftRight(63)).toUnsigned()},d.zigZagDecode64=function(e){return"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned()),e.shiftRightUnsigned(1).xor(e.and(f.ONE).toSigned().negate()).toSigned()},s.writeVarint64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned());var n=d.calculateVarint64(e),i=e.toInt()>>>0,o=e.shiftRightUnsigned(28).toInt()>>>0,s=e.shiftRightUnsigned(56).toInt()>>>0;t+=n;var a=this.buffer.byteLength;switch(at?a:t),t-=n,n){case 10:this.view[t+9]=s>>>7&1;case 9:this.view[t+8]=9!==n?128|s:127&s;case 8:this.view[t+7]=8!==n?o>>>21|128:o>>>21&127;case 7:this.view[t+6]=7!==n?o>>>14|128:o>>>14&127;case 6:this.view[t+5]=6!==n?o>>>7|128:o>>>7&127;case 5:this.view[t+4]=5!==n?128|o:127&o;case 4:this.view[t+3]=4!==n?i>>>21|128:i>>>21&127;case 3:this.view[t+2]=3!==n?i>>>14|128:i>>>14&127;case 2:this.view[t+1]=2!==n?i>>>7|128:i>>>7&127;case 1:this.view[t]=1!==n?128|i:127&i}return r?(this.offset+=n,this):n},s.writeVarint64ZigZag=function(e,t){return this.writeVarint64(d.zigZagEncode64(e),t)},s.readVarint64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=e,n=0,i=0,o=0,s=0;if(n=127&(s=this.view[e++]),128&s&&(n|=(127&(s=this.view[e++]))<<7,(128&s||this.noAssert&&void 0===s)&&(n|=(127&(s=this.view[e++]))<<14,(128&s||this.noAssert&&void 0===s)&&(n|=(127&(s=this.view[e++]))<<21,(128&s||this.noAssert&&void 0===s)&&(i=127&(s=this.view[e++]),(128&s||this.noAssert&&void 0===s)&&(i|=(127&(s=this.view[e++]))<<7,(128&s||this.noAssert&&void 0===s)&&(i|=(127&(s=this.view[e++]))<<14,(128&s||this.noAssert&&void 0===s)&&(i|=(127&(s=this.view[e++]))<<21,(128&s||this.noAssert&&void 0===s)&&(o=127&(s=this.view[e++]),(128&s||this.noAssert&&void 0===s)&&(o|=(127&(s=this.view[e++]))<<7,128&s||this.noAssert&&void 0===s))))))))))throw Error("Buffer overrun");var a=f.fromBits(n|i<<28,i>>>4|o<<24,!1);return t?(this.offset=e,a):{value:a,length:e-r}},s.readVarint64ZigZag=function(e){var t=this.readVarint64(e);return t&&t.value instanceof f?t.value=d.zigZagDecode64(t.value):t=d.zigZagDecode64(t),t}),s.writeCString=function(e,t){var r=void 0===t;r&&(t=this.offset);var n,i=e.length;if(!this.noAssert){if("string"!=typeof e)throw TypeError("Illegal str: Not a string");for(n=0;n>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}i=l.calculateUTF16asUTF8(a(e))[1],t+=i+1;var o=this.buffer.byteLength;return ot?o:t),t-=i+1,l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),this.view[t++]=0,r?(this.offset=t,this):i},s.readCString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r,n=e,i=-1;return l.decodeUTF8toUTF16(function(){if(0===i)return null;if(e>=this.limit)throw RangeError("Illegal range: Truncated data, "+e+" < "+this.limit);return 0===(i=this.view[e++])?null:i}.bind(this),r=u(),!0),t?(this.offset=e,r()):{string:r(),length:e-n}},s.writeIString=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("string"!=typeof e)throw TypeError("Illegal str: Not a string");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=t;n=l.calculateUTF16asUTF8(a(e),this.noAssert)[1],t+=4+n;var o=this.buffer.byteLength;if(ot?o:t),t-=4+n,this.littleEndian?(this.view[t+3]=n>>>24&255,this.view[t+2]=n>>>16&255,this.view[t+1]=n>>>8&255,this.view[t]=255&n):(this.view[t]=n>>>24&255,this.view[t+1]=n>>>16&255,this.view[t+2]=n>>>8&255,this.view[t+3]=255&n),t+=4,l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),t!==i+4+n)throw RangeError("Illegal range: Truncated data, "+t+" == "+(t+4+n));return r?(this.offset=t,this):t-i},s.readIString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=e,n=this.readUint32(e),i=this.readUTF8String(n,d.METRICS_BYTES,e+=4);return e+=i.length,t?(this.offset=e,i.string):{string:i.string,length:e-r}},d.METRICS_CHARS="c",d.METRICS_BYTES="b",s.writeUTF8String=function(e,t){var r,n=void 0===t;if(n&&(t=this.offset),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var i=t;r=l.calculateUTF16asUTF8(a(e))[1],t+=r;var o=this.buffer.byteLength;return ot?o:t),t-=r,l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),n?(this.offset=t,this):t-i},s.writeString=s.writeUTF8String,d.calculateUTF8Chars=function(e){return l.calculateUTF16asUTF8(a(e))[0]},d.calculateUTF8Bytes=function(e){return l.calculateUTF16asUTF8(a(e))[1]},d.calculateString=d.calculateUTF8Bytes,s.readUTF8String=function(e,t,r){"number"==typeof t&&(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),void 0===t&&(t=d.METRICS_CHARS),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal length: "+e+" (not an integer)");if(e|=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}var i,o=0,s=r;if(t===d.METRICS_CHARS){if(i=u(),l.decodeUTF8(function(){return o>>=0)<0||r+e>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+"+e+") <= "+this.buffer.byteLength)}var a=r+e;if(l.decodeUTF8toUTF16(function(){return r>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i,o=t;n=l.calculateUTF16asUTF8(a(e),this.noAssert)[1],i=d.calculateVarint32(n),t+=i+n;var s=this.buffer.byteLength;if(st?s:t),t-=i+n,t+=this.writeVarint32(n,t),l.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),t!==o+n+i)throw RangeError("Illegal range: Truncated data, "+t+" == "+(t+n+i));return r?(this.offset=t,this):t-o},s.readVString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=e,n=this.readVarint32(e),i=this.readUTF8String(n.value,d.METRICS_BYTES,e+=n.length);return e+=i.length,t?(this.offset=e,i.string):{string:i.string,length:e-r}},s.append=function(e,t,r){"number"!=typeof t&&"string"==typeof t||(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),!this.noAssert){if("number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}e instanceof d||(e=d.wrap(e,t));var i=e.limit-e.offset;if(i<=0)return this;r+=i;var o=this.buffer.byteLength;return or?o:r),r-=i,this.view.set(e.view.subarray(e.offset,e.limit),r),e.offset+=i,n&&(this.offset+=i),this},s.appendTo=function(e,t){return e.append(this,t),this},s.assert=function(e){return this.noAssert=!e,this},s.capacity=function(){return this.buffer.byteLength},s.clear=function(){return this.offset=0,this.limit=this.buffer.byteLength,this.markedOffset=-1,this},s.clone=function(e){var t=new d(0,this.littleEndian,this.noAssert);return t.view=e?(t.buffer=new ArrayBuffer(this.buffer.byteLength),new Uint8Array(t.buffer)):(t.buffer=this.buffer,this.view),t.offset=this.offset,t.markedOffset=this.markedOffset,t.limit=this.limit,t},s.compact=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}if(0===e&&t===this.buffer.byteLength)return this;var r=t-e;if(0===r)return this.buffer=o,this.view=null,0<=this.markedOffset&&(this.markedOffset-=e),this.offset=0,this.limit=0,this;var n=new ArrayBuffer(r),i=new Uint8Array(n);return i.set(this.view.subarray(e,t)),this.buffer=n,this.view=i,0<=this.markedOffset&&(this.markedOffset-=e),this.offset=0,this.limit=r,this},s.copy=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}if(e===t)return new d(0,this.littleEndian,this.noAssert);var r=t-e,n=new d(r,this.littleEndian,this.noAssert);return n.offset=0,n.limit=r,0<=n.markedOffset&&(n.markedOffset-=e),this.copyTo(n,0,e,t),n},s.copyTo=function(e,t,r,n){var i,o;if(!this.noAssert&&!d.isByteBuffer(e))throw TypeError("Illegal target: Not a ByteBuffer");if(t=(o=void 0===t)?e.offset:0|t,r=(i=void 0===r)?this.offset:0|r,n=void 0===n?this.limit:0|n,t<0||t>e.buffer.byteLength)throw RangeError("Illegal target range: 0 <= "+t+" <= "+e.buffer.byteLength);if(r<0||n>this.buffer.byteLength)throw RangeError("Illegal source range: 0 <= "+r+" <= "+this.buffer.byteLength);var s=n-r;return 0===s?e:(e.ensureCapacity(t+s),e.view.set(this.view.subarray(r,n),t),i&&(this.offset+=s),o&&(e.offset+=s),this)},s.ensureCapacity=function(e){var t=this.buffer.byteLength;return te?t:e):this},s.fill=function(e,t,r){var n=void 0===t;if(n&&(t=this.offset),"string"==typeof e&&0>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal end: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}if(r<=t)return this;for(;t>>=0)<0||e+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+0) <= "+this.buffer.byteLength)}return this.markedOffset=e,this},s.order=function(e){if(!this.noAssert&&"boolean"!=typeof e)throw TypeError("Illegal littleEndian: Not a boolean");return this.littleEndian=!!e,this},s.LE=function(e){return this.littleEndian=void 0===e||!!e,this},s.BE=function(e){return this.littleEndian=void 0!==e&&!e,this},s.prepend=function(e,t,r){"number"!=typeof t&&"string"==typeof t||(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),!this.noAssert){if("number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}e instanceof d||(e=d.wrap(e,t));var i=e.limit-e.offset;if(i<=0)return this;var o=i-r;if(0>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}return e===t||Array.prototype.reverse.call(this.view.subarray(e,t)),this},s.skip=function(e){if(!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal length: "+e+" (not an integer)");e|=0}var t=this.offset+e;if(!this.noAssert&&(t<0||t>this.buffer.byteLength))throw RangeError("Illegal length: 0 <= "+this.offset+" + "+e+" <= "+this.buffer.byteLength);return this.offset=t,this},s.slice=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}var r=this.clone();return r.offset=e,r.limit=t,r},s.toBuffer=function(e){var t=this.offset,r=this.limit;if(!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: Not an integer");if(t>>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal limit: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}if(!e&&0===t&&r===this.buffer.byteLength)return this.buffer;if(t===r)return o;var n=new ArrayBuffer(r-t);return new Uint8Array(n).set(new Uint8Array(this.buffer).subarray(t,r),0),n},s.toArrayBuffer=s.toBuffer,s.toString=function(e,t,r){if(void 0===e)return"ByteBufferAB(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")";switch("number"==typeof e&&(r=t=e="utf8"),e){case"utf8":return this.toUTF8(t,r);case"base64":return this.toBase64(t,r);case"hex":return this.toHex(t,r);case"binary":return this.toBinary(t,r);case"debug":return this.toDebug();case"columns":return this.toColumns();default:throw Error("Unsupported encoding: "+e)}};var c=function(){for(var e={},i=[65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,54,55,56,57,43,47],s=[],t=0,r=i.length;t>2&63]),n=(3&r)<<4,null!==(r=e())?(t(i[63&((n|=r>>4&15)|r>>4&15)]),n=(15&r)<<2,null!==(r=e())?(t(i[63&(n|r>>6&3)]),t(i[63&r])):(t(i[63&n]),t(61))):(t(i[63&n]),t(61),t(61))},e.decode=function(e,t){var r,n,i;function o(e){throw Error("Illegal character code: "+e)}for(;null!==(r=e());)if(void 0===(n=s[r])&&o(r),null!==(r=e())&&(void 0===(i=s[r])&&o(r),t(n<<2>>>0|(48&i)>>4),null!==(r=e()))){if(void 0===(n=s[r])){if(61===r)break;o(r)}if(t((15&i)<<4>>>0|(60&n)>>2),null!==(r=e())){if(void 0===(i=s[r])){if(61===r)break;o(r)}t((3&n)<<6>>>0|i)}}},e.test=function(e){return/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(e)},e}();s.toBase64=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),t|=0,(e|=0)<0||t>this.capacity||tthis.capacity()||t":i+=r===this.markedOffset?"'":e||0!==r&&r!==n?" ":""}if(e&&" "!==i){for(;i.length<51;)i+=" ";s+=i+o+"\n"}return e?s:i},d.fromDebug=function(e,t,r){for(var n,i,o=e.length,s=new d((o+1)/3|0,t,r),a=0,f=0,u=!1,c=!1,h=!1,l=!1,p=!1;a":if(!r){if(l){p=!0;break}l=!0}s.limit=f,u=!1;break;case"'":if(!r){if(h){p=!0;break}h=!0}s.markedOffset=f,u=!1;break;case" ":u=!1;break;default:if(!r&&u){p=!0;break}if(i=parseInt(n+e.charAt(a++),16),!r&&(isNaN(i)||i<0||255>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}for(var r,n=new Array(t-e);e>6&31|192):(r<65536?t(r>>12&15|224):(t(r>>18&7|240),t(r>>12&63|128)),t(r>>6&63|128)),t(63&r|128)),r=null},decodeUTF8:function(e,t){for(var r,n,i,o,s=function(e){e=e.slice(0,e.indexOf(null));var t=Error(e.toString());throw t.name="TruncatedError",t.bytes=e,t};null!==(r=e());)if(0==(128&r))t(r);else if(192==(224&r))null===(n=e())&&s([r,n]),t((31&r)<<6|63&n);else if(224==(240&r))(null===(n=e())||null===(i=e()))&&s([r,n,i]),t((15&r)<<12|(63&n)<<6|63&i);else{if(240!=(248&r))throw RangeError("Illegal starting byte: "+r);(null===(n=e())||null===(i=e())||null===(o=e()))&&s([r,n,i,o]),t((7&r)<<18|(63&n)<<12|(63&i)<<6|63&o)}},UTF16toUTF8:function(e,t){for(var r,n=null;null!==(r=null!==n?n:e());)55296<=r&&r<=57343&&null!==(n=e())&&56320<=n&&n<=57343?(t(1024*(r-55296)+n-56320+65536),n=null):t(r);null!==n&&t(n)},UTF8toUTF16:function(e,t){var r=null;for("number"==typeof e&&(r=e,e=function(){return null});null!==r||null!==(r=e());)r<=65535?t(r):(t(55296+((r-=65536)>>10)),t(r%1024+56320)),r=null},encodeUTF16toUTF8:function(e,t){h.UTF16toUTF8(e,function(e){h.encodeUTF8(e,t)})},decodeUTF8toUTF16:function(e,t){h.decodeUTF8(e,function(e){h.UTF8toUTF16(e,t)})},calculateCodePoint:function(e){return e<128?1:e<2048?2:e<65536?3:4},calculateUTF8:function(e){for(var t,r=0;null!==(t=e());)r+=t<128?1:t<2048?2:t<65536?3:4;return r},calculateUTF16asUTF8:function(e){var t=0,r=0;return h.UTF16toUTF8(e,function(e){++t,r+=e<128?1:e<2048?2:e<65536?3:4}),[t,r]}};return s.toUTF8=function(t,r){if(void 0===t&&(t=this.offset),void 0===r&&(r=this.limit),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal begin: Not an integer");if(t>>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal end: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}var e;try{l.decodeUTF8toUTF16(function(){return tr)?t=("rmd160"===e?new f:u(e)).update(t).digest():t.length>>8^255&i^99,u[r]=i;var o=e[c[i]=r],s=e[o],a=e[s],f=257*e[i]^16843008*i;h[r]=f<<24|f>>>8,l[r]=f<<16|f>>>16,p[r]=f<<8|f>>>24,d[r]=f;f=16843009*a^65537*s^257*o^16843008*r;_[i]=f<<24|f>>>8,g[i]=f<<16|f>>>16,m[i]=f<<8|f>>>24,v[i]=f,r?(r=o^e[e[e[a^o]]],n^=e[e[n]]):r=n=1}}();var y=[0,1,2,4,8,16,32,64,128,27,54],n=r.AES=t.extend({_doReset:function(){if(!this._nRounds||this._keyPriorReset!==this._key){for(var e=this._keyPriorReset=this._key,t=e.words,r=e.sigBytes/4,n=4*((this._nRounds=r+6)+1),i=this._keySchedule=[],o=0;o>>24]<<24|u[s>>>16&255]<<16|u[s>>>8&255]<<8|u[255&s]):(s=u[(s=s<<8|s>>>24)>>>24]<<24|u[s>>>16&255]<<16|u[s>>>8&255]<<8|u[255&s],s^=y[o/r|0]<<24),i[o]=i[o-r]^s}for(var a=this._invKeySchedule=[],f=0;f>>24]]^g[u[s>>>16&255]]^m[u[s>>>8&255]]^v[u[255&s]]}}},encryptBlock:function(e,t){this._doCryptBlock(e,t,this._keySchedule,h,l,p,d,u)},decryptBlock:function(e,t){var r=e[t+1];e[t+1]=e[t+3],e[t+3]=r,this._doCryptBlock(e,t,this._invKeySchedule,_,g,m,v,c);r=e[t+1];e[t+1]=e[t+3],e[t+3]=r},_doCryptBlock:function(e,t,r,n,i,o,s,a){for(var f=this._nRounds,u=e[t]^r[0],c=e[t+1]^r[1],h=e[t+2]^r[2],l=e[t+3]^r[3],p=4,d=1;d>>24]^i[c>>>16&255]^o[h>>>8&255]^s[255&l]^r[p++],g=n[c>>>24]^i[h>>>16&255]^o[l>>>8&255]^s[255&u]^r[p++],m=n[h>>>24]^i[l>>>16&255]^o[u>>>8&255]^s[255&c]^r[p++],v=n[l>>>24]^i[u>>>16&255]^o[c>>>8&255]^s[255&h]^r[p++];u=_,c=g,h=m,l=v}_=(a[u>>>24]<<24|a[c>>>16&255]<<16|a[h>>>8&255]<<8|a[255&l])^r[p++],g=(a[c>>>24]<<24|a[h>>>16&255]<<16|a[l>>>8&255]<<8|a[255&u])^r[p++],m=(a[h>>>24]<<24|a[l>>>16&255]<<16|a[u>>>8&255]<<8|a[255&c])^r[p++],v=(a[l>>>24]<<24|a[u>>>16&255]<<16|a[c>>>8&255]<<8|a[255&h])^r[p++];e[t]=_,e[t+1]=g,e[t+2]=m,e[t+3]=v},keySize:8});e.AES=t._createHelper(n)}(),i.AES},"object"==typeof r?t.exports=r=i(e(47),e(48),e(52),e(50),e(46)):i(n.CryptoJS)},{46:46,47:47,48:48,50:50,52:52}],46:[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,f,i,o,s,a,u,c,h,l,p,d,_,g,m,v;e.lib.Cipher||(r=(t=e).lib,n=r.Base,f=r.WordArray,i=r.BufferedBlockAlgorithm,(o=t.enc).Utf8,s=o.Base64,a=t.algo.EvpKDF,u=r.Cipher=i.extend({cfg:n.extend(),createEncryptor:function(e,t){return this.create(this._ENC_XFORM_MODE,e,t)},createDecryptor:function(e,t){return this.create(this._DEC_XFORM_MODE,e,t)},init:function(e,t,r){this.cfg=this.cfg.extend(r),this._xformMode=e,this._key=t,this.reset()},reset:function(){i.reset.call(this),this._doReset()},process:function(e){return this._append(e),this._process()},finalize:function(e){return e&&this._append(e),this._doFinalize()},keySize:4,ivSize:4,_ENC_XFORM_MODE:1,_DEC_XFORM_MODE:2,_createHelper:function(){function i(e){return"string"==typeof e?v:g}return function(n){return{encrypt:function(e,t,r){return i(t).encrypt(n,e,t,r)},decrypt:function(e,t,r){return i(t).decrypt(n,e,t,r)}}}}()}),r.StreamCipher=u.extend({_doFinalize:function(){return this._process(!0)},blockSize:1}),c=t.mode={},h=r.BlockCipherMode=n.extend({createEncryptor:function(e,t){return this.Encryptor.create(e,t)},createDecryptor:function(e,t){return this.Decryptor.create(e,t)},init:function(e,t){this._cipher=e,this._iv=t}}),l=c.CBC=function(){var e=h.extend();function o(e,t,r){var n=this._iv;if(n){var i=n;this._iv=void 0}else i=this._prevBlock;for(var o=0;o>>2];e.sigBytes-=t}},r.BlockCipher=u.extend({cfg:u.cfg.extend({mode:l,padding:p}),reset:function(){u.reset.call(this);var e=this.cfg,t=e.iv,r=e.mode;if(this._xformMode==this._ENC_XFORM_MODE)var n=r.createEncryptor;else{n=r.createDecryptor;this._minBufferSize=1}this._mode&&this._mode.__creator==n?this._mode.init(this,t&&t.words):(this._mode=n.call(r,this,t&&t.words),this._mode.__creator=n)},_doProcessBlock:function(e,t){this._mode.processBlock(e,t)},_doFinalize:function(){var e=this.cfg.padding;if(this._xformMode==this._ENC_XFORM_MODE){e.pad(this._data,this.blockSize);var t=this._process(!0)}else{t=this._process(!0);e.unpad(t)}return t},blockSize:4}),d=r.CipherParams=n.extend({init:function(e){this.mixIn(e)},toString:function(e){return(e||this.formatter).stringify(this)}}),_=(t.format={}).OpenSSL={stringify:function(e){var t=e.ciphertext,r=e.salt;if(r)var n=f.create([1398893684,1701076831]).concat(r).concat(t);else n=t;return n.toString(s)},parse:function(e){var t=s.parse(e),r=t.words;if(1398893684==r[0]&&1701076831==r[1]){var n=f.create(r.slice(2,4));r.splice(0,4),t.sigBytes-=16}return d.create({ciphertext:t,salt:n})}},g=r.SerializableCipher=n.extend({cfg:n.extend({format:_}),encrypt:function(e,t,r,n){n=this.cfg.extend(n);var i=e.createEncryptor(r,n),o=i.finalize(t),s=i.cfg;return d.create({ciphertext:o,key:r,iv:s.iv,algorithm:e,mode:s.mode,padding:s.padding,blockSize:e.blockSize,formatter:n.format})},decrypt:function(e,t,r,n){return n=this.cfg.extend(n),t=this._parse(t,n.format),e.createDecryptor(r,n).finalize(t.ciphertext)},_parse:function(e,t){return"string"==typeof e?t.parse(e,this):e}}),m=(t.kdf={}).OpenSSL={execute:function(e,t,r,n){n||(n=f.random(8));var i=a.create({keySize:t+r}).compute(e,n),o=f.create(i.words.slice(t),4*r);return i.sigBytes=4*t,d.create({key:i,iv:o,salt:n})}},v=r.PasswordBasedCipher=g.extend({cfg:g.cfg.extend({kdf:m}),encrypt:function(e,t,r,n){var i=(n=this.cfg.extend(n)).kdf.execute(r,e.keySize,e.ivSize);n.iv=i.iv;var o=g.encrypt.call(this,e,t,i.key,n);return o.mixIn(i),o},decrypt:function(e,t,r,n){n=this.cfg.extend(n),t=this._parse(t,n.format);var i=n.kdf.execute(r,e.keySize,e.ivSize,t.salt);return n.iv=i.iv,g.decrypt.call(this,e,t,i.key,n)}}))},"object"==typeof r?t.exports=r=i(e(47),e(50)):i(n.CryptoJS)},{47:47,50:50}],47:[function(e,t,r){var n,i;n=this,i=function(){var c,r,e,t,n,h,i,o,s,a,f,u,l=l||(c=Math,r=Object.create||function(){function r(){}return function(e){var t;return r.prototype=e,t=new r,r.prototype=null,t}}(),t=(e={}).lib={},n=t.Base={extend:function(e){var t=r(this);return e&&t.mixIn(e),t.hasOwnProperty("init")&&this.init!==t.init||(t.init=function(){t.$super.init.apply(this,arguments)}),(t.init.prototype=t).$super=this,t},create:function(){var e=this.extend();return e.init.apply(e,arguments),e},init:function(){},mixIn:function(e){for(var t in e)e.hasOwnProperty(t)&&(this[t]=e[t]);e.hasOwnProperty("toString")&&(this.toString=e.toString)},clone:function(){return this.init.prototype.extend(this)}},h=t.WordArray=n.extend({init:function(e,t){e=this.words=e||[],this.sigBytes=null!=t?t:4*e.length},toString:function(e){return(e||o).stringify(this)},concat:function(e){var t=this.words,r=e.words,n=this.sigBytes,i=e.sigBytes;if(this.clamp(),n%4)for(var o=0;o>>2]>>>24-o%4*8&255;t[n+o>>>2]|=s<<24-(n+o)%4*8}else for(o=0;o>>2]=r[o>>>2];return this.sigBytes+=i,this},clamp:function(){var e=this.words,t=this.sigBytes;e[t>>>2]&=4294967295<<32-t%4*8,e.length=c.ceil(t/4)},clone:function(){var e=n.clone.call(this);return e.words=this.words.slice(0),e},random:function(e){for(var t,r=[],n=function(t){t=t;var r=987654321,n=4294967295;return function(){var e=((r=36969*(65535&r)+(r>>16)&n)<<16)+(t=18e3*(65535&t)+(t>>16)&n)&n;return e/=4294967296,(e+=.5)*(.5>>2]>>>24-i%4*8&255;n.push((o>>>4).toString(16)),n.push((15&o).toString(16))}return n.join("")},parse:function(e){for(var t=e.length,r=[],n=0;n>>3]|=parseInt(e.substr(n,2),16)<<24-n%8*4;return new h.init(r,t/2)}},s=i.Latin1={stringify:function(e){for(var t=e.words,r=e.sigBytes,n=[],i=0;i>>2]>>>24-i%4*8&255;n.push(String.fromCharCode(o))}return n.join("")},parse:function(e){for(var t=e.length,r=[],n=0;n>>2]|=(255&e.charCodeAt(n))<<24-n%4*8;return new h.init(r,t)}},a=i.Utf8={stringify:function(e){try{return decodeURIComponent(escape(s.stringify(e)))}catch(e){throw new Error("Malformed UTF-8 data")}},parse:function(e){return s.parse(unescape(encodeURIComponent(e)))}},f=t.BufferedBlockAlgorithm=n.extend({reset:function(){this._data=new h.init,this._nDataBytes=0},_append:function(e){"string"==typeof e&&(e=a.parse(e)),this._data.concat(e),this._nDataBytes+=e.sigBytes},_process:function(e){var t=this._data,r=t.words,n=t.sigBytes,i=this.blockSize,o=n/(4*i),s=(o=e?c.ceil(o):c.max((0|o)-this._minBufferSize,0))*i,a=c.min(4*s,n);if(s){for(var f=0;f>>2]>>>24-o%4*8&255)<<16|(t[o+1>>>2]>>>24-(o+1)%4*8&255)<<8|t[o+2>>>2]>>>24-(o+2)%4*8&255,a=0;a<4&&o+.75*a>>6*(3-a)&63));var f=n.charAt(64);if(f)for(;i.length%4;)i.push(f);return i.join("")},parse:function(e){var t=e.length,r=this._map,n=this._reverseMap;if(!n){n=this._reverseMap=[];for(var i=0;i>>6-o%4*2;n[i>>>2]|=(s|a)<<24-i%4*8,i++}return f.create(n,i)}(e,t,n)},_map:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="},e.enc.Base64},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],49:[function(e,t,r){var n,i;n=this,i=function(e){return e.enc.Hex},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],50:[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,c,i,o,s;return r=(t=e).lib,n=r.Base,c=r.WordArray,i=t.algo,o=i.MD5,s=i.EvpKDF=n.extend({cfg:n.extend({keySize:4,hasher:o,iterations:1}),init:function(e){this.cfg=this.cfg.extend(e)},compute:function(e,t){for(var r=this.cfg,n=r.hasher.create(),i=c.create(),o=i.words,s=r.keySize,a=r.iterations;o.lengthn&&(t=e.finalize(t)),t.clamp();for(var i=this._oKey=t.clone(),o=this._iKey=t.clone(),s=i.words,a=o.words,f=0;f>>24)|4278255360&(i<<24|i>>>8)}var o=this._hash.words,s=e[t+0],a=e[t+1],f=e[t+2],u=e[t+3],c=e[t+4],h=e[t+5],l=e[t+6],p=e[t+7],d=e[t+8],_=e[t+9],g=e[t+10],m=e[t+11],v=e[t+12],y=e[t+13],b=e[t+14],w=e[t+15],E=o[0],B=o[1],k=o[2],T=o[3];B=O(B=O(B=O(B=O(B=A(B=A(B=A(B=A(B=I(B=I(B=I(B=I(B=x(B=x(B=x(B=x(B,k=x(k,T=x(T,E=x(E,B,k,T,s,7,S[0]),B,k,a,12,S[1]),E,B,f,17,S[2]),T,E,u,22,S[3]),k=x(k,T=x(T,E=x(E,B,k,T,c,7,S[4]),B,k,h,12,S[5]),E,B,l,17,S[6]),T,E,p,22,S[7]),k=x(k,T=x(T,E=x(E,B,k,T,d,7,S[8]),B,k,_,12,S[9]),E,B,g,17,S[10]),T,E,m,22,S[11]),k=x(k,T=x(T,E=x(E,B,k,T,v,7,S[12]),B,k,y,12,S[13]),E,B,b,17,S[14]),T,E,w,22,S[15]),k=I(k,T=I(T,E=I(E,B,k,T,a,5,S[16]),B,k,l,9,S[17]),E,B,m,14,S[18]),T,E,s,20,S[19]),k=I(k,T=I(T,E=I(E,B,k,T,h,5,S[20]),B,k,g,9,S[21]),E,B,w,14,S[22]),T,E,c,20,S[23]),k=I(k,T=I(T,E=I(E,B,k,T,_,5,S[24]),B,k,b,9,S[25]),E,B,u,14,S[26]),T,E,d,20,S[27]),k=I(k,T=I(T,E=I(E,B,k,T,y,5,S[28]),B,k,f,9,S[29]),E,B,p,14,S[30]),T,E,v,20,S[31]),k=A(k,T=A(T,E=A(E,B,k,T,h,4,S[32]),B,k,d,11,S[33]),E,B,m,16,S[34]),T,E,b,23,S[35]),k=A(k,T=A(T,E=A(E,B,k,T,a,4,S[36]),B,k,c,11,S[37]),E,B,p,16,S[38]),T,E,g,23,S[39]),k=A(k,T=A(T,E=A(E,B,k,T,y,4,S[40]),B,k,s,11,S[41]),E,B,u,16,S[42]),T,E,l,23,S[43]),k=A(k,T=A(T,E=A(E,B,k,T,_,4,S[44]),B,k,v,11,S[45]),E,B,w,16,S[46]),T,E,f,23,S[47]),k=O(k,T=O(T,E=O(E,B,k,T,s,6,S[48]),B,k,p,10,S[49]),E,B,b,15,S[50]),T,E,h,21,S[51]),k=O(k,T=O(T,E=O(E,B,k,T,v,6,S[52]),B,k,u,10,S[53]),E,B,g,15,S[54]),T,E,a,21,S[55]),k=O(k,T=O(T,E=O(E,B,k,T,d,6,S[56]),B,k,w,10,S[57]),E,B,l,15,S[58]),T,E,y,21,S[59]),k=O(k,T=O(T,E=O(E,B,k,T,c,6,S[60]),B,k,m,10,S[61]),E,B,f,15,S[62]),T,E,_,21,S[63]),o[0]=o[0]+E|0,o[1]=o[1]+B|0,o[2]=o[2]+k|0,o[3]=o[3]+T|0},_doFinalize:function(){var e=this._data,t=e.words,r=8*this._nDataBytes,n=8*e.sigBytes;t[n>>>5]|=128<<24-n%32;var i=c.floor(r/4294967296),o=r;t[15+(n+64>>>9<<4)]=16711935&(i<<8|i>>>24)|4278255360&(i<<24|i>>>8),t[14+(n+64>>>9<<4)]=16711935&(o<<8|o>>>24)|4278255360&(o<<24|o>>>8),e.sigBytes=4*(t.length+1),this._process();for(var s=this._hash,a=s.words,f=0;f<4;f++){var u=a[f];a[f]=16711935&(u<<8|u>>>24)|4278255360&(u<<24|u>>>8)}return s},clone:function(){var e=n.clone.call(this);return e._hash=this._hash.clone(),e}});function x(e,t,r,n,i,o,s){var a=e+(t&r|~t&n)+i+s;return(a<>>32-o)+t}function I(e,t,r,n,i,o,s){var a=e+(t&n|r&~n)+i+s;return(a<>>32-o)+t}function A(e,t,r,n,i,o,s){var a=e+(t^r^n)+i+s;return(a<>>32-o)+t}function O(e,t,r,n,i,o,s){var a=e+(r^(t|~n))+i+s;return(a<>>32-o)+t}e.MD5=n._createHelper(o),e.HmacMD5=n._createHmacHelper(o)}(Math),s.MD5},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],53:[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,i,o,h,s;return r=(t=e).lib,n=r.WordArray,i=r.Hasher,o=t.algo,h=[],s=o.SHA1=i.extend({_doReset:function(){this._hash=new n.init([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(e,t){for(var r=this._hash.words,n=r[0],i=r[1],o=r[2],s=r[3],a=r[4],f=0;f<80;f++){if(f<16)h[f]=0|e[t+f];else{var u=h[f-3]^h[f-8]^h[f-14]^h[f-16];h[f]=u<<1|u>>>31}var c=(n<<5|n>>>27)+a+h[f];c+=f<20?1518500249+(i&o|~i&s):f<40?1859775393+(i^o^s):f<60?(i&o|i&s|o&s)-1894007588:(i^o^s)-899497514,a=s,s=o,o=i<<30|i>>>2,i=n,n=c}r[0]=r[0]+n|0,r[1]=r[1]+i|0,r[2]=r[2]+o|0,r[3]=r[3]+s|0,r[4]=r[4]+a|0},_doFinalize:function(){var e=this._data,t=e.words,r=8*this._nDataBytes,n=8*e.sigBytes;return t[n>>>5]|=128<<24-n%32,t[14+(n+64>>>9<<4)]=Math.floor(r/4294967296),t[15+(n+64>>>9<<4)]=r,e.sigBytes=4*t.length,this._process(),this._hash},clone:function(){var e=i.clone.call(this);return e._hash=this._hash.clone(),e}}),t.SHA1=i._createHelper(s),t.HmacSHA1=i._createHmacHelper(s),e.SHA1},"object"==typeof r?t.exports=r=i(e(47)):i(n.CryptoJS)},{47:47}],54:[function(e,t,r){var a=Array.prototype.slice,f=e(56),u=e(55),c=t.exports=function(e,t,r){return r||(r={}),e===t||(e instanceof Date&&t instanceof Date?e.getTime()===t.getTime():!e||!t||"object"!=typeof e&&"object"!=typeof t?r.strict?e===t:e==t:function(e,t,r){var n,i;if(h(e)||h(t))return!1;if(e.prototype!==t.prototype)return!1;if(u(e))return!!u(t)&&(e=a.call(e),t=a.call(t),c(e,t,r));if(l(e)){if(!l(t))return!1;if(e.length!==t.length)return!1;for(n=0;nr&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},n.prototype.once=function(e,t){if(!f(t))throw TypeError("listener must be a function");var r=!1;function n(){this.removeListener(e,n),r||(r=!0,t.apply(this,arguments))}return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var r,n,i,o;if(!f(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(i=(r=this._events[e]).length,n=-1,r===t||f(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(u(r)){for(o=i;0=this._blockSize;){for(var i=this._blockOffset;i>1,c=-7,h=r?i-1:0,l=r?-1:1,p=e[t+h];for(h+=l,o=p&(1<<-c)-1,p>>=-c,c+=a;0>=-c,c+=n;0>1,l=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,_=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(f=Math.pow(2,-s))<1&&(s--,f*=2),2<=(t+=1<=s+h?l/f:l*Math.pow(2,1-h))*f&&(s++,f/=2),c<=s+h?(a=0,s=c):1<=s+h?(a=(t*f-1)*Math.pow(2,i),s+=h):(a=t*Math.pow(2,h-1)*Math.pow(2,i),s=0));8<=i;e[r+p]=255&a,p+=d,a/=256,i-=8);for(s=s<>>=0)&&e<256)&&(n=s[e])?n:(r=_(e,(0|e)<0?-1:0,!0),i&&(s[e]=r),r):(i=-128<=(e|=0)&&e<128)&&(n=o[e])?n:(r=_(e,e<0?-1:0,!1),i&&(o[e]=r),r)}function d(e,t){if(isNaN(e)||!isFinite(e))return t?f:v;if(t){if(e<0)return f;if(i<=e)return w}else{if(e<=-a)return E;if(a<=e+1)return b}return e<0?d(-e,t).neg():_(e%r|0,e/r|0,t)}function _(e,t,r){return new n(e,t,r)}n.fromInt=e,n.fromNumber=d,n.fromBits=_;var c=Math.pow;function h(e,t,r){if(0===e.length)throw Error("empty string");if("NaN"===e||"Infinity"===e||"+Infinity"===e||"-Infinity"===e)return v;if(t="number"==typeof t?(r=t,!1):!!t,(r=r||10)<2||36>>0:this.low},t.toNumber=function(){return this.unsigned?(this.high>>>0)*r+(this.low>>>0):this.high*r+(this.low>>>0)},t.toString=function(e){if((e=e||10)<2||36>>0).toString(e);if((o=a).isZero())return f+s;for(;f.length<6;)f="0"+f;s=""+f+s}},t.getHighBits=function(){return this.high},t.getHighBitsUnsigned=function(){return this.high>>>0},t.getLowBits=function(){return this.low},t.getLowBitsUnsigned=function(){return this.low>>>0},t.getNumBitsAbs=function(){if(this.isNegative())return this.eq(E)?64:this.neg().getNumBitsAbs();for(var e=0!=this.high?this.high:this.low,t=31;0>>31!=1||e.high>>>31!=1)&&(this.high===e.high&&this.low===e.low)},t.eq=t.equals,t.notEquals=function(e){return!this.eq(e)},t.neq=t.notEquals,t.lessThan=function(e){return this.comp(e)<0},t.lt=t.lessThan,t.lessThanOrEqual=function(e){return this.comp(e)<=0},t.lte=t.lessThanOrEqual,t.greaterThan=function(e){return 0>>0>this.high>>>0||e.high===this.high&&e.low>>>0>this.low>>>0?-1:1:this.sub(e).isNegative()?-1:1},t.comp=t.compare,t.negate=function(){return!this.unsigned&&this.eq(E)?E:this.not().add(u)},t.neg=t.negate,t.add=function(e){p(e)||(e=g(e));var t=this.high>>>16,r=65535&this.high,n=this.low>>>16,i=65535&this.low,o=e.high>>>16,s=65535&e.high,a=e.low>>>16,f=0,u=0,c=0,h=0;return c+=(h+=i+(65535&e.low))>>>16,u+=(c+=n+a)>>>16,f+=(u+=r+s)>>>16,f+=t+o,_((c&=65535)<<16|(h&=65535),(f&=65535)<<16|(u&=65535),this.unsigned)},t.subtract=function(e){return p(e)||(e=g(e)),this.add(e.neg())},t.sub=t.subtract,t.multiply=function(e){if(this.isZero())return v;if(p(e)||(e=g(e)),e.isZero())return v;if(this.eq(E))return e.isOdd()?E:v;if(e.eq(E))return this.isOdd()?E:v;if(this.isNegative())return e.isNegative()?this.neg().mul(e.neg()):this.neg().mul(e).neg();if(e.isNegative())return this.mul(e.neg()).neg();if(this.lt(m)&&e.lt(m))return d(this.toNumber()*e.toNumber(),this.unsigned);var t=this.high>>>16,r=65535&this.high,n=this.low>>>16,i=65535&this.low,o=e.high>>>16,s=65535&e.high,a=e.low>>>16,f=65535&e.low,u=0,c=0,h=0,l=0;return h+=(l+=i*f)>>>16,c+=(h+=n*f)>>>16,h&=65535,c+=(h+=i*a)>>>16,u+=(c+=r*f)>>>16,c&=65535,u+=(c+=n*a)>>>16,c&=65535,u+=(c+=i*s)>>>16,u+=t*f+r*a+n*s+i*o,_((h&=65535)<<16|(l&=65535),(u&=65535)<<16|(c&=65535),this.unsigned)},t.mul=t.multiply,t.divide=function(e){if(p(e)||(e=g(e)),e.isZero())throw Error("division by zero");if(this.isZero())return this.unsigned?f:v;var t,r,n;if(this.unsigned){if(e.unsigned||(e=e.toUnsigned()),e.gt(this))return f;if(e.gt(this.shru(1)))return l;n=f}else{if(this.eq(E))return e.eq(u)||e.eq(y)?E:e.eq(E)?u:(t=this.shr(1).div(e).shl(1)).eq(v)?e.isNegative()?u:y:(r=this.sub(e.mul(t)),n=t.add(r.div(e)));else if(e.eq(E))return this.unsigned?f:v;if(this.isNegative())return e.isNegative()?this.neg().div(e.neg()):this.neg().div(e).neg();if(e.isNegative())return this.div(e.neg()).neg();n=v}for(r=this;r.gte(e);){t=Math.max(1,Math.floor(r.toNumber()/e.toNumber()));for(var i=Math.ceil(Math.log(t)/Math.LN2),o=i<=48?1:c(2,i-48),s=d(t),a=s.mul(e);a.isNegative()||a.gt(r);)a=(s=d(t-=o,this.unsigned)).mul(e);s.isZero()&&(s=u),n=n.add(s),r=r.sub(a)}return n},t.div=t.divide,t.modulo=function(e){return p(e)||(e=g(e)),this.sub(this.div(e).mul(e))},t.mod=t.modulo,t.not=function(){return _(~this.low,~this.high,this.unsigned)},t.and=function(e){return p(e)||(e=g(e)),_(this.low&e.low,this.high&e.high,this.unsigned)},t.or=function(e){return p(e)||(e=g(e)),_(this.low|e.low,this.high|e.high,this.unsigned)},t.xor=function(e){return p(e)||(e=g(e)),_(this.low^e.low,this.high^e.high,this.unsigned)},t.shiftLeft=function(e){return p(e)&&(e=e.toInt()),0==(e&=63)?this:e<32?_(this.low<>>32-e,this.unsigned):_(0,this.low<>>e|this.high<<32-e,this.high>>e,this.unsigned):_(this.high>>e-32,0<=this.high?0:-1,this.unsigned)},t.shr=t.shiftRight,t.shiftRightUnsigned=function(e){if(p(e)&&(e=e.toInt()),0===(e&=63))return this;var t=this.high;return e<32?_(this.low>>>e|t<<32-e,t>>>e,this.unsigned):_(32===e?t:t>>>e-32,0,this.unsigned)},t.shru=t.shiftRightUnsigned,t.toSigned=function(){return this.unsigned?_(this.low,this.high,!1):this},t.toUnsigned=function(){return this.unsigned?this:_(this.low,this.high,!0)},t.toBytes=function(e){return e?this.toBytesLE():this.toBytesBE()},t.toBytesLE=function(){var e=this.high,t=this.low;return[255&t,t>>>8&255,t>>>16&255,t>>>24&255,255&e,e>>>8&255,e>>>16&255,e>>>24&255]},t.toBytesBE=function(){var e=this.high,t=this.low;return[e>>>24&255,e>>>16&255,e>>>8&255,255&e,t>>>24&255,t>>>16&255,t>>>8&255,255&t]},n},"function"==typeof e&&"object"==typeof t&&t&&t.exports?t.exports=i():(n.dcodeIO=n.dcodeIO||{}).Long=i()},{}],69:[function(i,o,e){(function(t){"use strict";var e=i(65),r=i(63),s=new Array(16);function n(){r.call(this,64),this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878}function a(e,t){return e<>>32-t}function f(e,t,r,n,i,o,s){return a(e+(t&r|~t&n)+i+o|0,s)+t|0}function u(e,t,r,n,i,o,s){return a(e+(t&n|r&~n)+i+o|0,s)+t|0}function c(e,t,r,n,i,o,s){return a(e+(t^r^n)+i+o|0,s)+t|0}function h(e,t,r,n,i,o,s){return a(e+(r^(t|~n))+i+o|0,s)+t|0}e(n,r),n.prototype._update=function(){for(var e=s,t=0;t<16;++t)e[t]=this._block.readInt32LE(4*t);var r=this._a,n=this._b,i=this._c,o=this._d;n=h(n=h(n=h(n=h(n=c(n=c(n=c(n=c(n=u(n=u(n=u(n=u(n=f(n=f(n=f(n=f(n,i=f(i,o=f(o,r=f(r,n,i,o,e[0],3614090360,7),n,i,e[1],3905402710,12),r,n,e[2],606105819,17),o,r,e[3],3250441966,22),i=f(i,o=f(o,r=f(r,n,i,o,e[4],4118548399,7),n,i,e[5],1200080426,12),r,n,e[6],2821735955,17),o,r,e[7],4249261313,22),i=f(i,o=f(o,r=f(r,n,i,o,e[8],1770035416,7),n,i,e[9],2336552879,12),r,n,e[10],4294925233,17),o,r,e[11],2304563134,22),i=f(i,o=f(o,r=f(r,n,i,o,e[12],1804603682,7),n,i,e[13],4254626195,12),r,n,e[14],2792965006,17),o,r,e[15],1236535329,22),i=u(i,o=u(o,r=u(r,n,i,o,e[1],4129170786,5),n,i,e[6],3225465664,9),r,n,e[11],643717713,14),o,r,e[0],3921069994,20),i=u(i,o=u(o,r=u(r,n,i,o,e[5],3593408605,5),n,i,e[10],38016083,9),r,n,e[15],3634488961,14),o,r,e[4],3889429448,20),i=u(i,o=u(o,r=u(r,n,i,o,e[9],568446438,5),n,i,e[14],3275163606,9),r,n,e[3],4107603335,14),o,r,e[8],1163531501,20),i=u(i,o=u(o,r=u(r,n,i,o,e[13],2850285829,5),n,i,e[2],4243563512,9),r,n,e[7],1735328473,14),o,r,e[12],2368359562,20),i=c(i,o=c(o,r=c(r,n,i,o,e[5],4294588738,4),n,i,e[8],2272392833,11),r,n,e[11],1839030562,16),o,r,e[14],4259657740,23),i=c(i,o=c(o,r=c(r,n,i,o,e[1],2763975236,4),n,i,e[4],1272893353,11),r,n,e[7],4139469664,16),o,r,e[10],3200236656,23),i=c(i,o=c(o,r=c(r,n,i,o,e[13],681279174,4),n,i,e[0],3936430074,11),r,n,e[3],3572445317,16),o,r,e[6],76029189,23),i=c(i,o=c(o,r=c(r,n,i,o,e[9],3654602809,4),n,i,e[12],3873151461,11),r,n,e[15],530742520,16),o,r,e[2],3299628645,23),i=h(i,o=h(o,r=h(r,n,i,o,e[0],4096336452,6),n,i,e[7],1126891415,10),r,n,e[14],2878612391,15),o,r,e[5],4237533241,21),i=h(i,o=h(o,r=h(r,n,i,o,e[12],1700485571,6),n,i,e[3],2399980690,10),r,n,e[10],4293915773,15),o,r,e[1],2240044497,21),i=h(i,o=h(o,r=h(r,n,i,o,e[8],1873313359,6),n,i,e[15],4264355552,10),r,n,e[6],2734768916,15),o,r,e[13],1309151649,21),i=h(i,o=h(o,r=h(r,n,i,o,e[4],4149444226,6),n,i,e[11],3174756917,10),r,n,e[2],718787259,15),o,r,e[9],3951481745,21),this._a=this._a+r|0,this._b=this._b+n|0,this._c=this._c+i|0,this._d=this._d+o|0},n.prototype._digest=function(){this._block[this._blockOffset++]=128,56this.urls.length-1)return t(new Error("Tried "+(i+1)+" connections, none of which worked: "+JSON.stringify(this.urls.concat(this.url))));var s=function(e,t){return o.logFailure(n),o.connectWithFallback(r,o.urls[i],i+1,e,t)};return e&&t?this.connect(r,n).then(e).catch(function(){s(e,t)}):new Promise(function(e,t){o.connect(r).then(e).catch(function(){s(e,t)})})},n.prototype.checkConnections=function(){var i=0t.highWaterMark&&(t.highWaterMark=(_<=(r=e)?r=_:(r--,r|=r>>>1,r|=r>>>2,r|=r>>>4,r|=r>>>8,r|=r>>>16,r++),r)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0));var r}function E(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(b("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?m.nextTick(B,e):B(e))}function B(e){b("emit readable"),e.emit("readable"),I(e)}function k(e,t){t.readingMore||(t.readingMore=!0,m.nextTick(T,e,t))}function T(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var n;eo.length?o.length:e;if(s===o.length?i+=o:i+=o.slice(0,e),0===(e-=s)){s===o.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r).data=o.slice(s);break}++n}return t.length-=n,i}(e,t):function(e,t){var r=u.allocUnsafe(e),n=t.head,i=1;n.data.copy(r),e-=n.data.length;for(;n=n.next;){var o=n.data,s=e>o.length?o.length:e;if(o.copy(r,r.length-e,0,s),0===(e-=s)){s===o.length?(++i,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n).data=o.slice(s);break}++i}return t.length-=i,r}(e,t);return n}(e,t.buffer,t.decoder),r);var r}function O(e){var t=e._readableState;if(0=t.highWaterMark||t.ended))return b("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?O(this):E(this),null;if(0===(e=w(e,t))&&t.ended)return 0===t.length&&O(this),null;var n,i=t.needReadable;return b("need readable",i),(0===t.length||t.length-e>>0),o=this.head,s=0;o;)t=o.data,r=i,n=s,t.copy(r,n),s+=o.data.length,o=o.next;return i},e}(),n&&n.inspect&&n.inspect.custom&&(t.exports.prototype[n.inspect.custom]=function(){var e=n.inspect({length:this.length});return this.constructor.name+" "+e})},{34:34,93:93}],85:[function(e,t,r){"use strict";var o=e(76);function s(e,t){e.emit("error",t)}t.exports={destroy:function(e,t){var r=this,n=this._readableState&&this._readableState.destroyed,i=this._writableState&&this._writableState.destroyed;return n||i?t?t(e):!e||this._writableState&&this._writableState.errorEmitted||o.nextTick(s,this,e):(this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(e||null,function(e){!t&&e?(o.nextTick(s,r,e),r._writableState&&(r._writableState.errorEmitted=!0)):t&&t(e)})),this},undestroy:function(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}}},{76:76}],86:[function(e,t,r){t.exports=e(62).EventEmitter},{62:62}],87:[function(e,t,r){arguments[4][65][0].apply(r,arguments)},{65:65}],88:[function(e,t,r){t.exports=e(89).PassThrough},{89:89}],89:[function(e,t,r){(((r=t.exports=e(81)).Stream=r).Readable=r).Writable=e(83),r.Duplex=e(79),r.Transform=e(82),r.PassThrough=e(80)},{79:79,80:80,81:81,82:82,83:83}],90:[function(e,t,r){t.exports=e(89).Transform},{89:89}],91:[function(e,t,r){t.exports=e(83)},{83:83}],92:[function(e,t,r){"use strict";var n=e(35).Buffer,i=e(65),o=e(63),g=new Array(16),m=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8,3,10,14,4,9,15,8,1,2,7,0,6,13,11,5,12,1,9,11,10,0,8,12,4,13,3,7,15,14,5,6,2,4,0,5,9,7,12,2,10,14,1,3,8,11,6,15,13],v=[5,14,7,0,9,2,11,4,13,6,15,8,1,10,3,12,6,11,3,7,0,13,5,10,14,15,8,12,4,9,1,2,15,5,1,3,7,14,6,9,11,8,12,2,10,0,4,13,8,6,4,1,3,11,15,0,5,12,2,13,9,7,10,14,12,15,10,4,1,5,8,7,6,2,13,14,0,3,9,11],y=[11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8,7,6,8,13,11,9,7,15,7,12,15,9,11,7,13,12,11,13,6,7,14,9,13,15,14,8,13,6,5,12,7,5,11,12,14,15,14,15,9,8,9,14,5,6,8,6,5,12,9,15,5,11,6,8,13,12,5,12,13,14,11,8,5,6],b=[8,9,9,11,13,15,15,5,7,7,8,11,14,14,12,6,9,13,15,7,12,8,9,11,7,7,12,7,6,15,13,11,9,7,15,11,8,6,6,14,12,13,5,14,13,13,7,5,15,5,8,11,14,14,6,14,6,9,12,9,12,5,15,8,8,5,12,9,12,5,14,6,8,13,6,5,15,13,11,11],w=[0,1518500249,1859775393,2400959708,2840853838],E=[1352829926,1548603684,1836072691,2053994217,0];function s(){o.call(this,64),this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520}function B(e,t){return e<>>32-t}function k(e,t,r,n,i,o,s,a){return B(e+(t^r^n)+o+s|0,a)+i|0}function T(e,t,r,n,i,o,s,a){return B(e+(t&r|~t&n)+o+s|0,a)+i|0}function S(e,t,r,n,i,o,s,a){return B(e+((t|~r)^n)+o+s|0,a)+i|0}function x(e,t,r,n,i,o,s,a){return B(e+(t&n|r&~n)+o+s|0,a)+i|0}function I(e,t,r,n,i,o,s,a){return B(e+(t^(r|~n))+o+s|0,a)+i|0}i(s,o),s.prototype._update=function(){for(var e=g,t=0;t<16;++t)e[t]=this._block.readInt32LE(4*t);for(var r=0|this._a,n=0|this._b,i=0|this._c,o=0|this._d,s=0|this._e,a=0|this._a,f=0|this._b,u=0|this._c,c=0|this._d,h=0|this._e,l=0;l<80;l+=1){var p,d;d=l<16?(p=k(r,n,i,o,s,e[m[l]],w[0],y[l]),I(a,f,u,c,h,e[v[l]],E[0],b[l])):l<32?(p=T(r,n,i,o,s,e[m[l]],w[1],y[l]),x(a,f,u,c,h,e[v[l]],E[1],b[l])):l<48?(p=S(r,n,i,o,s,e[m[l]],w[2],y[l]),S(a,f,u,c,h,e[v[l]],E[2],b[l])):l<64?(p=x(r,n,i,o,s,e[m[l]],w[3],y[l]),T(a,f,u,c,h,e[v[l]],E[3],b[l])):(p=I(r,n,i,o,s,e[m[l]],w[4],y[l]),k(a,f,u,c,h,e[v[l]],E[4],b[l])),r=s,s=o,o=B(i,10),i=n,n=p,a=h,h=c,c=B(u,10),u=f,f=d}var _=this._b+i+c|0;this._b=this._c+o+h|0,this._c=this._d+s+a|0,this._d=this._e+r+f|0,this._e=this._a+n+u|0,this._a=_},s.prototype._digest=function(){this._block[this._blockOffset++]=128,56=this._finalSize&&(this._update(this._block),this._block.fill(0));var r=8*this._len;if(r<=4294967295)this._block.writeUInt32BE(r,this._blockSize-4);else{var n=(4294967295&r)>>>0,i=(r-n)/4294967296;this._block.writeUInt32BE(i,this._blockSize-8),this._block.writeUInt32BE(n,this._blockSize-4)}this._update(this._block);var o=this._hash();return e?o.toString(e):o},n.prototype._update=function(){throw new Error("_update must be implemented by subclass")},t.exports=n},{93:93}],96:[function(e,t,r){(r=t.exports=function(e){e=e.toLowerCase();var t=r[e];if(!t)throw new Error(e+" is not supported (we accept pull requests)");return new t}).sha=e(97),r.sha1=e(98),r.sha224=e(99),r.sha256=e(100),r.sha384=e(101),r.sha512=e(102)},{100:100,101:101,102:102,97:97,98:98,99:99}],97:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,m=[1518500249,1859775393,-1894007588,-899497514],s=new Array(80);function a(){this.init(),this._w=s,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a=this._w,f=0|this._a,u=0|this._b,c=0|this._c,h=0|this._d,l=0|this._e,p=0;p<16;++p)a[p]=e.readInt32BE(4*p);for(;p<80;++p)a[p]=a[p-3]^a[p-8]^a[p-14]^a[p-16];for(var d=0;d<80;++d){var _=~~(d/20),g=0|((s=f)<<5|s>>>27)+(n=u,i=c,o=h,0===(r=_)?n&i|~n&o:2===r?n&i|n&o|i&o:n^i^o)+l+a[d]+m[_];l=h,h=c,c=(t=u)<<30|t>>>2,u=f,f=g}this._a=f+this._a|0,this._b=u+this._b|0,this._c=c+this._c|0,this._d=h+this._d|0,this._e=l+this._e|0},a.prototype._hash=function(){var e=o.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},t.exports=a},{65:65,93:93,95:95}],98:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,v=[1518500249,1859775393,-1894007588,-899497514],s=new Array(80);function a(){this.init(),this._w=s,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a,f=this._w,u=0|this._a,c=0|this._b,h=0|this._c,l=0|this._d,p=0|this._e,d=0;d<16;++d)f[d]=e.readInt32BE(4*d);for(;d<80;++d)f[d]=(t=f[d-3]^f[d-8]^f[d-14]^f[d-16])<<1|t>>>31;for(var _=0;_<80;++_){var g=~~(_/20),m=0|((a=u)<<5|a>>>27)+(i=c,o=h,s=l,0===(n=g)?i&o|~i&s:2===n?i&o|i&s|o&s:i^o^s)+p+f[_]+v[g];p=l,l=h,h=(r=c)<<30|r>>>2,c=u,u=m}this._a=u+this._a|0,this._b=c+this._b|0,this._c=h+this._c|0,this._d=l+this._d|0,this._e=p+this._e|0},a.prototype._hash=function(){var e=o.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},t.exports=a},{65:65,93:93,95:95}],99:[function(e,t,r){var n=e(65),i=e(100),o=e(95),s=e(93).Buffer,a=new Array(64);function f(){this.init(),this._w=a,o.call(this,64,56)}n(f,i),f.prototype.init=function(){return this._a=3238371032,this._b=914150663,this._c=812702999,this._d=4144912697,this._e=4290775857,this._f=1750603025,this._g=1694076839,this._h=3204075428,this},f.prototype._hash=function(){var e=s.allocUnsafe(28);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e},t.exports=f},{100:100,65:65,93:93,95:95}],100:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,w=[1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298],s=new Array(64);function a(){this.init(),this._w=s,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1779033703,this._b=3144134277,this._c=1013904242,this._d=2773480762,this._e=1359893119,this._f=2600822924,this._g=528734635,this._h=1541459225,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a,f=this._w,u=0|this._a,c=0|this._b,h=0|this._c,l=0|this._d,p=0|this._e,d=0|this._f,_=0|this._g,g=0|this._h,m=0;m<16;++m)f[m]=e.readInt32BE(4*m);for(;m<64;++m)f[m]=0|(((r=f[m-2])>>>17|r<<15)^(r>>>19|r<<13)^r>>>10)+f[m-7]+(((t=f[m-15])>>>7|t<<25)^(t>>>18|t<<14)^t>>>3)+f[m-16];for(var v=0;v<64;++v){var y=g+(((a=p)>>>6|a<<26)^(a>>>11|a<<21)^(a>>>25|a<<7))+((s=_)^p&(d^s))+w[v]+f[v]|0,b=0|(((o=u)>>>2|o<<30)^(o>>>13|o<<19)^(o>>>22|o<<10))+((n=u)&(i=c)|h&(n|i));g=_,_=d,d=p,p=l+y|0,l=h,h=c,c=u,u=y+b|0}this._a=u+this._a|0,this._b=c+this._b|0,this._c=h+this._c|0,this._d=l+this._d|0,this._e=p+this._e|0,this._f=d+this._f|0,this._g=_+this._g|0,this._h=g+this._h|0},a.prototype._hash=function(){var e=o.allocUnsafe(32);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e.writeInt32BE(this._h,28),e},t.exports=a},{65:65,93:93,95:95}],101:[function(e,t,r){var n=e(65),i=e(102),o=e(95),s=e(93).Buffer,a=new Array(160);function f(){this.init(),this._w=a,o.call(this,128,112)}n(f,i),f.prototype.init=function(){return this._ah=3418070365,this._bh=1654270250,this._ch=2438529370,this._dh=355462360,this._eh=1731405415,this._fh=2394180231,this._gh=3675008525,this._hh=1203062813,this._al=3238371032,this._bl=914150663,this._cl=812702999,this._dl=4144912697,this._el=4290775857,this._fl=1750603025,this._gl=1694076839,this._hl=3204075428,this},f.prototype._hash=function(){var n=s.allocUnsafe(48);function e(e,t,r){n.writeInt32BE(e,r),n.writeInt32BE(t,r+4)}return e(this._ah,this._al,0),e(this._bh,this._bl,8),e(this._ch,this._cl,16),e(this._dh,this._dl,24),e(this._eh,this._el,32),e(this._fh,this._fl,40),n},t.exports=f},{102:102,65:65,93:93,95:95}],102:[function(e,t,r){var n=e(65),i=e(95),o=e(93).Buffer,ee=[1116352408,3609767458,1899447441,602891725,3049323471,3964484399,3921009573,2173295548,961987163,4081628472,1508970993,3053834265,2453635748,2937671579,2870763221,3664609560,3624381080,2734883394,310598401,1164996542,607225278,1323610764,1426881987,3590304994,1925078388,4068182383,2162078206,991336113,2614888103,633803317,3248222580,3479774868,3835390401,2666613458,4022224774,944711139,264347078,2341262773,604807628,2007800933,770255983,1495990901,1249150122,1856431235,1555081692,3175218132,1996064986,2198950837,2554220882,3999719339,2821834349,766784016,2952996808,2566594879,3210313671,3203337956,3336571891,1034457026,3584528711,2466948901,113926993,3758326383,338241895,168717936,666307205,1188179964,773529912,1546045734,1294757372,1522805485,1396182291,2643833823,1695183700,2343527390,1986661051,1014477480,2177026350,1206759142,2456956037,344077627,2730485921,1290863460,2820302411,3158454273,3259730800,3505952657,3345764771,106217008,3516065817,3606008344,3600352804,1432725776,4094571909,1467031594,275423344,851169720,430227734,3100823752,506948616,1363258195,659060556,3750685593,883997877,3785050280,958139571,3318307427,1322822218,3812723403,1537002063,2003034995,1747873779,3602036899,1955562222,1575990012,2024104815,1125592928,2227730452,2716904306,2361852424,442776044,2428436474,593698344,2756734187,3733110249,3204031479,2999351573,3329325298,3815920427,3391569614,3928383900,3515267271,566280711,3940187606,3454069534,4118630271,4000239992,116418474,1914138554,174292421,2731055270,289380356,3203993006,460393269,320620315,685471733,587496836,852142971,1086792851,1017036298,365543100,1126000580,2618297676,1288033470,3409855158,1501505948,4234509866,1607167915,987167468,1816402316,1246189591],s=new Array(160);function a(){this.init(),this._w=s,i.call(this,128,112)}function te(e,t,r){return r^e&(t^r)}function re(e,t,r){return e&t|r&(e|t)}function ne(e,t){return(e>>>28|t<<4)^(t>>>2|e<<30)^(t>>>7|e<<25)}function ie(e,t){return(e>>>14|t<<18)^(e>>>18|t<<14)^(t>>>9|e<<23)}function oe(e,t){return e>>>0>>0?1:0}n(a,i),a.prototype.init=function(){return this._ah=1779033703,this._bh=3144134277,this._ch=1013904242,this._dh=2773480762,this._eh=1359893119,this._fh=2600822924,this._gh=528734635,this._hh=1541459225,this._al=4089235720,this._bl=2227873595,this._cl=4271175723,this._dl=1595750129,this._el=2917565137,this._fl=725511199,this._gl=4215389547,this._hl=327033209,this},a.prototype._update=function(e){for(var t,r,n,i,o,s,a,f,u=this._w,c=0|this._ah,h=0|this._bh,l=0|this._ch,p=0|this._dh,d=0|this._eh,_=0|this._fh,g=0|this._gh,m=0|this._hh,v=0|this._al,y=0|this._bl,b=0|this._cl,w=0|this._dl,E=0|this._el,B=0|this._fl,k=0|this._gl,T=0|this._hl,S=0;S<32;S+=2)u[S]=e.readInt32BE(4*S),u[S+1]=e.readInt32BE(4*S+4);for(;S<160;S+=2){var x=u[S-30],I=u[S-30+1],A=((a=x)>>>1|(f=I)<<31)^(a>>>8|f<<24)^a>>>7,O=((o=I)>>>1|(s=x)<<31)^(o>>>8|s<<24)^(o>>>7|s<<25);x=u[S-4],I=u[S-4+1];var L=((n=x)>>>19|(i=I)<<13)^(i>>>29|n<<3)^n>>>6,C=((t=I)>>>19|(r=x)<<13)^(r>>>29|t<<3)^(t>>>6|r<<26),R=u[S-14],U=u[S-14+1],j=u[S-32],M=u[S-32+1],D=O+U|0,q=A+R+oe(D,O)|0;q=(q=q+L+oe(D=D+C|0,C)|0)+j+oe(D=D+M|0,M)|0,u[S]=q,u[S+1]=D}for(var P=0;P<160;P+=2){q=u[P],D=u[P+1];var N=re(c,h,l),z=re(v,y,b),F=ne(c,v),H=ne(v,c),V=ie(d,E),Y=ie(E,d),K=ee[P],W=ee[P+1],Z=te(d,_,g),G=te(E,B,k),J=T+Y|0,X=m+V+oe(J,T)|0;X=(X=(X=X+Z+oe(J=J+G|0,G)|0)+K+oe(J=J+W|0,W)|0)+q+oe(J=J+D|0,D)|0;var $=H+z|0,Q=F+N+oe($,H)|0;m=g,T=k,g=_,k=B,_=d,B=E,d=p+X+oe(E=w+J|0,w)|0,p=l,w=b,l=h,b=y,h=c,y=v,c=X+Q+oe(v=J+$|0,J)|0}this._al=this._al+v|0,this._bl=this._bl+y|0,this._cl=this._cl+b|0,this._dl=this._dl+w|0,this._el=this._el+E|0,this._fl=this._fl+B|0,this._gl=this._gl+k|0,this._hl=this._hl+T|0,this._ah=this._ah+c+oe(this._al,v)|0,this._bh=this._bh+h+oe(this._bl,y)|0,this._ch=this._ch+l+oe(this._cl,b)|0,this._dh=this._dh+p+oe(this._dl,w)|0,this._eh=this._eh+d+oe(this._el,E)|0,this._fh=this._fh+_+oe(this._fl,B)|0,this._gh=this._gh+g+oe(this._gl,k)|0,this._hh=this._hh+m+oe(this._hl,T)|0},a.prototype._hash=function(){var n=o.allocUnsafe(64);function e(e,t,r){n.writeInt32BE(e,r),n.writeInt32BE(t,r+4)}return e(this._ah,this._al,0),e(this._bh,this._bl,8),e(this._ch,this._cl,16),e(this._dh,this._dl,24),e(this._eh,this._el,32),e(this._fh,this._fl,40),e(this._gh,this._gl,48),e(this._hh,this._hl,56),n},t.exports=a},{65:65,93:93,95:95}],103:[function(e,t,r){t.exports=n;var c=e(62).EventEmitter;function n(){c.call(this)}e(65)(n,c),n.Readable=e(89),n.Writable=e(91),n.Duplex=e(78),n.Transform=e(90),n.PassThrough=e(88),(n.Stream=n).prototype.pipe=function(t,e){var r=this;function n(e){t.writable&&!1===t.write(e)&&r.pause&&r.pause()}function i(){r.readable&&r.resume&&r.resume()}r.on("data",n),t.on("drain",i),t._isStdio||e&&!1===e.end||(r.on("end",s),r.on("close",a));var o=!1;function s(){o||(o=!0,t.end())}function a(){o||(o=!0,"function"==typeof t.destroy&&t.destroy())}function f(e){if(u(),0===c.listenerCount(this,"error"))throw e}function u(){r.removeListener("data",n),t.removeListener("drain",i),r.removeListener("end",s),r.removeListener("close",a),r.removeListener("error",f),t.removeListener("error",f),r.removeListener("end",u),r.removeListener("close",u),t.removeListener("close",u)}return r.on("error",f),t.on("error",f),r.on("end",u),r.on("close",u),t.on("close",u),t.emit("pipe",r),t}},{62:62,65:65,78:78,88:88,89:89,90:90,91:91}],104:[function(e,t,r){"use strict";var n=e(93).Buffer,i=n.isEncoding||function(e){switch((e=""+e)&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};function o(e){var t;switch(this.encoding=function(e){var t=function(e){if(!e)return"utf8";for(var t;;)switch(e){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return e;default:if(t)return;e=(""+e).toLowerCase(),t=!0}}(e);if("string"!=typeof t&&(n.isEncoding===i||!i(e)))throw new Error("Unknown encoding: "+e);return t||e}(e),this.encoding){case"utf16le":this.text=f,this.end=u,t=4;break;case"utf8":this.fillLast=a,t=4;break;case"base64":this.text=c,this.end=h,t=3;break;default:return this.write=l,void(this.end=p)}this.lastNeed=0,this.lastTotal=0,this.lastChar=n.allocUnsafe(t)}function s(e){return e<=127?0:e>>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function a(e){var t=this.lastTotal-this.lastNeed,r=function(e,t,r){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(1 %s (%d bytes)",i.operation_name,t[1],s,s.length/2)}o.tr_buffer=d.transaction.toBuffer(o)}))})}},{key:"id",value:function(){if(!this.tr_buffer)throw new Error("not finalized");return s.sha256(this.tr_buffer).toString("hex").substring(0,40)}},{key:"add_operation",value:function(e){if(this.tr_buffer)throw new Error("already finalized");if(u(e,"operation"),!Array.isArray(e))throw new Error("Expecting array [operation_id, operation]");this.operations.push(e)}},{key:"get_type_operation",value:function(e,t){if(this.tr_buffer)throw new Error("already finalized");u(e,"name"),u(t,"operation");var r=d[e];u(r,"Unknown operation "+e);var n=i.operations[r.operation_name];if(void 0===n)throw new Error("unknown operation: "+r.operation_name);return t.fee||(t.fee={amount:0,asset_id:0}),"proposal_create"===e&&(t.expiration_time||(t.expiration_time=y()+m.expire_in_secs_proposal)),[n,r.fromObject(t)]}},{key:"set_expire_seconds",value:function(e){if(this.tr_buffer)throw new Error("already finalized");return this.expiration=y()+e}},{key:"propose",value:function(e){if(this.tr_buffer)throw new Error("already finalized");if(!this.operations.length)throw new Error("add operation first");u(e,"proposal_create_options"),u(e.fee_paying_account,"proposal_create_options.fee_paying_account");var t=this.operations.map(function(e){return{op:e}});return this.operations=[],this.signatures=[],this.signer_private_keys=[],e.proposed_ops=t,this.add_type_operation("proposal_create",e),this}},{key:"has_proposed_operation",value:function(){for(var e=!1,t=0;tparseInt(c,10)&&(a=f,u="1.3.0")}var i=[];!function e(t){if(Array.isArray(t))for(var r=0;r>1?o.add(i):o,c=e.pointFromX(f,u),l=c.multiply(i);m(e.isInfinity(l),"nR is not a valid curve point");var h=t.negate().mod(i),d=o.modInverse(i),p=c.multiplyTwo(a,s,h).multiply(d);return e.validate(p),p}t.exports={calcPubKeyRecoveryParam:function(e,t,r,n){for(var i=0;i<4;i++)if(s(e,t,r,i).equals(n))return i;throw new Error("Unable to find valid recovery factor")},deterministicGenerateK:p,recoverPubKey:s,sign:function(r,e,n,t){var i,s,o=h.fromBuffer(e),a=r.n,f=r.G,u=(p(r,e,n,function(e){var t=f.multiply(e);return!r.isInfinity(t)&&0!==(i=t.affineX.mod(a)).signum()&&0!==(s=e.modInverse(a).multiply(o.add(n.multiply(i))).mod(a)).signum()},t),a.shiftRight(1));return 0i.length;)e.writeUint8(0)}}},{key:"public_key",value:function(e,t){if(e){if(!t)return r=n.fixed_data(e,33),i.fromBuffer(r);var r=t.toBuffer();e.append(r.toString("binary"),"binary")}}},{key:"ripemd160",value:function(e,t){if(e)return t?void n.fixed_data(e,20,t):n.fixed_data(e,20)}},{key:"sha256",value:function(e,t){if(e)return t?void n.fixed_data(e,32,t):n.fixed_data(e,32)}},{key:"time_point_sec",value:function(e,t){return t?(t=Math.ceil(t/1e3),void e.writeInt32(t)):(t=e.readInt32(),new Date(1e3*t))}}]),n}();n.exports=t}).call(this,r("buffer").Buffer)},{"../../ecc/src/PublicKey":"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/ecc/src/PublicKey.js",buffer:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/dist/serializer/src/SerializerValidation.js":[function(e,t,r){"use strict";var n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},i=e("bytebuffer").Long,s=e("../../chain/src/ChainTypes"),o=9007199254740991,a=-9007199254740991,f={is_empty:function(e){return null==e},required:function(e){var t=1>=8;for(;0>=8}for(var o=0;e[o]===c&&o>16&255,s[o++]=t>>8&255,s[o++]=255&t;var u,c;2===i&&(t=l[e.charCodeAt(f)]<<2|l[e.charCodeAt(f+1)]>>4,s[o++]=255&t);1===i&&(t=l[e.charCodeAt(f)]<<10|l[e.charCodeAt(f+1)]<<4|l[e.charCodeAt(f+2)]>>2,s[o++]=t>>8&255,s[o++]=255&t);return s},r.fromByteArray=function(e){for(var t,r=e.length,n=r%3,i=[],s=0,o=r-n;s>2]+a[t<<4&63]+"==")):2===n&&(t=(e[r-2]<<8)+e[r-1],i.push(a[t>>10]+a[t>>4&63]+a[t<<2&63]+"="));return i.join("")};for(var a=[],l=[],h="undefined"!=typeof Uint8Array?Uint8Array:Array,n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,s=n.length;i>18&63]+a[i>>12&63]+a[i>>6&63]+a[63&i]);return s.join("")}l["-".charCodeAt(0)]=62,l["_".charCodeAt(0)]=63},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bigi/lib/bigi.js":[function(e,t,r){function w(e,t,r){if(!(this instanceof w))return new w(e,t,r);null!=e&&("number"==typeof e?this.fromNumber(e,t,r):null==t&&"string"!=typeof e?this.fromString(e,256):this.fromString(e,t))}var n=w.prototype;n.__bigi=e("../package.json").version,w.isBigInteger=function(e,t){return e&&e.__bigi&&(!t||e.__bigi===n.__bigi)},w.prototype.am=function(e,t,r,n,i,s){for(;0<=--s;){var o=t*this[e++]+r[n]+i;i=Math.floor(o/67108864),r[n++]=67108863&o}return i},w.prototype.DB=26,w.prototype.DM=67108863;var i=w.prototype.DV=1<<26;w.prototype.FV=Math.pow(2,52),w.prototype.F1=26,w.prototype.F2=0;var s,o,a="0123456789abcdefghijklmnopqrstuvwxyz",f=new Array;for(s="0".charCodeAt(0),o=0;o<=9;++o)f[s++]=o;for(s="a".charCodeAt(0),o=10;o<36;++o)f[s++]=o;for(s="A".charCodeAt(0),o=10;o<36;++o)f[s++]=o;function u(e){return a.charAt(e)}function c(e,t){var r=f[e.charCodeAt(t)];return null==r?-1:r}function y(e){var t=new w;return t.fromInt(e),t}function v(e){var t,r=1;return 0!=(t=e>>>16)&&(e=t,r+=16),0!=(t=e>>8)&&(e=t,r+=8),0!=(t=e>>4)&&(e=t,r+=4),0!=(t=e>>2)&&(e=t,r+=2),0!=(t=e>>1)&&(e=t,r+=1),r}function b(e){this.m=e}function _(e){this.m=e,this.mp=e.invDigit(),this.mpl=32767&this.mp,this.mph=this.mp>>15,this.um=(1<>=16,t+=16),0==(255&e)&&(e>>=8,t+=8),0==(15&e)&&(e>>=4,t+=4),0==(3&e)&&(e>>=2,t+=2),0==(1&e)&&++t,t}function g(e){for(var t=0;0!=e;)e&=e-1,++t;return t}function j(){}function E(e){return e}function B(e){this.r2=new w,this.q3=new w,w.ONE.dlShiftTo(2*e.t,this.r2),this.mu=this.r2.divide(e),this.m=e}b.prototype.convert=function(e){return e.s<0||0<=e.compareTo(this.m)?e.mod(this.m):e},b.prototype.revert=function(e){return e},b.prototype.reduce=function(e){e.divRemTo(this.m,null,e)},b.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},b.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)},_.prototype.convert=function(e){var t=new w;return e.abs().dlShiftTo(this.m.t,t),t.divRemTo(this.m,null,t),e.s<0&&0>15)*this.mpl&this.um)<<15)&e.DM;for(e[r=t+this.m.t]+=this.m.am(0,n,e,t,0,this.m.t);e[r]>=e.DV;)e[r]-=e.DV,e[++r]++}e.clamp(),e.drShiftTo(this.m.t,e),0<=e.compareTo(this.m)&&e.subTo(this.m,e)},_.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},_.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)},n.copyTo=function(e){for(var t=this.t-1;0<=t;--t)e[t]=this[t];e.t=this.t,e.s=this.s},n.fromInt=function(e){this.t=1,this.s=e<0?-1:0,0n.DB?(n[n.t-1]|=(a&(1<>n.DB-o):n[n.t-1]|=a<=n.DB&&(o-=n.DB))}8==r&&0!=(128&e[0])&&(n.s=-1,0>s|f,f=(n[r]&o)<=r.t)t.t=0;else{var i=e%r.DB,s=r.DB-i,o=(1<>i;for(var a=n+1;a>i;0>=r.DB;if(e.t>=r.DB;i+=r.s}else{for(i+=r.s;n>=r.DB;i-=e.s}t.s=i<0?-1:0,i<-1?t[n++]=r.DV+i:0=t.DV&&(e[r+t.t]-=t.DV,e[r+t.t+1]=1)}0>n.F2:0),d=n.FV/h,p=(1<>f)&&(s=!0,o=u(n));0<=a;)f>(f+=r.DB-t)):(n=r[a]>>(f-=t)&i,f<=0&&(f+=r.DB,--a)),0>3},n.mod=function(e){var t=new w;return this.abs().divRemTo(e,null,t),this.s<0&&02*this.m.t)return e.mod(this.m);if(e.compareTo(this.m)<0)return e;var t=new w;return e.copyTo(t),this.reduce(t),t},B.prototype.revert=function(e){return e},B.prototype.reduce=function(e){var t=this;for(e.drShiftTo(t.m.t-1,t.r2),e.t>t.m.t+1&&(e.t=t.m.t+1,e.clamp()),t.mu.multiplyUpperTo(t.r2,t.m.t+1,t.q3),t.m.multiplyLowerTo(t.q3,t.m.t+1,t.r2);e.compareTo(t.r2)<0;)e.dAddOffset(1,t.m.t+1);for(e.subTo(t.r2,e);0<=e.compareTo(t.m);)e.subTo(t.m,e)},B.prototype.mulTo=function(e,t,r){e.multiplyTo(t,r),this.reduce(r)},B.prototype.sqrTo=function(e,t){e.squareTo(t),this.reduce(t)};var x=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997],U=(1<<26)/x[x.length-1];n.chunkSize=function(e){return Math.floor(Math.LN2*this.DB/Math.log(e))},n.toRadix=function(e){if(null==e&&(e=10),0==this.signum()||e<2||36=n&&(r.dMultiply(i),r.dAddOffset(a,0),a=o=0))}0e&&n.subTo(w.ONE.shiftLeft(e-1),n);else{var i=new Array,s=7&e;i.length=1+(e>>3),t.nextBytes(i),0>=r.DB;if(e.t>=r.DB;i+=r.s}else{for(i+=r.s;n>=r.DB;i+=e.s}t.s=i<0?-1:0,0=this.DV;)this[t]-=this.DV,++t>=this.t&&(this[this.t++]=0),++this[t]}},n.multiplyLowerTo=function(e,t,r){var n,i=Math.min(this.t+e.t,t);for(r.s=0,r.t=i;0>1)&&(e=x.length);for(var i=new w(null),s=[],o=0;o>24},n.shortValue=function(){return 0==this.t?this.s:this[0]<<16>>16},n.signum=function(){return this.s<0?-1:this.t<=0||1==this.t&&this[0]<=0?0:1},n.toByteArray=function(){var e=this,t=e.t,r=new Array;r[0]=e.s;var n,i=e.DB-t*e.DB%8,s=0;if(0>i)!=(e.s&e.DM)>>i&&(r[s++]=n|e.s<>(i+=e.DB-8)):(n=e[t]>>(i-=8)&255,i<=0&&(i+=e.DB,--t)),0!=(128&n)&&(n|=-256),0===s&&(128&e.s)!=(128&n)&&++s,(0=this.t?0!=this.s:0!=(this[t]&1<>i-f&u:(l=(e[d]&(1<>this.DB+i-f)),a=r;0==(1&l);)l>>=1,--a;if((i-=a)<0&&(i+=this.DB,--d),p)o[l].copyTo(s),p=!1;else{for(;1=r())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+r().toString(16)+" bytes");return 0|e}function d(e,t){if(l.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return C(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return R(e).length;default:if(n)return C(e).length;t=(""+t).toLowerCase(),n=!0}}function p(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function m(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):2147483647=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=l.from(t,n)),l.isBuffer(t))return 0===t.length?-1:y(e,t,r,n,i);if("number"==typeof t)return t&=255,l.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):y(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function y(e,t,r,n,i){var s,o=1,a=e.length,f=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;a/=o=2,f/=2,r/=2}function u(e,t){return 1===o?e[t]:e.readUInt16BE(t*o)}if(i){var c=-1;for(s=r;s>>10&1023|55296),c=56320|1023&c),n.push(c),i+=l}return function(e){var t=e.length;if(t<=v)return String.fromCharCode.apply(String,e);var r="",n=0;for(;nthis.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return B(this,t,r);case"utf8":case"utf-8":return w(this,t,r);case"ascii":return j(this,t,r);case"latin1":case"binary":return E(this,t,r);case"base64":return g(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return x(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}.apply(this,arguments)},l.prototype.equals=function(e){if(!l.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===l.compare(this,e)},l.prototype.inspect=function(){var e="",t=q.INSPECT_MAX_BYTES;return 0t&&(e+=" ... ")),""},l.prototype.compare=function(e,t,r,n,i){if(!l.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(i<=n&&r<=t)return 0;if(i<=n)return-1;if(r<=t)return 1;if(this===e)return 0;for(var s=(i>>>=0)-(n>>>=0),o=(r>>>=0)-(t>>>=0),a=Math.min(s,o),f=this.slice(n,i),u=e.slice(t,r),c=0;cthis.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var s,o,a,f,u,c,l,h,d,p=!1;;)switch(n){case"hex":return b(this,e,t,r);case"utf8":case"utf-8":return h=t,d=r,P(C(e,(l=this).length-h),l,h,d);case"ascii":return _(this,e,t,r);case"latin1":case"binary":return _(this,e,t,r);case"base64":return f=this,u=t,c=r,P(R(e),f,u,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return o=t,a=r,P(function(e,t){for(var r,n,i,s=[],o=0;o>8,i=r%256,s.push(i),s.push(n);return s}(e,(s=this).length-o),s,o,a);default:if(p)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),p=!0}},l.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var v=4096;function j(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;ie.length)throw new RangeError("Index out of range")}function D(e,t,r,n){t<0&&(t=65535+t+1);for(var i=0,s=Math.min(e.length-r,2);i>>8*(n?i:1-i)}function T(e,t,r,n){t<0&&(t=4294967295+t+1);for(var i=0,s=Math.min(e.length-r,4);i>>8*(n?i:3-i)&255}function S(e,t,r,n,i,s){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function I(e,t,r,n,i){return i||S(e,0,r,4),s.write(e,t,r,n,23,4),r+4}function A(e,t,r,n,i){return i||S(e,0,r,8),s.write(e,t,r,n,52,8),r+8}l.prototype.slice=function(e,t){var r,n=this.length;if((e=~~e)<0?(e+=n)<0&&(e=0):n>>8):D(this,e,t,!0),t+2},l.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,2,65535,0),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):D(this,e,t,!1),t+2},l.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,4,4294967295,0),l.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):T(this,e,t,!0),t+4},l.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,4,4294967295,0),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):T(this,e,t,!1),t+4},l.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);k(this,e,t,r,i-1,-i)}var s=0,o=1,a=0;for(this[t]=255&e;++s>0)-a&255;return t+r},l.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);k(this,e,t,r,i-1,-i)}var s=r-1,o=1,a=0;for(this[t+s]=255&e;0<=--s&&(o*=256);)e<0&&0===a&&0!==this[t+s+1]&&(a=1),this[t+s]=(e/o>>0)-a&255;return t+r},l.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,1,127,-128),l.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},l.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,2,32767,-32768),l.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):D(this,e,t,!0),t+2},l.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,2,32767,-32768),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):D(this,e,t,!1),t+2},l.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,4,2147483647,-2147483648),l.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):T(this,e,t,!0),t+4},l.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||k(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):T(this,e,t,!1),t+4},l.prototype.writeFloatLE=function(e,t,r){return I(this,e,t,!0,r)},l.prototype.writeFloatBE=function(e,t,r){return I(this,e,t,!1,r)},l.prototype.writeDoubleLE=function(e,t,r){return A(this,e,t,!0,r)},l.prototype.writeDoubleBE=function(e,t,r){return A(this,e,t,!1,r)},l.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),0=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(s=t;s>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;s.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;s.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return s}function R(e){return n.toByteArray(function(e){var t;if((e=(t=e,t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")).replace(O,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function P(e,t,r,n){for(var i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"base64-js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/base64-js/index.js",ieee754:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ieee754/index.js",isarray:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/isarray/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/string_decoder/index.js":[function(e,t,r){var n=e("buffer").Buffer,i=n.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};var s=r.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),function(e){if(e&&!i(e))throw new Error("Unknown encoding: "+e)}(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=a;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=f;break;default:return void(this.write=o)}this.charBuffer=new n(6),this.charReceived=0,this.charLength=0};function o(e){return e.toString(this.encoding)}function a(e){this.charReceived=e.length%2,this.charLength=this.charReceived?2:0}function f(e){this.charReceived=e.length%3,this.charLength=this.charReceived?3:0}s.prototype.write=function(e){for(var t="";this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived>5==6){this.charLength=2;break}if(t<=2&&r>>4==14){this.charLength=3;break}if(t<=3&&r>>3==30){this.charLength=4;break}}this.charReceived=t},s.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;t+=n.slice(0,r).toString(i)}return t}},{buffer:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browserify/node_modules/buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bs58/index.js":[function(e,t,r){var n=e("base-x");t.exports=n("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")},{"base-x":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/base-x/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/bytebuffer/dist/bytebuffer.js":[function(t,e,r){var n,i;n=this,i=function(f){"use strict";var p=function(e,t,r){if(void 0===e&&(e=p.DEFAULT_CAPACITY),void 0===t&&(t=p.DEFAULT_ENDIAN),void 0===r&&(r=p.DEFAULT_NOASSERT),!r){if((e|=0)<0)throw RangeError("Illegal capacity");t=!!t,r=!!r}this.buffer=0===e?s:new ArrayBuffer(e),this.view=0===e?null:new Uint8Array(this.buffer),this.offset=0,this.markedOffset=-1,this.limit=e,this.littleEndian=t,this.noAssert=r};p.VERSION="5.0.1",p.LITTLE_ENDIAN=!0,p.BIG_ENDIAN=!1,p.DEFAULT_CAPACITY=16,p.DEFAULT_ENDIAN=p.BIG_ENDIAN,p.DEFAULT_NOASSERT=!1,p.Long=f||null;var o=p.prototype;o.__isByteBuffer__,Object.defineProperty(o,"__isByteBuffer__",{value:!0,enumerable:!1,configurable:!1});var s=new ArrayBuffer(0),r=String.fromCharCode;function a(e){var t=0;return function(){return t>1,c=-7,l=r?i-1:0,h=r?-1:1,d=e[t+l];for(l+=h,s=d&(1<<-c)-1,d>>=-c,c+=a;0>=-c,c+=n;0>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,d=n?0:s-1,p=n?1:-1,m=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,o=c):(o=Math.floor(Math.log(t)/Math.LN2),t*(f=Math.pow(2,-o))<1&&(o--,f*=2),2<=(t+=1<=o+l?h/f:h*Math.pow(2,1-l))*f&&(o++,f/=2),c<=o+l?(a=0,o=c):1<=o+l?(a=(t*f-1)*Math.pow(2,i),o+=l):(a=t*Math.pow(2,l-1)*Math.pow(2,i),o=0));8<=i;e[r+d]=255&a,d+=p,a/=256,i-=8);for(o=o<>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=t,s=e.length,o=s>>3,a=0;for(t+=this.writeVarint32(s,t);o--;)n=1&!!e[a++]|(1&!!e[a++])<<1|(1&!!e[a++])<<2|(1&!!e[a++])<<3|(1&!!e[a++])<<4|(1&!!e[a++])<<5|(1&!!e[a++])<<6|(1&!!e[a++])<<7,this.writeByte(n,t++);if(a>3,o=0,a=[];for(e+=n.length;s--;)r=this.readByte(e++),a[o++]=!!(1&r),a[o++]=!!(2&r),a[o++]=!!(4&r),a[o++]=!!(8&r),a[o++]=!!(16&r),a[o++]=!!(32&r),a[o++]=!!(64&r),a[o++]=!!(128&r);if(o>f++&1)}return t&&(this.offset=e),a},o.readBytes=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+e>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+"+e+") <= "+this.buffer.byteLength)}var n=this.slice(t,t+e);return r&&(this.offset+=e),n},o.writeBytes=o.append,o.writeInt8=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=1;var n=this.buffer.byteLength;return nt?n:t),t-=1,this.view[t]=e,r&&(this.offset+=1),this},o.writeByte=o.writeInt8,o.readInt8=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=this.view[e];return 128==(128&r)&&(r=-(255-r+1)),t&&(this.offset+=1),r},o.readByte=o.readInt8,o.writeUint8=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=1;var n=this.buffer.byteLength;return nt?n:t),t-=1,this.view[t]=e,r&&(this.offset+=1),this},o.writeUInt8=o.writeUint8,o.readUint8=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=this.view[e];return t&&(this.offset+=1),r},o.readUInt8=o.readUint8,o.writeInt16=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=2;var n=this.buffer.byteLength;return nt?n:t),t-=2,this.littleEndian?(this.view[t+1]=(65280&e)>>>8,this.view[t]=255&e):(this.view[t]=(65280&e)>>>8,this.view[t+1]=255&e),r&&(this.offset+=2),this},o.writeShort=o.writeInt16,o.readInt16=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+2>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+2) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e],r|=this.view[e+1]<<8):(r=this.view[e]<<8,r|=this.view[e+1]),32768==(32768&r)&&(r=-(65535-r+1)),t&&(this.offset+=2),r},o.readShort=o.readInt16,o.writeUint16=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=2;var n=this.buffer.byteLength;return nt?n:t),t-=2,this.littleEndian?(this.view[t+1]=(65280&e)>>>8,this.view[t]=255&e):(this.view[t]=(65280&e)>>>8,this.view[t+1]=255&e),r&&(this.offset+=2),this},o.writeUInt16=o.writeUint16,o.readUint16=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+2>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+2) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e],r|=this.view[e+1]<<8):(r=this.view[e]<<8,r|=this.view[e+1]),t&&(this.offset+=2),r},o.readUInt16=o.readUint16,o.writeInt32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,this.littleEndian?(this.view[t+3]=e>>>24&255,this.view[t+2]=e>>>16&255,this.view[t+1]=e>>>8&255,this.view[t]=255&e):(this.view[t]=e>>>24&255,this.view[t+1]=e>>>16&255,this.view[t+2]=e>>>8&255,this.view[t+3]=255&e),r&&(this.offset+=4),this},o.writeInt=o.writeInt32,o.readInt32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0):(r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0),r|=0,t&&(this.offset+=4),r},o.readInt=o.readInt32,o.writeUint32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,this.littleEndian?(this.view[t+3]=e>>>24&255,this.view[t+2]=e>>>16&255,this.view[t+1]=e>>>8&255,this.view[t]=255&e):(this.view[t]=e>>>24&255,this.view[t+1]=e>>>16&255,this.view[t+2]=e>>>8&255,this.view[t+3]=255&e),r&&(this.offset+=4),this},o.writeUInt32=o.writeUint32,o.readUint32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=0;return this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0):(r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0),t&&(this.offset+=4),r},o.readUInt32=o.readUint32,f&&(o.writeInt64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e)),t+=8;var n=this.buffer.byteLength;nt?n:t),t-=8;var i=e.low,s=e.high;return this.littleEndian?(this.view[t+3]=i>>>24&255,this.view[t+2]=i>>>16&255,this.view[t+1]=i>>>8&255,this.view[t]=255&i,t+=4,this.view[t+3]=s>>>24&255,this.view[t+2]=s>>>16&255,this.view[t+1]=s>>>8&255,this.view[t]=255&s):(this.view[t]=s>>>24&255,this.view[t+1]=s>>>16&255,this.view[t+2]=s>>>8&255,this.view[t+3]=255&s,t+=4,this.view[t]=i>>>24&255,this.view[t+1]=i>>>16&255,this.view[t+2]=i>>>8&255,this.view[t+3]=255&i),r&&(this.offset+=8),this},o.writeLong=o.writeInt64,o.readInt64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=0,n=0;this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0,e+=4,n=this.view[e+2]<<16,n|=this.view[e+1]<<8,n|=this.view[e],n+=this.view[e+3]<<24>>>0):(n=this.view[e+1]<<16,n|=this.view[e+2]<<8,n|=this.view[e+3],n+=this.view[e]<<24>>>0,e+=4,r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0);var i=new f(r,n,!1);return t&&(this.offset+=8),i},o.readLong=o.readInt64,o.writeUint64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e)),t+=8;var n=this.buffer.byteLength;nt?n:t),t-=8;var i=e.low,s=e.high;return this.littleEndian?(this.view[t+3]=i>>>24&255,this.view[t+2]=i>>>16&255,this.view[t+1]=i>>>8&255,this.view[t]=255&i,t+=4,this.view[t+3]=s>>>24&255,this.view[t+2]=s>>>16&255,this.view[t+1]=s>>>8&255,this.view[t]=255&s):(this.view[t]=s>>>24&255,this.view[t+1]=s>>>16&255,this.view[t+2]=s>>>8&255,this.view[t+3]=255&s,t+=4,this.view[t]=i>>>24&255,this.view[t+1]=i>>>16&255,this.view[t+2]=i>>>8&255,this.view[t+3]=255&i),r&&(this.offset+=8),this},o.writeUInt64=o.writeUint64,o.readUint64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=0,n=0;this.littleEndian?(r=this.view[e+2]<<16,r|=this.view[e+1]<<8,r|=this.view[e],r+=this.view[e+3]<<24>>>0,e+=4,n=this.view[e+2]<<16,n|=this.view[e+1]<<8,n|=this.view[e],n+=this.view[e+3]<<24>>>0):(n=this.view[e+1]<<16,n|=this.view[e+2]<<8,n|=this.view[e+3],n+=this.view[e]<<24>>>0,e+=4,r=this.view[e+1]<<16,r|=this.view[e+2]<<8,r|=this.view[e+3],r+=this.view[e]<<24>>>0);var i=new f(r,n,!0);return t&&(this.offset+=8),i},o.readUInt64=o.readUint64),o.writeFloat32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e)throw TypeError("Illegal value: "+e+" (not a number)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=4;var n=this.buffer.byteLength;return nt?n:t),t-=4,i(this.view,e,t,this.littleEndian,23,4),r&&(this.offset+=4),this},o.writeFloat=o.writeFloat32,o.readFloat32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=n(this.view,e,this.littleEndian,23,4);return t&&(this.offset+=4),r},o.readFloat=o.readFloat32,o.writeFloat64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e)throw TypeError("Illegal value: "+e+" (not a number)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}t+=8;var n=this.buffer.byteLength;return nt?n:t),t-=8,i(this.view,e,t,this.littleEndian,52,8),r&&(this.offset+=8),this},o.writeDouble=o.writeFloat64,o.readFloat64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+8>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+8) <= "+this.buffer.byteLength)}var r=n(this.view,e,this.littleEndian,52,8);return t&&(this.offset+=8),r},o.readDouble=o.readFloat64,p.MAX_VARINT32_BYTES=5,p.calculateVarint32=function(e){return(e>>>=0)<128?1:e<16384?2:e<1<<21?3:e<1<<28?4:5},p.zigZagEncode32=function(e){return((e|=0)<<1^e>>31)>>>0},p.zigZagDecode32=function(e){return e>>>1^-(1&e)|0},o.writeVarint32=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal value: "+e+" (not an integer)");if(e|=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=p.calculateVarint32(e);t+=i;var s=this.buffer.byteLength;for(st?s:t),t-=i,e>>>=0;128<=e;)n=127&e|128,this.view[t++]=n,e>>>=7;return this.view[t++]=e,r?(this.offset=t,this):i},o.writeVarint32ZigZag=function(e,t){return this.writeVarint32(p.zigZagEncode32(e),t)},o.readVarint32=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r,n=0,i=0;do{if(!this.noAssert&&e>this.limit){var s=Error("Truncated");throw s.truncated=!0,s}r=this.view[e++],n<5&&(i|=(127&r)<<7*n),++n}while(0!=(128&r));return i|=0,t?(this.offset=e,i):{value:i,length:n}},o.readVarint32ZigZag=function(e){var t=this.readVarint32(e);return"object"==typeof t?t.value=p.zigZagDecode32(t.value):t=p.zigZagDecode32(t),t},f&&(p.MAX_VARINT64_BYTES=10,p.calculateVarint64=function(e){"number"==typeof e?e=f.fromNumber(e):"string"==typeof e&&(e=f.fromString(e));var t=e.toInt()>>>0,r=e.shiftRightUnsigned(28).toInt()>>>0,n=e.shiftRightUnsigned(56).toInt()>>>0;return 0==n?0==r?t<16384?t<128?1:2:t<1<<21?3:4:r<16384?r<128?5:6:r<1<<21?7:8:n<128?9:10},p.zigZagEncode64=function(e){return"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned()),e.shiftLeft(1).xor(e.shiftRight(63)).toUnsigned()},p.zigZagDecode64=function(e){return"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned()),e.shiftRightUnsigned(1).xor(e.and(f.ONE).toSigned().negate()).toSigned()},o.writeVarint64=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("number"==typeof e)e=f.fromNumber(e);else if("string"==typeof e)e=f.fromString(e);else if(!(e&&e instanceof f))throw TypeError("Illegal value: "+e+" (not an integer or Long)");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}"number"==typeof e?e=f.fromNumber(e,!1):"string"==typeof e?e=f.fromString(e,!1):!1!==e.unsigned&&(e=e.toSigned());var n=p.calculateVarint64(e),i=e.toInt()>>>0,s=e.shiftRightUnsigned(28).toInt()>>>0,o=e.shiftRightUnsigned(56).toInt()>>>0;t+=n;var a=this.buffer.byteLength;switch(at?a:t),t-=n,n){case 10:this.view[t+9]=o>>>7&1;case 9:this.view[t+8]=9!==n?128|o:127&o;case 8:this.view[t+7]=8!==n?s>>>21|128:s>>>21&127;case 7:this.view[t+6]=7!==n?s>>>14|128:s>>>14&127;case 6:this.view[t+5]=6!==n?s>>>7|128:s>>>7&127;case 5:this.view[t+4]=5!==n?128|s:127&s;case 4:this.view[t+3]=4!==n?i>>>21|128:i>>>21&127;case 3:this.view[t+2]=3!==n?i>>>14|128:i>>>14&127;case 2:this.view[t+1]=2!==n?i>>>7|128:i>>>7&127;case 1:this.view[t]=1!==n?128|i:127&i}return r?(this.offset+=n,this):n},o.writeVarint64ZigZag=function(e,t){return this.writeVarint64(p.zigZagEncode64(e),t)},o.readVarint64=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=e,n=0,i=0,s=0,o=0;if(n=127&(o=this.view[e++]),128&o&&(n|=(127&(o=this.view[e++]))<<7,(128&o||this.noAssert&&void 0===o)&&(n|=(127&(o=this.view[e++]))<<14,(128&o||this.noAssert&&void 0===o)&&(n|=(127&(o=this.view[e++]))<<21,(128&o||this.noAssert&&void 0===o)&&(i=127&(o=this.view[e++]),(128&o||this.noAssert&&void 0===o)&&(i|=(127&(o=this.view[e++]))<<7,(128&o||this.noAssert&&void 0===o)&&(i|=(127&(o=this.view[e++]))<<14,(128&o||this.noAssert&&void 0===o)&&(i|=(127&(o=this.view[e++]))<<21,(128&o||this.noAssert&&void 0===o)&&(s=127&(o=this.view[e++]),(128&o||this.noAssert&&void 0===o)&&(s|=(127&(o=this.view[e++]))<<7,128&o||this.noAssert&&void 0===o))))))))))throw Error("Buffer overrun");var a=f.fromBits(n|i<<28,i>>>4|s<<24,!1);return t?(this.offset=e,a):{value:a,length:e-r}},o.readVarint64ZigZag=function(e){var t=this.readVarint64(e);return t&&t.value instanceof f?t.value=p.zigZagDecode64(t.value):t=p.zigZagDecode64(t),t}),o.writeCString=function(e,t){var r=void 0===t;r&&(t=this.offset);var n,i=e.length;if(!this.noAssert){if("string"!=typeof e)throw TypeError("Illegal str: Not a string");for(n=0;n>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}i=h.calculateUTF16asUTF8(a(e))[1],t+=i+1;var s=this.buffer.byteLength;return st?s:t),t-=i+1,h.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),this.view[t++]=0,r?(this.offset=t,this):i},o.readCString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r,n=e,i=-1;return h.decodeUTF8toUTF16(function(){if(0===i)return null;if(e>=this.limit)throw RangeError("Illegal range: Truncated data, "+e+" < "+this.limit);return 0===(i=this.view[e++])?null:i}.bind(this),r=u(),!0),t?(this.offset=e,r()):{string:r(),length:e-n}},o.writeIString=function(e,t){var r=void 0===t;if(r&&(t=this.offset),!this.noAssert){if("string"!=typeof e)throw TypeError("Illegal str: Not a string");if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i=t;n=h.calculateUTF16asUTF8(a(e),this.noAssert)[1],t+=4+n;var s=this.buffer.byteLength;if(st?s:t),t-=4+n,this.littleEndian?(this.view[t+3]=n>>>24&255,this.view[t+2]=n>>>16&255,this.view[t+1]=n>>>8&255,this.view[t]=255&n):(this.view[t]=n>>>24&255,this.view[t+1]=n>>>16&255,this.view[t+2]=n>>>8&255,this.view[t+3]=255&n),t+=4,h.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),t!==i+4+n)throw RangeError("Illegal range: Truncated data, "+t+" == "+(t+4+n));return r?(this.offset=t,this):t-i},o.readIString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+4>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+4) <= "+this.buffer.byteLength)}var r=e,n=this.readUint32(e),i=this.readUTF8String(n,p.METRICS_BYTES,e+=4);return e+=i.length,t?(this.offset=e,i.string):{string:i.string,length:e-r}},p.METRICS_CHARS="c",p.METRICS_BYTES="b",o.writeUTF8String=function(e,t){var r,n=void 0===t;if(n&&(t=this.offset),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: "+t+" (not an integer)");if((t>>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var i=t;r=h.calculateUTF16asUTF8(a(e))[1],t+=r;var s=this.buffer.byteLength;return st?s:t),t-=r,h.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),n?(this.offset=t,this):t-i},o.writeString=o.writeUTF8String,p.calculateUTF8Chars=function(e){return h.calculateUTF16asUTF8(a(e))[0]},p.calculateUTF8Bytes=function(e){return h.calculateUTF16asUTF8(a(e))[1]},p.calculateString=p.calculateUTF8Bytes,o.readUTF8String=function(e,t,r){"number"==typeof t&&(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),void 0===t&&(t=p.METRICS_CHARS),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal length: "+e+" (not an integer)");if(e|=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}var i,s=0,o=r;if(t===p.METRICS_CHARS){if(i=u(),h.decodeUTF8(function(){return s>>=0)<0||r+e>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+"+e+") <= "+this.buffer.byteLength)}var a=r+e;if(h.decodeUTF8toUTF16(function(){return r>>=0)<0||t+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+t+" (+0) <= "+this.buffer.byteLength)}var n,i,s=t;n=h.calculateUTF16asUTF8(a(e),this.noAssert)[1],i=p.calculateVarint32(n),t+=i+n;var o=this.buffer.byteLength;if(ot?o:t),t-=i+n,t+=this.writeVarint32(n,t),h.encodeUTF16toUTF8(a(e),function(e){this.view[t++]=e}.bind(this)),t!==s+n+i)throw RangeError("Illegal range: Truncated data, "+t+" == "+(t+n+i));return r?(this.offset=t,this):t-s},o.readVString=function(e){var t=void 0===e;if(t&&(e=this.offset),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal offset: "+e+" (not an integer)");if((e>>>=0)<0||e+1>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+1) <= "+this.buffer.byteLength)}var r=e,n=this.readVarint32(e),i=this.readUTF8String(n.value,p.METRICS_BYTES,e+=n.length);return e+=i.length,t?(this.offset=e,i.string):{string:i.string,length:e-r}},o.append=function(e,t,r){"number"!=typeof t&&"string"==typeof t||(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),!this.noAssert){if("number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}e instanceof p||(e=p.wrap(e,t));var i=e.limit-e.offset;if(i<=0)return this;r+=i;var s=this.buffer.byteLength;return sr?s:r),r-=i,this.view.set(e.view.subarray(e.offset,e.limit),r),e.offset+=i,n&&(this.offset+=i),this},o.appendTo=function(e,t){return e.append(this,t),this},o.assert=function(e){return this.noAssert=!e,this},o.capacity=function(){return this.buffer.byteLength},o.clear=function(){return this.offset=0,this.limit=this.buffer.byteLength,this.markedOffset=-1,this},o.clone=function(e){var t=new p(0,this.littleEndian,this.noAssert);return t.view=e?(t.buffer=new ArrayBuffer(this.buffer.byteLength),new Uint8Array(t.buffer)):(t.buffer=this.buffer,this.view),t.offset=this.offset,t.markedOffset=this.markedOffset,t.limit=this.limit,t},o.compact=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}if(0===e&&t===this.buffer.byteLength)return this;var r=t-e;if(0===r)return this.buffer=s,this.view=null,0<=this.markedOffset&&(this.markedOffset-=e),this.offset=0,this.limit=0,this;var n=new ArrayBuffer(r),i=new Uint8Array(n);return i.set(this.view.subarray(e,t)),this.buffer=n,this.view=i,0<=this.markedOffset&&(this.markedOffset-=e),this.offset=0,this.limit=r,this},o.copy=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}if(e===t)return new p(0,this.littleEndian,this.noAssert);var r=t-e,n=new p(r,this.littleEndian,this.noAssert);return n.offset=0,n.limit=r,0<=n.markedOffset&&(n.markedOffset-=e),this.copyTo(n,0,e,t),n},o.copyTo=function(e,t,r,n){var i,s;if(!this.noAssert&&!p.isByteBuffer(e))throw TypeError("Illegal target: Not a ByteBuffer");if(t=(s=void 0===t)?e.offset:0|t,r=(i=void 0===r)?this.offset:0|r,n=void 0===n?this.limit:0|n,t<0||t>e.buffer.byteLength)throw RangeError("Illegal target range: 0 <= "+t+" <= "+e.buffer.byteLength);if(r<0||n>this.buffer.byteLength)throw RangeError("Illegal source range: 0 <= "+r+" <= "+this.buffer.byteLength);var o=n-r;return 0===o?e:(e.ensureCapacity(t+o),e.view.set(this.view.subarray(r,n),t),i&&(this.offset+=o),s&&(e.offset+=o),this)},o.ensureCapacity=function(e){var t=this.buffer.byteLength;return te?t:e):this},o.fill=function(e,t,r){var n=void 0===t;if(n&&(t=this.offset),"string"==typeof e&&0>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal end: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}if(r<=t)return this;for(;t>>=0)<0||e+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+e+" (+0) <= "+this.buffer.byteLength)}return this.markedOffset=e,this},o.order=function(e){if(!this.noAssert&&"boolean"!=typeof e)throw TypeError("Illegal littleEndian: Not a boolean");return this.littleEndian=!!e,this},o.LE=function(e){return this.littleEndian=void 0===e||!!e,this},o.BE=function(e){return this.littleEndian=void 0!==e&&!e,this},o.prepend=function(e,t,r){"number"!=typeof t&&"string"==typeof t||(r=t,t=void 0);var n=void 0===r;if(n&&(r=this.offset),!this.noAssert){if("number"!=typeof r||r%1!=0)throw TypeError("Illegal offset: "+r+" (not an integer)");if((r>>>=0)<0||r+0>this.buffer.byteLength)throw RangeError("Illegal offset: 0 <= "+r+" (+0) <= "+this.buffer.byteLength)}e instanceof p||(e=p.wrap(e,t));var i=e.limit-e.offset;if(i<=0)return this;var s=i-r;if(0>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}return e===t||Array.prototype.reverse.call(this.view.subarray(e,t)),this},o.skip=function(e){if(!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal length: "+e+" (not an integer)");e|=0}var t=this.offset+e;if(!this.noAssert&&(t<0||t>this.buffer.byteLength))throw RangeError("Illegal length: 0 <= "+this.offset+" + "+e+" <= "+this.buffer.byteLength);return this.offset=t,this},o.slice=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),!this.noAssert){if("number"!=typeof e||e%1!=0)throw TypeError("Illegal begin: Not an integer");if(e>>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}var r=this.clone();return r.offset=e,r.limit=t,r},o.toBuffer=function(e){var t=this.offset,r=this.limit;if(!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal offset: Not an integer");if(t>>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal limit: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}if(!e&&0===t&&r===this.buffer.byteLength)return this.buffer;if(t===r)return s;var n=new ArrayBuffer(r-t);return new Uint8Array(n).set(new Uint8Array(this.buffer).subarray(t,r),0),n},o.toArrayBuffer=o.toBuffer,o.toString=function(e,t,r){if(void 0===e)return"ByteBufferAB(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")";switch("number"==typeof e&&(r=t=e="utf8"),e){case"utf8":return this.toUTF8(t,r);case"base64":return this.toBase64(t,r);case"hex":return this.toHex(t,r);case"binary":return this.toBinary(t,r);case"debug":return this.toDebug();case"columns":return this.toColumns();default:throw Error("Unsupported encoding: "+e)}};var c=function(){for(var e={},i=[65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,54,55,56,57,43,47],o=[],t=0,r=i.length;t>2&63]),n=(3&r)<<4,null!==(r=e())?(t(i[63&((n|=r>>4&15)|r>>4&15)]),n=(15&r)<<2,null!==(r=e())?(t(i[63&(n|r>>6&3)]),t(i[63&r])):(t(i[63&n]),t(61))):(t(i[63&n]),t(61),t(61))},e.decode=function(e,t){var r,n,i;function s(e){throw Error("Illegal character code: "+e)}for(;null!==(r=e());)if(void 0===(n=o[r])&&s(r),null!==(r=e())&&(void 0===(i=o[r])&&s(r),t(n<<2>>>0|(48&i)>>4),null!==(r=e()))){if(void 0===(n=o[r])){if(61===r)break;s(r)}if(t((15&i)<<4>>>0|(60&n)>>2),null!==(r=e())){if(void 0===(i=o[r])){if(61===r)break;s(r)}t((3&n)<<6>>>0|i)}}},e.test=function(e){return/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(e)},e}();o.toBase64=function(e,t){if(void 0===e&&(e=this.offset),void 0===t&&(t=this.limit),t|=0,(e|=0)<0||t>this.capacity||tthis.capacity()||t":i+=r===this.markedOffset?"'":e||0!==r&&r!==n?" ":""}if(e&&" "!==i){for(;i.length<51;)i+=" ";o+=i+s+"\n"}return e?o:i},p.fromDebug=function(e,t,r){for(var n,i,s=e.length,o=new p((s+1)/3|0,t,r),a=0,f=0,u=!1,c=!1,l=!1,h=!1,d=!1;a":if(!r){if(h){d=!0;break}h=!0}o.limit=f,u=!1;break;case"'":if(!r){if(l){d=!0;break}l=!0}o.markedOffset=f,u=!1;break;case" ":u=!1;break;default:if(!r&&u){d=!0;break}if(i=parseInt(n+e.charAt(a++),16),!r&&(isNaN(i)||i<0||255>>=0,"number"!=typeof t||t%1!=0)throw TypeError("Illegal end: Not an integer");if(t>>>=0,e<0||tthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+e+" <= "+t+" <= "+this.buffer.byteLength)}for(var r,n=new Array(t-e);e>6&31|192):(r<65536?t(r>>12&15|224):(t(r>>18&7|240),t(r>>12&63|128)),t(r>>6&63|128)),t(63&r|128)),r=null},decodeUTF8:function(e,t){for(var r,n,i,s,o=function(e){e=e.slice(0,e.indexOf(null));var t=Error(e.toString());throw t.name="TruncatedError",t.bytes=e,t};null!==(r=e());)if(0==(128&r))t(r);else if(192==(224&r))null===(n=e())&&o([r,n]),t((31&r)<<6|63&n);else if(224==(240&r))(null===(n=e())||null===(i=e()))&&o([r,n,i]),t((15&r)<<12|(63&n)<<6|63&i);else{if(240!=(248&r))throw RangeError("Illegal starting byte: "+r);(null===(n=e())||null===(i=e())||null===(s=e()))&&o([r,n,i,s]),t((7&r)<<18|(63&n)<<12|(63&i)<<6|63&s)}},UTF16toUTF8:function(e,t){for(var r,n=null;null!==(r=null!==n?n:e());)55296<=r&&r<=57343&&null!==(n=e())&&56320<=n&&n<=57343?(t(1024*(r-55296)+n-56320+65536),n=null):t(r);null!==n&&t(n)},UTF8toUTF16:function(e,t){var r=null;for("number"==typeof e&&(r=e,e=function(){return null});null!==r||null!==(r=e());)r<=65535?t(r):(t(55296+((r-=65536)>>10)),t(r%1024+56320)),r=null},encodeUTF16toUTF8:function(e,t){l.UTF16toUTF8(e,function(e){l.encodeUTF8(e,t)})},decodeUTF8toUTF16:function(e,t){l.decodeUTF8(e,function(e){l.UTF8toUTF16(e,t)})},calculateCodePoint:function(e){return e<128?1:e<2048?2:e<65536?3:4},calculateUTF8:function(e){for(var t,r=0;null!==(t=e());)r+=t<128?1:t<2048?2:t<65536?3:4;return r},calculateUTF16asUTF8:function(e){var t=0,r=0;return l.UTF16toUTF8(e,function(e){++t,r+=e<128?1:e<2048?2:e<65536?3:4}),[t,r]}};return o.toUTF8=function(t,r){if(void 0===t&&(t=this.offset),void 0===r&&(r=this.limit),!this.noAssert){if("number"!=typeof t||t%1!=0)throw TypeError("Illegal begin: Not an integer");if(t>>>=0,"number"!=typeof r||r%1!=0)throw TypeError("Illegal end: Not an integer");if(r>>>=0,t<0||rthis.buffer.byteLength)throw RangeError("Illegal range: 0 <= "+t+" <= "+r+" <= "+this.buffer.byteLength)}var e;try{h.decodeUTF8toUTF16(function(){return tr)?t=("rmd160"===e?new f:u(e)).update(t).digest():t.length>>8^255&i^99,u[r]=i;var s=e[c[i]=r],o=e[s],a=e[o],f=257*e[i]^16843008*i;l[r]=f<<24|f>>>8,h[r]=f<<16|f>>>16,d[r]=f<<8|f>>>24,p[r]=f;f=16843009*a^65537*o^257*s^16843008*r;m[i]=f<<24|f>>>8,y[i]=f<<16|f>>>16,b[i]=f<<8|f>>>24,_[i]=f,r?(r=s^e[e[e[a^s]]],n^=e[e[n]]):r=n=1}}();var g=[0,1,2,4,8,16,32,64,128,27,54],n=r.AES=t.extend({_doReset:function(){if(!this._nRounds||this._keyPriorReset!==this._key){for(var e=this._keyPriorReset=this._key,t=e.words,r=e.sigBytes/4,n=4*((this._nRounds=r+6)+1),i=this._keySchedule=[],s=0;s>>24]<<24|u[o>>>16&255]<<16|u[o>>>8&255]<<8|u[255&o]):(o=u[(o=o<<8|o>>>24)>>>24]<<24|u[o>>>16&255]<<16|u[o>>>8&255]<<8|u[255&o],o^=g[s/r|0]<<24),i[s]=i[s-r]^o}for(var a=this._invKeySchedule=[],f=0;f>>24]]^y[u[o>>>16&255]]^b[u[o>>>8&255]]^_[u[255&o]]}}},encryptBlock:function(e,t){this._doCryptBlock(e,t,this._keySchedule,l,h,d,p,u)},decryptBlock:function(e,t){var r=e[t+1];e[t+1]=e[t+3],e[t+3]=r,this._doCryptBlock(e,t,this._invKeySchedule,m,y,b,_,c);r=e[t+1];e[t+1]=e[t+3],e[t+3]=r},_doCryptBlock:function(e,t,r,n,i,s,o,a){for(var f=this._nRounds,u=e[t]^r[0],c=e[t+1]^r[1],l=e[t+2]^r[2],h=e[t+3]^r[3],d=4,p=1;p>>24]^i[c>>>16&255]^s[l>>>8&255]^o[255&h]^r[d++],y=n[c>>>24]^i[l>>>16&255]^s[h>>>8&255]^o[255&u]^r[d++],b=n[l>>>24]^i[h>>>16&255]^s[u>>>8&255]^o[255&c]^r[d++],_=n[h>>>24]^i[u>>>16&255]^s[c>>>8&255]^o[255&l]^r[d++];u=m,c=y,l=b,h=_}m=(a[u>>>24]<<24|a[c>>>16&255]<<16|a[l>>>8&255]<<8|a[255&h])^r[d++],y=(a[c>>>24]<<24|a[l>>>16&255]<<16|a[h>>>8&255]<<8|a[255&u])^r[d++],b=(a[l>>>24]<<24|a[h>>>16&255]<<16|a[u>>>8&255]<<8|a[255&c])^r[d++],_=(a[h>>>24]<<24|a[u>>>16&255]<<16|a[c>>>8&255]<<8|a[255&l])^r[d++];e[t]=m,e[t+1]=y,e[t+2]=b,e[t+3]=_},keySize:8});e.AES=t._createHelper(n)}(),i.AES},"object"==typeof r?t.exports=r=i(e("./core"),e("./enc-base64"),e("./md5"),e("./evpkdf"),e("./cipher-core")):i(n.CryptoJS)},{"./cipher-core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/cipher-core.js","./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js","./enc-base64":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-base64.js","./evpkdf":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/evpkdf.js","./md5":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/md5.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/cipher-core.js":[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,f,i,s,o,a,u,c,l,h,d,p,m,y,b,_;e.lib.Cipher||(r=(t=e).lib,n=r.Base,f=r.WordArray,i=r.BufferedBlockAlgorithm,(s=t.enc).Utf8,o=s.Base64,a=t.algo.EvpKDF,u=r.Cipher=i.extend({cfg:n.extend(),createEncryptor:function(e,t){return this.create(this._ENC_XFORM_MODE,e,t)},createDecryptor:function(e,t){return this.create(this._DEC_XFORM_MODE,e,t)},init:function(e,t,r){this.cfg=this.cfg.extend(r),this._xformMode=e,this._key=t,this.reset()},reset:function(){i.reset.call(this),this._doReset()},process:function(e){return this._append(e),this._process()},finalize:function(e){return e&&this._append(e),this._doFinalize()},keySize:4,ivSize:4,_ENC_XFORM_MODE:1,_DEC_XFORM_MODE:2,_createHelper:function(){function i(e){return"string"==typeof e?_:y}return function(n){return{encrypt:function(e,t,r){return i(t).encrypt(n,e,t,r)},decrypt:function(e,t,r){return i(t).decrypt(n,e,t,r)}}}}()}),r.StreamCipher=u.extend({_doFinalize:function(){return this._process(!0)},blockSize:1}),c=t.mode={},l=r.BlockCipherMode=n.extend({createEncryptor:function(e,t){return this.Encryptor.create(e,t)},createDecryptor:function(e,t){return this.Decryptor.create(e,t)},init:function(e,t){this._cipher=e,this._iv=t}}),h=c.CBC=function(){var e=l.extend();function s(e,t,r){var n=this._iv;if(n){var i=n;this._iv=void 0}else i=this._prevBlock;for(var s=0;s>>2];e.sigBytes-=t}},r.BlockCipher=u.extend({cfg:u.cfg.extend({mode:h,padding:d}),reset:function(){u.reset.call(this);var e=this.cfg,t=e.iv,r=e.mode;if(this._xformMode==this._ENC_XFORM_MODE)var n=r.createEncryptor;else{n=r.createDecryptor;this._minBufferSize=1}this._mode=n.call(r,this,t&&t.words)},_doProcessBlock:function(e,t){this._mode.processBlock(e,t)},_doFinalize:function(){var e=this.cfg.padding;if(this._xformMode==this._ENC_XFORM_MODE){e.pad(this._data,this.blockSize);var t=this._process(!0)}else{t=this._process(!0);e.unpad(t)}return t},blockSize:4}),p=r.CipherParams=n.extend({init:function(e){this.mixIn(e)},toString:function(e){return(e||this.formatter).stringify(this)}}),m=(t.format={}).OpenSSL={stringify:function(e){var t=e.ciphertext,r=e.salt;if(r)var n=f.create([1398893684,1701076831]).concat(r).concat(t);else n=t;return n.toString(o)},parse:function(e){var t=o.parse(e),r=t.words;if(1398893684==r[0]&&1701076831==r[1]){var n=f.create(r.slice(2,4));r.splice(0,4),t.sigBytes-=16}return p.create({ciphertext:t,salt:n})}},y=r.SerializableCipher=n.extend({cfg:n.extend({format:m}),encrypt:function(e,t,r,n){n=this.cfg.extend(n);var i=e.createEncryptor(r,n),s=i.finalize(t),o=i.cfg;return p.create({ciphertext:s,key:r,iv:o.iv,algorithm:e,mode:o.mode,padding:o.padding,blockSize:e.blockSize,formatter:n.format})},decrypt:function(e,t,r,n){return n=this.cfg.extend(n),t=this._parse(t,n.format),e.createDecryptor(r,n).finalize(t.ciphertext)},_parse:function(e,t){return"string"==typeof e?t.parse(e,this):e}}),b=(t.kdf={}).OpenSSL={execute:function(e,t,r,n){n||(n=f.random(8));var i=a.create({keySize:t+r}).compute(e,n),s=f.create(i.words.slice(t),4*r);return i.sigBytes=4*t,p.create({key:i,iv:s,salt:n})}},_=r.PasswordBasedCipher=y.extend({cfg:y.cfg.extend({kdf:b}),encrypt:function(e,t,r,n){var i=(n=this.cfg.extend(n)).kdf.execute(r,e.keySize,e.ivSize);n.iv=i.iv;var s=y.encrypt.call(this,e,t,i.key,n);return s.mixIn(i),s},decrypt:function(e,t,r,n){n=this.cfg.extend(n),t=this._parse(t,n.format);var i=n.kdf.execute(r,e.keySize,e.ivSize,t.salt);return n.iv=i.iv,y.decrypt.call(this,e,t,i.key,n)}}))},"object"==typeof r?t.exports=r=i(e("./core")):i(n.CryptoJS)},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js":[function(e,t,r){var n,i;n=this,i=function(){var c,r,e,t,n,l,i,s,o,a,f,u,h=h||(c=Math,r=Object.create||function(){function r(){}return function(e){var t;return r.prototype=e,t=new r,r.prototype=null,t}}(),t=(e={}).lib={},n=t.Base={extend:function(e){var t=r(this);return e&&t.mixIn(e),t.hasOwnProperty("init")&&this.init!==t.init||(t.init=function(){t.$super.init.apply(this,arguments)}),(t.init.prototype=t).$super=this,t},create:function(){var e=this.extend();return e.init.apply(e,arguments),e},init:function(){},mixIn:function(e){for(var t in e)e.hasOwnProperty(t)&&(this[t]=e[t]);e.hasOwnProperty("toString")&&(this.toString=e.toString)},clone:function(){return this.init.prototype.extend(this)}},l=t.WordArray=n.extend({init:function(e,t){e=this.words=e||[],this.sigBytes=null!=t?t:4*e.length},toString:function(e){return(e||s).stringify(this)},concat:function(e){var t=this.words,r=e.words,n=this.sigBytes,i=e.sigBytes;if(this.clamp(),n%4)for(var s=0;s>>2]>>>24-s%4*8&255;t[n+s>>>2]|=o<<24-(n+s)%4*8}else for(s=0;s>>2]=r[s>>>2];return this.sigBytes+=i,this},clamp:function(){var e=this.words,t=this.sigBytes;e[t>>>2]&=4294967295<<32-t%4*8,e.length=c.ceil(t/4)},clone:function(){var e=n.clone.call(this);return e.words=this.words.slice(0),e},random:function(e){for(var t,r=[],n=function(t){t=t;var r=987654321,n=4294967295;return function(){var e=((r=36969*(65535&r)+(r>>16)&n)<<16)+(t=18e3*(65535&t)+(t>>16)&n)&n;return e/=4294967296,(e+=.5)*(.5>>2]>>>24-i%4*8&255;n.push((s>>>4).toString(16)),n.push((15&s).toString(16))}return n.join("")},parse:function(e){for(var t=e.length,r=[],n=0;n>>3]|=parseInt(e.substr(n,2),16)<<24-n%8*4;return new l.init(r,t/2)}},o=i.Latin1={stringify:function(e){for(var t=e.words,r=e.sigBytes,n=[],i=0;i>>2]>>>24-i%4*8&255;n.push(String.fromCharCode(s))}return n.join("")},parse:function(e){for(var t=e.length,r=[],n=0;n>>2]|=(255&e.charCodeAt(n))<<24-n%4*8;return new l.init(r,t)}},a=i.Utf8={stringify:function(e){try{return decodeURIComponent(escape(o.stringify(e)))}catch(e){throw new Error("Malformed UTF-8 data")}},parse:function(e){return o.parse(unescape(encodeURIComponent(e)))}},f=t.BufferedBlockAlgorithm=n.extend({reset:function(){this._data=new l.init,this._nDataBytes=0},_append:function(e){"string"==typeof e&&(e=a.parse(e)),this._data.concat(e),this._nDataBytes+=e.sigBytes},_process:function(e){var t=this._data,r=t.words,n=t.sigBytes,i=this.blockSize,s=n/(4*i),o=(s=e?c.ceil(s):c.max((0|s)-this._minBufferSize,0))*i,a=c.min(4*o,n);if(o){for(var f=0;f>>2]>>>24-s%4*8&255)<<16|(t[s+1>>>2]>>>24-(s+1)%4*8&255)<<8|t[s+2>>>2]>>>24-(s+2)%4*8&255,a=0;a<4&&s+.75*a>>6*(3-a)&63));var f=n.charAt(64);if(f)for(;i.length%4;)i.push(f);return i.join("")},parse:function(e){var t=e.length,r=this._map,n=this._reverseMap;if(!n){n=this._reverseMap=[];for(var i=0;i>>6-s%4*2;n[i>>>2]|=(o|a)<<24-i%4*8,i++}return f.create(n,i)}(e,t,n)},_map:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="},e.enc.Base64},"object"==typeof r?t.exports=r=i(e("./core")):i(n.CryptoJS)},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/enc-hex.js":[function(e,t,r){var n,i;n=this,i=function(e){return e.enc.Hex},"object"==typeof r?t.exports=r=i(e("./core")):i(n.CryptoJS)},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/evpkdf.js":[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,c,i,s,o;return r=(t=e).lib,n=r.Base,c=r.WordArray,i=t.algo,s=i.MD5,o=i.EvpKDF=n.extend({cfg:n.extend({keySize:4,hasher:s,iterations:1}),init:function(e){this.cfg=this.cfg.extend(e)},compute:function(e,t){for(var r=this.cfg,n=r.hasher.create(),i=c.create(),s=i.words,o=r.keySize,a=r.iterations;s.lengthn&&(t=e.finalize(t)),t.clamp();for(var i=this._oKey=t.clone(),s=this._iKey=t.clone(),o=i.words,a=s.words,f=0;f>>24)|4278255360&(i<<24|i>>>8)}var s=this._hash.words,o=e[t+0],a=e[t+1],f=e[t+2],u=e[t+3],c=e[t+4],l=e[t+5],h=e[t+6],d=e[t+7],p=e[t+8],m=e[t+9],y=e[t+10],b=e[t+11],_=e[t+12],g=e[t+13],w=e[t+14],v=e[t+15],j=s[0],E=s[1],B=s[2],x=s[3];E=S(E=S(E=S(E=S(E=T(E=T(E=T(E=T(E=D(E=D(E=D(E=D(E=k(E=k(E=k(E=k(E,B=k(B,x=k(x,j=k(j,E,B,x,o,7,U[0]),E,B,a,12,U[1]),j,E,f,17,U[2]),x,j,u,22,U[3]),B=k(B,x=k(x,j=k(j,E,B,x,c,7,U[4]),E,B,l,12,U[5]),j,E,h,17,U[6]),x,j,d,22,U[7]),B=k(B,x=k(x,j=k(j,E,B,x,p,7,U[8]),E,B,m,12,U[9]),j,E,y,17,U[10]),x,j,b,22,U[11]),B=k(B,x=k(x,j=k(j,E,B,x,_,7,U[12]),E,B,g,12,U[13]),j,E,w,17,U[14]),x,j,v,22,U[15]),B=D(B,x=D(x,j=D(j,E,B,x,a,5,U[16]),E,B,h,9,U[17]),j,E,b,14,U[18]),x,j,o,20,U[19]),B=D(B,x=D(x,j=D(j,E,B,x,l,5,U[20]),E,B,y,9,U[21]),j,E,v,14,U[22]),x,j,c,20,U[23]),B=D(B,x=D(x,j=D(j,E,B,x,m,5,U[24]),E,B,w,9,U[25]),j,E,u,14,U[26]),x,j,p,20,U[27]),B=D(B,x=D(x,j=D(j,E,B,x,g,5,U[28]),E,B,f,9,U[29]),j,E,d,14,U[30]),x,j,_,20,U[31]),B=T(B,x=T(x,j=T(j,E,B,x,l,4,U[32]),E,B,p,11,U[33]),j,E,b,16,U[34]),x,j,w,23,U[35]),B=T(B,x=T(x,j=T(j,E,B,x,a,4,U[36]),E,B,c,11,U[37]),j,E,d,16,U[38]),x,j,y,23,U[39]),B=T(B,x=T(x,j=T(j,E,B,x,g,4,U[40]),E,B,o,11,U[41]),j,E,u,16,U[42]),x,j,h,23,U[43]),B=T(B,x=T(x,j=T(j,E,B,x,m,4,U[44]),E,B,_,11,U[45]),j,E,v,16,U[46]),x,j,f,23,U[47]),B=S(B,x=S(x,j=S(j,E,B,x,o,6,U[48]),E,B,d,10,U[49]),j,E,w,15,U[50]),x,j,l,21,U[51]),B=S(B,x=S(x,j=S(j,E,B,x,_,6,U[52]),E,B,u,10,U[53]),j,E,y,15,U[54]),x,j,a,21,U[55]),B=S(B,x=S(x,j=S(j,E,B,x,p,6,U[56]),E,B,v,10,U[57]),j,E,h,15,U[58]),x,j,g,21,U[59]),B=S(B,x=S(x,j=S(j,E,B,x,c,6,U[60]),E,B,b,10,U[61]),j,E,f,15,U[62]),x,j,m,21,U[63]),s[0]=s[0]+j|0,s[1]=s[1]+E|0,s[2]=s[2]+B|0,s[3]=s[3]+x|0},_doFinalize:function(){var e=this._data,t=e.words,r=8*this._nDataBytes,n=8*e.sigBytes;t[n>>>5]|=128<<24-n%32;var i=c.floor(r/4294967296),s=r;t[15+(n+64>>>9<<4)]=16711935&(i<<8|i>>>24)|4278255360&(i<<24|i>>>8),t[14+(n+64>>>9<<4)]=16711935&(s<<8|s>>>24)|4278255360&(s<<24|s>>>8),e.sigBytes=4*(t.length+1),this._process();for(var o=this._hash,a=o.words,f=0;f<4;f++){var u=a[f];a[f]=16711935&(u<<8|u>>>24)|4278255360&(u<<24|u>>>8)}return o},clone:function(){var e=n.clone.call(this);return e._hash=this._hash.clone(),e}});function k(e,t,r,n,i,s,o){var a=e+(t&r|~t&n)+i+o;return(a<>>32-s)+t}function D(e,t,r,n,i,s,o){var a=e+(t&n|r&~n)+i+o;return(a<>>32-s)+t}function T(e,t,r,n,i,s,o){var a=e+(t^r^n)+i+o;return(a<>>32-s)+t}function S(e,t,r,n,i,s,o){var a=e+(r^(t|~n))+i+o;return(a<>>32-s)+t}e.MD5=n._createHelper(s),e.HmacMD5=n._createHmacHelper(s)}(Math),o.MD5},"object"==typeof r?t.exports=r=i(e("./core")):i(n.CryptoJS)},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/sha1.js":[function(e,t,r){var n,i;n=this,i=function(e){var t,r,n,i,s,l,o;return r=(t=e).lib,n=r.WordArray,i=r.Hasher,s=t.algo,l=[],o=s.SHA1=i.extend({_doReset:function(){this._hash=new n.init([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(e,t){for(var r=this._hash.words,n=r[0],i=r[1],s=r[2],o=r[3],a=r[4],f=0;f<80;f++){if(f<16)l[f]=0|e[t+f];else{var u=l[f-3]^l[f-8]^l[f-14]^l[f-16];l[f]=u<<1|u>>>31}var c=(n<<5|n>>>27)+a+l[f];c+=f<20?1518500249+(i&s|~i&o):f<40?1859775393+(i^s^o):f<60?(i&s|i&o|s&o)-1894007588:(i^s^o)-899497514,a=o,o=s,s=i<<30|i>>>2,i=n,n=c}r[0]=r[0]+n|0,r[1]=r[1]+i|0,r[2]=r[2]+s|0,r[3]=r[3]+o|0,r[4]=r[4]+a|0},_doFinalize:function(){var e=this._data,t=e.words,r=8*this._nDataBytes,n=8*e.sigBytes;return t[n>>>5]|=128<<24-n%32,t[14+(n+64>>>9<<4)]=Math.floor(r/4294967296),t[15+(n+64>>>9<<4)]=r,e.sigBytes=4*t.length,this._process(),this._hash},clone:function(){var e=i.clone.call(this);return e._hash=this._hash.clone(),e}}),t.SHA1=i._createHelper(o),t.HmacSHA1=i._createHmacHelper(o),e.SHA1},"object"==typeof r?t.exports=r=i(e("./core")):i(n.CryptoJS)},{"./core":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/crypto-js/core.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/deep-equal/index.js":[function(e,t,r){var a=Array.prototype.slice,f=e("./lib/keys.js"),u=e("./lib/is_arguments.js"),c=t.exports=function(e,t,r){return r||(r={}),e===t||(e instanceof Date&&t instanceof Date?e.getTime()===t.getTime():!e||!t||"object"!=typeof e&&"object"!=typeof t?r.strict?e===t:e==t:function(e,t,r){var n,i;if(l(e)||l(t))return!1;if(e.prototype!==t.prototype)return!1;if(u(e))return!!u(t)&&(e=a.call(e),t=a.call(t),c(e,t,r));if(h(e)){if(!h(t))return!1;if(e.length!==t.length)return!1;for(n=0;nr&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},n.prototype.once=function(e,t){if(!f(t))throw TypeError("listener must be a function");var r=!1;function n(){this.removeListener(e,n),r||(r=!0,t.apply(this,arguments))}return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var r,n,i,s;if(!f(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(i=(r=this._events[e]).length,n=-1,r===t||f(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(u(r)){for(s=i;0=this._blockSize;){for(var i=this._blockOffset;i>1,c=-7,l=r?i-1:0,h=r?-1:1,d=e[t+l];for(l+=h,s=d&(1<<-c)-1,d>>=-c,c+=a;0>=-c,c+=n;0>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,d=n?0:s-1,p=n?1:-1,m=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,o=c):(o=Math.floor(Math.log(t)/Math.LN2),t*(f=Math.pow(2,-o))<1&&(o--,f*=2),2<=(t+=1<=o+l?h/f:h*Math.pow(2,1-l))*f&&(o++,f/=2),c<=o+l?(a=0,o=c):1<=o+l?(a=(t*f-1)*Math.pow(2,i),o+=l):(a=t*Math.pow(2,l-1)*Math.pow(2,i),o=0));8<=i;e[r+d]=255&a,d+=p,a/=256,i-=8);for(o=o<>>=0)&&e<256)&&(n=o[e])?n:(r=m(e,(0|e)<0?-1:0,!0),i&&(o[e]=r),r):(i=-128<=(e|=0)&&e<128)&&(n=s[e])?n:(r=m(e,e<0?-1:0,!1),i&&(s[e]=r),r)}function p(e,t){if(isNaN(e)||!isFinite(e))return t?f:_;if(t){if(e<0)return f;if(i<=e)return v}else{if(e<=-a)return j;if(a<=e+1)return w}return e<0?p(-e,t).neg():m(e%r|0,e/r|0,t)}function m(e,t,r){return new n(e,t,r)}n.fromInt=e,n.fromNumber=p,n.fromBits=m;var c=Math.pow;function l(e,t,r){if(0===e.length)throw Error("empty string");if("NaN"===e||"Infinity"===e||"+Infinity"===e||"-Infinity"===e)return _;if(t="number"==typeof t?(r=t,!1):!!t,(r=r||10)<2||36>>0:this.low},t.toNumber=function(){return this.unsigned?(this.high>>>0)*r+(this.low>>>0):this.high*r+(this.low>>>0)},t.toString=function(e){if((e=e||10)<2||36>>0).toString(e);if((s=a).isZero())return f+o;for(;f.length<6;)f="0"+f;o=""+f+o}},t.getHighBits=function(){return this.high},t.getHighBitsUnsigned=function(){return this.high>>>0},t.getLowBits=function(){return this.low},t.getLowBitsUnsigned=function(){return this.low>>>0},t.getNumBitsAbs=function(){if(this.isNegative())return this.eq(j)?64:this.neg().getNumBitsAbs();for(var e=0!=this.high?this.high:this.low,t=31;0>>31!=1||e.high>>>31!=1)&&(this.high===e.high&&this.low===e.low)},t.eq=t.equals,t.notEquals=function(e){return!this.eq(e)},t.neq=t.notEquals,t.lessThan=function(e){return this.comp(e)<0},t.lt=t.lessThan,t.lessThanOrEqual=function(e){return this.comp(e)<=0},t.lte=t.lessThanOrEqual,t.greaterThan=function(e){return 0>>0>this.high>>>0||e.high===this.high&&e.low>>>0>this.low>>>0?-1:1:this.sub(e).isNegative()?-1:1},t.comp=t.compare,t.negate=function(){return!this.unsigned&&this.eq(j)?j:this.not().add(u)},t.neg=t.negate,t.add=function(e){d(e)||(e=y(e));var t=this.high>>>16,r=65535&this.high,n=this.low>>>16,i=65535&this.low,s=e.high>>>16,o=65535&e.high,a=e.low>>>16,f=0,u=0,c=0,l=0;return c+=(l+=i+(65535&e.low))>>>16,u+=(c+=n+a)>>>16,f+=(u+=r+o)>>>16,f+=t+s,m((c&=65535)<<16|(l&=65535),(f&=65535)<<16|(u&=65535),this.unsigned)},t.subtract=function(e){return d(e)||(e=y(e)),this.add(e.neg())},t.sub=t.subtract,t.multiply=function(e){if(this.isZero())return _;if(d(e)||(e=y(e)),e.isZero())return _;if(this.eq(j))return e.isOdd()?j:_;if(e.eq(j))return this.isOdd()?j:_;if(this.isNegative())return e.isNegative()?this.neg().mul(e.neg()):this.neg().mul(e).neg();if(e.isNegative())return this.mul(e.neg()).neg();if(this.lt(b)&&e.lt(b))return p(this.toNumber()*e.toNumber(),this.unsigned);var t=this.high>>>16,r=65535&this.high,n=this.low>>>16,i=65535&this.low,s=e.high>>>16,o=65535&e.high,a=e.low>>>16,f=65535&e.low,u=0,c=0,l=0,h=0;return l+=(h+=i*f)>>>16,c+=(l+=n*f)>>>16,l&=65535,c+=(l+=i*a)>>>16,u+=(c+=r*f)>>>16,c&=65535,u+=(c+=n*a)>>>16,c&=65535,u+=(c+=i*o)>>>16,u+=t*f+r*a+n*o+i*s,m((l&=65535)<<16|(h&=65535),(u&=65535)<<16|(c&=65535),this.unsigned)},t.mul=t.multiply,t.divide=function(e){if(d(e)||(e=y(e)),e.isZero())throw Error("division by zero");if(this.isZero())return this.unsigned?f:_;var t,r,n;if(this.unsigned){if(e.unsigned||(e=e.toUnsigned()),e.gt(this))return f;if(e.gt(this.shru(1)))return h;n=f}else{if(this.eq(j))return e.eq(u)||e.eq(g)?j:e.eq(j)?u:(t=this.shr(1).div(e).shl(1)).eq(_)?e.isNegative()?u:g:(r=this.sub(e.mul(t)),n=t.add(r.div(e)));else if(e.eq(j))return this.unsigned?f:_;if(this.isNegative())return e.isNegative()?this.neg().div(e.neg()):this.neg().div(e).neg();if(e.isNegative())return this.div(e.neg()).neg();n=_}for(r=this;r.gte(e);){t=Math.max(1,Math.floor(r.toNumber()/e.toNumber()));for(var i=Math.ceil(Math.log(t)/Math.LN2),s=i<=48?1:c(2,i-48),o=p(t),a=o.mul(e);a.isNegative()||a.gt(r);)a=(o=p(t-=s,this.unsigned)).mul(e);o.isZero()&&(o=u),n=n.add(o),r=r.sub(a)}return n},t.div=t.divide,t.modulo=function(e){return d(e)||(e=y(e)),this.sub(this.div(e).mul(e))},t.mod=t.modulo,t.not=function(){return m(~this.low,~this.high,this.unsigned)},t.and=function(e){return d(e)||(e=y(e)),m(this.low&e.low,this.high&e.high,this.unsigned)},t.or=function(e){return d(e)||(e=y(e)),m(this.low|e.low,this.high|e.high,this.unsigned)},t.xor=function(e){return d(e)||(e=y(e)),m(this.low^e.low,this.high^e.high,this.unsigned)},t.shiftLeft=function(e){return d(e)&&(e=e.toInt()),0==(e&=63)?this:e<32?m(this.low<>>32-e,this.unsigned):m(0,this.low<>>e|this.high<<32-e,this.high>>e,this.unsigned):m(this.high>>e-32,0<=this.high?0:-1,this.unsigned)},t.shr=t.shiftRight,t.shiftRightUnsigned=function(e){if(d(e)&&(e=e.toInt()),0===(e&=63))return this;var t=this.high;return e<32?m(this.low>>>e|t<<32-e,t>>>e,this.unsigned):m(32===e?t:t>>>e-32,0,this.unsigned)},t.shru=t.shiftRightUnsigned,t.toSigned=function(){return this.unsigned?m(this.low,this.high,!1):this},t.toUnsigned=function(){return this.unsigned?this:m(this.low,this.high,!0)},t.toBytes=function(e){return e?this.toBytesLE():this.toBytesBE()},t.toBytesLE=function(){var e=this.high,t=this.low;return[255&t,t>>>8&255,t>>>16&255,t>>>24&255,255&e,e>>>8&255,e>>>16&255,e>>>24&255]},t.toBytesBE=function(){var e=this.high,t=this.low;return[e>>>24&255,e>>>16&255,e>>>8&255,255&e,t>>>24&255,t>>>16&255,t>>>8&255,255&t]},n},"function"==typeof e&&"object"==typeof t&&t&&t.exports?t.exports=i():(n.dcodeIO=n.dcodeIO||{}).Long=i()},{}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/md5.js/index.js":[function(i,s,e){(function(t){"use strict";var e=i("inherits"),r=i("hash-base"),o=new Array(16);function n(){r.call(this,64),this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878}function a(e,t){return e<>>32-t}function f(e,t,r,n,i,s,o){return a(e+(t&r|~t&n)+i+s|0,o)+t|0}function u(e,t,r,n,i,s,o){return a(e+(t&n|r&~n)+i+s|0,o)+t|0}function c(e,t,r,n,i,s,o){return a(e+(t^r^n)+i+s|0,o)+t|0}function l(e,t,r,n,i,s,o){return a(e+(r^(t|~n))+i+s|0,o)+t|0}e(n,r),n.prototype._update=function(){for(var e=o,t=0;t<16;++t)e[t]=this._block.readInt32LE(4*t);var r=this._a,n=this._b,i=this._c,s=this._d;n=l(n=l(n=l(n=l(n=c(n=c(n=c(n=c(n=u(n=u(n=u(n=u(n=f(n=f(n=f(n=f(n,i=f(i,s=f(s,r=f(r,n,i,s,e[0],3614090360,7),n,i,e[1],3905402710,12),r,n,e[2],606105819,17),s,r,e[3],3250441966,22),i=f(i,s=f(s,r=f(r,n,i,s,e[4],4118548399,7),n,i,e[5],1200080426,12),r,n,e[6],2821735955,17),s,r,e[7],4249261313,22),i=f(i,s=f(s,r=f(r,n,i,s,e[8],1770035416,7),n,i,e[9],2336552879,12),r,n,e[10],4294925233,17),s,r,e[11],2304563134,22),i=f(i,s=f(s,r=f(r,n,i,s,e[12],1804603682,7),n,i,e[13],4254626195,12),r,n,e[14],2792965006,17),s,r,e[15],1236535329,22),i=u(i,s=u(s,r=u(r,n,i,s,e[1],4129170786,5),n,i,e[6],3225465664,9),r,n,e[11],643717713,14),s,r,e[0],3921069994,20),i=u(i,s=u(s,r=u(r,n,i,s,e[5],3593408605,5),n,i,e[10],38016083,9),r,n,e[15],3634488961,14),s,r,e[4],3889429448,20),i=u(i,s=u(s,r=u(r,n,i,s,e[9],568446438,5),n,i,e[14],3275163606,9),r,n,e[3],4107603335,14),s,r,e[8],1163531501,20),i=u(i,s=u(s,r=u(r,n,i,s,e[13],2850285829,5),n,i,e[2],4243563512,9),r,n,e[7],1735328473,14),s,r,e[12],2368359562,20),i=c(i,s=c(s,r=c(r,n,i,s,e[5],4294588738,4),n,i,e[8],2272392833,11),r,n,e[11],1839030562,16),s,r,e[14],4259657740,23),i=c(i,s=c(s,r=c(r,n,i,s,e[1],2763975236,4),n,i,e[4],1272893353,11),r,n,e[7],4139469664,16),s,r,e[10],3200236656,23),i=c(i,s=c(s,r=c(r,n,i,s,e[13],681279174,4),n,i,e[0],3936430074,11),r,n,e[3],3572445317,16),s,r,e[6],76029189,23),i=c(i,s=c(s,r=c(r,n,i,s,e[9],3654602809,4),n,i,e[12],3873151461,11),r,n,e[15],530742520,16),s,r,e[2],3299628645,23),i=l(i,s=l(s,r=l(r,n,i,s,e[0],4096336452,6),n,i,e[7],1126891415,10),r,n,e[14],2878612391,15),s,r,e[5],4237533241,21),i=l(i,s=l(s,r=l(r,n,i,s,e[12],1700485571,6),n,i,e[3],2399980690,10),r,n,e[10],4293915773,15),s,r,e[1],2240044497,21),i=l(i,s=l(s,r=l(r,n,i,s,e[8],1873313359,6),n,i,e[15],4264355552,10),r,n,e[6],2734768916,15),s,r,e[13],1309151649,21),i=l(i,s=l(s,r=l(r,n,i,s,e[4],4149444226,6),n,i,e[11],3174756917,10),r,n,e[2],718787259,15),s,r,e[9],3951481745,21),this._a=this._a+r|0,this._b=this._b+n|0,this._c=this._c+i|0,this._d=this._d+s|0},n.prototype._digest=function(){this._block[this._blockOffset++]=128,56this.urls.length-1)return t(new Error("Tried "+(i+1)+" connections, none of which worked: "+JSON.stringify(this.urls.concat(this.url))));var o=function(e,t){return s.logFailure(n),s.connectWithFallback(r,s.urls[i],i+1,e,t)};return e&&t?this.connect(r,n).then(e).catch(function(){o(e,t)}):new Promise(function(e,t){s.connect(r).then(e).catch(function(){o(e,t)})})},n.prototype.checkConnections=function(){var i=0t.highWaterMark&&(t.highWaterMark=(m<=(r=e)?r=m:(r--,r|=r>>>1,r|=r>>>2,r|=r>>>4,r|=r>>>8,r|=r>>>16,r++),r)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0));var r}function j(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(w("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?b.nextTick(E,e):E(e))}function E(e){w("emit readable"),e.emit("readable"),D(e)}function B(e,t){t.readingMore||(t.readingMore=!0,b.nextTick(x,e,t))}function x(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var n;es.length?s.length:e;if(o===s.length?i+=s:i+=s.slice(0,e),0===(e-=o)){o===s.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r).data=s.slice(o);break}++n}return t.length-=n,i}(e,t):function(e,t){var r=u.allocUnsafe(e),n=t.head,i=1;n.data.copy(r),e-=n.data.length;for(;n=n.next;){var s=n.data,o=e>s.length?s.length:e;if(s.copy(r,r.length-e,0,o),0===(e-=o)){o===s.length?(++i,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n).data=s.slice(o);break}++i}return t.length-=i,r}(e,t);return n}(e,t.buffer,t.decoder),r);var r}function S(e){var t=e._readableState;if(0=t.highWaterMark||t.ended))return w("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?S(this):j(this),null;if(0===(e=v(e,t))&&t.ended)return 0===t.length&&S(this),null;var n,i=t.needReadable;return w("need readable",i),(0===t.length||t.length-e>>0),s=this.head,o=0;s;)t=s.data,r=i,n=o,t.copy(r,n),o+=s.data.length,s=s.next;return i},e}(),n&&n.inspect&&n.inspect.custom&&(t.exports.prototype[n.inspect.custom]=function(){var e=n.inspect({length:this.length});return this.constructor.name+" "+e})},{"safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js",util:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/browser-resolve/empty.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/destroy.js":[function(e,t,r){"use strict";var s=e("process-nextick-args");function o(e,t){e.emit("error",t)}t.exports={destroy:function(e,t){var r=this,n=this._readableState&&this._readableState.destroyed,i=this._writableState&&this._writableState.destroyed;return n||i?t?t(e):!e||this._writableState&&this._writableState.errorEmitted||s.nextTick(o,this,e):(this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(e||null,function(e){!t&&e?(s.nextTick(o,r,e),r._writableState&&(r._writableState.errorEmitted=!0)):t&&t(e)})),this},undestroy:function(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}}},{"process-nextick-args":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/process-nextick-args/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/internal/streams/stream-browser.js":[function(e,t,r){t.exports=e("events").EventEmitter},{events:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/events/events.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/passthrough.js":[function(e,t,r){t.exports=e("./readable").PassThrough},{"./readable":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js":[function(e,t,r){(((r=t.exports=e("./lib/_stream_readable.js")).Stream=r).Readable=r).Writable=e("./lib/_stream_writable.js"),r.Duplex=e("./lib/_stream_duplex.js"),r.Transform=e("./lib/_stream_transform.js"),r.PassThrough=e("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_duplex.js","./lib/_stream_passthrough.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_passthrough.js","./lib/_stream_readable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_readable.js","./lib/_stream_transform.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_transform.js","./lib/_stream_writable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_writable.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/transform.js":[function(e,t,r){t.exports=e("./readable").Transform},{"./readable":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/writable-browser.js":[function(e,t,r){t.exports=e("./lib/_stream_writable.js")},{"./lib/_stream_writable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/lib/_stream_writable.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/ripemd160/index.js":[function(e,t,r){"use strict";var n=e("buffer").Buffer,i=e("inherits"),s=e("hash-base"),y=new Array(16),b=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8,3,10,14,4,9,15,8,1,2,7,0,6,13,11,5,12,1,9,11,10,0,8,12,4,13,3,7,15,14,5,6,2,4,0,5,9,7,12,2,10,14,1,3,8,11,6,15,13],_=[5,14,7,0,9,2,11,4,13,6,15,8,1,10,3,12,6,11,3,7,0,13,5,10,14,15,8,12,4,9,1,2,15,5,1,3,7,14,6,9,11,8,12,2,10,0,4,13,8,6,4,1,3,11,15,0,5,12,2,13,9,7,10,14,12,15,10,4,1,5,8,7,6,2,13,14,0,3,9,11],g=[11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8,7,6,8,13,11,9,7,15,7,12,15,9,11,7,13,12,11,13,6,7,14,9,13,15,14,8,13,6,5,12,7,5,11,12,14,15,14,15,9,8,9,14,5,6,8,6,5,12,9,15,5,11,6,8,13,12,5,12,13,14,11,8,5,6],w=[8,9,9,11,13,15,15,5,7,7,8,11,14,14,12,6,9,13,15,7,12,8,9,11,7,7,12,7,6,15,13,11,9,7,15,11,8,6,6,14,12,13,5,14,13,13,7,5,15,5,8,11,14,14,6,14,6,9,12,9,12,5,15,8,8,5,12,9,12,5,14,6,8,13,6,5,15,13,11,11],v=[0,1518500249,1859775393,2400959708,2840853838],j=[1352829926,1548603684,1836072691,2053994217,0];function o(){s.call(this,64),this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520}function E(e,t){return e<>>32-t}function B(e,t,r,n,i,s,o,a){return E(e+(t^r^n)+s+o|0,a)+i|0}function x(e,t,r,n,i,s,o,a){return E(e+(t&r|~t&n)+s+o|0,a)+i|0}function U(e,t,r,n,i,s,o,a){return E(e+((t|~r)^n)+s+o|0,a)+i|0}function k(e,t,r,n,i,s,o,a){return E(e+(t&n|r&~n)+s+o|0,a)+i|0}function D(e,t,r,n,i,s,o,a){return E(e+(t^(r|~n))+s+o|0,a)+i|0}i(o,s),o.prototype._update=function(){for(var e=y,t=0;t<16;++t)e[t]=this._block.readInt32LE(4*t);for(var r=0|this._a,n=0|this._b,i=0|this._c,s=0|this._d,o=0|this._e,a=0|this._a,f=0|this._b,u=0|this._c,c=0|this._d,l=0|this._e,h=0;h<80;h+=1){var d,p;p=h<16?(d=B(r,n,i,s,o,e[b[h]],v[0],g[h]),D(a,f,u,c,l,e[_[h]],j[0],w[h])):h<32?(d=x(r,n,i,s,o,e[b[h]],v[1],g[h]),k(a,f,u,c,l,e[_[h]],j[1],w[h])):h<48?(d=U(r,n,i,s,o,e[b[h]],v[2],g[h]),U(a,f,u,c,l,e[_[h]],j[2],w[h])):h<64?(d=k(r,n,i,s,o,e[b[h]],v[3],g[h]),x(a,f,u,c,l,e[_[h]],j[3],w[h])):(d=D(r,n,i,s,o,e[b[h]],v[4],g[h]),B(a,f,u,c,l,e[_[h]],j[4],w[h])),r=o,o=s,s=E(i,10),i=n,n=d,a=l,l=c,c=E(u,10),u=f,f=p}var m=this._b+i+c|0;this._b=this._c+s+l|0,this._c=this._d+o+a|0,this._d=this._e+r+f|0,this._e=this._a+n+u|0,this._a=m},o.prototype._digest=function(){this._block[this._blockOffset++]=128,56=this._finalSize&&(this._update(this._block),this._block.fill(0));var r=8*this._len;if(r<=4294967295)this._block.writeUInt32BE(r,this._blockSize-4);else{var n=(4294967295&r)>>>0,i=(r-n)/4294967296;this._block.writeUInt32BE(i,this._blockSize-8),this._block.writeUInt32BE(n,this._blockSize-4)}this._update(this._block);var s=this._hash();return e?s.toString(e):s},n.prototype._update=function(){throw new Error("_update must be implemented by subclass")},t.exports=n},{"safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/index.js":[function(e,t,r){(r=t.exports=function(e){e=e.toLowerCase();var t=r[e];if(!t)throw new Error(e+" is not supported (we accept pull requests)");return new t}).sha=e("./sha"),r.sha1=e("./sha1"),r.sha224=e("./sha224"),r.sha256=e("./sha256"),r.sha384=e("./sha384"),r.sha512=e("./sha512")},{"./sha":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha.js","./sha1":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha1.js","./sha224":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha224.js","./sha256":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha256.js","./sha384":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha384.js","./sha512":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha512.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha.js":[function(e,t,r){var n=e("inherits"),i=e("./hash"),s=e("safe-buffer").Buffer,b=[1518500249,1859775393,-1894007588,-899497514],o=new Array(80);function a(){this.init(),this._w=o,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},a.prototype._update=function(e){for(var t,r,n,i,s,o,a=this._w,f=0|this._a,u=0|this._b,c=0|this._c,l=0|this._d,h=0|this._e,d=0;d<16;++d)a[d]=e.readInt32BE(4*d);for(;d<80;++d)a[d]=a[d-3]^a[d-8]^a[d-14]^a[d-16];for(var p=0;p<80;++p){var m=~~(p/20),y=0|((o=f)<<5|o>>>27)+(n=u,i=c,s=l,0===(r=m)?n&i|~n&s:2===r?n&i|n&s|i&s:n^i^s)+h+a[p]+b[m];h=l,l=c,c=(t=u)<<30|t>>>2,u=f,f=y}this._a=f+this._a|0,this._b=u+this._b|0,this._c=c+this._c|0,this._d=l+this._d|0,this._e=h+this._e|0},a.prototype._hash=function(){var e=s.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},t.exports=a},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha1.js":[function(e,t,r){var n=e("inherits"),i=e("./hash"),s=e("safe-buffer").Buffer,_=[1518500249,1859775393,-1894007588,-899497514],o=new Array(80);function a(){this.init(),this._w=o,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},a.prototype._update=function(e){for(var t,r,n,i,s,o,a,f=this._w,u=0|this._a,c=0|this._b,l=0|this._c,h=0|this._d,d=0|this._e,p=0;p<16;++p)f[p]=e.readInt32BE(4*p);for(;p<80;++p)f[p]=(t=f[p-3]^f[p-8]^f[p-14]^f[p-16])<<1|t>>>31;for(var m=0;m<80;++m){var y=~~(m/20),b=0|((a=u)<<5|a>>>27)+(i=c,s=l,o=h,0===(n=y)?i&s|~i&o:2===n?i&s|i&o|s&o:i^s^o)+d+f[m]+_[y];d=h,h=l,l=(r=c)<<30|r>>>2,c=u,u=b}this._a=u+this._a|0,this._b=c+this._b|0,this._c=l+this._c|0,this._d=h+this._d|0,this._e=d+this._e|0},a.prototype._hash=function(){var e=s.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},t.exports=a},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha224.js":[function(e,t,r){var n=e("inherits"),i=e("./sha256"),s=e("./hash"),o=e("safe-buffer").Buffer,a=new Array(64);function f(){this.init(),this._w=a,s.call(this,64,56)}n(f,i),f.prototype.init=function(){return this._a=3238371032,this._b=914150663,this._c=812702999,this._d=4144912697,this._e=4290775857,this._f=1750603025,this._g=1694076839,this._h=3204075428,this},f.prototype._hash=function(){var e=o.allocUnsafe(28);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e},t.exports=f},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","./sha256":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha256.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha256.js":[function(e,t,r){var n=e("inherits"),i=e("./hash"),s=e("safe-buffer").Buffer,v=[1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298],o=new Array(64);function a(){this.init(),this._w=o,i.call(this,64,56)}n(a,i),a.prototype.init=function(){return this._a=1779033703,this._b=3144134277,this._c=1013904242,this._d=2773480762,this._e=1359893119,this._f=2600822924,this._g=528734635,this._h=1541459225,this},a.prototype._update=function(e){for(var t,r,n,i,s,o,a,f=this._w,u=0|this._a,c=0|this._b,l=0|this._c,h=0|this._d,d=0|this._e,p=0|this._f,m=0|this._g,y=0|this._h,b=0;b<16;++b)f[b]=e.readInt32BE(4*b);for(;b<64;++b)f[b]=0|(((r=f[b-2])>>>17|r<<15)^(r>>>19|r<<13)^r>>>10)+f[b-7]+(((t=f[b-15])>>>7|t<<25)^(t>>>18|t<<14)^t>>>3)+f[b-16];for(var _=0;_<64;++_){var g=y+(((a=d)>>>6|a<<26)^(a>>>11|a<<21)^(a>>>25|a<<7))+((o=m)^d&(p^o))+v[_]+f[_]|0,w=0|(((s=u)>>>2|s<<30)^(s>>>13|s<<19)^(s>>>22|s<<10))+((n=u)&(i=c)|l&(n|i));y=m,m=p,p=d,d=h+g|0,h=l,l=c,c=u,u=g+w|0}this._a=u+this._a|0,this._b=c+this._b|0,this._c=l+this._c|0,this._d=h+this._d|0,this._e=d+this._e|0,this._f=p+this._f|0,this._g=m+this._g|0,this._h=y+this._h|0},a.prototype._hash=function(){var e=s.allocUnsafe(32);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e.writeInt32BE(this._h,28),e},t.exports=a},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha384.js":[function(e,t,r){var n=e("inherits"),i=e("./sha512"),s=e("./hash"),o=e("safe-buffer").Buffer,a=new Array(160);function f(){this.init(),this._w=a,s.call(this,128,112)}n(f,i),f.prototype.init=function(){return this._ah=3418070365,this._bh=1654270250,this._ch=2438529370,this._dh=355462360,this._eh=1731405415,this._fh=2394180231,this._gh=3675008525,this._hh=1203062813,this._al=3238371032,this._bl=914150663,this._cl=812702999,this._dl=4144912697,this._el=4290775857,this._fl=1750603025,this._gl=1694076839,this._hl=3204075428,this},f.prototype._hash=function(){var n=o.allocUnsafe(48);function e(e,t,r){n.writeInt32BE(e,r),n.writeInt32BE(t,r+4)}return e(this._ah,this._al,0),e(this._bh,this._bl,8),e(this._ch,this._cl,16),e(this._dh,this._dl,24),e(this._eh,this._el,32),e(this._fh,this._fl,40),n},t.exports=f},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js","./sha512":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha512.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/sha512.js":[function(e,t,r){var n=e("inherits"),i=e("./hash"),s=e("safe-buffer").Buffer,ee=[1116352408,3609767458,1899447441,602891725,3049323471,3964484399,3921009573,2173295548,961987163,4081628472,1508970993,3053834265,2453635748,2937671579,2870763221,3664609560,3624381080,2734883394,310598401,1164996542,607225278,1323610764,1426881987,3590304994,1925078388,4068182383,2162078206,991336113,2614888103,633803317,3248222580,3479774868,3835390401,2666613458,4022224774,944711139,264347078,2341262773,604807628,2007800933,770255983,1495990901,1249150122,1856431235,1555081692,3175218132,1996064986,2198950837,2554220882,3999719339,2821834349,766784016,2952996808,2566594879,3210313671,3203337956,3336571891,1034457026,3584528711,2466948901,113926993,3758326383,338241895,168717936,666307205,1188179964,773529912,1546045734,1294757372,1522805485,1396182291,2643833823,1695183700,2343527390,1986661051,1014477480,2177026350,1206759142,2456956037,344077627,2730485921,1290863460,2820302411,3158454273,3259730800,3505952657,3345764771,106217008,3516065817,3606008344,3600352804,1432725776,4094571909,1467031594,275423344,851169720,430227734,3100823752,506948616,1363258195,659060556,3750685593,883997877,3785050280,958139571,3318307427,1322822218,3812723403,1537002063,2003034995,1747873779,3602036899,1955562222,1575990012,2024104815,1125592928,2227730452,2716904306,2361852424,442776044,2428436474,593698344,2756734187,3733110249,3204031479,2999351573,3329325298,3815920427,3391569614,3928383900,3515267271,566280711,3940187606,3454069534,4118630271,4000239992,116418474,1914138554,174292421,2731055270,289380356,3203993006,460393269,320620315,685471733,587496836,852142971,1086792851,1017036298,365543100,1126000580,2618297676,1288033470,3409855158,1501505948,4234509866,1607167915,987167468,1816402316,1246189591],o=new Array(160);function a(){this.init(),this._w=o,i.call(this,128,112)}function te(e,t,r){return r^e&(t^r)}function re(e,t,r){return e&t|r&(e|t)}function ne(e,t){return(e>>>28|t<<4)^(t>>>2|e<<30)^(t>>>7|e<<25)}function ie(e,t){return(e>>>14|t<<18)^(e>>>18|t<<14)^(t>>>9|e<<23)}function se(e,t){return e>>>0>>0?1:0}n(a,i),a.prototype.init=function(){return this._ah=1779033703,this._bh=3144134277,this._ch=1013904242,this._dh=2773480762,this._eh=1359893119,this._fh=2600822924,this._gh=528734635,this._hh=1541459225,this._al=4089235720,this._bl=2227873595,this._cl=4271175723,this._dl=1595750129,this._el=2917565137,this._fl=725511199,this._gl=4215389547,this._hl=327033209,this},a.prototype._update=function(e){for(var t,r,n,i,s,o,a,f,u=this._w,c=0|this._ah,l=0|this._bh,h=0|this._ch,d=0|this._dh,p=0|this._eh,m=0|this._fh,y=0|this._gh,b=0|this._hh,_=0|this._al,g=0|this._bl,w=0|this._cl,v=0|this._dl,j=0|this._el,E=0|this._fl,B=0|this._gl,x=0|this._hl,U=0;U<32;U+=2)u[U]=e.readInt32BE(4*U),u[U+1]=e.readInt32BE(4*U+4);for(;U<160;U+=2){var k=u[U-30],D=u[U-30+1],T=((a=k)>>>1|(f=D)<<31)^(a>>>8|f<<24)^a>>>7,S=((s=D)>>>1|(o=k)<<31)^(s>>>8|o<<24)^(s>>>7|o<<25);k=u[U-4],D=u[U-4+1];var I=((n=k)>>>19|(i=D)<<13)^(i>>>29|n<<3)^n>>>6,A=((t=D)>>>19|(r=k)<<13)^(r>>>29|t<<3)^(t>>>6|r<<26),O=u[U-14],L=u[U-14+1],C=u[U-32],R=u[U-32+1],P=S+L|0,q=T+O+se(P,S)|0;q=(q=q+I+se(P=P+A|0,A)|0)+C+se(P=P+R|0,R)|0,u[U]=q,u[U+1]=P}for(var M=0;M<160;M+=2){q=u[M],P=u[M+1];var z=re(c,l,h),N=re(_,g,w),F=ne(c,_),K=ne(_,c),H=ie(p,j),V=ie(j,p),Y=ee[M],W=ee[M+1],Z=te(p,m,y),G=te(j,E,B),J=x+V|0,X=b+H+se(J,x)|0;X=(X=(X=X+Z+se(J=J+G|0,G)|0)+Y+se(J=J+W|0,W)|0)+q+se(J=J+P|0,P)|0;var $=K+N|0,Q=F+z+se($,K)|0;b=y,x=B,y=m,B=E,m=p,E=j,p=d+X+se(j=v+J|0,v)|0,d=h,v=w,h=l,w=g,l=c,g=_,c=X+Q+se(_=J+$|0,J)|0}this._al=this._al+_|0,this._bl=this._bl+g|0,this._cl=this._cl+w|0,this._dl=this._dl+v|0,this._el=this._el+j|0,this._fl=this._fl+E|0,this._gl=this._gl+B|0,this._hl=this._hl+x|0,this._ah=this._ah+c+se(this._al,_)|0,this._bh=this._bh+l+se(this._bl,g)|0,this._ch=this._ch+h+se(this._cl,w)|0,this._dh=this._dh+d+se(this._dl,v)|0,this._eh=this._eh+p+se(this._el,j)|0,this._fh=this._fh+m+se(this._fl,E)|0,this._gh=this._gh+y+se(this._gl,B)|0,this._hh=this._hh+b+se(this._hl,x)|0},a.prototype._hash=function(){var n=s.allocUnsafe(64);function e(e,t,r){n.writeInt32BE(e,r),n.writeInt32BE(t,r+4)}return e(this._ah,this._al,0),e(this._bh,this._bl,8),e(this._ch,this._cl,16),e(this._dh,this._dl,24),e(this._eh,this._el,32),e(this._fh,this._fl,40),e(this._gh,this._gl,48),e(this._hh,this._hl,56),n},t.exports=a},{"./hash":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/sha.js/hash.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","safe-buffer":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/safe-buffer/index.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/stream-browserify/index.js":[function(e,t,r){t.exports=n;var c=e("events").EventEmitter;function n(){c.call(this)}e("inherits")(n,c),n.Readable=e("readable-stream/readable.js"),n.Writable=e("readable-stream/writable.js"),n.Duplex=e("readable-stream/duplex.js"),n.Transform=e("readable-stream/transform.js"),n.PassThrough=e("readable-stream/passthrough.js"),(n.Stream=n).prototype.pipe=function(t,e){var r=this;function n(e){t.writable&&!1===t.write(e)&&r.pause&&r.pause()}function i(){r.readable&&r.resume&&r.resume()}r.on("data",n),t.on("drain",i),t._isStdio||e&&!1===e.end||(r.on("end",o),r.on("close",a));var s=!1;function o(){s||(s=!0,t.end())}function a(){s||(s=!0,"function"==typeof t.destroy&&t.destroy())}function f(e){if(u(),0===c.listenerCount(this,"error"))throw e}function u(){r.removeListener("data",n),t.removeListener("drain",i),r.removeListener("end",o),r.removeListener("close",a),r.removeListener("error",f),t.removeListener("error",f),r.removeListener("end",u),r.removeListener("close",u),t.removeListener("close",u)}return r.on("error",f),t.on("error",f),r.on("end",u),r.on("close",u),t.on("close",u),t.emit("pipe",r),t}},{events:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/events/events.js",inherits:"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/inherits/inherits_browser.js","readable-stream/duplex.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/duplex-browser.js","readable-stream/passthrough.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/passthrough.js","readable-stream/readable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/readable-browser.js","readable-stream/transform.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/transform.js","readable-stream/writable.js":"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/readable-stream/writable-browser.js"}],"/Users/mseaward/Documents/code/peerplaysjs-lib/node_modules/string_decoder/lib/string_decoder.js":[function(e,t,r){"use strict";var n=e("safe-buffer").Buffer,i=n.isEncoding||function(e){switch((e=""+e)&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};function s(e){var t;switch(this.encoding=function(e){var t=function(e){if(!e)return"utf8";for(var t;;)switch(e){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return e;default:if(t)return;e=(""+e).toLowerCase(),t=!0}}(e);if("string"!=typeof t&&(n.isEncoding===i||!i(e)))throw new Error("Unknown encoding: "+e);return t||e}(e),this.encoding){case"utf16le":this.text=f,this.end=u,t=4;break;case"utf8":this.fillLast=a,t=4;break;case"base64":this.text=c,this.end=l,t=3;break;default:return this.write=h,void(this.end=d)}this.lastNeed=0,this.lastTotal=0,this.lastChar=n.allocUnsafe(t)}function o(e){return e<=127?0:e>>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function a(e){var t=this.lastTotal-this.lastNeed,r=function(e,t,r){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(1=1.1.13-1 <1.2.0-0", - "xtend": ">=4.0.0 <4.1.0-0" - } - } - } - }, - "combine-source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.6.1.tgz", - "integrity": "sha1-m0oJwxYDPXaODxHgKfonMOB5rZY=", - "dev": true, - "requires": { - "convert-source-map": "~1.1.0", - "inline-source-map": "~0.5.0", - "lodash.memoize": "~3.0.3", - "source-map": "~0.4.2" - } - }, - "convert-source-map": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", - "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=", - "dev": true - }, - "inline-source-map": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.5.0.tgz", - "integrity": "sha1-Skxd2OT7Xps82mDIIt+tyu5m4K8=", - "dev": true, - "requires": { - "source-map": "~0.4.0" - } - }, - "isarray": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", - "dev": true - }, - "minimist": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", - "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", - "dev": true - }, - "readable-stream": { - "version": "1.1.14", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", - "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", - "dev": true, - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.1", - "isarray": "0.0.1", - "string_decoder": "~0.10.x" - } - }, - "source-map": { - "version": "0.4.4", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.4.4.tgz", - "integrity": "sha1-66T12pwNyZneaAMti092FzZSA2s=", - "dev": true, - "requires": { - "amdefine": ">=0.0.4" - } - }, - "string_decoder": { - "version": "0.10.31", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", - "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", - "dev": true - } - } - }, "bytebuffer": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/bytebuffer/-/bytebuffer-5.0.1.tgz", @@ -1570,21 +1168,6 @@ "integrity": "sha1-0JxLUoAKpMB44t2BqGmqyQ0uVOc=", "dev": true }, - "caller-path": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz", - "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", - "dev": true, - "requires": { - "callsites": "^0.2.0" - } - }, - "callsites": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz", - "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", - "dev": true - }, "caseless": { "version": "0.12.0", "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", @@ -1605,12 +1188,6 @@ "supports-color": "^2.0.0" } }, - "chardet": { - "version": "0.4.2", - "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz", - "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=", - "dev": true - }, "cheerio": { "version": "1.0.0-rc.2", "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.2.tgz", @@ -1652,41 +1229,12 @@ "safe-buffer": "^5.0.1" } }, - "circular-json": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz", - "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==", - "dev": true - }, - "cli-cursor": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", - "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", - "dev": true, - "requires": { - "restore-cursor": "^2.0.0" - } - }, - "cli-width": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz", - "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=", - "dev": true - }, "co": { "version": "4.6.0", "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", - "dev": true - }, - "color-convert": { - "version": "1.9.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", - "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", "dev": true, - "requires": { - "color-name": "1.1.3" - } + "optional": true }, "color-logger": { "version": "0.0.6", @@ -1694,12 +1242,6 @@ "integrity": "sha1-5WJF7ymCJlcRDHy3WpzXhstp7Rs=", "dev": true }, - "color-name": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", - "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", - "dev": true - }, "combine-source-map": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.8.0.tgz", @@ -1795,12 +1337,6 @@ "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", "dev": true }, - "contains-path": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", - "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=", - "dev": true - }, "convert-source-map": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz", @@ -1854,17 +1390,6 @@ "sha.js": "^2.4.8" } }, - "cross-spawn": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", - "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", - "dev": true, - "requires": { - "lru-cache": "^4.0.1", - "shebang-command": "^1.2.0", - "which": "^1.2.9" - } - }, "crypto-browserify": { "version": "3.12.0", "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", @@ -1885,9 +1410,9 @@ } }, "crypto-js": { - "version": "3.1.9-1", - "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-3.1.9-1.tgz", - "integrity": "sha1-/aGedh/Ad+Af+/3G6f38WeiAbNg=" + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-3.1.8.tgz", + "integrity": "sha1-cV8HC/YBTyrpkqmLOSkli3E/CNU=" }, "css-select": { "version": "1.2.0", @@ -1931,12 +1456,6 @@ "es5-ext": "^0.10.9" } }, - "damerau-levenshtein": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.4.tgz", - "integrity": "sha1-AxkcQyy27qFou3fzpV/9zLiXhRQ=", - "dev": true - }, "dashdash": { "version": "1.14.1", "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", @@ -1971,16 +1490,8 @@ "version": "0.1.3", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", - "dev": true - }, - "define-properties": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", - "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", "dev": true, - "requires": { - "object-keys": "^1.0.12" - } + "optional": true }, "defined": { "version": "1.0.0", @@ -2036,9 +1547,9 @@ } }, "diff": { - "version": "3.5.0", - "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", - "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-1.4.0.tgz", + "integrity": "sha1-fyjS657nsVqX79ic5j3P2qPMur8=", "dev": true }, "diffie-hellman": { @@ -2052,15 +1563,6 @@ "randombytes": "^2.0.0" } }, - "doctrine": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", - "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", - "dev": true, - "requires": { - "esutils": "^2.0.2" - } - }, "dom-serializer": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.0.tgz", @@ -2153,52 +1655,12 @@ "minimalistic-crypto-utils": "^1.0.0" } }, - "emoji-regex": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", - "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", - "dev": true - }, "entities": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.1.tgz", "integrity": "sha1-blwtClYhtdra7O+AuQ7ftc13cvA=", "dev": true }, - "error-ex": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", - "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", - "dev": true, - "requires": { - "is-arrayish": "^0.2.1" - } - }, - "es-abstract": { - "version": "1.13.0", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.13.0.tgz", - "integrity": "sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==", - "dev": true, - "requires": { - "es-to-primitive": "^1.2.0", - "function-bind": "^1.1.1", - "has": "^1.0.3", - "is-callable": "^1.1.4", - "is-regex": "^1.0.4", - "object-keys": "^1.0.12" - } - }, - "es-to-primitive": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz", - "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==", - "dev": true, - "requires": { - "is-callable": "^1.1.4", - "is-date-object": "^1.0.1", - "is-symbol": "^1.0.2" - } - }, "es5-ext": { "version": "0.10.45", "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.45.tgz", @@ -2290,314 +1752,6 @@ } } }, - "eslint": { - "version": "4.19.1", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.19.1.tgz", - "integrity": "sha512-bT3/1x1EbZB7phzYu7vCr1v3ONuzDtX8WjuM9c0iYxe+cq+pwcKEoQjl7zd3RpC6YOLgnSy3cTN58M2jcoPDIQ==", - "dev": true, - "requires": { - "ajv": "^5.3.0", - "babel-code-frame": "^6.22.0", - "chalk": "^2.1.0", - "concat-stream": "^1.6.0", - "cross-spawn": "^5.1.0", - "debug": "^3.1.0", - "doctrine": "^2.1.0", - "eslint-scope": "^3.7.1", - "eslint-visitor-keys": "^1.0.0", - "espree": "^3.5.4", - "esquery": "^1.0.0", - "esutils": "^2.0.2", - "file-entry-cache": "^2.0.0", - "functional-red-black-tree": "^1.0.1", - "glob": "^7.1.2", - "globals": "^11.0.1", - "ignore": "^3.3.3", - "imurmurhash": "^0.1.4", - "inquirer": "^3.0.6", - "is-resolvable": "^1.0.0", - "js-yaml": "^3.9.1", - "json-stable-stringify-without-jsonify": "^1.0.1", - "levn": "^0.3.0", - "lodash": "^4.17.4", - "minimatch": "^3.0.2", - "mkdirp": "^0.5.1", - "natural-compare": "^1.4.0", - "optionator": "^0.8.2", - "path-is-inside": "^1.0.2", - "pluralize": "^7.0.0", - "progress": "^2.0.0", - "regexpp": "^1.0.1", - "require-uncached": "^1.0.3", - "semver": "^5.3.0", - "strip-ansi": "^4.0.0", - "strip-json-comments": "~2.0.1", - "table": "4.0.2", - "text-table": "~0.2.0" - }, - "dependencies": { - "ansi-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", - "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", - "dev": true - }, - "ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", - "dev": true, - "requires": { - "color-convert": "^1.9.0" - } - }, - "chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", - "dev": true, - "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" - } - }, - "concat-stream": { - "version": "1.6.2", - "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", - "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", - "dev": true, - "requires": { - "buffer-from": "^1.0.0", - "inherits": "^2.0.3", - "readable-stream": "^2.2.2", - "typedarray": "^0.0.6" - } - }, - "debug": { - "version": "3.2.6", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", - "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "globals": { - "version": "11.10.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-11.10.0.tgz", - "integrity": "sha512-0GZF1RiPKU97IHUO5TORo9w1PwrH/NBPl+fS7oMLdaTRiYmYbwK4NWoZWrAdd0/abG9R2BU+OiwyQpTpE6pdfQ==", - "dev": true - }, - "ms": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", - "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", - "dev": true - }, - "strip-ansi": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", - "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", - "dev": true, - "requires": { - "ansi-regex": "^3.0.0" - } - }, - "supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", - "dev": true, - "requires": { - "has-flag": "^3.0.0" - } - } - } - }, - "eslint-config-airbnb": { - "version": "17.1.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb/-/eslint-config-airbnb-17.1.0.tgz", - "integrity": "sha512-R9jw28hFfEQnpPau01NO5K/JWMGLi6aymiF6RsnMURjTk+MqZKllCqGK/0tOvHkPi/NWSSOU2Ced/GX++YxLnw==", - "dev": true, - "requires": { - "eslint-config-airbnb-base": "^13.1.0", - "object.assign": "^4.1.0", - "object.entries": "^1.0.4" - } - }, - "eslint-config-airbnb-base": { - "version": "13.1.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-13.1.0.tgz", - "integrity": "sha512-XWwQtf3U3zIoKO1BbHh6aUhJZQweOwSt4c2JrPDg9FP3Ltv3+YfEv7jIDB8275tVnO/qOHbfuYg3kzw6Je7uWw==", - "dev": true, - "requires": { - "eslint-restricted-globals": "^0.1.1", - "object.assign": "^4.1.0", - "object.entries": "^1.0.4" - } - }, - "eslint-import-resolver-node": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.2.tgz", - "integrity": "sha512-sfmTqJfPSizWu4aymbPr4Iidp5yKm8yDkHp+Ir3YiTHiiDfxh69mOUsmiqW6RZ9zRXFaF64GtYmN7e+8GHBv6Q==", - "dev": true, - "requires": { - "debug": "^2.6.9", - "resolve": "^1.5.0" - } - }, - "eslint-module-utils": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.3.0.tgz", - "integrity": "sha512-lmDJgeOOjk8hObTysjqH7wyMi+nsHwwvfBykwfhjR1LNdd7C2uFJBvx4OpWYpXOw4df1yE1cDEVd1yLHitk34w==", - "dev": true, - "requires": { - "debug": "^2.6.8", - "pkg-dir": "^2.0.0" - } - }, - "eslint-plugin-import": { - "version": "2.16.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.16.0.tgz", - "integrity": "sha512-z6oqWlf1x5GkHIFgrSvtmudnqM6Q60KM4KvpWi5ubonMjycLjndvd5+8VAZIsTlHC03djdgJuyKG6XO577px6A==", - "dev": true, - "requires": { - "contains-path": "^0.1.0", - "debug": "^2.6.9", - "doctrine": "1.5.0", - "eslint-import-resolver-node": "^0.3.2", - "eslint-module-utils": "^2.3.0", - "has": "^1.0.3", - "lodash": "^4.17.11", - "minimatch": "^3.0.4", - "read-pkg-up": "^2.0.0", - "resolve": "^1.9.0" - }, - "dependencies": { - "doctrine": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz", - "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=", - "dev": true, - "requires": { - "esutils": "^2.0.2", - "isarray": "^1.0.0" - } - }, - "lodash": { - "version": "4.17.11", - "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz", - "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==", - "dev": true - }, - "path-parse": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", - "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", - "dev": true - }, - "resolve": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.10.0.tgz", - "integrity": "sha512-3sUr9aq5OfSg2S9pNtPA9hL1FVEAjvfOC4leW0SNf/mpnaakz2a9femSd6LqAww2RaFctwyf1lCqnTHuF1rxDg==", - "dev": true, - "requires": { - "path-parse": "^1.0.6" - } - } - } - }, - "eslint-plugin-jsx-a11y": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.2.0.tgz", - "integrity": "sha512-KpibpIdKT0nbDG7G/ILWoZoN5G9cj3h1IHARxzvHk5Nt2LQ7oPUutbO9QbT1FKNHLPZB6BaoA1ASSLOiJZVEUQ==", - "dev": true, - "requires": { - "aria-query": "^3.0.0", - "array-includes": "^3.0.3", - "ast-types-flow": "^0.0.7", - "axobject-query": "^2.0.2", - "damerau-levenshtein": "^1.0.4", - "emoji-regex": "^7.0.2", - "has": "^1.0.3", - "jsx-ast-utils": "^2.0.1" - } - }, - "eslint-plugin-prettier": { - "version": "2.7.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-2.7.0.tgz", - "integrity": "sha512-CStQYJgALoQBw3FsBzH0VOVDRnJ/ZimUlpLm226U8qgqYJfPOY/CPK6wyRInMxh73HSKg5wyRwdS4BVYYHwokA==", - "dev": true, - "requires": { - "fast-diff": "^1.1.1", - "jest-docblock": "^21.0.0" - } - }, - "eslint-plugin-react": { - "version": "7.12.4", - "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.12.4.tgz", - "integrity": "sha512-1puHJkXJY+oS1t467MjbqjvX53uQ05HXwjqDgdbGBqf5j9eeydI54G3KwiJmWciQ0HTBacIKw2jgwSBSH3yfgQ==", - "dev": true, - "requires": { - "array-includes": "^3.0.3", - "doctrine": "^2.1.0", - "has": "^1.0.3", - "jsx-ast-utils": "^2.0.1", - "object.fromentries": "^2.0.0", - "prop-types": "^15.6.2", - "resolve": "^1.9.0" - }, - "dependencies": { - "path-parse": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", - "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", - "dev": true - }, - "resolve": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.10.0.tgz", - "integrity": "sha512-3sUr9aq5OfSg2S9pNtPA9hL1FVEAjvfOC4leW0SNf/mpnaakz2a9femSd6LqAww2RaFctwyf1lCqnTHuF1rxDg==", - "dev": true, - "requires": { - "path-parse": "^1.0.6" - } - } - } - }, - "eslint-restricted-globals": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/eslint-restricted-globals/-/eslint-restricted-globals-0.1.1.tgz", - "integrity": "sha1-NfDVy8ZMLj7WLpO0saevBbp+1Nc=", - "dev": true - }, - "eslint-scope": { - "version": "3.7.3", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.3.tgz", - "integrity": "sha512-W+B0SvF4gamyCTmUc+uITPY0989iXVfKvhwtmJocTaYoc/3khEHmEmvfY/Gn9HA9VV75jrQECsHizkNw1b68FA==", - "dev": true, - "requires": { - "esrecurse": "^4.1.0", - "estraverse": "^4.1.1" - } - }, - "eslint-visitor-keys": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz", - "integrity": "sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==", - "dev": true - }, - "espree": { - "version": "3.5.4", - "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.4.tgz", - "integrity": "sha512-yAcIQxtmMiB/jL32dzEp2enBeidsB7xWPLNiw3IIkpVds1P+h7qF9YwJq1yUNzp2OKXgAprs4F61ih66UsoD1A==", - "dev": true, - "requires": { - "acorn": "^5.5.0", - "acorn-jsx": "^3.0.0" - } - }, "esprima": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", @@ -2605,29 +1759,12 @@ "dev": true, "optional": true }, - "esquery": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.1.tgz", - "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==", - "dev": true, - "requires": { - "estraverse": "^4.0.0" - } - }, - "esrecurse": { - "version": "4.2.1", - "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz", - "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==", - "dev": true, - "requires": { - "estraverse": "^4.1.0" - } - }, "estraverse": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=", - "dev": true + "dev": true, + "optional": true }, "esutils": { "version": "2.0.2", @@ -2687,17 +1824,6 @@ "dev": true, "optional": true }, - "external-editor": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz", - "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==", - "dev": true, - "requires": { - "chardet": "^0.4.0", - "iconv-lite": "^0.4.17", - "tmp": "^0.0.33" - } - }, "extglob": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz", @@ -2714,68 +1840,26 @@ "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=", "dev": true }, - "falafel": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.1.0.tgz", - "integrity": "sha1-lrsXdh2rqU9G0AFzizzt86Z/4Gw=", - "dev": true, - "requires": { - "acorn": "^5.0.0", - "foreach": "^2.0.5", - "isarray": "0.0.1", - "object-keys": "^1.0.6" - }, - "dependencies": { - "isarray": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", - "dev": true - } - } - }, "fast-deep-equal": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=", - "dev": true - }, - "fast-diff": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz", - "integrity": "sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==", - "dev": true + "dev": true, + "optional": true }, "fast-json-stable-stringify": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=", - "dev": true + "dev": true, + "optional": true }, "fast-levenshtein": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", - "dev": true - }, - "figures": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", - "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", "dev": true, - "requires": { - "escape-string-regexp": "^1.0.5" - } - }, - "file-entry-cache": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz", - "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", - "dev": true, - "requires": { - "flat-cache": "^1.2.1", - "object-assign": "^4.0.1" - } + "optional": true }, "filename-regex": { "version": "2.0.1", @@ -2798,27 +1882,6 @@ "repeat-string": "^1.5.2" } }, - "find-up": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", - "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", - "dev": true, - "requires": { - "locate-path": "^2.0.0" - } - }, - "flat-cache": { - "version": "1.3.4", - "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.4.tgz", - "integrity": "sha512-VwyB3Lkgacfik2vhqR4uv2rvebqmDvFu4jlN/C1RzWoJEo8I7z4Q404oiqYCkq41mni8EzQnm95emU9seckwtg==", - "dev": true, - "requires": { - "circular-json": "^0.3.1", - "graceful-fs": "^4.1.2", - "rimraf": "~2.6.2", - "write": "^0.2.1" - } - }, "for-in": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", @@ -2836,12 +1899,6 @@ "for-in": "^1.0.1" } }, - "foreach": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", - "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", - "dev": true - }, "forever-agent": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", @@ -3419,12 +2476,6 @@ "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", "dev": true }, - "functional-red-black-tree": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", - "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", - "dev": true - }, "get-assigned-identifiers": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/get-assigned-identifiers/-/get-assigned-identifiers-1.2.0.tgz", @@ -3488,9 +2539,9 @@ "dev": true }, "growl": { - "version": "1.10.5", - "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", - "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", + "version": "1.9.2", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.9.2.tgz", + "integrity": "sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=", "dev": true }, "har-schema": { @@ -3529,18 +2580,6 @@ "ansi-regex": "^2.0.0" } }, - "has-flag": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", - "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", - "dev": true - }, - "has-symbols": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz", - "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=", - "dev": true - }, "hash-base": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", @@ -3560,12 +2599,6 @@ "minimalistic-assert": "^1.0.1" } }, - "he": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", - "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=", - "dev": true - }, "hmac-drbg": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", @@ -3587,12 +2620,6 @@ "os-tmpdir": "^1.0.1" } }, - "hosted-git-info": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.7.1.tgz", - "integrity": "sha512-7T/BxH19zbcCTa8XkMlbK5lTo1WtgkFi3GvdWEyNuc4Vex7/9Dqbnpsf4JMydcfj9HCg4zUWFTL3Za6lapg5/w==", - "dev": true - }, "htmlescape": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", @@ -3717,24 +2744,10 @@ } } }, - "iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", - "dev": true, - "requires": { - "safer-buffer": ">= 2.1.2 < 3" - } - }, "ieee754": { "version": "1.1.12", "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz", - "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==" - }, - "ignore": { - "version": "3.3.10", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.10.tgz", - "integrity": "sha512-Pgs951kaMm5GXP7MOvxERINe3gsaVjUWFm+UZPSq9xYriQAksyhg0csnS0KXSNRD5NmNdapXEpjxG49+AKh/ug==", + "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==", "dev": true }, "immutable": { @@ -3742,12 +2755,6 @@ "resolved": "https://registry.npmjs.org/immutable/-/immutable-3.8.2.tgz", "integrity": "sha1-wkOZUUVbs5kT2vKBN28VMOEErfM=" }, - "imurmurhash": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", - "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", - "dev": true - }, "indexof": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", @@ -3778,74 +2785,6 @@ "source-map": "~0.5.3" } }, - "inquirer": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.3.0.tgz", - "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==", - "dev": true, - "requires": { - "ansi-escapes": "^3.0.0", - "chalk": "^2.0.0", - "cli-cursor": "^2.1.0", - "cli-width": "^2.0.0", - "external-editor": "^2.0.4", - "figures": "^2.0.0", - "lodash": "^4.3.0", - "mute-stream": "0.0.7", - "run-async": "^2.2.0", - "rx-lite": "^4.0.8", - "rx-lite-aggregates": "^4.0.8", - "string-width": "^2.1.0", - "strip-ansi": "^4.0.0", - "through": "^2.3.6" - }, - "dependencies": { - "ansi-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", - "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", - "dev": true - }, - "ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", - "dev": true, - "requires": { - "color-convert": "^1.9.0" - } - }, - "chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", - "dev": true, - "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" - } - }, - "strip-ansi": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", - "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", - "dev": true, - "requires": { - "ansi-regex": "^3.0.0" - } - }, - "supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", - "dev": true, - "requires": { - "has-flag": "^3.0.0" - } - } - } - }, "insert-module-globals": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.0.tgz", @@ -3887,12 +2826,6 @@ "loose-envify": "^1.0.0" } }, - "is-arrayish": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", - "dev": true - }, "is-binary-path": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", @@ -3909,27 +2842,6 @@ "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", "dev": true }, - "is-builtin-module": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", - "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", - "dev": true, - "requires": { - "builtin-modules": "^1.0.0" - } - }, - "is-callable": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz", - "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==", - "dev": true - }, - "is-date-object": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", - "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=", - "dev": true - }, "is-dotfile": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz", @@ -3969,12 +2881,6 @@ "number-is-nan": "^1.0.0" } }, - "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", - "dev": true - }, "is-glob": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", @@ -4008,36 +2914,6 @@ "dev": true, "optional": true }, - "is-promise": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz", - "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=", - "dev": true - }, - "is-regex": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", - "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", - "dev": true, - "requires": { - "has": "^1.0.1" - } - }, - "is-resolvable": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.1.0.tgz", - "integrity": "sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==", - "dev": true - }, - "is-symbol": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz", - "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==", - "dev": true, - "requires": { - "has-symbols": "^1.0.0" - } - }, "is-typedarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", @@ -4051,12 +2927,6 @@ "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", "dev": true }, - "isexe": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", - "dev": true - }, "isobject": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", @@ -4074,36 +2944,36 @@ "dev": true, "optional": true }, - "jest-docblock": { - "version": "21.2.0", - "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-21.2.0.tgz", - "integrity": "sha512-5IZ7sY9dBAYSV+YjQ0Ovb540Ku7AO9Z5o2Cg789xj167iQuZ2cG+z0f3Uct6WeYLbU6aQiM2pCs7sZ+4dotydw==", - "dev": true - }, - "js-tokens": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", - "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", - "dev": true - }, - "js-yaml": { - "version": "3.12.1", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.1.tgz", - "integrity": "sha512-um46hB9wNOKlwkHgiuyEVAybXBjwFUV0Z/RaHJblRd9DXltue9FTYvzCr9ErQrK9Adz5MU4gHWVaNUfdmrC8qA==", + "jade": { + "version": "0.26.3", + "resolved": "https://registry.npmjs.org/jade/-/jade-0.26.3.tgz", + "integrity": "sha1-jxDXl32NefL2/4YqgbBRPMslaGw=", "dev": true, "requires": { - "argparse": "^1.0.7", - "esprima": "^4.0.0" + "commander": "0.6.1", + "mkdirp": "0.3.0" }, "dependencies": { - "esprima": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", - "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "commander": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-0.6.1.tgz", + "integrity": "sha1-+mihT2qUXVTbvlDYzbMyDp47GgY=", + "dev": true + }, + "mkdirp": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.0.tgz", + "integrity": "sha1-G79asbqCevI1dRQ0kEJkVfSB/h4=", "dev": true } } }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", + "dev": true + }, "jsbn": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", @@ -4168,7 +3038,8 @@ "version": "0.3.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=", - "dev": true + "dev": true, + "optional": true }, "json-stable-stringify": { "version": "0.0.1", @@ -4179,12 +3050,6 @@ "jsonify": "~0.0.0" } }, - "json-stable-stringify-without-jsonify": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", - "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", - "dev": true - }, "json-stringify-safe": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", @@ -4232,15 +3097,6 @@ "verror": "1.10.0" } }, - "jsx-ast-utils": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-2.0.1.tgz", - "integrity": "sha1-6AGxs5mF4g//yHtA43SAgOLcrH8=", - "dev": true, - "requires": { - "array-includes": "^3.0.3" - } - }, "kind-of": { "version": "3.2.2", "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", @@ -4274,45 +3130,36 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", "dev": true, + "optional": true, "requires": { "prelude-ls": "~1.1.2", "type-check": "~0.3.2" } }, - "load-json-file": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", - "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "strip-bom": "^3.0.0" - } - }, - "locate-path": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", - "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", - "dev": true, - "requires": { - "p-locate": "^2.0.0", - "path-exists": "^3.0.0" - } - }, "lodash": { "version": "4.17.10", "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.10.tgz", "integrity": "sha512-UejweD1pDoXu+AD825lWwp4ZGtSwgnpZxb3JDViD7StjQz+Nb/6l093lx4OQ0foGWNRoc19mWy7BzL+UAK2iVg==", "dev": true }, + "lodash.assign": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz", + "integrity": "sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=", + "dev": true + }, "lodash.memoize": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", "dev": true }, + "lodash.pickby": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.pickby/-/lodash.pickby-4.6.0.tgz", + "integrity": "sha1-feoh2MGNdwOifHBMFdO4SmfjOv8=", + "dev": true + }, "long": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/long/-/long-3.2.0.tgz", @@ -4327,16 +3174,6 @@ "js-tokens": "^3.0.0 || ^4.0.0" } }, - "lru-cache": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", - "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==", - "dev": true, - "requires": { - "pseudomap": "^1.0.2", - "yallist": "^2.1.2" - } - }, "marked": { "version": "0.3.19", "resolved": "https://registry.npmjs.org/marked/-/marked-0.3.19.tgz", @@ -4406,12 +3243,6 @@ "mime-db": "~1.33.0" } }, - "mimic-fn": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz", - "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==", - "dev": true - }, "minimalistic-assert": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", @@ -4449,47 +3280,81 @@ } }, "mocha": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/mocha/-/mocha-5.2.0.tgz", - "integrity": "sha512-2IUgKDhc3J7Uug+FxMXuqIyYzH7gJjXECKe/w43IGgQHTSj3InJi+yAA7T24L9bQMRKiUEHxEX37G5JpVUGLcQ==", - "dev": true, - "requires": { - "browser-stdout": "1.3.1", - "commander": "2.15.1", - "debug": "3.1.0", - "diff": "3.5.0", - "escape-string-regexp": "1.0.5", - "glob": "7.1.2", - "growl": "1.10.5", - "he": "1.1.1", - "minimatch": "3.0.4", + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-2.5.3.tgz", + "integrity": "sha1-FhvlvetJZ3HrmzV0UFC2IrWu/Fg=", + "dev": true, + "requires": { + "commander": "2.3.0", + "debug": "2.2.0", + "diff": "1.4.0", + "escape-string-regexp": "1.0.2", + "glob": "3.2.11", + "growl": "1.9.2", + "jade": "0.26.3", "mkdirp": "0.5.1", - "supports-color": "5.4.0" + "supports-color": "1.2.0", + "to-iso-string": "0.0.2" }, "dependencies": { "commander": { - "version": "2.15.1", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.15.1.tgz", - "integrity": "sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.3.0.tgz", + "integrity": "sha1-/UMOiJgy7DU7ms0d4hfBHLPu+HM=", "dev": true }, "debug": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", - "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.2.0.tgz", + "integrity": "sha1-+HBX6ZWxofauaklgZkE3vFbwOdo=", "dev": true, "requires": { - "ms": "2.0.0" + "ms": "0.7.1" } }, - "supports-color": { - "version": "5.4.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", - "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "escape-string-regexp": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.2.tgz", + "integrity": "sha1-Tbwv5nTnGUnK8/smlc5/LcHZqNE=", + "dev": true + }, + "glob": { + "version": "3.2.11", + "resolved": "https://registry.npmjs.org/glob/-/glob-3.2.11.tgz", + "integrity": "sha1-Spc/Y1uRkPcV0QmH1cAP0oFevj0=", + "dev": true, + "requires": { + "inherits": "2", + "minimatch": "0.3" + } + }, + "lru-cache": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.7.3.tgz", + "integrity": "sha1-bUUk6LlV+V1PW1iFHOId1y+06VI=", + "dev": true + }, + "minimatch": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-0.3.0.tgz", + "integrity": "sha1-J12O2qxPG7MyZHIInnlJyDlGmd0=", "dev": true, "requires": { - "has-flag": "^3.0.0" + "lru-cache": "2", + "sigmund": "~1.0.0" } + }, + "ms": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-0.7.1.tgz", + "integrity": "sha1-nNE8A62/8ltl7/3nzoZO6VIBcJg=", + "dev": true + }, + "supports-color": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-1.2.0.tgz", + "integrity": "sha1-/x7R5hFp0Gs88tWI4YixjYhH4X4=", + "dev": true } } }, @@ -4522,12 +3387,6 @@ "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", "dev": true }, - "mute-stream": { - "version": "0.0.7", - "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", - "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=", - "dev": true - }, "nan": { "version": "2.10.0", "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz", @@ -4535,28 +3394,10 @@ "dev": true, "optional": true }, - "natural-compare": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", - "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", - "dev": true - }, "next-tick": { "version": "1.0.0", "resolved": "http://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz", - "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=" - }, - "normalize-package-data": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.2.tgz", - "integrity": "sha512-YcMnjqeoUckXTPKZSAsPjUPLxH85XotbpqK3w4RyCwdFQSU5FxxBys8buehkSfg0j9fKvV1hn7O0+8reEgkAiw==", - "dev": true, - "requires": { - "hosted-git-info": "^2.1.4", - "is-builtin-module": "^1.0.0", - "semver": "2 || 3 || 4 || 5", - "validate-npm-package-license": "^3.0.1" - } + "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=" }, "normalize-path": { "version": "2.1.1", @@ -4602,48 +3443,6 @@ "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", "dev": true }, - "object-keys": { - "version": "1.0.12", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz", - "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==", - "dev": true - }, - "object.assign": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", - "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", - "dev": true, - "requires": { - "define-properties": "^1.1.2", - "function-bind": "^1.1.1", - "has-symbols": "^1.0.0", - "object-keys": "^1.0.11" - } - }, - "object.entries": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.0.tgz", - "integrity": "sha512-l+H6EQ8qzGRxbkHOd5I/aHRhHDKoQXQ8g0BYt4uSweQU1/J6dZUOyWh9a2Vky35YCKjzmgxOzta2hH6kf9HuXA==", - "dev": true, - "requires": { - "define-properties": "^1.1.3", - "es-abstract": "^1.12.0", - "function-bind": "^1.1.1", - "has": "^1.0.3" - } - }, - "object.fromentries": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.0.tgz", - "integrity": "sha512-9iLiI6H083uiqUuvzyY6qrlmc/Gz8hLQFOcb/Ri/0xXFkSNS3ctV+CbE6yM2+AnkYfOB3dGjdzC0wrMLIhQICA==", - "dev": true, - "requires": { - "define-properties": "^1.1.2", - "es-abstract": "^1.11.0", - "function-bind": "^1.1.1", - "has": "^1.0.1" - } - }, "object.omit": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz", @@ -4664,20 +3463,12 @@ "wrappy": "1" } }, - "onetime": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz", - "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", - "dev": true, - "requires": { - "mimic-fn": "^1.0.0" - } - }, "optionator": { "version": "0.8.2", "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", "dev": true, + "optional": true, "requires": { "deep-is": "~0.1.3", "fast-levenshtein": "~2.0.4", @@ -4716,30 +3507,6 @@ "object-assign": "^4.1.0" } }, - "p-limit": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", - "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", - "dev": true, - "requires": { - "p-try": "^1.0.0" - } - }, - "p-locate": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", - "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", - "dev": true, - "requires": { - "p-limit": "^1.1.0" - } - }, - "p-try": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", - "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", - "dev": true - }, "pako": { "version": "0.2.9", "resolved": "https://registry.npmjs.org/pako/-/pako-0.2.9.tgz", @@ -4781,15 +3548,6 @@ "is-glob": "^2.0.0" } }, - "parse-json": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", - "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", - "dev": true, - "requires": { - "error-ex": "^1.2.0" - } - }, "parse5": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/parse5/-/parse5-3.0.3.tgz", @@ -4805,24 +3563,12 @@ "integrity": "sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==", "dev": true }, - "path-exists": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", - "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", - "dev": true - }, "path-is-absolute": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", "dev": true }, - "path-is-inside": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz", - "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=", - "dev": true - }, "path-parse": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", @@ -4835,15 +3581,6 @@ "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=", "dev": true }, - "path-type": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", - "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", - "dev": true, - "requires": { - "pify": "^2.0.0" - } - }, "pbkdf2": { "version": "3.0.16", "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.16.tgz", @@ -4858,8 +3595,8 @@ } }, "peerplaysjs-ws": { - "version": "git+ssh://git@github.com/PBSA/peerplaysjs-ws.git#a92c3d94297d79e41c75c0c9f63898e59a888a2a", - "from": "git+ssh://git@github.com/PBSA/peerplaysjs-ws.git", + "version": "0.1.11", + "resolved": "git+ssh://git@github.com/PBSA/peerplaysjs-ws.git#a92c3d94297d79e41c75c0c9f63898e59a888a2a", "requires": { "ws": "2.3.1" } @@ -4871,27 +3608,6 @@ "dev": true, "optional": true }, - "pify": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", - "dev": true - }, - "pkg-dir": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-2.0.0.tgz", - "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", - "dev": true, - "requires": { - "find-up": "^2.1.0" - } - }, - "pluralize": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz", - "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==", - "dev": true - }, "prelude-ls": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", @@ -4905,12 +3621,6 @@ "dev": true, "optional": true }, - "prettier": { - "version": "1.16.3", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-1.16.3.tgz", - "integrity": "sha512-kn/GU6SMRYPxUakNXhpP0EedT/KmaPzr0H5lIsDogrykbaxOpOfAFfk5XA7DZrJyMAv1wlMV3CPcZruGXVVUZw==", - "dev": true - }, "private": { "version": "0.1.8", "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", @@ -4929,28 +3639,6 @@ "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==", "dev": true }, - "progress": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", - "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", - "dev": true - }, - "prop-types": { - "version": "15.6.2", - "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.6.2.tgz", - "integrity": "sha512-3pboPvLiWD7dkI3qf3KbUe6hKFKa52w+AE0VCqECtf+QHAKgOL37tTaNCnuX1nAAQ4ZhyP+kYVKf8rLmJ/feDQ==", - "dev": true, - "requires": { - "loose-envify": "^1.3.1", - "object-assign": "^4.1.1" - } - }, - "pseudomap": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", - "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", - "dev": true - }, "psl": { "version": "1.1.28", "resolved": "https://registry.npmjs.org/psl/-/psl-1.1.28.tgz", @@ -5052,27 +3740,6 @@ "readable-stream": "^2.0.2" } }, - "read-pkg": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", - "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", - "dev": true, - "requires": { - "load-json-file": "^2.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^2.0.0" - } - }, - "read-pkg-up": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", - "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", - "dev": true, - "requires": { - "find-up": "^2.0.0", - "read-pkg": "^2.0.0" - } - }, "readable-stream": { "version": "2.3.6", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", @@ -5134,12 +3801,6 @@ "is-equal-shallow": "^0.1.3" } }, - "regexpp": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-1.1.0.tgz", - "integrity": "sha512-LOPw8FpgdQF9etWMaAfG/WRthIdXJGYp4mJ2Jgn/2lpkbod9jPn0t9UqN7AxBOKNfzRbYyVfgc7Vk4t/MpnXgw==", - "dev": true - }, "regexpu-core": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", @@ -5243,16 +3904,6 @@ } } }, - "require-uncached": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz", - "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", - "dev": true, - "requires": { - "caller-path": "^0.1.0", - "resolve-from": "^1.0.0" - } - }, "resolve": { "version": "1.8.1", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.8.1.tgz", @@ -5262,47 +3913,6 @@ "path-parse": "^1.0.5" } }, - "resolve-from": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz", - "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=", - "dev": true - }, - "restore-cursor": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz", - "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", - "dev": true, - "requires": { - "onetime": "^2.0.0", - "signal-exit": "^3.0.2" - } - }, - "rimraf": { - "version": "2.6.3", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", - "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", - "dev": true, - "requires": { - "glob": "^7.1.3" - }, - "dependencies": { - "glob": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", - "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", - "dev": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - } - } - }, "ripemd160": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", @@ -5312,30 +3922,6 @@ "inherits": "^2.0.1" } }, - "run-async": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", - "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", - "dev": true, - "requires": { - "is-promise": "^2.1.0" - } - }, - "rx-lite": { - "version": "4.0.8", - "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-4.0.8.tgz", - "integrity": "sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=", - "dev": true - }, - "rx-lite-aggregates": { - "version": "4.0.8", - "resolved": "https://registry.npmjs.org/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz", - "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=", - "dev": true, - "requires": { - "rx-lite": "*" - } - }, "safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", @@ -5345,7 +3931,8 @@ "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", - "dev": true + "dev": true, + "optional": true }, "sax": { "version": "1.2.4", @@ -5359,12 +3946,6 @@ "resolved": "https://registry.npmjs.org/secure-random/-/secure-random-1.1.1.tgz", "integrity": "sha1-CIDy2MUYX0vLRoQFjINrTdsHFFo=" }, - "semver": { - "version": "5.6.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz", - "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==", - "dev": true - }, "set-immediate-shim": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", @@ -5391,21 +3972,6 @@ "sha.js": "~2.4.4" } }, - "shebang-command": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", - "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", - "dev": true, - "requires": { - "shebang-regex": "^1.0.0" - } - }, - "shebang-regex": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", - "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", - "dev": true - }, "shell-quote": { "version": "1.6.1", "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.6.1.tgz", @@ -5418,10 +3984,10 @@ "jsonify": "~0.0.0" } }, - "signal-exit": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", - "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "sigmund": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz", + "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=", "dev": true }, "simple-concat": { @@ -5436,15 +4002,6 @@ "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=", "dev": true }, - "slice-ansi": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz", - "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", - "dev": true, - "requires": { - "is-fullwidth-code-point": "^2.0.0" - } - }, "source-map": { "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", @@ -5460,44 +4017,6 @@ "source-map": "^0.5.6" } }, - "spdx-correct": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz", - "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==", - "dev": true, - "requires": { - "spdx-expression-parse": "^3.0.0", - "spdx-license-ids": "^3.0.0" - } - }, - "spdx-exceptions": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz", - "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==", - "dev": true - }, - "spdx-expression-parse": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", - "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", - "dev": true, - "requires": { - "spdx-exceptions": "^2.1.0", - "spdx-license-ids": "^3.0.0" - } - }, - "spdx-license-ids": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.3.tgz", - "integrity": "sha512-uBIcIl3Ih6Phe3XHK1NqboJLdGfwr1UN3k6wSD1dZpmPsIkb8AGNbZYJ1fOBk834+Gxy8rpfDxrS6XLEMZMY2g==", - "dev": true - }, - "sprintf-js": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", - "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", - "dev": true - }, "sshpk": { "version": "1.14.2", "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.2.tgz", @@ -5559,33 +4078,6 @@ "readable-stream": "^2.0.2" } }, - "string-width": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", - "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", - "dev": true, - "requires": { - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^4.0.0" - }, - "dependencies": { - "ansi-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", - "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", - "dev": true - }, - "strip-ansi": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", - "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", - "dev": true, - "requires": { - "ansi-regex": "^3.0.0" - } - } - } - }, "string_decoder": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", @@ -5604,18 +4096,6 @@ "ansi-regex": "^2.0.0" } }, - "strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", - "dev": true - }, - "strip-json-comments": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", - "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", - "dev": true - }, "subarg": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", @@ -5655,63 +4135,12 @@ "acorn-node": "^1.2.0" } }, - "table": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/table/-/table-4.0.2.tgz", - "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==", - "dev": true, - "requires": { - "ajv": "^5.2.3", - "ajv-keywords": "^2.1.0", - "chalk": "^2.1.0", - "lodash": "^4.17.4", - "slice-ansi": "1.0.0", - "string-width": "^2.1.1" - }, - "dependencies": { - "ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", - "dev": true, - "requires": { - "color-convert": "^1.9.0" - } - }, - "chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", - "dev": true, - "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" - } - }, - "supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", - "dev": true, - "requires": { - "has-flag": "^3.0.0" - } - } - } - }, "taffydb": { "version": "2.7.3", "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.7.3.tgz", "integrity": "sha1-KtNxaWKUmPylvIQkMJbTzeDsOjQ=", "dev": true }, - "text-table": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", - "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", - "dev": true - }, "through": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", @@ -5737,15 +4166,6 @@ "process": "~0.11.0" } }, - "tmp": { - "version": "0.0.33", - "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", - "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", - "dev": true, - "requires": { - "os-tmpdir": "~1.0.2" - } - }, "to-arraybuffer": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", @@ -5758,6 +4178,12 @@ "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=", "dev": true }, + "to-iso-string": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/to-iso-string/-/to-iso-string-0.0.2.tgz", + "integrity": "sha1-TcGeZk38y+Jb2NtQiwDG2hWCVdE=", + "dev": true + }, "tough-cookie": { "version": "2.4.3", "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz", @@ -5820,29 +4246,11 @@ "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", "dev": true }, - "uglify-js": { - "version": "3.4.9", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.4.9.tgz", - "integrity": "sha512-8CJsbKOtEbnJsTyv6LE6m6ZKniqMiFWmm9sRbopbkGs3gMPPfd3Fh8iIA4Ykv5MgaTbqHr4BaoGLJLZNhsrW1Q==", - "dev": true, - "requires": { - "commander": "~2.17.1", - "source-map": "~0.6.1" - }, - "dependencies": { - "commander": { - "version": "2.17.1", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.17.1.tgz", - "integrity": "sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==", - "dev": true - }, - "source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "dev": true - } - } + "uglifyjs": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/uglifyjs/-/uglifyjs-2.4.11.tgz", + "integrity": "sha1-NEDWTgRXWViVJEGOtkHGi7kNET4=", + "dev": true }, "ultron": { "version": "1.1.1", @@ -5901,6 +4309,7 @@ "version": "0.10.3", "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "dev": true, "requires": { "inherits": "2.0.1" }, @@ -5908,7 +4317,8 @@ "inherits": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", - "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=" + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", + "dev": true } } }, @@ -5934,16 +4344,6 @@ "user-home": "^1.1.1" } }, - "validate-npm-package-license": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", - "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", - "dev": true, - "requires": { - "spdx-correct": "^3.0.0", - "spdx-expression-parse": "^3.0.0" - } - }, "verror": { "version": "1.10.0", "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", @@ -5982,20 +4382,12 @@ "tr46": "~0.0.1" } }, - "which": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", - "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", - "dev": true, - "requires": { - "isexe": "^2.0.0" - } - }, "wordwrap": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", - "dev": true + "dev": true, + "optional": true }, "wrappy": { "version": "1.0.2", @@ -6003,15 +4395,6 @@ "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", "dev": true }, - "write": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz", - "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", - "dev": true, - "requires": { - "mkdirp": "^0.5.1" - } - }, "ws": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/ws/-/ws-2.3.1.tgz", @@ -6040,12 +4423,6 @@ "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=", "dev": true - }, - "yallist": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", - "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", - "dev": true } } } diff --git a/package.json b/package.json index cccf9d9..9b521be 100644 --- a/package.json +++ b/package.json @@ -1,84 +1,71 @@ { - "name": "peerplaysjs-lib", - "version": "0.4.24", - "description": "Pure JavaScript Peerplaysjs library for node.js and browsers.", - "browser": { - "ws": false, - "crypto": false - }, - "scripts": { - "test": "BABEL_ENV=test mocha --compilers js:babel-register --recursive", - "test:chain": "BABEL_ENV=test mocha --compilers js:babel-register ./test/chain --recursive", - "test:ecc": "BABEL_ENV=test mocha --compilers js:babel-register ./test/ecc --recursive", - "test:serializer": "BABEL_ENV=test mocha --compilers js:babel-register ./test/serializer --recursive", - "test:watch": "npm test -- --watch", - "clean": "rm -rf ./dist/* & rm -rf ./build/*", - "prebuild": "npm run clean", - "build": "babel lib -d dist", - "postbuild": "npm run browserify", - "build:watch": "babel lib -d dist --watch", - "prebrowserify": "rm -rf ./build/*", - "browserify": "browserify -t [browserify-package-json --global=true] -p [bundle-collapser/plugin] dist/browser.js --full-path=false --standalone peerplays_js -o build/peerplaysjs-lib.js -d", - "postbrowserify": "uglifyjs --compress --mangle --sequences --drop_console --output build/peerplaysjs-lib.min.js -- build/peerplaysjs-lib.js", - "doc": "esdoc -c esdoc.json", - "example:transfer": "babel-node examples/transfer", - "example:chainStore": "babel-node examples/chainStore", - "example:privKey": "babel-node examples/privKey" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/PBSA/peerplaysjs-lib" - }, - "author": "Sigve Kvalsvik (https://github.com/svk31)", - "contributors": [ - "James Calfee (https://github.com/jcalfee/)", - "Daniel Larimer (https://github.com/bytemaster/)", - "Valentine Zavgorodnev (https://github.com/valzav/)" - ], - "license": "MIT", - "bugs": { - "url": "https://github.com/PBSA/peerplaysjs-lib/issues" - }, - "engines": { - "node": ">= 6.0.0" - }, - "main": "dist/index.js", - "jsnext:main": "lib/index.js", - "dependencies": { - "assert": "^1.3.0", - "bigi": "^1.4.1", - "bs58": "^3.0.0", - "buffer": "^5.1.0", - "bytebuffer": "^5.0.0", - "create-hash": "^1.1.2", - "create-hmac": "^1.1.4", - "crypto-js": "^3.1.9-1", - "deep-equal": "^1.0.1", - "ecurve": "^1.0.2", - "event-emitter": "^0.3.4", - "immutable": "^3.7.6", - "peerplaysjs-ws": "git+ssh://git@github.com:PBSA/peerplaysjs-ws.git", - "secure-random": "^1.1.1" - }, - "devDependencies": { - "babel-cli": "^6.18.0", - "babel-core": "^6.21.0", - "babel-eslint": "^7.1.1", - "babel-plugin-add-module-exports": "^0.2.1", - "babel-preset-es2015": "^6.18.0", - "babel-preset-stage-1": "^6.16.0", - "browserify": "^13.1.0", - "browserify-package-json": "^1.0.1", - "bundle-collapser": "^1.3.0", - "esdoc": "^1.1.0", - "eslint": "^4.19.1", - "eslint-config-airbnb": "^17.0.0", - "eslint-plugin-import": "^2.13.0", - "eslint-plugin-jsx-a11y": "^6.1.1", - "eslint-plugin-prettier": "^2.6.2", - "eslint-plugin-react": "^7.10.0", - "mocha": "^5.2.0", - "prettier": "^1.13.7", - "uglify-js": "^3.4.9" - } + "name": "peerplaysjs-lib", + "version": "0.4.20", + "description": "Pure JavaScript Peerplays/Graphene library for node.js and browsers.", + "browser": { + "ws": false, + "crypto": false + }, + "scripts": { + "test": "mocha --compilers js:babel-core/register --recursive", + "test:chain": "mocha --compilers js:babel-core/register ./test/chain --recursive", + "test:ecc": "mocha --compilers js:babel-core/register ./test/ecc --recursive", + "test:serializer": "mocha --compilers js:babel-core/register ./test/serializer --recursive", + "test:watch": "npm test -- --watch", + "clean": "rm -rf ./dist/* & rm -rf ./build/*", + "prebuild": "npm run clean", + "build": "babel lib --presets es2015-generators-async --plugins transform-async-to-generator --out-dir dist", + "build:watch": "babel lib --presets es2015-generators-async --out-dir dist --watch", + "prebrowserify": "rm -rf ./build/*", + "browserify": "browserify --full-paths dist/browser.js --standalone steemJS -o build/peerplaysjs-lib.js -d", + "postbrowserify": "uglifyjs --compress --mangle --sequences --drop_console --output build/peerplaysjs-lib.min.js -- build/peerplaysjs-lib.js", + "prepublish": "npm run build", + "doc": "esdoc -c esdoc.json" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/PBSA/peerplaysjs-lib.git" + }, + "author": "Sigve Kvalsvik (https://github.com/svk31)", + "contributors": [ + "James Calfee (https://github.com/jcalfee/)", + "Daniel Larimer (https://github.com/bytemaster/)", + "Valentine Zavgorodnev (https://github.com/valzav/)" + ], + "license": "BSD-2-Clause-FreeBSD", + "bugs": { + "url": "https://github.com/PBSA/peerplaysjs-lib/issues" + }, + "engines": { + "node": ">= 6.0.0" + }, + "main": "./dist/index.js", + "dependencies": { + "bigi": "^1.4.1", + "bluebird": "^3.5.0", + "bs58": "^3.0.0", + "bytebuffer": "^5.0.0", + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "crypto-js": "^3.1.5", + "deep-equal": "^1.0.1", + "ecurve": "^1.0.2", + "event-emitter": "^0.3.4", + "immutable": "^3.7.6", + "peerplaysjs-ws": "^0.1.11", + "secure-random": "^1.1.1" + }, + "devDependencies": { + "assert": "^1.3.0", + "babel-cli": "^6.9.0", + "babel-core": "^6.10.4", + "babel-eslint": "^6.0.4", + "babel-plugin-transform-async-to-generator": "^6.24.1", + "babel-preset-es2015": "^6.24.1", + "babel-preset-es2015-generators-async": "^6.3.13", + "browserify": "^13.1.0", + "esdoc": "^1.1.0", + "mocha": "^2.5.3", + "uglifyjs": "^2.4.10" + } } From fd68ba19485a2b133531aaa0a76028c74cea2ed3 Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 15:34:58 -0400 Subject: [PATCH 09/15] include dist --- .gitignore | 3 +- dist/browser.js | 11 + dist/chain/index.js | 23 + dist/chain/src/AccountLogin.js | 132 ++ dist/chain/src/ChainStore.js | 1711 +++++++++++++++++++ dist/chain/src/ChainTypes.js | 116 ++ dist/chain/src/ChainValidation.js | 144 ++ dist/chain/src/EmitterInstance.js | 14 + dist/chain/src/GameMoves.js | 113 ++ dist/chain/src/NumberUtils.js | 44 + dist/chain/src/ObjectId.js | 71 + dist/chain/src/TransactionBuilder.js | 591 +++++++ dist/chain/src/TransactionHelper.js | 104 ++ dist/chain/src/state.js | 19 + dist/ecc/index.js | 12 + dist/ecc/src/BrainKey.js | 9 + dist/ecc/src/KeyUtils.js | 202 +++ dist/ecc/src/PrivateKey.js | 213 +++ dist/ecc/src/PublicKey.js | 236 +++ dist/ecc/src/address.js | 95 + dist/ecc/src/aes.js | 308 ++++ dist/ecc/src/ecdsa.js | 219 +++ dist/ecc/src/ecsignature.js | 128 ++ dist/ecc/src/enforce_types.js | 49 + dist/ecc/src/hash.js | 60 + dist/ecc/src/signature.js | 187 ++ dist/index.js | 3 + dist/serializer/index.js | 22 + dist/serializer/src/FastParser.js | 90 + dist/serializer/src/SerializerValidation.js | 363 ++++ dist/serializer/src/convert.js | 37 + dist/serializer/src/error_with_cause.js | 42 + dist/serializer/src/operations.js | 709 ++++++++ dist/serializer/src/precision.js | 95 + dist/serializer/src/serializer.js | 207 +++ dist/serializer/src/template.js | 17 + dist/serializer/src/types.js | 1024 +++++++++++ 37 files changed, 7421 insertions(+), 2 deletions(-) create mode 100644 dist/browser.js create mode 100644 dist/chain/index.js create mode 100644 dist/chain/src/AccountLogin.js create mode 100644 dist/chain/src/ChainStore.js create mode 100644 dist/chain/src/ChainTypes.js create mode 100644 dist/chain/src/ChainValidation.js create mode 100644 dist/chain/src/EmitterInstance.js create mode 100644 dist/chain/src/GameMoves.js create mode 100644 dist/chain/src/NumberUtils.js create mode 100644 dist/chain/src/ObjectId.js create mode 100644 dist/chain/src/TransactionBuilder.js create mode 100644 dist/chain/src/TransactionHelper.js create mode 100644 dist/chain/src/state.js create mode 100644 dist/ecc/index.js create mode 100644 dist/ecc/src/BrainKey.js create mode 100644 dist/ecc/src/KeyUtils.js create mode 100644 dist/ecc/src/PrivateKey.js create mode 100644 dist/ecc/src/PublicKey.js create mode 100644 dist/ecc/src/address.js create mode 100644 dist/ecc/src/aes.js create mode 100644 dist/ecc/src/ecdsa.js create mode 100644 dist/ecc/src/ecsignature.js create mode 100644 dist/ecc/src/enforce_types.js create mode 100644 dist/ecc/src/hash.js create mode 100644 dist/ecc/src/signature.js create mode 100644 dist/index.js create mode 100644 dist/serializer/index.js create mode 100644 dist/serializer/src/FastParser.js create mode 100644 dist/serializer/src/SerializerValidation.js create mode 100644 dist/serializer/src/convert.js create mode 100644 dist/serializer/src/error_with_cause.js create mode 100644 dist/serializer/src/operations.js create mode 100644 dist/serializer/src/precision.js create mode 100644 dist/serializer/src/serializer.js create mode 100644 dist/serializer/src/template.js create mode 100644 dist/serializer/src/types.js diff --git a/.gitignore b/.gitignore index 3d658a9..0b79b02 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ .npmrc npm-debug.log node_modules -.babelrc -dist +.babelrc \ No newline at end of file diff --git a/dist/browser.js b/dist/browser.js new file mode 100644 index 0000000..dc2b3d3 --- /dev/null +++ b/dist/browser.js @@ -0,0 +1,11 @@ +"use strict"; + +module.exports = { + PrivateKey: require("./ecc/src/PrivateKey"), + PublicKey: require("./ecc/src/PublicKey"), + Signature: require("./ecc/src/signature"), + key: require("./ecc/src/KeyUtils"), + TransactionBuilder: require("./chain/src/TransactionBuilder"), + Login: require("./chain/src/AccountLogin"), + grapheneWS: require("peerplaysjs-ws") +}; \ No newline at end of file diff --git a/dist/chain/index.js b/dist/chain/index.js new file mode 100644 index 0000000..9b10496 --- /dev/null +++ b/dist/chain/index.js @@ -0,0 +1,23 @@ +"use strict"; + +var ChainStore = require("./src/ChainStore"); +var TransactionBuilder = require("./src/TransactionBuilder"); + +module.exports = { + ChainStore: ChainStore, + TransactionBuilder: TransactionBuilder, + FetchChainObjects: ChainStore.FetchChainObjects, + + ChainTypes: require("./src/ChainTypes"), + ObjectId: require("./src/ObjectId"), + NumberUtils: require("./src/NumberUtils"), + TransactionHelper: require("./src/TransactionHelper"), + ChainValidation: require("./src/ChainValidation"), + EmitterInstance: require("./src/EmitterInstance"), + Login: require("./src/AccountLogin"), + GameMoves: require("./src/GameMoves"), + + /** Helper function for FetchChainObjects */ + FetchChain: ChainStore.FetchChain + +}; \ No newline at end of file diff --git a/dist/chain/src/AccountLogin.js b/dist/chain/src/AccountLogin.js new file mode 100644 index 0000000..b082e45 --- /dev/null +++ b/dist/chain/src/AccountLogin.js @@ -0,0 +1,132 @@ +"use strict"; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var PrivateKey = require("../../ecc/src/PrivateKey"); +var key = require("../../ecc/src/KeyUtils"); + +var _require = require("./state"), + get = _require.get, + set = _require.set; + +var _keyCachePriv = {}; +var _keyCachePub = {}; + +var AccountLogin = function () { + function AccountLogin() { + _classCallCheck(this, AccountLogin); + + var state = { loggedIn: false, roles: ["active", "owner", "memo"] }; + this.get = get(state); + this.set = set(state); + + this.subs = {}; + } + + _createClass(AccountLogin, [{ + key: "addSubscription", + value: function addSubscription(cb) { + this.subs[cb] = cb; + } + }, { + key: "setRoles", + value: function setRoles(roles) { + this.set("roles", roles); + } + }, { + key: "generateKeys", + value: function generateKeys(accountName, password, roles, prefix) { + var start = new Date().getTime(); + if (!accountName || !password) { + throw new Error("Account name or password required"); + } + if (password.length < 12) { + throw new Error("Password must have at least 12 characters"); + } + + var privKeys = {}; + var pubKeys = {}; + + (roles || this.get("roles")).forEach(function (role) { + var seed = accountName + role + password; + var pkey = _keyCachePriv[seed] ? _keyCachePriv[seed] : PrivateKey.fromSeed(key.normalize_brainKey(seed)); + _keyCachePriv[seed] = pkey; + + privKeys[role] = pkey; + pubKeys[role] = _keyCachePub[seed] ? _keyCachePub[seed] : pkey.toPublicKey().toString(prefix); + + _keyCachePub[seed] = pubKeys[role]; + }); + + return { privKeys: privKeys, pubKeys: pubKeys }; + } + }, { + key: "checkKeys", + value: function checkKeys(_ref) { + var _this = this; + + var accountName = _ref.accountName, + password = _ref.password, + auths = _ref.auths; + + if (!accountName || !password || !auths) { + throw new Error("checkKeys: Missing inputs"); + } + var hasKey = false; + + var _loop = function _loop(role) { + var _generateKeys = _this.generateKeys(accountName, password, [role]), + privKeys = _generateKeys.privKeys, + pubKeys = _generateKeys.pubKeys; + + auths[role].forEach(function (key) { + if (key[0] === pubKeys[role]) { + hasKey = true; + _this.set(role, { priv: privKeys[role], pub: pubKeys[role] }); + } + }); + }; + + for (var role in auths) { + _loop(role); + }; + + if (hasKey) { + this.set("name", accountName); + } + + this.set("loggedIn", hasKey); + + return hasKey; + } + }, { + key: "signTransaction", + value: function signTransaction(tr) { + var _this2 = this; + + var myKeys = {}; + var hasKey = false; + + this.get("roles").forEach(function (role) { + var myKey = _this2.get(role); + if (myKey) { + hasKey = true; + console.log("adding signer:", myKey.pub); + tr.add_signer(myKey.priv, myKey.pub); + } + }); + + if (!hasKey) { + throw new Error("You do not have any private keys to sign this transaction"); + } + } + }]); + + return AccountLogin; +}(); + +var accountLogin = new AccountLogin(); + +module.exports = accountLogin; \ No newline at end of file diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js new file mode 100644 index 0000000..a00b15e --- /dev/null +++ b/dist/chain/src/ChainStore.js @@ -0,0 +1,1711 @@ +"use strict"; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Immutable = require("immutable"); + +var _require = require("peerplaysjs-ws"), + Apis = _require.Apis; + +var _require2 = require("./ChainTypes"), + object_type = _require2.object_type, + impl_object_type = _require2.impl_object_type; + +var ChainValidation = require("./ChainValidation"); +var BigInteger = require("bigi"); +var ee = require("./EmitterInstance"); + +var emitter = ee.emitter(); + +var op_history = parseInt(object_type.operation_history, 10); +var limit_order = parseInt(object_type.limit_order, 10); +var call_order = parseInt(object_type.call_order, 10); +var proposal = parseInt(object_type.proposal, 10); +var balance_type = parseInt(object_type.balance, 10); +var vesting_balance_type = parseInt(object_type.vesting_balance, 10); +var witness_object_type = parseInt(object_type.witness, 10); +var worker_object_type = parseInt(object_type.worker, 10); +var committee_member_object_type = parseInt(object_type.committee_member, 10); +var account_object_type = parseInt(object_type.account, 10); +var asset_object_type = parseInt(object_type.asset, 10); +var tournament_object_type = parseInt(object_type.tournament, 10); +var tournament_details_object_type = parseInt(object_type.tournament_details, 10); + +var order_prefix = "1." + limit_order + "."; +var call_order_prefix = "1." + call_order + "."; +var proposal_prefix = "1." + proposal + "."; +var balance_prefix = "2." + parseInt(impl_object_type.account_balance, 10) + "."; +var account_stats_prefix = "2." + parseInt(impl_object_type.account_statistics, 10) + "."; +var asset_dynamic_data_prefix = "2." + parseInt(impl_object_type.asset_dynamic_data, 10) + "."; +var bitasset_data_prefix = "2." + parseInt(impl_object_type.asset_bitasset_data, 10) + "."; +var vesting_balance_prefix = "1." + vesting_balance_type + "."; +var witness_prefix = "1." + witness_object_type + "."; +var worker_prefix = "1." + worker_object_type + "."; +var committee_prefix = "1." + committee_member_object_type + "."; +var asset_prefix = "1." + asset_object_type + "."; +var account_prefix = "1." + account_object_type + "."; +var tournament_prefix = "1." + tournament_object_type + "."; +var tournament_details_prefix = "1." + tournament_details_object_type + "."; + +// count last operations should be stored in memory +var operations_stack_size = 100; +// count last blocks should be stored in memory +var block_stack_size = 20; + +var DEBUG = JSON.parse(process.env.npm_config__graphene_chain_chain_debug || false); + +/** + * @brief maintains a local cache of blockchain state + * + * The ChainStore maintains a local cache of blockchain state and exposes + * an API that makes it easy to query objects and receive updates when + * objects are available. + */ + +var ChainStore = function () { + function ChainStore() { + _classCallCheck(this, ChainStore); + + /** tracks everyone who wants to receive updates when the cache changes */ + this.subscribers = new Set(); + this.subscribed = false; + this.clearCache(); + this.progress = 0; + // this.chain_time_offset is used to estimate the blockchain time + this.chain_time_offset = []; + this.dispatchFrequency = 40; + } + + /** + * Clears all cached state. This should be called any time the network connection is + * reset. + */ + + + _createClass(ChainStore, [{ + key: "clearCache", + value: function clearCache() { + this.objects_by_id = Immutable.Map(); + this.accounts_by_name = Immutable.Map(); + this.assets_by_symbol = Immutable.Map(); + this.account_ids_by_key = Immutable.Map(); + this.balance_objects_by_address = Immutable.Map(); + this.get_account_refs_of_keys_calls = Immutable.Set(); + this.account_history_requests = new Map(); ///< tracks pending history requests + this.witness_by_account_id = new Map(); + this.account_by_witness_id = new Map(); + this.committee_by_account_id = new Map(); + this.objects_by_vote_id = new Map(); + this.fetching_get_full_accounts = new Map(); + this.recent_operations = Immutable.List(); + this.recent_blocks = Immutable.List(); + this.recent_blocks_by_id = Immutable.Map(); + this.last_processed_block = null; + this.simple_objects_by_id = Immutable.Map(); + + // tournament_ids_by_state is a + // Map(account => Map(state_string => Set of tournament ids)) + // it maintains a map of tournaments a given account is allowed to participate + // in (open-registration tournaments or tournaments they are whitelisted for). + // the null account maps to all tournaments + // accounts and states will not be tracked until their first access + this.tournament_ids_by_state = Immutable.Map().set(null, new Immutable.Map()); + + // registered_tournaments_details_by_player is a map of + // Map(registered_account_id => Set of tournament details objects) + // it only tracks tournaments which the account has registered to play in + this.registered_tournament_ids_by_player = Immutable.Map(); + + this.last_tournament_id = undefined; + + this.store_initialized = false; + } + }, { + key: "resetCache", + value: function resetCache() { + this.subscribed = false; + this.clearCache(); + this.head_block_time_string = null; + this.init().then(function (result) { + console.log("resetCache init success"); + }).catch(function (err) { + console.log("resetCache init error:", err); + }); + } + }, { + key: "setDispatchFrequency", + value: function setDispatchFrequency(freq) { + this.dispatchFrequency = freq; + } + }, { + key: "init", + value: function init() { + var _this = this; + + var reconnectCounter = 0; + var _init = function _init(resolve, reject) { + var db_api = Apis.instance().db_api(); + if (!db_api) { + return reject(new Error("Api not found, please initialize the api instance before calling the ChainStore")); + } + return db_api.exec("get_objects", [["2.1.0"]]).then(function (optional_objects) { + //if(DEBUG) console.log('... optional_objects',optional_objects ? optional_objects[0].id : null) + for (var i = 0; i < optional_objects.length; i++) { + var optional_object = optional_objects[i]; + if (optional_object) { + + _this._updateObject(optional_object, true); + + var head_time = new Date(optional_object.time + "+00:00").getTime(); + _this.head_block_time_string = optional_object.time; + _this.chain_time_offset.push(new Date().getTime() - _this.timeStringToDate(optional_object.time).getTime()); + var now = new Date().getTime(); + var delta = (now - head_time) / 1000; + var start = Date.parse('Sep 1, 2015'); + var progress_delta = head_time - start; + _this.progress = progress_delta / (now - start); + + if (delta < 60) { + Apis.instance().db_api().exec("set_subscribe_callback", [_this.onUpdate.bind(_this), true]).then(function (v) { + console.log("synced and subscribed, chainstore ready"); + _this.subscribed = true; + _this.fetchRecentOperations(); + resolve(); + }).catch(function (error) { + reject(error); + console.log("Error: ", error); + }); + } else { + console.log("not yet synced, retrying in 1s"); + reconnectCounter++; + if (reconnectCounter > 10) { + throw new Error("ChainStore sync error, please check your system clock"); + } + setTimeout(_init.bind(_this, resolve, reject), 1000); + } + } else { + setTimeout(_init.bind(_this, resolve, reject), 1000); + } + } + }).catch(function (error) { + // in the event of an error clear the pending state for id + console.log('!!! Chain API error', error); + _this.objects_by_id = _this.objects_by_id.delete("2.1.0"); + reject(error); + }); + }; + + return new Promise(function (resolve, reject) { + return _init(resolve, reject); + }); + } + }, { + key: "onUpdate", + value: function onUpdate(updated_objects) /// map from account id to objects + { + emitter.emit('heartbeat'); + // updated_objects is the parameter list, it should always be exactly + // one element long. + // The single parameter to this callback function is a vector of variants, where + // each entry indicates one changed object. + // If the entry is an object id, it means the object has been removed. If it + // is an full object, then the object is either newly-created or changed. + for (var a = 0; a < updated_objects.length; ++a) { + for (var i = 0; i < updated_objects[a].length; ++i) { + var obj = updated_objects[a][i]; + + if (ChainValidation.is_object_id(obj)) { + /// the object was removed + // Cancelled limit order, emit event for MarketStore to update it's state + if (obj.search(order_prefix) == 0) { + var old_obj = this.objects_by_id.get(obj); + if (!old_obj) { + return; + } + emitter.emit('cancel-order', old_obj.get("id")); + var account = this.objects_by_id.get(old_obj.get("seller")); + if (account && account.has("orders")) { + var limit_orders = account.get("orders"); + if (account.get("orders").has(obj)) { + account = account.set("orders", limit_orders.delete(obj)); + this.objects_by_id = this.objects_by_id.set(account.get("id"), account); + } + } + } + + // Update nested call_order inside account object + if (obj.search(call_order_prefix) == 0) { + + var _old_obj = this.objects_by_id.get(obj); + if (!_old_obj) { + return; + } + emitter.emit('close-call', _old_obj.get("id")); + var _account = this.objects_by_id.get(_old_obj.get("borrower")); + if (_account && _account.has("call_orders")) { + var call_orders = _account.get("call_orders"); + if (_account.get("call_orders").has(obj)) { + _account = _account.set("call_orders", call_orders.delete(obj)); + this.objects_by_id = this.objects_by_id.set(_account.get("id"), _account); + } + } + } + + // Remove the object + this.objects_by_id = this.objects_by_id.set(obj, null); + } else this._updateObject(obj, false); + } + } + this.notifySubscribers(); + } + }, { + key: "notifySubscribers", + value: function notifySubscribers() { + var _this2 = this; + + // Dispatch at most only once every x milliseconds + if (!this.dispatched) { + this.dispatched = true; + setTimeout(function () { + _this2.dispatched = false; + _this2.subscribers.forEach(function (callback) { + callback(); + }); + }, this.dispatchFrequency); + } + } + + /** + * Add a callback that will be called anytime any object in the cache is updated + */ + + }, { + key: "subscribe", + value: function subscribe(callback) { + if (this.subscribers.has(callback)) console.error("Subscribe callback already exists", callback); + this.subscribers.add(callback); + } + + /** + * Remove a callback that was previously added via subscribe + */ + + }, { + key: "unsubscribe", + value: function unsubscribe(callback) { + if (!this.subscribers.has(callback)) console.error("Unsubscribe callback does not exists", callback); + this.subscribers.delete(callback); + } + + /** Clear an object from the cache to force it to be fetched again. This may + * be useful if a query failed the first time and the wallet has reason to believe + * it may succeede the second time. + */ + + }, { + key: "clearObjectCache", + value: function clearObjectCache(id) { + this.objects_by_id = this.objects_by_id.delete(id); + } + + /** + * There are three states an object id could be in: + * + * 1. undefined - returned if a query is pending + * 3. defined - return an object + * 4. null - query return null + * + */ + + }, { + key: "getObject", + value: function getObject(id) { + var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (!ChainValidation.is_object_id(id)) throw Error("argument is not an object id: " + JSON.stringify(id)); + + var result = this.objects_by_id.get(id); + if (result === undefined || force) return this.fetchObject(id, force); + if (result === true) return undefined; + + return result; + } + }, { + key: "getSimpleObjectById", + value: function getSimpleObjectById(id) { + var _this3 = this; + + return new Promise(function (success, fail) { + if (!ChainValidation.is_object_id(id)) fail("argument is not an object id: " + JSON.stringify(id)); + + var result = _this3.simple_objects_by_id.get(id); + + if (result) { + return success(result); + } + Apis.instance().db_api().exec("get_objects", [[id]]).then(function (objects) { + var object = objects[0]; + if (!object) return success(null); + _this3.simple_objects_by_id = _this3.simple_objects_by_id.set(id, object); + success(object); + }); + }); + } + + /** + * @return undefined if a query is pending + * @return null if id_or_symbol has been queired and does not exist + * @return object if the id_or_symbol exists + */ + + }, { + key: "getAsset", + value: function getAsset(id_or_symbol) { + var _this4 = this; + + if (!id_or_symbol) return null; + + if (ChainValidation.is_object_id(id_or_symbol)) { + var asset = this.getObject(id_or_symbol); + + if (asset && asset.get("bitasset") && !asset.getIn(["bitasset", "current_feed"])) { + return undefined; + } + return asset; + } + + /// TODO: verify id_or_symbol is a valid symbol name + + var asset_id = this.assets_by_symbol.get(id_or_symbol); + + if (ChainValidation.is_object_id(asset_id)) { + var _asset = this.getObject(asset_id); + + if (_asset && _asset.get("bitasset") && !_asset.getIn(["bitasset", "current_feed"])) { + return undefined; + } + return _asset; + } + + if (asset_id === null) return null; + + if (asset_id === true) return undefined; + + Apis.instance().db_api().exec("lookup_asset_symbols", [[id_or_symbol]]).then(function (asset_objects) { + // console.log( "lookup symbol ", id_or_symbol ) + if (asset_objects.length && asset_objects[0]) _this4._updateObject(asset_objects[0], true);else { + _this4.assets_by_symbol = _this4.assets_by_symbol.set(id_or_symbol, null); + _this4.notifySubscribers(); + } + }).catch(function (error) { + console.log("Error: ", error); + _this4.assets_by_symbol = _this4.assets_by_symbol.delete(id_or_symbol); + }); + + return undefined; + } + + /** + * @param the public key to find accounts that reference it + * + * @return Set of account ids that reference the given key + * @return a empty Set if no items are found + * @return undefined if the result is unknown + * + * If this method returns undefined, then it will send a request to + * the server for the current set of accounts after which the + * server will notify us of any accounts that reference these keys + */ + + }, { + key: "getAccountRefsOfKey", + value: function getAccountRefsOfKey(key) { + var _this5 = this; + + if (this.get_account_refs_of_keys_calls.has(key)) return this.account_ids_by_key.get(key);else { + this.get_account_refs_of_keys_calls = this.get_account_refs_of_keys_calls.add(key); + Apis.instance().db_api().exec("get_key_references", [[key]]).then(function (vec_account_id) { + var refs = Immutable.Set(); + vec_account_id = vec_account_id[0]; + refs = refs.withMutations(function (r) { + for (var i = 0; i < vec_account_id.length; ++i) { + r.add(vec_account_id[i]); + } + }); + _this5.account_ids_by_key = _this5.account_ids_by_key.set(key, refs); + _this5.notifySubscribers(); + }, function (error) { + _this5.account_ids_by_key = _this5.account_ids_by_key.delete(key); + _this5.get_account_refs_of_keys_calls = _this5.get_account_refs_of_keys_calls.delete(key); + }); + return undefined; + } + return undefined; + } + + /** + * @return a Set of balance ids that are claimable with the given address + * @return undefined if a query is pending and the set is not known at this time + * @return a empty Set if no items are found + * + * If this method returns undefined, then it will send a request to the server for + * the current state after which it will be subscribed to changes to this set. + */ + + }, { + key: "getBalanceObjects", + value: function getBalanceObjects(address) { + var _this6 = this; + + var current = this.balance_objects_by_address.get(address); + if (current === undefined) { + /** because balance objects are simply part of the genesis state, there is no need to worry about + * having to update them / merge them or index them in updateObject. + */ + this.balance_objects_by_address = this.balance_objects_by_address.set(address, Immutable.Set()); + Apis.instance().db_api().exec("get_balance_objects", [[address]]).then(function (balance_objects) { + var set = new Set(); + for (var i = 0; i < balance_objects.length; ++i) { + _this6._updateObject(balance_objects[i]); + set.add(balance_objects[i].id); + } + _this6.balance_objects_by_address = _this6.balance_objects_by_address.set(address, Immutable.Set(set)); + _this6.notifySubscribers(); + }, function (error) { + _this6.balance_objects_by_address = _this6.balance_objects_by_address.delete(address); + }); + } + return this.balance_objects_by_address.get(address); + } + + /** + * @return a list of tournament ids for upcoming tournaments + * @return an empty list if a query is pending and the set is not known at this time + * or if there are no upcoming touraments + * + * If we have not yet requested tournaments for this account, it will send a request to the server for + * the current list, after which it will be subscribed to changes to this set. + */ + + }, { + key: "getTournamentIdsInState", + value: function getTournamentIdsInState(accountId, stateString) { + var _this7 = this; + + var tournamentIdsForThisAccountAndState = undefined; + var tournamentIdsForThisAccount = this.tournament_ids_by_state.get(accountId); + if (tournamentIdsForThisAccount === undefined) { + tournamentIdsForThisAccountAndState = new Immutable.Set(); + tournamentIdsForThisAccount = new Immutable.Map().set(stateString, tournamentIdsForThisAccountAndState); + this.tournament_ids_by_state = this.tournament_ids_by_state.set(accountId, tournamentIdsForThisAccount); + } else { + tournamentIdsForThisAccountAndState = tournamentIdsForThisAccount.get(stateString); + if (tournamentIdsForThisAccountAndState !== undefined) return tournamentIdsForThisAccountAndState; + + tournamentIdsForThisAccountAndState = new Immutable.Set(); + tournamentIdsForThisAccount = tournamentIdsForThisAccount.set(stateString, tournamentIdsForThisAccountAndState); + this.tournament_ids_by_state = this.tournament_ids_by_state.set(accountId, tournamentIdsForThisAccount); + } + + Apis.instance().db_api().exec("get_tournaments_in_state", [stateString, 100]).then(function (tournaments) { + var originalTournamentIdsInState = _this7.tournament_ids_by_state.getIn([accountId, stateString]); + // call updateObject on each tournament, which will classify it + tournaments.forEach(function (tournament) { + /** + * Fix bug: we cant update tournament_ids_by_state if objects_by_id has a tournament + */ + if (!originalTournamentIdsInState.get(tournament.id)) { + _this7.clearObjectCache(tournament.id); + } + + _this7._updateObject(tournament, false); // false = don't notify on change + }); + if (_this7.tournament_ids_by_state.getIn([accountId, stateString]) != originalTournamentIdsInState) _this7.notifySubscribers(); + }); + return tournamentIdsForThisAccountAndState; + } + }, { + key: "getRegisteredTournamentIds", + value: function getRegisteredTournamentIds(accountId) { + var _this8 = this; + + var tournamentIds = this.registered_tournament_ids_by_player.get(accountId); + if (tournamentIds !== undefined) return tournamentIds; + tournamentIds = new Immutable.Set(); + this.registered_tournament_ids_by_player = this.registered_tournament_ids_by_player.set(accountId, tournamentIds); + + Apis.instance().db_api().exec("get_registered_tournaments", [accountId, 100]).then(function (tournamentIds) { + var originalTournamentIds = _this8.registered_tournament_ids_by_player.get(accountId); + var newTournamentIds = new Immutable.Set(tournamentIds); + if (!originalTournamentIds.equals(newTournamentIds)) { + _this8.registered_tournament_ids_by_player = _this8.registered_tournament_ids_by_player.set(accountId, newTournamentIds); + _this8.notifySubscribers(); + } + }); + + return tournamentIds; + } + + /** + * If there is not already a pending request to fetch this object, a new + * request will be made. + * + * @return null if the object does not exist, + * @return undefined if the object might exist but is not in cache + * @return the object if it does exist and is in our cache + */ + + }, { + key: "fetchObject", + value: function fetchObject(id) { + var _this9 = this; + + var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (typeof id !== 'string') { + var _result = []; + for (var i = 0; i < id.length; ++i) { + _result.push(this.fetchObject(id[i])); + }return _result; + } + + if (DEBUG) console.log("!!! fetchObject: ", id, this.subscribed, !this.subscribed && !force); + if (!this.subscribed && !force) return undefined; + + if (DEBUG) console.log("maybe fetch object: ", id); + if (!ChainValidation.is_object_id(id)) throw Error("argument is not an object id: " + id); + + if (id.substring(0, 4) == "1.2.") return this.fetchFullAccount(id); + + var result = this.objects_by_id.get(id); + if (result === undefined) { + // the fetch + if (DEBUG) console.log("fetching object: ", id); + this.objects_by_id = this.objects_by_id.set(id, true); + Apis.instance().db_api().exec("get_objects", [[id]]).then(function (optional_objects) { + if (DEBUG) console.log('... optional_objects', optional_objects ? optional_objects[0].id : null); + for (var _i = 0; _i < optional_objects.length; _i++) { + var optional_object = optional_objects[_i]; + if (optional_object) { + _this9._updateObject(optional_object, true); + _this9.simple_objects_by_id = _this9.simple_objects_by_id.set(id, optional_object); + } else { + _this9.objects_by_id = _this9.objects_by_id.set(id, null); + _this9.notifySubscribers(); + } + } + }).catch(function (error) { + // in the event of an error clear the pending state for id + console.log('!!! Chain API error', error); + _this9.objects_by_id = _this9.objects_by_id.delete(id); + }); + } else if (result === true) // then we are waiting a response + return undefined; + return result; // we have a response, return it + } + + /** + * @return null if no such account exists + * @return undefined if such an account may exist, and fetch the the full account if not already pending + * @return the account object if it does exist + */ + + }, { + key: "getAccount", + value: function getAccount(name_or_id) { + + if (!name_or_id) return null; + + if ((typeof name_or_id === "undefined" ? "undefined" : _typeof(name_or_id)) === 'object') { + if (name_or_id.id) return this.getAccount(name_or_id.id);else if (name_or_id.get) return this.getAccount(name_or_id.get('id'));else return undefined; + } + + if (ChainValidation.is_object_id(name_or_id)) { + var account = this.getObject(name_or_id); + if (account === null) { + return null; + } + if (account === undefined || account.get('name') === undefined) { + return this.fetchFullAccount(name_or_id); + } + return account; + } else if (ChainValidation.is_account_name(name_or_id, true)) { + var account_id = this.accounts_by_name.get(name_or_id); + if (account_id === null) return null; // already fetched and it wasn't found + if (account_id === undefined) // then no query, fetch it + return this.fetchFullAccount(name_or_id); + return this.getObject(account_id); // return it + } + //throw Error( `Argument is not an account name or id: ${name_or_id}` ) + } + + /** + * This method will attempt to lookup witness by account_id. + * If witness doesn't exist it will return null, if witness is found it will return witness object, + * if it's not fetched yet it will return undefined. + * @param account_id - account id + */ + + }, { + key: "getWitnessById", + value: function getWitnessById(account_id) { + var witness_id = this.witness_by_account_id.get(account_id); + if (witness_id === undefined) { + this.fetchWitnessByAccount(account_id); + return undefined; + } + return witness_id ? this.getObject(witness_id) : null; + } + + /** + * This method will attempt to lookup witness by account_id. + * If witness doesn't exist it will return null, if witness is found it will return witness object, + * if it's not fetched yet it will return undefined. + * @param witness_id - witness id + */ + + }, { + key: "getWitnessAccount", + value: function getWitnessAccount(witness_id) { + var _this10 = this; + + return new Promise(function (success, fail) { + var account = _this10.account_by_witness_id.get(witness_id); + + if (account) return success(account); + + _this10.getSimpleObjectById(witness_id).then(function (witness) { + _this10.getSimpleObjectById(witness.witness_account).then(function (account) { + _this10.account_by_witness_id = _this10.account_by_witness_id.set(witness_id, account); + success(account); + }); + }); + }); + } + + /** + * This method will attempt to lookup committee member by account_id. + * If committee member doesn't exist it will return null, if committee member is found it will return committee member object, + * if it's not fetched yet it will return undefined. + * @param account_id - account id + */ + + }, { + key: "getCommitteeMemberById", + value: function getCommitteeMemberById(account_id) { + var cm_id = this.committee_by_account_id.get(account_id); + if (cm_id === undefined) { + this.fetchCommitteeMemberByAccount(account_id); + return undefined; + } + return cm_id ? this.getObject(cm_id) : null; + } + + /** + * Obsolete! Please use getWitnessById + * This method will attempt to lookup the account, and then query to see whether or not there is + * a witness for this account. If the answer is known, it will return the witness_object, otherwise + * it will attempt to look it up and return null. Once the lookup has completed on_update will + * be called. + * + * @param id_or_account may either be an account_id, a witness_id, or an account_name + */ + + }, { + key: "getWitness", + value: function getWitness(id_or_account) { + var _this11 = this; + + var account = this.getAccount(id_or_account); + if (!account) return null; + var account_id = account.get('id'); + + var witness_id = this.witness_by_account_id.get(account_id); + if (witness_id === undefined) this.fetchWitnessByAccount(account_id); + return this.getObject(witness_id); + + if (ChainValidation.is_account_name(id_or_account, true) || id_or_account.substring(0, 4) == "1.2.") { + var _account2 = this.getAccount(id_or_account); + if (!_account2) { + this.lookupAccountByName(id_or_account).then(function (account) { + if (!account) return null; + + var account_id = account.get('id'); + var witness_id = _this11.witness_by_account_id.get(account_id); + if (ChainValidation.is_object_id(witness_id)) return _this11.getObject(witness_id, on_update); + + if (witness_id == undefined) _this11.fetchWitnessByAccount(account_id).then(function (witness) { + _this11.witness_by_account_id.set(account_id, witness ? witness.get('id') : null); + if (witness && on_update) on_update(); + }); + }, function (error) { + var witness_id = _this11.witness_by_account_id.set(id_or_account, null); + }); + } else { + var _account_id = _account2.get('id'); + var _witness_id = this.witness_by_account_id.get(_account_id); + if (ChainValidation.is_object_id(_witness_id)) return this.getObject(_witness_id, on_update); + + if (_witness_id == undefined) this.fetchWitnessByAccount(_account_id).then(function (witness) { + _this11.witness_by_account_id.set(_account_id, witness ? witness.get('id') : null); + if (witness && on_update) on_update(); + }); + } + return null; + } + return null; + } + + // Obsolete! Please use getCommitteeMemberById + + }, { + key: "getCommitteeMember", + value: function getCommitteeMember(id_or_account) { + var _this12 = this; + + var on_update = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + if (ChainValidation.is_account_name(id_or_account, true) || id_or_account.substring(0, 4) == "1.2.") { + var account = this.getAccount(id_or_account); + + if (!account) { + this.lookupAccountByName(id_or_account).then(function (account) { + var account_id = account.get('id'); + var committee_id = _this12.committee_by_account_id.get(account_id); + if (ChainValidation.is_object_id(committee_id)) return _this12.getObject(committee_id, on_update); + + if (committee_id == undefined) { + _this12.fetchCommitteeMemberByAccount(account_id).then(function (committee) { + _this12.committee_by_account_id.set(account_id, committee ? committee.get('id') : null); + if (on_update && committee) on_update(); + }); + } + }, function (error) { + var witness_id = _this12.committee_by_account_id.set(id_or_account, null); + }); + } else { + var account_id = account.get('id'); + var committee_id = this.committee_by_account_id.get(account_id); + if (ChainValidation.is_object_id(committee_id)) return this.getObject(committee_id, on_update); + + if (committee_id == undefined) { + this.fetchCommitteeMemberByAccount(account_id).then(function (committee) { + _this12.committee_by_account_id.set(account_id, committee ? committee.get('id') : null); + if (on_update && committee) on_update(); + }); + } + } + } + return null; + } + + /** + * + * @returns a promise with a list of all witness ids. Regardless of if they have been voted in or not. + * @memberof ChainStore + */ + + }, { + key: "fetchWitnessAccounts", + value: function fetchWitnessAccounts() { + var _this24 = this; + return new Promise(function (resolve, reject) { + Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then(function (w) { + if (w) { + var witnessArr = []; + + for (var i = 0, length = w.length; i < length; i++) { + witnessArr.push(w[i][1]); // ids only + } + + _this24.witnesses = _this24.witnesses.merge(witnessArr); + _this24._updateObject(witnessArr, true); + resolve(_this24.witnesses); + } else { + resolve(null); + } + }); + }); + } + + /** + * + * @return a promise with the witness object + */ + + }, { + key: "fetchWitnessByAccount", + value: function fetchWitnessByAccount(account_id) { + var _this13 = this; + + return new Promise(function (resolve, reject) { + Apis.instance().db_api().exec("get_witness_by_account", [account_id]).then(function (optional_witness_object) { + if (optional_witness_object) { + _this13.witness_by_account_id = _this13.witness_by_account_id.set(optional_witness_object.witness_account, optional_witness_object.id); + var witness_object = _this13._updateObject(optional_witness_object, true); + resolve(witness_object); + } else { + _this13.witness_by_account_id = _this13.witness_by_account_id.set(account_id, null); + _this13.notifySubscribers(); + resolve(null); + } + }, reject); + }); + } + + /** + * + * @return a promise with the witness object + */ + + }, { + key: "fetchCommitteeMemberByAccount", + value: function fetchCommitteeMemberByAccount(account_id) { + var _this14 = this; + + return new Promise(function (resolve, reject) { + Apis.instance().db_api().exec("get_committee_member_by_account", [account_id]).then(function (optional_committee_object) { + if (optional_committee_object) { + _this14.committee_by_account_id = _this14.committee_by_account_id.set(optional_committee_object.committee_member_account, optional_committee_object.id); + var committee_object = _this14._updateObject(optional_committee_object, true); + resolve(committee_object); + } else { + _this14.committee_by_account_id = _this14.committee_by_account_id.set(account_id, null); + _this14.notifySubscribers(); + resolve(null); + } + }, reject); + }); + } + + /** + * Fetches an account and all of its associated data in a single query + * + * @param an account name or account id + * + * @return undefined if the account in question is in the process of being fetched + * @return the object if it has already been fetched + * @return null if the object has been queried and was not found + */ + + }, { + key: "fetchFullAccount", + value: function fetchFullAccount(name_or_id) { + var _this15 = this; + + if (DEBUG) console.log("Fetch full account: ", name_or_id); + + var fetch_account = false; + if (ChainValidation.is_object_id(name_or_id)) { + var current = this.objects_by_id.get(name_or_id); + fetch_account = current === undefined; + if (!fetch_account && fetch_account.get('name')) return current; + } else { + if (!ChainValidation.is_account_name(name_or_id, true)) throw Error("argument is not an account name: " + name_or_id); + + var account_id = this.accounts_by_name.get(name_or_id); + if (ChainValidation.is_object_id(account_id)) return this.getAccount(account_id); + } + + /// only fetch once every 5 seconds if it wasn't found + if (!this.fetching_get_full_accounts.has(name_or_id) || Date.now() - this.fetching_get_full_accounts.get(name_or_id) > 5000) { + this.fetching_get_full_accounts.set(name_or_id, Date.now()); + //console.log( "FETCHING FULL ACCOUNT: ", name_or_id ) + Apis.instance().db_api().exec("get_full_accounts", [[name_or_id], true]).then(function (results) { + if (results.length === 0) { + if (ChainValidation.is_object_id(name_or_id)) { + _this15.objects_by_id = _this15.objects_by_id.set(name_or_id, null); + _this15.notifySubscribers(); + } + return; + } + var full_account = results[0][1]; + if (DEBUG) console.log("full_account: ", full_account); + + var account = full_account.account, + vesting_balances = full_account.vesting_balances, + pending_dividend_payments = full_account.pending_dividend_payments, + statistics = full_account.statistics, + call_orders = full_account.call_orders, + limit_orders = full_account.limit_orders, + referrer_name = full_account.referrer_name, + registrar_name = full_account.registrar_name, + lifetime_referrer_name = full_account.lifetime_referrer_name, + votes = full_account.votes, + proposals = full_account.proposals; + + + _this15.accounts_by_name = _this15.accounts_by_name.set(account.name, account.id); + account.referrer_name = referrer_name; + account.lifetime_referrer_name = lifetime_referrer_name; + account.registrar_name = registrar_name; + account.balances = {}; + account.orders = new Immutable.Set(); + account.vesting_balances = new Immutable.Set(); + account.pending_dividend_payments = new Immutable.Set(); + account.balances = new Immutable.Map(); + account.call_orders = new Immutable.Set(); + account.proposals = new Immutable.Set(); + account.vesting_balances = account.vesting_balances.withMutations(function (set) { + vesting_balances.forEach(function (vb) { + _this15._updateObject(vb, false); + set.add(vb.id); + }); + }); + + votes.forEach(function (v) { + return _this15._updateObject(v, false); + }); + + account.balances = account.balances.withMutations(function (map) { + full_account.balances.forEach(function (b) { + _this15._updateObject(b, false); + map.set(b.asset_type, b.id); + }); + }); + + account.orders = account.orders.withMutations(function (set) { + limit_orders.forEach(function (order) { + _this15._updateObject(order, false); + set.add(order.id); + }); + }); + + account.pending_dividend_payments = account.pending_dividend_payments.withMutations(function (set) { + pending_dividend_payments.forEach(function (payments) { + _this15._updateObject(payments, false); + set.add(payments); + }); + }); + + account.call_orders = account.call_orders.withMutations(function (set) { + call_orders.forEach(function (co) { + _this15._updateObject(co, false); + set.add(co.id); + }); + }); + + account.proposals = account.proposals.withMutations(function (set) { + proposals.forEach(function (p) { + _this15._updateObject(p, false); + set.add(p.id); + }); + }); + + _this15._updateObject(statistics, false); + var updated_account = _this15._updateObject(account, false); + _this15.fetchRecentHistory(updated_account); + _this15.notifySubscribers(); + }, function (error) { + console.log("Error: ", error); + if (ChainValidation.is_object_id(name_or_id)) _this15.objects_by_id = _this15.objects_by_id.delete(name_or_id);else _this15.accounts_by_name = _this15.accounts_by_name.delete(name_or_id); + }); + } + return undefined; + } + }, { + key: "getAccountMemberStatus", + value: function getAccountMemberStatus(account) { + if (account === undefined) return undefined; + if (account === null) return "unknown"; + if (account.get('lifetime_referrer') == account.get('id')) return "lifetime"; + var exp = new Date(account.get('membership_expiration_date')).getTime(); + var now = new Date().getTime(); + if (exp < now) return "basic"; + return "annual"; + } + }, { + key: "getAccountBalance", + value: function getAccountBalance(account, asset_type) { + var balances = account.get('balances'); + if (!balances) return 0; + + var balance_obj_id = balances.get(asset_type); + if (balance_obj_id) { + var bal_obj = this.objects_by_id.get(balance_obj_id); + if (bal_obj) return bal_obj.get('balance'); + } + return 0; + } + + /** + * There are two ways to extend the account history, add new more + * recent history, and extend historic hstory. This method will fetch + * the most recent account history and prepend it to the list of + * historic operations. + * + * @param account immutable account object + * @return a promise with the account history + */ + + }, { + key: "fetchRecentHistory", + value: function fetchRecentHistory(account) { + var _this16 = this; + + var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100; + + // console.log( "get account history: ", account ) + /// TODO: make sure we do not submit a query if there is already one + /// in flight... + var account_id = account; + if (!ChainValidation.is_object_id(account_id) && account.toJS) account_id = account.get('id'); + + if (!ChainValidation.is_object_id(account_id)) return; + + account = this.objects_by_id.get(account_id); + if (!account) return; + + var pending_request = this.account_history_requests.get(account_id); + if (pending_request) { + pending_request.requests++; + return pending_request.promise; + } else pending_request = { requests: 0 }; + + var most_recent = "1." + op_history + ".0"; + var history = account.get('history'); + + if (history && history.size) most_recent = history.first().get('id'); + + /// starting at 0 means start at NOW, set this to something other than 0 + /// to skip recent transactions and fetch the tail + var start = "1." + op_history + ".0"; + + pending_request.promise = new Promise(function (resolve, reject) { + Apis.instance().history_api().exec("get_account_history", [account_id, most_recent, limit, start]).then(function (operations) { + var current_account = _this16.objects_by_id.get(account_id); + var current_history = current_account.get('history'); + if (!current_history) current_history = Immutable.List(); + var updated_history = Immutable.fromJS(operations); + updated_history = updated_history.withMutations(function (list) { + for (var i = 0; i < current_history.size; ++i) { + list.push(current_history.get(i)); + } + }); + var updated_account = current_account.set('history', updated_history); + _this16.objects_by_id = _this16.objects_by_id.set(account_id, updated_account); + + //if( current_history != updated_history ) + // this._notifyAccountSubscribers( account_id ) + + var pending_request = _this16.account_history_requests.get(account_id); + _this16.account_history_requests.delete(account_id); + if (pending_request.requests > 0) { + // it looks like some more history may have come in while we were + // waiting on the result, lets fetch anything new before we resolve + // this query. + _this16.fetchRecentHistory(updated_account, limit).then(resolve, reject); + } else resolve(updated_account); + }); // end then + }); + + this.account_history_requests.set(account_id, pending_request); + return pending_request.promise; + } + + //_notifyAccountSubscribers( account_id ) + //{ + // let sub = this.subscriptions_by_account.get( account_id ) + // let acnt = this.objects_by_id.get(account_id) + // if( !sub ) return + // for( let item of sub.subscriptions ) + // item( acnt ) + //} + + /** + * Callback that receives notification of objects that have been + * added, remove, or changed and are relevant to account_id + * + * This method updates or removes objects from the main index and + * then updates the account object with relevant meta-info depending + * upon the type of account + */ + // _updateAccount( account_id, payload ) + // { + // let updates = payload[0] + + // for( let i = 0; i < updates.length; ++i ) + // { + // let update = updates[i] + // if( typeof update == 'string' ) + // { + // let old_obj = this._removeObject( update ) + + // if( update.search( order_prefix ) == 0 ) + // { + // acnt = acnt.setIn( ['orders'], set => set.delete(update) ) + // } + // else if( update.search( vesting_balance_prefix ) == 0 ) + // { + // acnt = acnt.setIn( ['vesting_balances'], set => set.delete(update) ) + // } + // } + // else + // { + // let updated_obj = this._updateObject( update ) + // if( update.id.search( balance_prefix ) == 0 ) + // { + // if( update.owner == account_id ) + // acnt = acnt.setIn( ['balances'], map => map.set(update.asset_type,update.id) ) + // } + // else if( update.id.search( order_prefix ) == 0 ) + // { + // if( update.owner == account_id ) + // acnt = acnt.setIn( ['orders'], set => set.add(update.id) ) + // } + // else if( update.id.search( vesting_balance_prefix ) == 0 ) + // { + // if( update.owner == account_id ) + // acnt = acnt.setIn( ['vesting_balances'], set => set.add(update.id) ) + // } + + // this.objects_by_id = this.objects_by_id.set( acnt.id, acnt ) + // } + // } + // this.fetchRecentHistory( acnt ) + // } + + /** + * Updates the object in place by only merging the set + * properties of object. + * + * This method will create an immutable object with the given ID if + * it does not already exist. + * + * This is a "private" method called when data is received from the + * server and should not be used by others. + * + * @pre object.id must be a valid object ID + * @return an Immutable constructed from object and deep merged with the current state + */ + + }, { + key: "_updateObject", + value: function _updateObject(object, notify_subscribers) { + var emit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + + + if (!("id" in object)) { + console.log("object with no id:", object); + if ("balance" in object && "owner" in object && "settlement_date" in object) { + // Settle order object + emitter.emit("settle-order-update", object); + } + return; + } + // if (!(object.id.split(".")[0] == 2) && !(object.id.split(".")[1] == 6)) { + // console.log( "update: ", object ) + // } + + // DYNAMIC GLOBAL OBJECT + if (object.id == "2.1.0") { + object.participation = 100 * (BigInteger(object.recent_slots_filled).bitCount() / 128.0); + this.head_block_time_string = object.time; + this.chain_time_offset.push(Date.now() - this.timeStringToDate(object.time).getTime()); + if (this.chain_time_offset.length > 10) this.chain_time_offset.shift(); // remove first + this.fetchRecentOperations(object.head_block_number); + } + + var current = this.objects_by_id.get(object.id, undefined); + if (current === undefined || current === true) current = Immutable.Map(); + var prior = current; + if (current === undefined || current === true) this.objects_by_id = this.objects_by_id.set(object.id, current = Immutable.fromJS(object));else this.objects_by_id = this.objects_by_id.set(object.id, current = current.mergeDeep(Immutable.fromJS(object))); + + // BALANCE OBJECT + if (object.id.substring(0, balance_prefix.length) == balance_prefix) { + var owner = this.objects_by_id.get(object.owner); + if (owner === undefined || owner === null) { + return; + /* This prevents the full account from being looked up later + owner = {id:object.owner, balances:{ } } + owner.balances[object.asset_type] = object.id + owner = Immutable.fromJS( owner ) + */ + } else { + var balances = owner.get("balances"); + if (!balances) owner = owner.set("balances", Immutable.Map()); + owner = owner.setIn(['balances', object.asset_type], object.id); + } + this.objects_by_id = this.objects_by_id.set(object.owner, owner); + } + // ACCOUNT STATS OBJECT + else if (object.id.substring(0, account_stats_prefix.length) == account_stats_prefix) { + // console.log( "HISTORY CHANGED" ) + var prior_most_recent_op = prior ? prior.get('most_recent_op') : "2.9.0"; + + if (prior_most_recent_op != object.most_recent_op) { + this.fetchRecentHistory(object.owner); + } + } + // WITNESS OBJECT + else if (object.id.substring(0, witness_prefix.length) == witness_prefix) { + this.witness_by_account_id.set(object.witness_account, object.id); + this.objects_by_vote_id.set(object.vote_id, object.id); + } + // COMMITTEE MEMBER OBJECT + else if (object.id.substring(0, committee_prefix.length) == committee_prefix) { + this.committee_by_account_id.set(object.committee_member_account, object.id); + this.objects_by_vote_id.set(object.vote_id, object.id); + } + // ACCOUNT OBJECT + else if (object.id.substring(0, account_prefix.length) == account_prefix) { + current = current.set('active', Immutable.fromJS(object.active)); + current = current.set('owner', Immutable.fromJS(object.owner)); + current = current.set('options', Immutable.fromJS(object.options)); + current = current.set('pending_dividend_payments', Immutable.fromJS(object.pending_dividend_payments)); + current = current.set('whitelisting_accounts', Immutable.fromJS(object.whitelisting_accounts)); + current = current.set('blacklisting_accounts', Immutable.fromJS(object.blacklisting_accounts)); + current = current.set('whitelisted_accounts', Immutable.fromJS(object.whitelisted_accounts)); + current = current.set('blacklisted_accounts', Immutable.fromJS(object.blacklisted_accounts)); + this.objects_by_id = this.objects_by_id.set(object.id, current); + this.accounts_by_name = this.accounts_by_name.set(object.name, object.id); + } + // ASSET OBJECT + else if (object.id.substring(0, asset_prefix.length) == asset_prefix) { + this.assets_by_symbol = this.assets_by_symbol.set(object.symbol, object.id); + var dynamic = current.get('dynamic'); + if (!dynamic) { + var dad = this.getObject(object.dynamic_asset_data_id, true); + if (!dad) dad = Immutable.Map(); + if (!dad.get('asset_id')) { + dad = dad.set('asset_id', object.id); + } + this.objects_by_id = this.objects_by_id.set(object.dynamic_asset_data_id, dad); + + current = current.set('dynamic', dad); + this.objects_by_id = this.objects_by_id.set(object.id, current); + } + + var bitasset = current.get('bitasset'); + if (!bitasset && object.bitasset_data_id) { + var bad = this.getObject(object.bitasset_data_id, true); + if (!bad) bad = Immutable.Map(); + + if (!bad.get('asset_id')) { + bad = bad.set('asset_id', object.id); + } + this.objects_by_id = this.objects_by_id.set(object.bitasset_data_id, bad); + + current = current.set('bitasset', bad); + this.objects_by_id = this.objects_by_id.set(object.id, current); + } + } + // ASSET DYNAMIC DATA OBJECT + else if (object.id.substring(0, asset_dynamic_data_prefix.length) == asset_dynamic_data_prefix) { + // let asset_id = asset_prefix + object.id.substring( asset_dynamic_data_prefix.length ) + var asset_id = current.get("asset_id"); + if (asset_id) { + var asset_obj = this.getObject(asset_id); + if (asset_obj && asset_obj.set) { + asset_obj = asset_obj.set('dynamic', current); + this.objects_by_id = this.objects_by_id.set(asset_id, asset_obj); + } + } + } + // WORKER OBJECT + else if (object.id.substring(0, worker_prefix.length) == worker_prefix) { + this.objects_by_vote_id.set(object.vote_for, object.id); + this.objects_by_vote_id.set(object.vote_against, object.id); + } + // BITASSET DATA OBJECT + else if (object.id.substring(0, bitasset_data_prefix.length) == bitasset_data_prefix) { + var _asset_id = current.get("asset_id"); + if (_asset_id) { + var asset = this.getObject(_asset_id); + if (asset) { + asset = asset.set("bitasset", current); + emitter.emit('bitasset-update', asset); + this.objects_by_id = this.objects_by_id.set(_asset_id, asset); + } + } + } + // CALL ORDER OBJECT + else if (object.id.substring(0, call_order_prefix.length) == call_order_prefix) { + // Update nested call_orders inside account object + if (emit) { + emitter.emit("call-order-update", object); + } + + var account = this.objects_by_id.get(object.borrower); + if (account && account.has("call_orders")) { + var call_orders = account.get("call_orders"); + if (!call_orders.has(object.id)) { + account = account.set("call_orders", call_orders.add(object.id)); + this.objects_by_id = this.objects_by_id.set(account.get("id"), account); + } + } + } + // LIMIT ORDER OBJECT + else if (object.id.substring(0, order_prefix.length) == order_prefix) { + var _account3 = this.objects_by_id.get(object.seller); + if (_account3 && _account3.has("orders")) { + var limit_orders = _account3.get("orders"); + if (!limit_orders.has(object.id)) { + _account3 = _account3.set("orders", limit_orders.add(object.id)); + this.objects_by_id = this.objects_by_id.set(_account3.get("id"), _account3); + } + } + } + // PROPOSAL OBJECT + else if (object.id.substring(0, proposal_prefix.length) == proposal_prefix) { + this.addProposalData(object.required_active_approvals, object.id); + this.addProposalData(object.required_owner_approvals, object.id); + } + // TOURNAMENT OBJECT + else if (object.id.substring(0, tournament_prefix.length) == tournament_prefix) { + var priorState = prior.get("state"); + var newState = current.get("state"); + + if (priorState !== newState) { + this.tournament_ids_by_state = this.tournament_ids_by_state.map(function (stateMap, accountId) { + return stateMap.map(function (tournamentIdSet, stateString) { + if (stateString === priorState) return tournamentIdSet.remove(object.id);else if (stateString === newState && (accountId === null || current.getIn(["options", "whitelist"]).isEmpty() || current.getIn(["options", "whitelist"]).includes(accountId))) return tournamentIdSet.add(object.id);else return tournamentIdSet; + }); + }); + } + + if (this.last_tournament_id !== undefined) { + this.setLastTournamentId(current.get('id')); + } + } else if (object.id.substring(0, tournament_details_prefix.length) == tournament_details_prefix) { + var priorRegisteredPlayers = prior.get("registered_players"); + var newRegisteredPlayers = current.get("registered_players"); + if (priorRegisteredPlayers != newRegisteredPlayers) this.registered_tournament_ids_by_player = this.registered_tournament_ids_by_player.map(function (tournamentIdsSet, accountId) { + if (newRegisteredPlayers.includes(accountId)) return tournamentIdsSet.add(current.get("tournament_id"));else return tournamentIdsSet; + // currently, you can't un-register for a tournament, so we don't have + // to deal with removing from a list + }); + } + + if (notify_subscribers) this.notifySubscribers(); + + return current; + } + }, { + key: "setLastTournamentId", + value: function setLastTournamentId(current_tournament_id) { + if (current_tournament_id === null) { + if (!this.last_tournament_id) { + this.last_tournament_id = current_tournament_id; + } + } else { + var current_tournament_id_short = parseFloat(current_tournament_id.substring(tournament_prefix.length)), + last_tournament_id_short = this.last_tournament_id ? parseFloat(this.last_tournament_id.substring(tournament_prefix.length)) : -1; + + if (current_tournament_id_short > last_tournament_id_short) { + this.last_tournament_id = current_tournament_id; + } + } + } + }, { + key: "getTournaments", + value: function getTournaments(last_tournament_id) { + var _this17 = this; + + var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5; + var start_tournament_id = arguments[2]; + + + return Apis.instance().db_api().exec("get_tournaments", [last_tournament_id, limit, start_tournament_id]).then(function (tournaments) { + var list = Immutable.List(); + + _this17.setLastTournamentId(null); + + if (tournaments && tournaments.length) { + list = list.withMutations(function (l) { + tournaments.forEach(function (tournament) { + + if (!_this17.objects_by_id.has(tournament.id)) { + _this17._updateObject(tournament, false); + } + + l.unshift(_this17.objects_by_id.get(tournament.id)); + }); + }); + } + + return list; + }); + } + }, { + key: "getLastTournamentId", + value: function getLastTournamentId() { + var _this18 = this; + + return new Promise(function (resolve, reject) { + if (_this18.last_tournament_id === undefined) { + + Apis.instance().db_api().exec("get_tournaments", [tournament_prefix + '0', 1, tournament_prefix + '0']).then(function (tournaments) { + + _this18.setLastTournamentId(null); + + if (tournaments && tournaments.length) { + + tournaments.forEach(function (tournament) { + _this18._updateObject(tournament, false); + }); + } + + resolve(_this18.last_tournament_id); + }); + } else { + + resolve(_this18.last_tournament_id); + } + }); + } + }, { + key: "getObjectsByVoteIds", + value: function getObjectsByVoteIds(vote_ids) { + var _this19 = this; + + var result = []; + var missing = []; + for (var i = 0; i < vote_ids.length; ++i) { + var obj = this.objects_by_vote_id.get(vote_ids[i]); + if (obj) result.push(this.getObject(obj));else { + result.push(null); + missing.push(vote_ids[i]); + } + } + + if (missing.length) { + // we may need to fetch some objects + Apis.instance().db_api().exec("lookup_vote_ids", [missing]).then(function (vote_obj_array) { + console.log("missing ===========> ", missing); + console.log("vote objects ===========> ", vote_obj_array); + for (var _i2 = 0; _i2 < vote_obj_array.length; ++_i2) { + if (vote_obj_array[_i2]) { + _this19._updateObject(vote_obj_array[_i2]); + } + } + }, function (error) { + return console.log("Error looking up vote ids: ", error); + }); + } + return result; + } + }, { + key: "getObjectByVoteID", + value: function getObjectByVoteID(vote_id) { + var obj_id = this.objects_by_vote_id.get(vote_id); + if (obj_id) return this.getObject(obj_id); + return undefined; + } + }, { + key: "getHeadBlockDate", + value: function getHeadBlockDate() { + return this.timeStringToDate(this.head_block_time_string); + } + }, { + key: "getEstimatedChainTimeOffset", + value: function getEstimatedChainTimeOffset() { + if (this.chain_time_offset.length === 0) return 0; + // Immutable is fast, sorts numbers correctly, and leaves the original unmodified + // This will fix itself if the user changes their clock + var median_offset = Immutable.List(this.chain_time_offset).sort().get(Math.floor((this.chain_time_offset.length - 1) / 2)); + // console.log("median_offset", median_offset) + return median_offset; + } + }, { + key: "addProposalData", + value: function addProposalData(approvals, objectId) { + var _this20 = this; + + approvals.forEach(function (id) { + var impactedAccount = _this20.objects_by_id.get(id); + if (impactedAccount) { + var proposals = impactedAccount.get("proposals"); + + if (!proposals.includes(objectId)) { + proposals = proposals.add(objectId); + impactedAccount = impactedAccount.set("proposals", proposals); + _this20._updateObject(impactedAccount.toJS(), false); + } + } + }); + } + }, { + key: "timeStringToDate", + value: function timeStringToDate(time_string) { + if (!time_string) return new Date("1970-01-01T00:00:00.000Z"); + if (!/Z$/.test(time_string)) //does not end in Z + // https://github.com/cryptonomex/graphene/issues/368 + time_string = time_string + "Z"; + return new Date(time_string); + } + }, { + key: "__getBlocksForScan", + value: function __getBlocksForScan(lastBlock) { + var _this21 = this; + + var db_api = Apis.instance().db_api(); + return new Promise(function (success, fail) { + + var scanToBlock = _this21.last_processed_block; + if (lastBlock) return success({ lastBlock: lastBlock, scanToBlock: scanToBlock }); + + db_api.exec("get_dynamic_global_properties", []).then(function (globalProperties) { + lastBlock = _this21.last_processed_block = globalProperties['head_block_number']; + scanToBlock = globalProperties['head_block_number'] - 2000; + scanToBlock = scanToBlock < 0 ? 1 : scanToBlock; + return success({ lastBlock: lastBlock, scanToBlock: scanToBlock }); + }); + }); + } + }, { + key: "__bindBlock", + value: function __bindBlock(lastBlock, scanToBlock, isInit) { + var _this22 = this; + + var db_api = Apis.instance().db_api(); + return new Promise(function (success, fail) { + db_api.exec("get_block", [lastBlock]).then(function (block) { + block.id = lastBlock; + if (typeof block.timestamp === "string") block.timestamp += "+00:00"; + block.timestamp = new Date(block.timestamp); + _this22.getWitnessAccount(block.witness).then(function (witness) { + block.witness_account_name = witness.name; + + if (!_this22.recent_blocks_by_id.get(lastBlock)) { + + _this22.recent_blocks_by_id = _this22.recent_blocks_by_id.set(lastBlock, block); + + if (_this22.last_processed_block < lastBlock) _this22.last_processed_block = lastBlock; + + if (!isInit) { + _this22.recent_blocks = _this22.recent_blocks.unshift(block); + if (_this22.recent_blocks.size > block_stack_size) { + _this22.recent_blocks = _this22.recent_blocks.pop(); + } + } else if (_this22.recent_blocks.size < block_stack_size) { + _this22.recent_blocks = _this22.recent_blocks.push(block); + } + + block.transactions.forEach(function (tx) { + return tx.operations.forEach(function (op) { + op[1].block_id = lastBlock; + op[1].created_at = block.timestamp; + if (!isInit) { + _this22.recent_operations = _this22.recent_operations.unshift(op); + } else { + if (_this22.recent_operations.size < operations_stack_size) { + _this22.recent_operations = _this22.recent_operations.push(op); + } + if (_this22.recent_operations.size >= operations_stack_size && _this22.recent_blocks.size >= block_stack_size) { + scanToBlock = lastBlock; + } + } + if (_this22.recent_operations.size > operations_stack_size) { + _this22.recent_operations = _this22.recent_operations.pop(); + } + }); + }); + } + lastBlock--; + if (lastBlock <= scanToBlock) { + return success(); + } + _this22.__bindBlock(lastBlock, scanToBlock, isInit).then(function () { + return success(); + }); + }); + }); + }); + } + }, { + key: "fetchRecentOperations", + value: function fetchRecentOperations() { + var _this23 = this; + + var lastBlock = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (lastBlock && !this.last_processed_block) return; + var isInit = !lastBlock; + + this.__getBlocksForScan(lastBlock).then(function (_ref) { + var lastBlock = _ref.lastBlock, + scanToBlock = _ref.scanToBlock; + + _this23.__bindBlock(lastBlock, scanToBlock, isInit).then(function () { + if (isInit) { + _this23.store_initialized = true; + } + }); + }); + } + }, { + key: "getRecentBlocks", + value: function getRecentBlocks() { + return this.recent_blocks; + } + }, { + key: "getRecentOperations", + value: function getRecentOperations() { + if (!this.store_initialized) return Immutable.List(); + return this.recent_operations; + } + }]); + + return ChainStore; +}(); + +var chain_store = new ChainStore(); + +function FetchChainObjects(method, object_ids, timeout) { + var get_object = method.bind(chain_store); + + return new Promise(function (resolve, reject) { + var timeout_handle = null; + + function onUpdate() { + var not_subscribed_yet = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + var res = object_ids.map(function (id) { + return get_object(id); + }); + if (res.findIndex(function (o) { + return o === undefined; + }) === -1) { + if (timeout_handle) clearTimeout(timeout_handle); + if (!not_subscribed_yet) chain_store.unsubscribe(onUpdate); + resolve(res); + return true; + } + return false; + } + + var resolved = onUpdate(true); + if (!resolved) chain_store.subscribe(onUpdate); + + if (timeout && !resolved) timeout_handle = setTimeout(function () { + chain_store.unsubscribe(onUpdate); + reject("timeout"); + }, timeout); + }); +} + +chain_store.FetchChainObjects = FetchChainObjects; + +function FetchChain(methodName, objectIds) { + var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1900; + + + var method = chain_store[methodName]; + if (!method) throw new Error("ChainStore does not have method " + methodName); + + var arrayIn = Array.isArray(objectIds); + if (!arrayIn) objectIds = [objectIds]; + + return chain_store.FetchChainObjects(method, Immutable.List(objectIds), timeout).then(function (res) { + return arrayIn ? res : res.get(0); + }); +} + +chain_store.FetchChain = FetchChain; + +module.exports = chain_store; \ No newline at end of file diff --git a/dist/chain/src/ChainTypes.js b/dist/chain/src/ChainTypes.js new file mode 100644 index 0000000..1a6ffa0 --- /dev/null +++ b/dist/chain/src/ChainTypes.js @@ -0,0 +1,116 @@ +"use strict"; + +var ChainTypes = {}; + +ChainTypes.reserved_spaces = { + relative_protocol_ids: 0, + protocol_ids: 1, + implementation_ids: 2 +}; + +ChainTypes.object_type = { + "null": 0, + base: 1, + account: 2, + asset: 3, + force_settlement: 4, + committee_member: 5, + witness: 6, + limit_order: 7, + call_order: 8, + custom: 9, + proposal: 10, + operation_history: 11, + withdraw_permission: 12, + vesting_balance: 13, + worker: 14, + balance: 15, + tournament: 16, + tournament_details: 17, + match_object_type: 18, + game: 19 +}; + +ChainTypes.impl_object_type = { + global_property: 0, + dynamic_global_property: 1, + index_meta: 2, + asset_dynamic_data: 3, + asset_bitasset_data: 4, + account_balance: 5, + account_statistics: 6, + transaction: 7, + block_summary: 8, + account_transaction_history: 9, + blinded_balance: 10, + chain_property: 11, + witness_schedule: 12, + budget_record: 13, + special_authority: 14, + buyback: 15, + fba_accumulator: 16, + asset_dividend_data: 17, + pending_dividend_payout_balance_for_holder: 18, + distributed_dividend_balance_data: 19 +}; + +ChainTypes.vote_type = { + committee: 0, + witness: 1, + worker: 2 +}; + +ChainTypes.operations = { + transfer: 0, + limit_order_create: 1, + limit_order_cancel: 2, + call_order_update: 3, + fill_order: 4, + account_create: 5, + account_update: 6, + account_whitelist: 7, + account_upgrade: 8, + account_transfer: 9, + asset_create: 10, + asset_update: 11, + asset_update_bitasset: 12, + asset_update_feed_producers: 13, + asset_issue: 14, + asset_reserve: 15, + asset_fund_fee_pool: 16, + asset_settle: 17, + asset_global_settle: 18, + asset_publish_feed: 19, + witness_create: 20, + witness_update: 21, + proposal_create: 22, + proposal_update: 23, + proposal_delete: 24, + withdraw_permission_create: 25, + withdraw_permission_update: 26, + withdraw_permission_claim: 27, + withdraw_permission_delete: 28, + committee_member_create: 29, + committee_member_update: 30, + committee_member_update_global_parameters: 31, + vesting_balance_create: 32, + vesting_balance_withdraw: 33, + worker_create: 34, + custom: 35, + assert: 36, + balance_claim: 37, + override_transfer: 38, + transfer_to_blind: 39, + blind_transfer: 40, + transfer_from_blind: 41, + asset_settle_cancel: 42, + asset_claim_fees: 43, + fba_distribute_operation: 44, + tournament_create: 45, + tournament_join: 46, + game_move: 47, + asset_update_dividend: 48, + asset_dividend_distribution: 49 +}; + +module.exports = ChainTypes; \ No newline at end of file diff --git a/dist/chain/src/ChainValidation.js b/dist/chain/src/ChainValidation.js new file mode 100644 index 0000000..eeb4d04 --- /dev/null +++ b/dist/chain/src/ChainValidation.js @@ -0,0 +1,144 @@ +'use strict'; + +/** + Account names may contain one or more names separated by a dot. + Each name needs to start with a letter and may contain + numbers, or well placed dashes. + @see is_valid_name graphene/libraries/chain/protocol/account.cpp +*/ +var id_regex = /\b\d+\.\d+\.(\d+)\b/; + +var chainValidation = { + is_account_name: function is_account_name(value) { + var allow_too_short = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + var i, label, len, length, ref; + + if (this.is_empty(value)) { + return false; + } + + length = value.length; + + if (!allow_too_short && length < 3 || length > 63) { + return false; + } + + ref = value.split('.'); + + for (i = 0, len = ref.length; i < len; i++) { + + label = ref[i]; + + if (!(/^[a-z][a-z0-9-]*$/.test(label) && !/--/.test(label) && /[a-z0-9]$/.test(label))) { + return false; + } + } + return true; + }, + + is_object_id: function is_object_id(obj_id) { + if ('string' != typeof obj_id) return false; + + var match = id_regex.exec(obj_id); + return match !== null && obj_id.split(".").length === 3; + }, + + is_empty: function is_empty(value) { + return value == null || value.length === 0; + }, + + is_account_name_error: function is_account_name_error(value, allow_too_short) { + var i, label, len, length, ref, suffix; + if (allow_too_short == null) { + allow_too_short = false; + } + suffix = "Account name should "; + if (this.is_empty(value)) { + return suffix + "not be empty."; + } + length = value.length; + if (!allow_too_short && length < 3) { + return suffix + "be longer."; + } + if (length > 63) { + return suffix + "be shorter."; + } + if (/\./.test(value)) { + suffix = "Each account segment should "; + } + ref = value.split('.'); + for (i = 0, len = ref.length; i < len; i++) { + label = ref[i]; + if (!/^[~a-z]/.test(label)) { + return suffix + "start with a letter."; + } + if (!/^[~a-z0-9-]*$/.test(label)) { + return suffix + "have only letters, digits, or dashes."; + } + if (/--/.test(label)) { + return suffix + "have only one dash in a row."; + } + if (!/[a-z0-9]$/.test(label)) { + return suffix + "end with a letter or digit."; + } + if (!(label.length >= 3)) { + return suffix + "be longer"; + } + } + return null; + }, + + is_cheap_name: function is_cheap_name(account_name) { + return (/[0-9-]/.test(account_name) || !/[aeiouy]/.test(account_name) + ); + }, + + is_empty_user_input: function is_empty_user_input(value) { + if (this.is_empty(value)) { + return true; + } + if ((value + "").trim() === "") { + return true; + } + return false; + }, + + required: function required(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + throw new Error("value required for " + field_name + ": " + value); + } + return value; + }, + + /** @see is_valid_symbol graphene/libraries/chain/protocol/asset_ops.cpp */ + is_valid_symbol_error: function is_valid_symbol_error(value) { + var suffix = "Asset name should "; + if (this.is_empty(value)) { + return suffix + "not be empty."; + } + if (value.split('.').length > 2) { + return suffix + "have only one dot."; + } + if (value.length < 3) { + return suffix + "be longer."; + } + if (value.length > 16) { + return suffix + "be shorter."; + } + if (!/^[A-Z]/.test(value)) { + return suffix + "start with a letter"; + } + if (!/[A-Z]$/.test(value)) { + return suffix + "end with a letter"; + } + if (/^[A-Z0-9\.]$/.test(value)) { + return suffix + "contain only letters numbers and perhaps a dot."; + } + return null; + } +}; + +module.exports = chainValidation; \ No newline at end of file diff --git a/dist/chain/src/EmitterInstance.js b/dist/chain/src/EmitterInstance.js new file mode 100644 index 0000000..9b03216 --- /dev/null +++ b/dist/chain/src/EmitterInstance.js @@ -0,0 +1,14 @@ +"use strict"; + +var ee = require("event-emitter"); + +var _emitter; + +module.exports = { + emitter: function emitter() { + if (!_emitter) { + _emitter = ee({}); + } + return _emitter; + } +}; \ No newline at end of file diff --git a/dist/chain/src/GameMoves.js b/dist/chain/src/GameMoves.js new file mode 100644 index 0000000..4c5cd1c --- /dev/null +++ b/dist/chain/src/GameMoves.js @@ -0,0 +1,113 @@ +"use strict"; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var assert = require("assert"); + +var _require = require("../../ecc"), + Signature = _require.Signature, + PublicKey = _require.PublicKey, + hash = _require.hash; + +var _require2 = require("../../serializer"), + Serializer = _require2.Serializer, + types = _require2.types; + +var _require3 = require('peerplaysjs-ws'), + Apis = _require3.Apis, + ChainConfig = _require3.ChainConfig; + +var ChainTypes = require('./ChainTypes'); +var head_block_time_string = void 0; +var ByteBuffer = require('bytebuffer'); +var secureRandom = require("secure-random"); + +var uint8 = types.uint8, + uint16 = types.uint16, + uint32 = types.uint32, + int64 = types.int64, + uint64 = types.uint64, + string = types.string, + bytes = types.bytes, + bool = types.bool, + array = types.array, + fixed_array = types.fixed_array, + protocol_id_type = types.protocol_id_type, + object_id_type = types.object_id_type, + vote_id = types.vote_id, + future_extensions = types.future_extensions, + static_variant = types.static_variant, + map = types.map, + set = types.set, + public_key = types.public_key, + address = types.address, + time_point_sec = types.time_point_sec, + optional = types.optional, + variant = types.variant, + variant_object = types.variant_object, + enumeration = types.enumeration, + sha256 = types.sha256; + + +var rock_paper_scissors_gesture = enumeration(["rock", "paper", "scissors", "spock", "lizard"]); + +var rock_paper_scissors_throw = new Serializer("rock_paper_scissors_throw", { nonce1: uint64, + nonce2: uint64, + gesture: rock_paper_scissors_gesture }); + +var rock_paper_scissors_throw_commit = new Serializer("rock_paper_scissors_throw_commit", { nonce1: uint64, + throw_hash: sha256 }); + +var rock_paper_scissors_throw_reveal = new Serializer("rock_paper_scissors_throw_reveal", { nonce2: uint64, + gesture: rock_paper_scissors_gesture }); + +var GameMoves = function () { + function GameMoves() { + _classCallCheck(this, GameMoves); + } + + _createClass(GameMoves, [{ + key: "createCommitAndRevealMoveOperations", + value: function createCommitAndRevealMoveOperations(move_type) { + var nonce1 = ByteBuffer.wrap(secureRandom.randomArray(8)).readUint64(); + var nonce2 = ByteBuffer.wrap(secureRandom.randomArray(8)).readUint64(); + + var throw_object = rock_paper_scissors_throw.fromObject({ + nonce1: nonce1, + nonce2: nonce2, + gesture: move_type + }); + var throw_object_reconstructed = rock_paper_scissors_throw.toObject(throw_object); + //console.log("Nonce1: %o, Nonce2: %o", nonce1, nonce2); + //console.log("As object: %O, as JS: %O", throw_object, throw_object_reconstructed); + var throw_buffer = rock_paper_scissors_throw.toBuffer(throw_object); + //console.log("As hex: %O", rock_paper_scissors_throw.toHex(throw_object)); + var throw_hash = hash.sha256(throw_buffer); + //console.log("Hash is : %O", throw_hash); + + var commit_move_operation_object = rock_paper_scissors_throw_commit.fromObject({ + nonce1: nonce1, + throw_hash: throw_hash + }); + var reveal_move_operation_object = rock_paper_scissors_throw_reveal.fromObject({ + nonce2: nonce2, + gesture: move_type + }); + + //console.log("Commit hex is %O, reveal hex is %O", rock_paper_scissors_throw_commit.toHex(commit_move_operation_object), rock_paper_scissors_throw_reveal.toHex(reveal_move_operation_object)); + + var commit_move_operation = rock_paper_scissors_throw_commit.toObject(commit_move_operation_object); + var reveal_move_operation = rock_paper_scissors_throw_reveal.toObject(reveal_move_operation_object); + //console.log("As JS, they are %O, %O", commit_move_operation, reveal_move_operation); + + + return [commit_move_operation, reveal_move_operation]; + } + }]); + + return GameMoves; +}(); + +module.exports = GameMoves; \ No newline at end of file diff --git a/dist/chain/src/NumberUtils.js b/dist/chain/src/NumberUtils.js new file mode 100644 index 0000000..bd772ee --- /dev/null +++ b/dist/chain/src/NumberUtils.js @@ -0,0 +1,44 @@ +"use strict"; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var assert = require("assert"); + +/** + Convert 12.34 with a precision of 3 into 12340 + + @arg {number|string} number - Use strings for large numbers. This may contain one decimal but no sign + @arg {number} precision - number of implied decimal places (usually causes right zero padding) + @return {string} - +*/ +module.exports = { + toImpliedDecimal: function toImpliedDecimal(number, precision) { + + if (typeof number === "number") { + assert(number <= 9007199254740991, "overflow"); + number = "" + number; + } else if (number.toString) number = number.toString(); + + assert(typeof number === "string", "number should be an actual number or string: " + (typeof number === "undefined" ? "undefined" : _typeof(number))); + number = number.trim(); + assert(/^[0-9]*\.?[0-9]*$/.test(number), "Invalid decimal number " + number); + + var _number$split = number.split("."), + _number$split2 = _slicedToArray(_number$split, 2), + _number$split2$ = _number$split2[0], + whole = _number$split2$ === undefined ? "" : _number$split2$, + _number$split2$2 = _number$split2[1], + decimal = _number$split2$2 === undefined ? "" : _number$split2$2; + + var padding = precision - decimal.length; + assert(padding >= 0, "Too many decimal digits in " + number + " to create an implied decimal of " + precision); + + for (var i = 0; i < padding; i++) { + decimal += "0"; + }while (whole.charAt(0) === "0") { + whole = whole.substring(1); + }return whole + decimal; + } +}; \ No newline at end of file diff --git a/dist/chain/src/ObjectId.js b/dist/chain/src/ObjectId.js new file mode 100644 index 0000000..86ff3a2 --- /dev/null +++ b/dist/chain/src/ObjectId.js @@ -0,0 +1,71 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _require = require('bytebuffer'), + Long = _require.Long; + +var v = require('../../serializer/src/SerializerValidation'); + +var DB_MAX_INSTANCE_ID = Long.fromNumber(Math.pow(2, 48) - 1); + +var ObjectId = function () { + function ObjectId(space, type, instance) { + _classCallCheck(this, ObjectId); + + this.space = space; + this.type = type; + this.instance = instance; + var instance_string = this.instance.toString(); + var _ObjectId = this.space + '.' + this.type + '.' + instance_string; + if (!v.is_digits(instance_string)) { + throw new ('Invalid object id ' + _ObjectId)(); + } + } + + _createClass(ObjectId, [{ + key: 'toLong', + value: function toLong() { + return Long.fromNumber(this.space).shiftLeft(56).or(Long.fromNumber(this.type).shiftLeft(48).or(this.instance)); + } + }, { + key: 'appendByteBuffer', + value: function appendByteBuffer(b) { + return b.writeUint64(this.toLong()); + } + }, { + key: 'toString', + value: function toString() { + return this.space + '.' + this.type + '.' + this.instance.toString(); + } + }], [{ + key: 'fromString', + value: function fromString(value) { + if (value.space !== undefined && value.type !== undefined && value.instance !== undefined) { + return value; + } + + var params = v.require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, v.required(value, "ObjectId"), "ObjectId"); + return new ObjectId(parseInt(params[1]), parseInt(params[2]), Long.fromString(params[3])); + } + }, { + key: 'fromLong', + value: function fromLong(long) { + var space = long.shiftRight(56).toInt(); + var type = long.shiftRight(48).toInt() & 0x00ff; + var instance = long.and(DB_MAX_INSTANCE_ID); + return new ObjectId(space, type, instance); + } + }, { + key: 'fromByteBuffer', + value: function fromByteBuffer(b) { + return ObjectId.fromLong(b.readUint64()); + } + }]); + + return ObjectId; +}(); + +module.exports = ObjectId; \ No newline at end of file diff --git a/dist/chain/src/TransactionBuilder.js b/dist/chain/src/TransactionBuilder.js new file mode 100644 index 0000000..8057fcc --- /dev/null +++ b/dist/chain/src/TransactionBuilder.js @@ -0,0 +1,591 @@ +"use strict"; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var assert = require("assert"); + +var _require = require("../../ecc"), + Signature = _require.Signature, + PublicKey = _require.PublicKey, + hash = _require.hash; + +var _require2 = require("../../serializer"), + ops = _require2.ops; + +var _require3 = require('peerplaysjs-ws'), + Apis = _require3.Apis, + ChainConfig = _require3.ChainConfig; + +var ChainTypes = require('./ChainTypes'); +var head_block_time_string; + +var TransactionBuilder = function () { + function TransactionBuilder() { + _classCallCheck(this, TransactionBuilder); + + this.ref_block_num = 0; + this.ref_block_prefix = 0; + this.expiration = 0; + this.operations = []; + this.signatures = []; + this.signer_private_keys = []; + + // semi-private method bindings + this._broadcast = _broadcast.bind(this); + } + + /** + @arg {string} name - like "transfer" + @arg {object} operation - JSON matchching the operation's format + */ + + + _createClass(TransactionBuilder, [{ + key: "add_type_operation", + value: function add_type_operation(name, operation) { + this.add_operation(this.get_type_operation(name, operation)); + return; + } + + /** + This does it all: set fees, finalize, sign, and broadcast (if wanted). + @arg {ConfidentialWallet} cwallet - must be unlocked, used to gather signing keys + @arg {array} [signer_pubkeys = null] - Optional ["GPHAbc9Def0...", ...]. These are additional signing keys. Some balance claims require propritary address formats, the witness node can't tell us which ones are needed so they must be passed in. If the witness node can figure out a signing key (mostly all other transactions), it should not be passed in here. + @arg {boolean} [broadcast = false] + */ + + }, { + key: "process_transaction", + value: function process_transaction(cwallet) { + var _this = this; + + var signer_pubkeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var broadcast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + + var wallet_object = cwallet.wallet.wallet_object; + if (Apis.instance().chain_id !== wallet_object.get("chain_id")) return Promise.reject("Mismatched chain_id; expecting " + wallet_object.get("chain_id") + ", but got " + Apis.instance().chain_id); + + return this.set_required_fees().then(function () { + var signer_pubkeys_added = {}; + if (signer_pubkeys) { + + // Balance claims are by address, only the private + // key holder can know about these additional + // potential keys. + var pubkeys = cwallet.getPubkeys_having_PrivateKey(signer_pubkeys); + if (!pubkeys.length) throw new Error("Missing signing key"); + + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = pubkeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var pubkey_string = _step.value; + + var private_key = cwallet.getPrivateKey(pubkey_string); + _this.add_signer(private_key, pubkey_string); + signer_pubkeys_added[pubkey_string] = true; + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + + return _this.get_potential_signatures().then(function (_ref) { + var pubkeys = _ref.pubkeys, + addys = _ref.addys; + + var my_pubkeys = cwallet.getPubkeys_having_PrivateKey(pubkeys, addys); + + //{//Testing only, don't send All public keys! + // var pubkeys_all = PrivateKeyStore.getPubkeys() // All public keys + // this.get_required_signatures(pubkeys_all).then( required_pubkey_strings => + // console.log('get_required_signatures all\t',required_pubkey_strings.sort(), pubkeys_all)) + // this.get_required_signatures(my_pubkeys).then( required_pubkey_strings => + // console.log('get_required_signatures normal\t',required_pubkey_strings.sort(), pubkeys)) + //} + + return _this.get_required_signatures(my_pubkeys).then(function (required_pubkeys) { + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = required_pubkeys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var _pubkey_string = _step2.value; + + if (signer_pubkeys_added[_pubkey_string]) continue; + var private_key = cwallet.getPrivateKey(_pubkey_string); + if (!private_key) + // This should not happen, get_required_signatures will only + // returned keys from my_pubkeys + throw new Error("Missing signing key for " + _pubkey_string); + _this.add_signer(private_key, _pubkey_string); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + }); + }).then(function () { + return broadcast ? _this.broadcast() : _this.serialize(); + }); + }); + } + + /** Typically this is called automatically just prior to signing. Once finalized this transaction can not be changed. */ + + }, { + key: "finalize", + value: function finalize() { + var _this2 = this; + + return new Promise(function (resolve, reject) { + + if (_this2.tr_buffer) { + throw new Error("already finalized"); + } + + resolve(Apis.instance().db_api().exec("get_objects", [["2.1.0"]]).then(function (r) { + head_block_time_string = r[0].time; + if (_this2.expiration === 0) _this2.expiration = base_expiration_sec() + ChainConfig.expire_in_secs; + _this2.ref_block_num = r[0].head_block_number & 0xFFFF; + _this2.ref_block_prefix = new Buffer(r[0].head_block_id, 'hex').readUInt32LE(4); + //DEBUG console.log("ref_block",@ref_block_num,@ref_block_prefix,r) + + var iterable = _this2.operations; + for (var i = 0, op; i < iterable.length; i++) { + op = iterable[i]; + if (op[1]["finalize"]) { + op[1].finalize(); + } + + var _type = ops.operation.st_operations[op[0]]; + var hexBuffer = _type.toBuffer(op[1]).toString("hex"); + console.log("Operation %s: %O => %s (%d bytes)", _type.operation_name, op[1], hexBuffer, hexBuffer.length / 2); + } + _this2.tr_buffer = ops.transaction.toBuffer(_this2); + })); + }); + } + + /** @return {string} hex transaction ID */ + + }, { + key: "id", + value: function id() { + if (!this.tr_buffer) { + throw new Error("not finalized"); + } + return hash.sha256(this.tr_buffer).toString('hex').substring(0, 40); + } + + /** + Typically one will use {@link this.add_type_operation} instead. + @arg {array} operation - [operation_id, operation] + */ + + }, { + key: "add_operation", + value: function add_operation(operation) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + assert(operation, "operation"); + if (!Array.isArray(operation)) { + throw new Error("Expecting array [operation_id, operation]"); + } + this.operations.push(operation); + return; + } + }, { + key: "get_type_operation", + value: function get_type_operation(name, operation) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + assert(name, "name"); + assert(operation, "operation"); + var _type = ops[name]; + assert(_type, "Unknown operation " + name); + var operation_id = ChainTypes.operations[_type.operation_name]; + if (operation_id === undefined) { + throw new Error("unknown operation: " + _type.operation_name); + } + if (!operation.fee) { + operation.fee = { amount: 0, asset_id: 0 }; + } + if (name === 'proposal_create') { + operation.expiration_time || (operation.expiration_time = base_expiration_sec() + ChainConfig.expire_in_secs_proposal); + } + var operation_instance = _type.fromObject(operation); + return [operation_id, operation_instance]; + } + + /** optional: there is a deafult expiration */ + + }, { + key: "set_expire_seconds", + value: function set_expire_seconds(sec) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + return this.expiration = base_expiration_sec() + sec; + } + + /* Wraps this transaction in a proposal_create transaction */ + + }, { + key: "propose", + value: function propose(proposal_create_options) { + if (this.tr_buffer) { + throw new Error("already finalized"); + } + if (!this.operations.length) { + throw new Error("add operation first"); + } + + assert(proposal_create_options, "proposal_create_options"); + assert(proposal_create_options.fee_paying_account, "proposal_create_options.fee_paying_account"); + + var proposed_ops = this.operations.map(function (op) { + return { op: op }; + }); + + this.operations = []; + this.signatures = []; + this.signer_private_keys = []; + proposal_create_options.proposed_ops = proposed_ops; + this.add_type_operation("proposal_create", proposal_create_options); + return this; + } + }, { + key: "has_proposed_operation", + value: function has_proposed_operation() { + var hasProposed = false; + for (var i = 0; i < this.operations.length; i++) { + if ("proposed_ops" in this.operations[i][1]) { + hasProposed = true; + break; + } + } + + return hasProposed; + } + + /** optional: the fees can be obtained from the witness node */ + + }, { + key: "set_required_fees", + value: function set_required_fees(asset_id) { + var _this3 = this; + + var fee_pool; + if (this.tr_buffer) { + throw new Error("already finalized"); + } + if (!this.operations.length) { + throw new Error("add operations first"); + } + var operations = []; + for (var i = 0, op; i < this.operations.length; i++) { + op = this.operations[i]; + operations.push(ops.operation.toObject(op)); + } + + if (!asset_id) { + var op1_fee = operations[0][1].fee; + if (op1_fee && op1_fee.asset_id !== null) { + asset_id = op1_fee.asset_id; + } else { + asset_id = "1.3.0"; + } + } + + var promises = [Apis.instance().db_api().exec("get_required_fees", [operations, asset_id])]; + + var feeAssetPromise = null; + if (asset_id !== "1.3.0") { + // This handles the fallback to paying fees in BTS if the fee pool is empty. + promises.push(Apis.instance().db_api().exec("get_required_fees", [operations, "1.3.0"])); + promises.push(Apis.instance().db_api().exec("get_objects", [[asset_id]])); + } + + return Promise.all(promises).then(function (results) { + var _results = _slicedToArray(results, 3), + fees = _results[0], + coreFees = _results[1], + asset = _results[2]; + + asset = asset ? asset[0] : null; + + var dynamicPromise = asset_id !== "1.3.0" && asset ? Apis.instance().db_api().exec("get_objects", [[asset.dynamic_asset_data_id]]) : new Promise(function (resolve, reject) { + resolve(); + }); + + return dynamicPromise.then(function (dynamicObject) { + if (asset_id !== "1.3.0") { + fee_pool = dynamicObject ? dynamicObject[0].fee_pool : 0; + var totalFees = 0; + for (var j = 0, fee; j < coreFees.length; j++) { + fee = coreFees[j]; + totalFees += fee.amount; + } + + if (totalFees > parseInt(fee_pool, 10)) { + fees = coreFees; + asset_id = "1.3.0"; + } + } + + // Proposed transactions need to be flattened + var flat_assets = []; + var flatten = function flatten(obj) { + if (Array.isArray(obj)) { + for (var k = 0, item; k < obj.length; k++) { + item = obj[k]; + flatten(item); + } + } else { + flat_assets.push(obj); + } + return; + }; + flatten(fees); + + var asset_index = 0; + + var set_fee = function set_fee(operation) { + if (!operation.fee || operation.fee.amount === 0 || operation.fee.amount.toString && operation.fee.amount.toString() === "0" // Long + ) { + operation.fee = flat_assets[asset_index]; + // console.log("new operation.fee", operation.fee) + } else { + // console.log("old operation.fee", operation.fee) + } + asset_index++; + if (operation.proposed_ops) { + var result = []; + for (var y = 0; y < operation.proposed_ops.length; y++) { + result.push(set_fee(operation.proposed_ops[y].op[1])); + }return result; + } + }; + for (var _i = 0; _i < _this3.operations.length; _i++) { + set_fee(_this3.operations[_i][1]); + } + }); + //DEBUG console.log('... get_required_fees',operations,asset_id,flat_assets) + }); + } + }, { + key: "get_potential_signatures", + value: function get_potential_signatures() { + var tr_object = ops.signed_transaction.toObject(this); + return Promise.all([Apis.instance().db_api().exec("get_potential_signatures", [tr_object]), Apis.instance().db_api().exec("get_potential_address_signatures", [tr_object])]).then(function (results) { + return { pubkeys: results[0], addys: results[1] }; + }); + } + }, { + key: "get_required_signatures", + value: function get_required_signatures(available_keys) { + if (!available_keys.length) { + return Promise.resolve([]); + } + var tr_object = ops.signed_transaction.toObject(this); + //DEBUG console.log('... tr_object',tr_object) + return Apis.instance().db_api().exec("get_required_signatures", [tr_object, available_keys]).then(function (required_public_keys) { + //DEBUG console.log('... get_required_signatures',required_public_keys) + return required_public_keys; + }); + } + }, { + key: "add_signer", + value: function add_signer(private_key) { + var public_key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : private_key.toPublicKey(); + + + assert(private_key.d, "required PrivateKey object"); + + if (this.signed) { + throw new Error("already signed"); + } + if (!public_key.Q) { + public_key = PublicKey.fromPublicKeyString(public_key); + } + // prevent duplicates + var spHex = private_key.toHex(); + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; + + try { + for (var _iterator3 = this.signer_private_keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var sp = _step3.value; + + if (sp[0].toHex() === spHex) return; + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } + + this.signer_private_keys.push([private_key, public_key]); + } + }, { + key: "sign", + value: function sign() { + var chain_id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Apis.instance().chain_id; + + if (!this.tr_buffer) { + throw new Error("not finalized"); + } + if (this.signed) { + throw new Error("already signed"); + } + if (!this.signer_private_keys.length) { + throw new Error("Transaction was not signed. Do you have a private key? [no_signers]"); + } + var end = this.signer_private_keys.length; + for (var i = 0; 0 < end ? i < end : i > end; 0 < end ? i++ : i++) { + var _signer_private_keys$ = _slicedToArray(this.signer_private_keys[i], 2), + private_key = _signer_private_keys$[0], + public_key = _signer_private_keys$[1]; + + var sig = Signature.signBuffer(Buffer.concat([new Buffer(chain_id, 'hex'), this.tr_buffer]), private_key, public_key); + this.signatures.push(sig.toBuffer()); + } + this.signer_private_keys = []; + this.signed = true; + return; + } + }, { + key: "serialize", + value: function serialize() { + return ops.signed_transaction.toObject(this); + } + }, { + key: "toObject", + value: function toObject() { + return ops.signed_transaction.toObject(this); + } + }, { + key: "broadcast", + value: function broadcast(was_broadcast_callback) { + var _this4 = this; + + if (this.tr_buffer) { + return this._broadcast(was_broadcast_callback); + } else { + return this.finalize().then(function () { + return _this4._broadcast(was_broadcast_callback); + }); + } + } + }]); + + return TransactionBuilder; +}(); + +var base_expiration_sec = function base_expiration_sec() { + var head_block_sec = Math.ceil(getHeadBlockDate().getTime() / 1000); + var now_sec = Math.ceil(Date.now() / 1000); + // The head block time should be updated every 3 seconds. If it isn't + // then help the transaction to expire (use head_block_sec) + if (now_sec - head_block_sec > 30) { + return head_block_sec; + } + // If the user's clock is very far behind, use the head block time. + return Math.max(now_sec, head_block_sec); +}; + +function _broadcast(was_broadcast_callback) { + var _this5 = this; + + return new Promise(function (resolve, reject) { + + if (!_this5.signed) { + _this5.sign(); + } + if (!_this5.tr_buffer) { + throw new Error("not finalized"); + } + if (!_this5.signatures.length) { + throw new Error("not signed"); + } + if (!_this5.operations.length) { + throw new Error("no operations"); + } + + var tr_object = ops.signed_transaction.toObject(_this5); + // console.log('... broadcast_transaction_with_callback !!!') + Apis.instance().network_api().exec("broadcast_transaction_with_callback", [function (res) { + return resolve(res); + }, tr_object]).then(function () { + //console.log('... broadcast success, waiting for callback') + if (was_broadcast_callback) was_broadcast_callback(); + return; + }).catch(function (error) { + // console.log may be redundant for network errors, other errors could occur + console.log(error); + var message = error.message; + if (!message) { + message = ""; + } + reject(new Error(message + "\n" + 'graphene-crypto ' + ' digest ' + hash.sha256(_this5.tr_buffer).toString('hex') + ' transaction ' + _this5.tr_buffer.toString('hex') + ' ' + JSON.stringify(tr_object))); + return; + }); + return; + }); +} + +function getHeadBlockDate() { + return timeStringToDate(head_block_time_string); +} + +function timeStringToDate(time_string) { + if (!time_string) return new Date("1970-01-01T00:00:00.000Z"); + if (!/Z$/.test(time_string)) //does not end in Z + // https://github.com/cryptonomex/graphene/issues/368 + time_string = time_string + "Z"; + return new Date(time_string); +} + +module.exports = TransactionBuilder; \ No newline at end of file diff --git a/dist/chain/src/TransactionHelper.js b/dist/chain/src/TransactionHelper.js new file mode 100644 index 0000000..238173f --- /dev/null +++ b/dist/chain/src/TransactionHelper.js @@ -0,0 +1,104 @@ +'use strict'; + +var helper; +module.exports = helper = {}; + +var secureRandom = require('secure-random'); + +//Promise = require '../common/Promise' + +var _require = require('bytebuffer'), + Long = _require.Long; + +var _require2 = require("../../ecc"), + Signature = _require2.Signature; + +var _require3 = require("../../serializer"), + ops = _require3.ops; + +var _require4 = require("peerplaysjs-ws"), + Apis = _require4.Apis; + +helper.unique_nonce_entropy = null; +helper.unique_nonce_uint64 = function () { + var entropy = helper.unique_nonce_entropy = function () { + + if (helper.unique_nonce_entropy === null) { + //console.log('... secureRandom.randomUint8Array(1)[0]',secureRandom.randomUint8Array(1)[0]) + return parseInt(secureRandom.randomUint8Array(1)[0]); + } else { + return ++helper.unique_nonce_entropy % 256; + } + }(); + var long = Long.fromNumber(Date.now()); + //console.log('unique_nonce_uint64 date\t',ByteBuffer.allocate(8).writeUint64(long).toHex(0)) + //console.log('unique_nonce_uint64 entropy\t',ByteBuffer.allocate(8).writeUint64(Long.fromNumber(entropy)).toHex(0)) + long = long.shiftLeft(8).or(Long.fromNumber(entropy)); + //console.log('unique_nonce_uint64 shift8\t',ByteBuffer.allocate(8).writeUint64(long).toHex(0)) + return long.toString(); +}; + +/* Todo, set fees */ +helper.to_json = function (tr) { + var broadcast = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + return function (tr, broadcast) { + var tr_object = ops.signed_transaction.toObject(tr); + if (broadcast) { + var net = Apis.instance().network_api(); + console.log('... tr_object', JSON.stringify(tr_object)); + return net.exec("broadcast_transaction", [tr_object]); + } else { + return tr_object; + } + }(tr, broadcast); +}; + +helper.signed_tr_json = function (tr, private_keys) { + var tr_buffer = ops.transaction.toBuffer(tr); + tr = ops.transaction.toObject(tr); + tr.signatures = function () { + var result = []; + for (var i = 0; 0 < private_keys.length ? i < private_keys.length : i > private_keys.length; 0 < private_keys.length ? i++ : i++) { + var private_key = private_keys[i]; + result.push(Signature.signBuffer(tr_buffer, private_key).toHex()); + } + return result; + }(); + return tr; +}; + +helper.expire_in_min = function (min) { + return Math.round(Date.now() / 1000) + min * 60; +}; + +helper.seconds_from_now = function (timeout_sec) { + return Math.round(Date.now() / 1000) + timeout_sec; +}; + +/** + Print to the console a JSON representation of any object in + @graphene/serializer { types } +*/ +helper.template = function (serializer_operation_type_name) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: true, annotate: true }; + + var so = type[serializer_operation_type_name]; + if (!so) { + throw new Error('unknown serializer_operation_type ' + serializer_operation_type_name); + } + return so.toObject(undefined, debug); +}; + +helper.new_operation = function (serializer_operation_type_name) { + var so = type[serializer_operation_type_name]; + if (!so) { + throw new Error('unknown serializer_operation_type ' + serializer_operation_type_name); + } + var object = so.toObject(undefined, { use_default: true, annotate: true }); + return so.fromObject(object); +}; + +helper.instance = function (ObjectId) { + return ObjectId.substring("0.0.".length); +}; \ No newline at end of file diff --git a/dist/chain/src/state.js b/dist/chain/src/state.js new file mode 100644 index 0000000..42971a3 --- /dev/null +++ b/dist/chain/src/state.js @@ -0,0 +1,19 @@ +"use strict"; + +function get(state) { + return function (key) { + return state[key] || ""; + }; +} + +function set(state) { + return function (key, value) { + state[key] = value; + return this; + }; +} + +module.exports = { + get: get, + set: set +}; \ No newline at end of file diff --git a/dist/ecc/index.js b/dist/ecc/index.js new file mode 100644 index 0000000..0444359 --- /dev/null +++ b/dist/ecc/index.js @@ -0,0 +1,12 @@ +"use strict"; + +module.exports = { + Address: require("./src/address"), + Aes: require("./src/aes"), + PrivateKey: require("./src/PrivateKey"), + PublicKey: require("./src/PublicKey"), + Signature: require("./src/signature"), + brainKey: require("./src/BrainKey"), + hash: require("./src/hash"), + key: require("./src/KeyUtils") +}; \ No newline at end of file diff --git a/dist/ecc/src/BrainKey.js b/dist/ecc/src/BrainKey.js new file mode 100644 index 0000000..998b065 --- /dev/null +++ b/dist/ecc/src/BrainKey.js @@ -0,0 +1,9 @@ +'use strict'; + +module.exports = function normalize(brainKey) { + if (typeof brainKey !== 'string') { + throw new Error("string required for brainKey"); + } + brainKey = brainKey.trim(); + return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); +}; \ No newline at end of file diff --git a/dist/ecc/src/KeyUtils.js b/dist/ecc/src/KeyUtils.js new file mode 100644 index 0000000..f993222 --- /dev/null +++ b/dist/ecc/src/KeyUtils.js @@ -0,0 +1,202 @@ +'use strict'; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +var key; +var PrivateKey = require('./PrivateKey'); +var PublicKey = require('./PublicKey'); +var Address = require('./address'); +var Aes = require('./aes'); + +var hash = require('./hash'); +// var dictionary = require('./dictionary_en'); +var secureRandom = require('secure-random'); + +var _require = require('peerplaysjs-ws'), + ChainConfig = _require.ChainConfig; + +// hash for .25 second + + +var HASH_POWER_MILLS = 250; + +module.exports = key = { + + /** Uses 1 second of hashing power to create a key/password checksum. An + implementation can re-call this method with the same password to re-match + the strength of the CPU (either after moving from a desktop to a mobile, + mobile to desktop, or N years from now when CPUs are presumably stronger). + A salt is used for all the normal reasons... + @return object { + aes_private: Aes, + checksum: "{hash_iteration_count},{salt},{checksum}" + } + */ + aes_checksum: function aes_checksum(password) { + if (!(typeof password === "string")) { + throw new "password string required"(); + } + var salt = secureRandom.randomBuffer(4).toString('hex'); + var iterations = 0; + var secret = salt + password; + // hash for .1 second + var start_t = Date.now(); + while (Date.now() - start_t < HASH_POWER_MILLS) { + secret = hash.sha256(secret); + iterations += 1; + } + + var checksum = hash.sha256(secret); + var checksum_string = [iterations, salt.toString('hex'), checksum.slice(0, 4).toString('hex')].join(','); + + return { aes_private: Aes.fromSeed(secret), + checksum: checksum_string + }; + }, + + + /** Provide a matching password and key_checksum. A "wrong password" + error is thrown if the password does not match. If this method takes + much more or less than 1 second to return, one should consider updating + all encyrpted fields using a new key.key_checksum. + */ + aes_private: function aes_private(password, key_checksum) { + var _key_checksum$split = key_checksum.split(','), + _key_checksum$split2 = _slicedToArray(_key_checksum$split, 3), + iterations = _key_checksum$split2[0], + salt = _key_checksum$split2[1], + checksum = _key_checksum$split2[2]; + + var secret = salt + password; + for (var i = 0; 0 < iterations ? i < iterations : i > iterations; 0 < iterations ? i++ : i++) { + secret = hash.sha256(secret); + } + var new_checksum = hash.sha256(secret); + if (!(new_checksum.slice(0, 4).toString('hex') === checksum)) { + throw new Error("wrong password"); + } + return Aes.fromSeed(secret); + }, + + + /** + A week random number generator can run out of entropy. This should ensure even the worst random number implementation will be reasonably safe. + @param1 string entropy of at least 32 bytes + */ + random32ByteBuffer: function random32ByteBuffer() { + var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy(); + + + if (!(typeof entropy === 'string')) { + throw new Error("string required for entropy"); + } + + if (entropy.length < 32) { + throw new Error("expecting at least 32 bytes of entropy"); + } + + var start_t = Date.now(); + + while (Date.now() - start_t < HASH_POWER_MILLS) { + entropy = hash.sha256(entropy); + }var hash_array = []; + hash_array.push(entropy); + + // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back). + hash_array.push(secureRandom.randomBuffer(32)); + + return hash.sha256(Buffer.concat(hash_array)); + }, + + + suggest_brain_key: function suggest_brain_key() { + var dictionary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ","; + var entropy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.browserEntropy(); + + + var randomBuffer = this.random32ByteBuffer(entropy); + + var word_count = 16; + var dictionary_lines = dictionary.split(','); + + if (!(dictionary_lines.length === 49744)) { + throw new Error('expecting ' + 49744 + ' but got ' + dictionary_lines.length + ' dictionary words'); + } + + var brainkey = []; + var end = word_count * 2; + + for (var i = 0; i < end; i += 2) { + + // randomBuffer has 256 bits / 16 bits per word == 16 words + var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; + + // convert into a number between 0 and 1 (inclusive) + var rndMultiplier = num / Math.pow(2, 16); + var wordIndex = Math.round(dictionary_lines.length * rndMultiplier); + + brainkey.push(dictionary_lines[wordIndex]); + } + return this.normalize_brainKey(brainkey.join(' ')); + }, + + get_random_key: function get_random_key(entropy) { + return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy)); + }, + get_brainPrivateKey: function get_brainPrivateKey(brainKey) { + var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + + if (sequence < 0) { + throw new Error("invalid sequence"); + } + brainKey = key.normalize_brainKey(brainKey); + return PrivateKey.fromBuffer(hash.sha256(hash.sha512(brainKey + " " + sequence))); + }, + + + // Turn invisible space like characters into a single space + normalize_brainKey: function normalize_brainKey(brainKey) { + if (!(typeof brainKey === 'string')) { + throw new Error("string required for brainKey"); + } + + brainKey = brainKey.trim(); + return brainKey.split(/[\t\n\v\f\r ]+/).join(' '); + }, + browserEntropy: function browserEntropy() { + + var entropyStr = ""; + try { + entropyStr = new Date().toString() + " " + window.screen.height + " " + window.screen.width + " " + window.screen.colorDepth + " " + " " + window.screen.availHeight + " " + window.screen.availWidth + " " + window.screen.pixelDepth + navigator.language + " " + window.location + " " + window.history.length; + + for (var i = 0, mimeType; i < navigator.mimeTypes.length; i++) { + mimeType = navigator.mimeTypes[i]; + entropyStr += mimeType.description + " " + mimeType.type + " " + mimeType.suffixes + " "; + } + console.log("INFO\tbrowserEntropy gathered"); + } catch (error) { + //nodejs:ReferenceError: window is not defined + entropyStr = hash.sha256(new Date().toString()); + } + + var b = new Buffer(entropyStr); + entropyStr += b.toString('binary') + " " + new Date().toString(); + return entropyStr; + }, + + + // @return array of 5 legacy addresses for a pubkey string parameter. + addresses: function addresses(pubkey) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + var public_key = PublicKey.fromPublicKeyString(pubkey, address_prefix); + // S L O W + var address_string = [Address.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed + Address.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed + Address.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed + Address.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed + public_key.toAddressString(address_prefix) // bts_short, most recent format + ]; + return address_string; + } +}; \ No newline at end of file diff --git a/dist/ecc/src/PrivateKey.js b/dist/ecc/src/PrivateKey.js new file mode 100644 index 0000000..8f4bfdc --- /dev/null +++ b/dist/ecc/src/PrivateKey.js @@ -0,0 +1,213 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var ecurve = require('ecurve'); + +var _require = require('ecurve'), + Point = _require.Point, + getCurveByName = _require.getCurveByName; + +var secp256k1 = getCurveByName('secp256k1'); +var BigInteger = require('bigi'); + +var _require2 = require('bs58'), + encode = _require2.encode, + decode = _require2.decode; + +var assert = require('assert'); +var hash = require('./hash'); +var PublicKey = require('./PublicKey'); +var deepEqual = require("deep-equal"); + +var G = secp256k1.G, + n = secp256k1.n; + +var PrivateKey = function () { + + /** + @private see static functions + @param {BigInteger} + */ + function PrivateKey(d) { + _classCallCheck(this, PrivateKey); + + this.d = d; + } + + _createClass(PrivateKey, [{ + key: 'toWif', + value: function toWif() { + var private_key = this.toBuffer(); + // checksum includes the version + private_key = Buffer.concat([new Buffer([0x80]), private_key]); + var checksum = hash.sha256(private_key); + checksum = hash.sha256(checksum); + checksum = checksum.slice(0, 4); + var private_wif = Buffer.concat([private_key, checksum]); + return encode(private_wif); + } + + /** + @return {Point} + */ + + }, { + key: 'toPublicKeyPoint', + value: function toPublicKeyPoint() { + var Q; + return Q = secp256k1.G.multiply(this.d); + } + }, { + key: 'toPublicKey', + value: function toPublicKey() { + if (this.public_key) { + return this.public_key; + } + return this.public_key = PublicKey.fromPoint(this.toPublicKeyPoint()); + } + }, { + key: 'toBuffer', + value: function toBuffer() { + return this.d.toBuffer(32); + } + + /** ECIES */ + + }, { + key: 'get_shared_secret', + value: function get_shared_secret(public_key) { + var legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + public_key = toPublic(public_key); + var KB = public_key.toUncompressed().toBuffer(); + var KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)), // x + BigInteger.fromBuffer(KB.slice(33, 65)) // y + ); + var r = this.toBuffer(); + var P = KBP.multiply(BigInteger.fromBuffer(r)); + var S = P.affineX.toBuffer({ size: 32 }); + /* + the input to sha512 must be exactly 32-bytes, to match the c++ implementation + of get_shared_secret. Right now S will be shorter if the most significant + byte(s) is zero. Pad it back to the full 32-bytes + */ + if (!legacy && S.length < 32) { + pad = new Buffer(32 - S.length).fill(0); + S = Buffer.concat([pad, S]); + } + + // SHA512 used in ECIES + return hash.sha512(S); + } + + // /** ECIES (does not always match the Point.fromAffine version above) */ + // get_shared_secret(public_key){ + // public_key = toPublic(public_key) + // var P = public_key.Q.multiply( this.d ); + // var S = P.affineX.toBuffer({size: 32}); + // // ECIES, adds an extra sha512 + // return hash.sha512(S); + // } + + /** @throws {Error} - overflow of the key could not be derived */ + + }, { + key: 'child', + value: function child(offset) { + offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]); + offset = hash.sha256(offset); + var c = BigInteger.fromBuffer(offset); + + if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again"); + + var derived = this.d.add(c); //.mod(n) + + if (derived.signum() === 0) throw new Error("Child offset derived to an invalid key, try again"); + + return new PrivateKey(derived); + } + + /* */ + + }, { + key: 'toByteBuffer', + value: function toByteBuffer() { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + } + }, { + key: 'toHex', + value: function toHex() { + return this.toBuffer().toString('hex'); + } + + /* */ + + }], [{ + key: 'fromBuffer', + value: function fromBuffer(buf) { + if (!Buffer.isBuffer(buf)) { + throw new Error("Expecting paramter to be a Buffer type"); + } + if (32 !== buf.length) { + console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack); + } + if (buf.length === 0) { + throw new Error("Empty buffer"); + } + return new PrivateKey(BigInteger.fromBuffer(buf)); + } + + /** @arg {string} seed - any length string. This is private, the same seed produces the same private key every time. */ + + }, { + key: 'fromSeed', + value: function fromSeed(seed) { + // generate_private_key + if (!(typeof seed === 'string')) { + throw new Error('seed must be of type string'); + } + return PrivateKey.fromBuffer(hash.sha256(seed)); + } + + /** @return {string} Wallet Import Format (still a secret, Not encrypted) */ + + }, { + key: 'fromWif', + value: function fromWif(_private_wif) { + var private_wif = new Buffer(decode(_private_wif)); + var version = private_wif.readUInt8(0); + assert.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version); + // checksum includes the version + var private_key = private_wif.slice(0, -4); + var checksum = private_wif.slice(-4); + var new_checksum = hash.sha256(private_key); + new_checksum = hash.sha256(new_checksum); + new_checksum = new_checksum.slice(0, 4); + var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum' + if (!isEqual) { + throw new Error("Checksum did not match"); + } + private_key = private_key.slice(1); + private_key = private_key.slice(0, 32); + return PrivateKey.fromBuffer(private_key); + } + }, { + key: 'fromHex', + value: function fromHex(hex) { + return PrivateKey.fromBuffer(new Buffer(hex, 'hex')); + } + }]); + + return PrivateKey; +}(); + +module.exports = PrivateKey; + +var toPublic = function toPublic(data) { + return data == null ? data : data.Q ? data : PublicKey.fromStringOrThrow(data); +}; \ No newline at end of file diff --git a/dist/ecc/src/PublicKey.js b/dist/ecc/src/PublicKey.js new file mode 100644 index 0000000..a04d063 --- /dev/null +++ b/dist/ecc/src/PublicKey.js @@ -0,0 +1,236 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var BigInteger = require('bigi'); + +var _require = require('ecurve'), + Point = _require.Point, + getCurveByName = _require.getCurveByName; + +var secp256k1 = getCurveByName('secp256k1'); + +var _require2 = require('bs58'), + encode = _require2.encode, + decode = _require2.decode; + +var hash = require('./hash'); + +var _require3 = require('peerplaysjs-ws'), + ChainConfig = _require3.ChainConfig; + +var assert = require('assert'); +var deepEqual = require("deep-equal"); + +var G = secp256k1.G, + n = secp256k1.n; + +var PublicKey = function () { + + /** @param {Point} public key */ + function PublicKey(Q) { + _classCallCheck(this, PublicKey); + + this.Q = Q; + } + + _createClass(PublicKey, [{ + key: 'toBuffer', + value: function toBuffer() { + var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null; + + if (this.Q === null) return new Buffer('000000000000000000000000000000000000000000000000000000000000000000', 'hex'); + return this.Q.getEncoded(compressed); + } + }, { + key: 'toUncompressed', + value: function toUncompressed() { + var buf = this.Q.getEncoded(false); + var point = Point.decodeFrom(secp256k1, buf); + return PublicKey.fromPoint(point); + } + + /** bts::blockchain::address (unique but not a full public key) */ + + }, { + key: 'toBlockchainAddress', + value: function toBlockchainAddress() { + var pub_buf = this.toBuffer(); + var pub_sha = hash.sha512(pub_buf); + return hash.ripemd160(pub_sha); + } + + /** Alias for {@link toPublicKeyString} */ + + }, { + key: 'toString', + value: function toString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; + + return this.toPublicKeyString(address_prefix); + } + + /** + Full public key + {return} string + */ + + }, { + key: 'toPublicKeyString', + value: function toPublicKeyString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; + + var pub_buf = this.toBuffer(); + var checksum = hash.ripemd160(pub_buf); + // Slice from the buffer directly, slicing from the checksum Uint8array will return the entire array each time. + var sliced = new Uint8Array(checksum.buffer.slice(0, 4)); + + // concat only accepts buffers so initialize the sliced Uint8array as a Buffer. + var addy = Buffer.concat([pub_buf, Buffer.from(sliced)]); + return address_prefix + encode(addy); + } + + /** + @arg {string} public_key - like GPHXyz... + @arg {string} address_prefix - like GPH + @return PublicKey or `null` (if the public_key string is invalid) + */ + + }, { + key: 'toAddressString', + value: function toAddressString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; + + var pub_buf = this.toBuffer(); + var pub_sha = hash.sha512(pub_buf); + var addy = hash.ripemd160(pub_sha); + var checksum = hash.ripemd160(addy); + addy = Buffer.concat([addy, checksum.slice(0, 4)]); + return address_prefix + encode(addy); + } + }, { + key: 'toPtsAddy', + value: function toPtsAddy() { + var pub_buf = this.toBuffer(); + var pub_sha = hash.sha256(pub_buf); + var addy = hash.ripemd160(pub_sha); + addy = Buffer.concat([new Buffer([0x38]), addy]); //version 56(decimal) + + var checksum = hash.sha256(addy); + checksum = hash.sha256(checksum); + + addy = Buffer.concat([addy, checksum.slice(0, 4)]); + return encode(addy); + } + }, { + key: 'child', + value: function child(offset) { + + assert(Buffer.isBuffer(offset), "Buffer required: offset"); + assert.equal(offset.length, 32, "offset length"); + + offset = Buffer.concat([this.toBuffer(), offset]); + offset = hash.sha256(offset); + + var c = BigInteger.fromBuffer(offset); + + if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again"); + + var cG = G.multiply(c); + var Qprime = this.Q.add(cG); + + if (secp256k1.isInfinity(Qprime)) throw new Error("Child offset derived to an invalid key, try again"); + + return PublicKey.fromPoint(Qprime); + } + + /* */ + + }, { + key: 'toByteBuffer', + value: function toByteBuffer() { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + } + }, { + key: 'toHex', + value: function toHex() { + return this.toBuffer().toString('hex'); + } + }], [{ + key: 'fromBinary', + value: function fromBinary(bin) { + return PublicKey.fromBuffer(new Buffer(bin, 'binary')); + } + }, { + key: 'fromBuffer', + value: function fromBuffer(buffer) { + if (buffer.toString('hex') === '000000000000000000000000000000000000000000000000000000000000000000') return new PublicKey(null); + return new PublicKey(Point.decodeFrom(secp256k1, buffer)); + } + }, { + key: 'fromPoint', + value: function fromPoint(point) { + return new PublicKey(point); + } + }, { + key: 'fromPublicKeyString', + value: function fromPublicKeyString(public_key) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + try { + return PublicKey.fromStringOrThrow(public_key, address_prefix); + } catch (e) { + return null; + } + } + + /** + @arg {string} public_key - like GPHXyz... + @arg {string} address_prefix - like GPH + @throws {Error} if public key is invalid + @return PublicKey + */ + + }, { + key: 'fromStringOrThrow', + value: function fromStringOrThrow(public_key) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + var prefix = public_key.slice(0, address_prefix.length); + assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); + public_key = public_key.slice(address_prefix.length); + + public_key = new Buffer(decode(public_key), 'binary'); + var checksum = public_key.slice(-4); + public_key = public_key.slice(0, -4); + var new_checksum = hash.ripemd160(public_key); + new_checksum = new_checksum.slice(0, 4); + var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum' + if (!isEqual) { + throw new Error("Checksum did not match"); + } + return PublicKey.fromBuffer(public_key); + } + }, { + key: 'fromHex', + value: function fromHex(hex) { + return PublicKey.fromBuffer(new Buffer(hex, 'hex')); + } + }, { + key: 'fromPublicKeyStringHex', + value: function fromPublicKeyStringHex(hex) { + return PublicKey.fromPublicKeyString(new Buffer(hex, 'hex')); + } + + /* */ + + }]); + + return PublicKey; +}(); + +module.exports = PublicKey; \ No newline at end of file diff --git a/dist/ecc/src/address.js b/dist/ecc/src/address.js new file mode 100644 index 0000000..919b85d --- /dev/null +++ b/dist/ecc/src/address.js @@ -0,0 +1,95 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var assert = require('assert'); + +var _require = require('peerplaysjs-ws'), + ChainConfig = _require.ChainConfig; + +var hash = require('./hash'); + +var _require2 = require('bs58'), + encode = _require2.encode, + decode = _require2.decode; + +var deepEqual = require("deep-equal"); + +/** Addresses are shortened non-reversable hashes of a public key. The full PublicKey is preferred. + @deprecated +*/ + +var Address = function () { + function Address(addy) { + _classCallCheck(this, Address); + + this.addy = addy; + } + + _createClass(Address, [{ + key: 'toBuffer', + value: function toBuffer() { + return this.addy; + } + }, { + key: 'toString', + value: function toString() { + var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChainConfig.address_prefix; + + var checksum = hash.ripemd160(this.addy); + var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]); + return address_prefix + encode(addy); + } + }], [{ + key: 'fromBuffer', + value: function fromBuffer(buffer) { + var _hash = hash.sha512(buffer); + var addy = hash.ripemd160(_hash); + return new Address(addy); + } + }, { + key: 'fromString', + value: function fromString(string) { + var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChainConfig.address_prefix; + + var prefix = string.slice(0, address_prefix.length); + assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix); + var addy = string.slice(address_prefix.length); + addy = new Buffer(decode(addy), 'binary'); + var checksum = addy.slice(-4); + addy = addy.slice(0, -4); + var new_checksum = hash.ripemd160(addy); + new_checksum = new_checksum.slice(0, 4); + var isEqual = deepEqual(checksum, new_checksum); //, 'Invalid checksum' + if (!isEqual) { + throw new Error("Checksum did not match"); + } + return new Address(addy); + } + }, { + key: 'fromPublic', + + + /** @return Address - Compressed PTS format (by default) */ + value: function fromPublic(public_key) { + var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 56; + + var sha2 = hash.sha256(public_key.toBuffer(compressed)); + var rep = hash.ripemd160(sha2); + var versionBuffer = new Buffer(1); + versionBuffer.writeUInt8(0xFF & version, 0); + var addr = Buffer.concat([versionBuffer, rep]); + var check = hash.sha256(addr); + check = hash.sha256(check); + var buffer = Buffer.concat([addr, check.slice(0, 4)]); + return new Address(hash.ripemd160(buffer)); + } + }]); + + return Address; +}(); + +module.exports = Address; \ No newline at end of file diff --git a/dist/ecc/src/aes.js b/dist/ecc/src/aes.js new file mode 100644 index 0000000..42f7487 --- /dev/null +++ b/dist/ecc/src/aes.js @@ -0,0 +1,308 @@ +"use strict"; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +// https://code.google.com/p/crypto-js +var AES = require("crypto-js/aes"); +var encHex = require("crypto-js/enc-hex"); +var encBase64 = require("crypto-js/enc-base64"); +var assert = require("assert"); + +var _require = require("bytebuffer"), + Long = _require.Long; + +var hash = require('./hash'); + +/** Provides symetric encrypt and decrypt via AES. */ + +var Aes = function () { + + /** @private */ + function Aes(iv, key) { + _classCallCheck(this, Aes); + + this.iv = iv, this.key = key; + } + + /** This is an excellent way to ensure that all references to Aes can not operate anymore (example: a wallet becomes locked). An application should ensure there is only one Aes object instance for a given secret `seed`. */ + + + _createClass(Aes, [{ + key: "clear", + value: function clear() { + return this.iv = this.key = undefined; + } + + /** @arg {string} seed - secret seed may be used to encrypt or decrypt. */ + + }, { + key: "_decrypt_word_array", + + + /** @private */ + value: function _decrypt_word_array(cipher) { + // https://code.google.com/p/crypto-js/#Custom_Key_and_IV + // see wallet_records.cpp master_key::decrypt_key + return AES.decrypt({ ciphertext: cipher, salt: null }, this.key, { iv: this.iv }); + } + + /** @private */ + + }, { + key: "_encrypt_word_array", + value: function _encrypt_word_array(plaintext) { + //https://code.google.com/p/crypto-js/issues/detail?id=85 + var cipher = AES.encrypt(plaintext, this.key, { iv: this.iv }); + return encBase64.parse(cipher.toString()); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} ciphertext + @return {Buffer} binary + */ + + }, { + key: "decrypt", + value: function decrypt(ciphertext) { + if (typeof ciphertext === "string") { + ciphertext = new Buffer(ciphertext, 'binary'); + } + if (!Buffer.isBuffer(ciphertext)) { + throw new Error("buffer required"); + } + assert(ciphertext, "Missing cipher text"); + // hex is the only common format + var hex = this.decryptHex(ciphertext.toString('hex')); + return new Buffer(hex, 'hex'); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} plaintext + @return {Buffer} binary + */ + + }, { + key: "encrypt", + value: function encrypt(plaintext) { + if (typeof plaintext === "string") { + plaintext = new Buffer(plaintext, 'binary'); + } + if (!Buffer.isBuffer(plaintext)) { + throw new Error("buffer required"); + } + //assert plaintext, "Missing plain text" + // hex is the only common format + var hex = this.encryptHex(plaintext.toString('hex')); + return new Buffer(hex, 'hex'); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string|Buffer} plaintext + @return {string} hex + */ + + }, { + key: "encryptToHex", + value: function encryptToHex(plaintext) { + if (typeof plaintext === "string") { + plaintext = new Buffer(plaintext, 'binary'); + } + if (!Buffer.isBuffer(plaintext)) { + throw new Error("buffer required"); + } + //assert plaintext, "Missing plain text" + // hex is the only common format + return this.encryptHex(plaintext.toString('hex')); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @return {string} binary (could easily be readable text) + */ + + }, { + key: "decryptHex", + value: function decryptHex(cipher) { + assert(cipher, "Missing cipher text"); + // Convert data into word arrays (used by Crypto) + var cipher_array = encHex.parse(cipher); + var plainwords = this._decrypt_word_array(cipher_array); + return encHex.stringify(plainwords); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @return {Buffer} encoded as specified by the parameter + */ + + }, { + key: "decryptHexToBuffer", + value: function decryptHexToBuffer(cipher) { + assert(cipher, "Missing cipher text"); + // Convert data into word arrays (used by Crypto) + var cipher_array = encHex.parse(cipher); + var plainwords = this._decrypt_word_array(cipher_array); + var plainhex = encHex.stringify(plainwords); + return new Buffer(plainhex, 'hex'); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} cipher - hex + @arg {string} [encoding = 'binary'] - a valid Buffer encoding + @return {String} encoded as specified by the parameter + */ + + }, { + key: "decryptHexToText", + value: function decryptHexToText(cipher) { + var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'binary'; + + return this.decryptHexToBuffer(cipher).toString(encoding); + } + + /** This method does not use a checksum, the returned data must be validated some other way. + @arg {string} plainhex - hex format + @return {String} hex + */ + + }, { + key: "encryptHex", + value: function encryptHex(plainhex) { + var plain_array = encHex.parse(plainhex); + var cipher_array = this._encrypt_word_array(plain_array); + return encHex.stringify(cipher_array); + } + }], [{ + key: "fromSeed", + value: function fromSeed(seed) { + if (seed === undefined) { + throw new Error("seed is required"); + } + var _hash = hash.sha512(seed); + _hash = _hash.toString('hex'); + // DEBUG console.log('... fromSeed _hash',_hash) + return Aes.fromSha512(_hash); + } + }, { + key: "fromSha512", + + + /** @arg {string} hash - A 128 byte hex string, typically one would call {@link fromSeed} instead. */ + value: function fromSha512(hash) { + assert.equal(hash.length, 128, "A Sha512 in HEX should be 128 characters long, instead got " + hash.length); + var iv = encHex.parse(hash.substring(64, 96)); + var key = encHex.parse(hash.substring(0, 64)); + return new Aes(iv, key); + } + }, { + key: "fromBuffer", + value: function fromBuffer(buf) { + assert(Buffer.isBuffer(buf), "Expecting Buffer"); + assert.equal(buf.length, 64, "A Sha512 Buffer should be 64 characters long, instead got " + buf.length); + return Aes.fromSha512(buf.toString("hex")); + } + /** + @throws {Error} - "Invalid Key, ..." + @arg {PrivateKey} private_key - required and used for decryption + @arg {PublicKey} public_key - required and used to calcualte the shared secret + @arg {string} [nonce = ""] optional but should always be provided and be unique when re-using the same private/public keys more than once. This nonce is not a secret. + @arg {string|Buffer} message - Encrypted message containing a checksum + @return {Buffer} + */ + + }, { + key: "decrypt_with_checksum", + value: function decrypt_with_checksum(private_key, public_key, nonce, message) { + var legacy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + + + // Warning: Do not put `nonce = ""` in the arguments, in es6 this will not convert "null" into an emtpy string + if (nonce == null) // null or undefined + nonce = ""; + + if (!Buffer.isBuffer(message)) { + message = new Buffer(message, 'hex'); + } + + var S = private_key.get_shared_secret(public_key, legacy); + // D E B U G + // console.log('decrypt_with_checksum', { + // priv_to_pub: private_key.toPublicKey().toString(), + // pub: public_key.toPublicKeyString(), + // nonce: nonce, + // message: message.length, + // S: S.toString('hex') + // }) + + var aes = Aes.fromSeed(Buffer.concat([ + // A null or empty string nonce will not effect the hash + new Buffer("" + nonce), new Buffer(S.toString('hex'))])); + + var planebuffer = aes.decrypt(message); + if (!(planebuffer.length >= 4)) { + throw new Error("Invalid key, could not decrypt message(1)"); + } + + // DEBUG console.log('... planebuffer',planebuffer) + var checksum = planebuffer.slice(0, 4); + var plaintext = planebuffer.slice(4); + + // console.log('... checksum',checksum.toString('hex')) + // console.log('... plaintext',plaintext.toString()) + + var new_checksum = hash.sha256(plaintext); + new_checksum = new_checksum.slice(0, 4); + new_checksum = new_checksum.toString('hex'); + + if (!(checksum.toString('hex') === new_checksum)) { + throw new Error("Invalid key, could not decrypt message(2)"); + } + + return plaintext; + } + }, { + key: "encrypt_with_checksum", + + + /** Identical to {@link decrypt_with_checksum} but used to encrypt. Should not throw an error. + @return {Buffer} message - Encrypted message which includes a checksum + */ + value: function encrypt_with_checksum(private_key, public_key, nonce, message) { + + // Warning: Do not put `nonce = ""` in the arguments, in es6 this will not convert "null" into an emtpy string + + if (nonce == null) // null or undefined + nonce = ""; + + if (!Buffer.isBuffer(message)) { + message = new Buffer(message, 'binary'); + } + + var S = private_key.get_shared_secret(public_key); + + // D E B U G + // console.log('encrypt_with_checksum', { + // priv_to_pub: private_key.toPublicKey().toString() + // pub: public_key.toPublicKeyString() + // nonce: nonce + // message: message.length + // S: S.toString('hex') + // }) + + var aes = Aes.fromSeed(Buffer.concat([ + // A null or empty string nonce will not effect the hash + new Buffer("" + nonce), new Buffer(S.toString('hex'))])); + // DEBUG console.log('... S',S.toString('hex')) + var checksum = hash.sha256(message).slice(0, 4); + var payload = Buffer.concat([checksum, message]); + // DEBUG console.log('... payload',payload.toString()) + return aes.encrypt(payload); + } + }]); + + return Aes; +}(); + +module.exports = Aes; \ No newline at end of file diff --git a/dist/ecc/src/ecdsa.js b/dist/ecc/src/ecdsa.js new file mode 100644 index 0000000..959a5da --- /dev/null +++ b/dist/ecc/src/ecdsa.js @@ -0,0 +1,219 @@ +'use strict'; + +var assert = require('assert'); // from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa +var crypto = require('./hash'); +var enforceType = require('./enforce_types'); + +var BigInteger = require('bigi'); +var ECSignature = require('./ecsignature'); + +// https://tools.ietf.org/html/rfc6979#section-3.2 +function deterministicGenerateK(curve, hash, d, checkSig, nonce) { + + enforceType('Buffer', hash); + enforceType(BigInteger, d); + + if (nonce) { + hash = crypto.sha256(Buffer.concat([hash, new Buffer(nonce)])); + } + + // sanity check + assert.equal(hash.length, 32, 'Hash must be 256 bit'); + + var x = d.toBuffer(32); + var k = new Buffer(32); + var v = new Buffer(32); + + // Step B + v.fill(1); + + // Step C + k.fill(0); + + // Step D + k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0]), x, hash]), k); + + // Step E + v = crypto.HmacSHA256(v, k); + + // Step F + k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([1]), x, hash]), k); + + // Step G + v = crypto.HmacSHA256(v, k); + + // Step H1/H2a, ignored as tlen === qlen (256 bit) + // Step H2b + v = crypto.HmacSHA256(v, k); + + var T = BigInteger.fromBuffer(v); + + // Step H3, repeat until T is within the interval [1, n - 1] + while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) { + k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0])]), k); + v = crypto.HmacSHA256(v, k); + + // Step H1/H2a, again, ignored as tlen === qlen (256 bit) + // Step H2b again + v = crypto.HmacSHA256(v, k); + + T = BigInteger.fromBuffer(v); + } + + return T; +} + +function sign(curve, hash, d, nonce) { + + var e = BigInteger.fromBuffer(hash); + var n = curve.n; + var G = curve.G; + + var r, s; + var k = deterministicGenerateK(curve, hash, d, function (k) { + // find canonically valid signature + var Q = G.multiply(k); + + if (curve.isInfinity(Q)) return false; + + r = Q.affineX.mod(n); + if (r.signum() === 0) return false; + + s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n); + if (s.signum() === 0) return false; + + return true; + }, nonce); + + var N_OVER_TWO = n.shiftRight(1); + + // enforce low S values, see bip62: 'low s values in signatures' + if (s.compareTo(N_OVER_TWO) > 0) { + s = n.subtract(s); + } + + return new ECSignature(r, s); +} + +function verifyRaw(curve, e, signature, Q) { + var n = curve.n; + var G = curve.G; + + var r = signature.r; + var s = signature.s; + + // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1] + if (r.signum() <= 0 || r.compareTo(n) >= 0) return false; + if (s.signum() <= 0 || s.compareTo(n) >= 0) return false; + + // c = s^-1 mod n + var c = s.modInverse(n); + + // 1.4.4 Compute u1 = es^−1 mod n + // u2 = rs^−1 mod n + var u1 = e.multiply(c).mod(n); + var u2 = r.multiply(c).mod(n); + + // 1.4.5 Compute R = (xR, yR) = u1G + u2Q + var R = G.multiplyTwo(u1, Q, u2); + + // 1.4.5 (cont.) Enforce R is not at infinity + if (curve.isInfinity(R)) return false; + + // 1.4.6 Convert the field element R.x to an integer + var xR = R.affineX; + + // 1.4.7 Set v = xR mod n + var v = xR.mod(n); + + // 1.4.8 If v = r, output "valid", and if v != r, output "invalid" + return v.equals(r); +} + +function verify(curve, hash, signature, Q) { + // 1.4.2 H = Hash(M), already done by the user + // 1.4.3 e = H + var e = BigInteger.fromBuffer(hash); + return verifyRaw(curve, e, signature, Q); +} + +/** + * Recover a public key from a signature. + * + * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public + * Key Recovery Operation". + * + * http://www.secg.org/download/aid-780/sec1-v2.pdf + */ +function recoverPubKey(curve, e, signature, i) { + assert.strictEqual(i & 3, i, 'Recovery param is more than two bits'); + + var n = curve.n; + var G = curve.G; + + var r = signature.r; + var s = signature.s; + + assert(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value'); + assert(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value'); + + // A set LSB signifies that the y-coordinate is odd + var isYOdd = i & 1; + + // The more significant bit specifies whether we should use the + // first or second candidate key. + var isSecondKey = i >> 1; + + // 1.1 Let x = r + jn + var x = isSecondKey ? r.add(n) : r; + var R = curve.pointFromX(isYOdd, x); + + // 1.4 Check that nR is at infinity + var nR = R.multiply(n); + assert(curve.isInfinity(nR), 'nR is not a valid curve point'); + + // Compute -e from e + var eNeg = e.negate().mod(n); + + // 1.6.1 Compute Q = r^-1 (sR - eG) + // Q = r^-1 (sR + -eG) + var rInv = r.modInverse(n); + + var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv); + curve.validate(Q); + + return Q; +} + +/** + * Calculate pubkey extraction parameter. + * + * When extracting a pubkey from a signature, we have to + * distinguish four different cases. Rather than putting this + * burden on the verifier, Bitcoin includes a 2-bit value with the + * signature. + * + * This function simply tries all four cases and returns the value + * that resulted in a successful pubkey recovery. + */ +function calcPubKeyRecoveryParam(curve, e, signature, Q) { + for (var i = 0; i < 4; i++) { + var Qprime = recoverPubKey(curve, e, signature, i); + + // 1.6.2 Verify Q + if (Qprime.equals(Q)) { + return i; + } + } + + throw new Error('Unable to find valid recovery factor'); +} + +module.exports = { + calcPubKeyRecoveryParam: calcPubKeyRecoveryParam, + deterministicGenerateK: deterministicGenerateK, + recoverPubKey: recoverPubKey, + sign: sign, + verify: verify, + verifyRaw: verifyRaw +}; \ No newline at end of file diff --git a/dist/ecc/src/ecsignature.js b/dist/ecc/src/ecsignature.js new file mode 100644 index 0000000..7debd70 --- /dev/null +++ b/dist/ecc/src/ecsignature.js @@ -0,0 +1,128 @@ +'use strict'; + +var assert = require('assert'); // from https://github.com/bitcoinjs/bitcoinjs-lib +var enforceType = require('./enforce_types'); + +var BigInteger = require('bigi'); + +function ECSignature(r, s) { + enforceType(BigInteger, r); + enforceType(BigInteger, s); + + this.r = r; + this.s = s; +} + +// Import operations +ECSignature.parseCompact = function (buffer) { + assert.equal(buffer.length, 65, 'Invalid signature length'); + var i = buffer.readUInt8(0) - 27; + + // At most 3 bits + assert.equal(i, i & 7, 'Invalid signature parameter'); + var compressed = !!(i & 4); + + // Recovery param only + i = i & 3; + + var r = BigInteger.fromBuffer(buffer.slice(1, 33)); + var s = BigInteger.fromBuffer(buffer.slice(33)); + + return { + compressed: compressed, + i: i, + signature: new ECSignature(r, s) + }; +}; + +ECSignature.fromDER = function (buffer) { + assert.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence'); + assert.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length'); + assert.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer'); + + var rLen = buffer.readUInt8(3); + assert(rLen > 0, 'R length is zero'); + + var offset = 4 + rLen; + assert.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)'); + + var sLen = buffer.readUInt8(offset + 1); + assert(sLen > 0, 'S length is zero'); + + var rB = buffer.slice(4, offset); + var sB = buffer.slice(offset + 2); + offset += 2 + sLen; + + if (rLen > 1 && rB.readUInt8(0) === 0x00) { + assert(rB.readUInt8(1) & 0x80, 'R value excessively padded'); + } + + if (sLen > 1 && sB.readUInt8(0) === 0x00) { + assert(sB.readUInt8(1) & 0x80, 'S value excessively padded'); + } + + assert.equal(offset, buffer.length, 'Invalid DER encoding'); + var r = BigInteger.fromDERInteger(rB); + var s = BigInteger.fromDERInteger(sB); + + assert(r.signum() >= 0, 'R value is negative'); + assert(s.signum() >= 0, 'S value is negative'); + + return new ECSignature(r, s); +}; + +// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, importing Transaction causes a circular dependency +ECSignature.parseScriptSignature = function (buffer) { + var hashType = buffer.readUInt8(buffer.length - 1); + var hashTypeMod = hashType & ~0x80; + + assert(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType'); + + return { + signature: ECSignature.fromDER(buffer.slice(0, -1)), + hashType: hashType + }; +}; + +// Export operations +ECSignature.prototype.toCompact = function (i, compressed) { + if (compressed) i += 4; + i += 27; + + var buffer = new Buffer(65); + buffer.writeUInt8(i, 0); + + this.r.toBuffer(32).copy(buffer, 1); + this.s.toBuffer(32).copy(buffer, 33); + + return buffer; +}; + +ECSignature.prototype.toDER = function () { + var rBa = this.r.toDERInteger(); + var sBa = this.s.toDERInteger(); + + var sequence = []; + + // INTEGER + sequence.push(0x02, rBa.length); + sequence = sequence.concat(rBa); + + // INTEGER + sequence.push(0x02, sBa.length); + sequence = sequence.concat(sBa); + + // SEQUENCE + sequence.unshift(0x30, sequence.length); + + return new Buffer(sequence); +}; + +ECSignature.prototype.toScriptSignature = function (hashType) { + var hashTypeBuffer = new Buffer(1); + hashTypeBuffer.writeUInt8(hashType, 0); + + return Buffer.concat([this.toDER(), hashTypeBuffer]); +}; + +module.exports = ECSignature; \ No newline at end of file diff --git a/dist/ecc/src/enforce_types.js b/dist/ecc/src/enforce_types.js new file mode 100644 index 0000000..f8bf7b7 --- /dev/null +++ b/dist/ecc/src/enforce_types.js @@ -0,0 +1,49 @@ +'use strict'; + +module.exports = function enforce(type, value) { + // Copied from https://github.com/bitcoinjs/bitcoinjs-lib + switch (type) { + case 'Array': + { + if (Array.isArray(value)) return; + break; + } + + case 'Boolean': + { + if (typeof value === 'boolean') return; + break; + } + + case 'Buffer': + { + if (Buffer.isBuffer(value)) return; + break; + } + + case 'Number': + { + if (typeof value === 'number') return; + break; + } + + case 'String': + { + if (typeof value === 'string') return; + break; + } + + default: + { + if (getName(value.constructor) === getName(type)) return; + } + } + + throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value); +}; + +function getName(fn) { + // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property + var match = fn.toString().match(/function (.*?)\(/); + return match ? match[1] : null; +} \ No newline at end of file diff --git a/dist/ecc/src/hash.js b/dist/ecc/src/hash.js new file mode 100644 index 0000000..5088cec --- /dev/null +++ b/dist/ecc/src/hash.js @@ -0,0 +1,60 @@ +"use strict"; + +var createHash = require("create-hash"); +var createHmac = require("create-hmac"); + +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha1(data, encoding) { + return createHash('sha1').update(data).digest(encoding); +} + +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha256(data, encoding) { + return createHash('sha256').update(data).digest(encoding); +} + +/** @arg {string|Buffer} data + @arg {string} [digest = null] - 'hex', 'binary' or 'base64' + @return {string|Buffer} - Buffer when digest is null, or string +*/ +function sha512(data, encoding) { + return createHash('sha512').update(data).digest(encoding); +} + +function HmacSHA256(buffer, secret) { + return createHmac('sha256', secret).update(buffer).digest(); +} + +function ripemd160(data) { + return createHash('rmd160').update(data).digest(); +} + +// function hash160(buffer) { +// return ripemd160(sha256(buffer)) +// } +// +// function hash256(buffer) { +// return sha256(sha256(buffer)) +// } + +// +// function HmacSHA512(buffer, secret) { +// return crypto.createHmac('sha512', secret).update(buffer).digest() +// } + +module.exports = { + sha1: sha1, + sha256: sha256, + sha512: sha512, + HmacSHA256: HmacSHA256, + ripemd160: ripemd160 + // hash160: hash160, + // hash256: hash256, + // HmacSHA512: HmacSHA512 +}; \ No newline at end of file diff --git a/dist/ecc/src/signature.js b/dist/ecc/src/signature.js new file mode 100644 index 0000000..2d27835 --- /dev/null +++ b/dist/ecc/src/signature.js @@ -0,0 +1,187 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var ecdsa = require('./ecdsa'); +var hash = require('./hash'); + +var _require = require('ecurve'), + getCurveByName = _require.getCurveByName; + +var secp256k1 = getCurveByName('secp256k1'); +var assert = require('assert'); +var BigInteger = require('bigi'); +var PublicKey = require('./PublicKey'); + +var Signature = function () { + function Signature(r1, s1, i1) { + _classCallCheck(this, Signature); + + this.r = r1; + this.s = s1; + this.i = i1; + assert.equal(this.r != null, true, 'Missing parameter'); + assert.equal(this.s != null, true, 'Missing parameter'); + assert.equal(this.i != null, true, 'Missing parameter'); + } + + _createClass(Signature, [{ + key: 'toBuffer', + value: function toBuffer() { + var buf; + buf = new Buffer(65); + buf.writeUInt8(this.i, 0); + this.r.toBuffer(32).copy(buf, 1); + this.s.toBuffer(32).copy(buf, 33); + return buf; + } + }, { + key: 'recoverPublicKeyFromBuffer', + value: function recoverPublicKeyFromBuffer(buffer) { + return this.recoverPublicKey(hash.sha256(buffer)); + } + }, { + key: 'recoverPublicKey', + + + /** + @return {PublicKey} + */ + value: function recoverPublicKey(sha256_buffer) { + var Q = void 0, + e = void 0, + i = void 0; + e = BigInteger.fromBuffer(sha256_buffer); + i = this.i; + i -= 27; + i = i & 3; + Q = ecdsa.recoverPubKey(secp256k1, e, this, i); + return PublicKey.fromPoint(Q); + } + }, { + key: 'verifyBuffer', + + + /** + @param {Buffer} un-hashed + @param {./PublicKey} + @return {boolean} + */ + value: function verifyBuffer(buf, public_key) { + var _hash = hash.sha256(buf); + return this.verifyHash(_hash, public_key); + } + }, { + key: 'verifyHash', + value: function verifyHash(hash, public_key) { + assert.equal(hash.length, 32, "A SHA 256 should be 32 bytes long, instead got " + hash.length); + return ecdsa.verify(secp256k1, hash, { + r: this.r, + s: this.s + }, public_key.Q); + } + }, { + key: 'toByteBuffer', + + + /* */ + + value: function toByteBuffer() { + var b; + b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b); + return b.copy(0, b.offset); + } + }, { + key: 'toHex', + value: function toHex() { + return this.toBuffer().toString("hex"); + } + }, { + key: 'verifyHex', + value: function verifyHex(hex, public_key) { + var buf; + buf = new Buffer(hex, 'hex'); + return this.verifyBuffer(buf, public_key); + } + }], [{ + key: 'fromBuffer', + value: function fromBuffer(buf) { + var i, r, s; + assert.equal(buf.length, 65, 'Invalid signature length'); + i = buf.readUInt8(0); + assert.equal(i - 27, i - 27 & 7, 'Invalid signature parameter'); + r = BigInteger.fromBuffer(buf.slice(1, 33)); + s = BigInteger.fromBuffer(buf.slice(33)); + return new Signature(r, s, i); + } + }, { + key: 'signBuffer', + + + /** + @param {Buffer} buf + @param {PrivateKey} private_key + @return {Signature} + */ + value: function signBuffer(buf, private_key) { + var _hash = hash.sha256(buf); + return Signature.signBufferSha256(_hash, private_key); + } + + /** Sign a buffer of exactally 32 bytes in size (sha256(text)) + @param {Buffer} buf - 32 bytes binary + @param {PrivateKey} private_key + @return {Signature} + */ + + }, { + key: 'signBufferSha256', + value: function signBufferSha256(buf_sha256, private_key) { + if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error("buf_sha256: 32 byte buffer requred"); + var der, e, ecsignature, i, lenR, lenS, nonce; + i = null; + nonce = 0; + e = BigInteger.fromBuffer(buf_sha256); + while (true) { + ecsignature = ecdsa.sign(secp256k1, buf_sha256, private_key.d, nonce++); + der = ecsignature.toDER(); + lenR = der[3]; + lenS = der[5 + lenR]; + if (lenR === 32 && lenS === 32) { + i = ecdsa.calcPubKeyRecoveryParam(secp256k1, e, ecsignature, private_key.toPublicKey().Q); + i += 4; // compressed + i += 27; // compact // 24 or 27 :( forcing odd-y 2nd key candidate) + break; + } + if (nonce % 10 === 0) { + console.log("WARN: " + nonce + " attempts to find canonical signature"); + } + } + return new Signature(ecsignature.r, ecsignature.s, i); + } + }, { + key: 'sign', + value: function sign(string, private_key) { + return Signature.signBuffer(new Buffer(string), private_key); + } + }, { + key: 'fromHex', + value: function fromHex(hex) { + return Signature.fromBuffer(new Buffer(hex, "hex")); + } + }, { + key: 'signHex', + value: function signHex(hex, private_key) { + var buf; + buf = new Buffer(hex, 'hex'); + return Signature.signBuffer(buf, private_key); + } + }]); + + return Signature; +}(); + +module.exports = Signature; \ No newline at end of file diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..88076da --- /dev/null +++ b/dist/index.js @@ -0,0 +1,3 @@ +"use strict"; + +module.exports = Object.assign(require("./chain"), require("./ecc"), require("./serializer")); \ No newline at end of file diff --git a/dist/serializer/index.js b/dist/serializer/index.js new file mode 100644 index 0000000..2059055 --- /dev/null +++ b/dist/serializer/index.js @@ -0,0 +1,22 @@ +'use strict'; + +module.exports = { + + // Primary class for creating operations + Serializer: require('./src/serializer'), + + // helper functions for creating operations + fp: require('./src/FastParser'), + + // Low level types + types: require('./src/types'), + + // Higher level operations (made out of generic types) + ops: require('./src/operations'), + + // Utility that generates JSON examples + template: require('./src/template'), + + // Serializer validation + SerializerValidation: require('./src/SerializerValidation') +}; \ No newline at end of file diff --git a/dist/serializer/src/FastParser.js b/dist/serializer/src/FastParser.js new file mode 100644 index 0000000..ee30cf4 --- /dev/null +++ b/dist/serializer/src/FastParser.js @@ -0,0 +1,90 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var PublicKey = require("../../ecc/src/PublicKey"); + +var FastParser = function () { + function FastParser() { + _classCallCheck(this, FastParser); + } + + _createClass(FastParser, null, [{ + key: 'fixed_data', + value: function fixed_data(b, len, buffer) { + if (!b) { + return; + } + if (buffer) { + var data = buffer.slice(0, len).toString('binary'); + b.append(data, 'binary'); + while (len-- > data.length) { + b.writeUint8(0); + } + } else { + var b_copy = b.copy(b.offset, b.offset + len); + b.skip(len); + return new Buffer(b_copy.toBinary(), 'binary'); + } + } + }, { + key: 'public_key', + value: function public_key(b, _public_key) { + if (!b) { + return; + } + if (_public_key) { + var buffer = _public_key.toBuffer(); + b.append(buffer.toString('binary'), 'binary'); + return; + } else { + buffer = FastParser.fixed_data(b, 33); + return PublicKey.fromBuffer(buffer); + } + } + }, { + key: 'ripemd160', + value: function ripemd160(b, _ripemd) { + if (!b) { + return; + } + if (_ripemd) { + FastParser.fixed_data(b, 20, _ripemd); + return; + } else { + return FastParser.fixed_data(b, 20); + } + } + }, { + key: 'sha256', + value: function sha256(b, _sha) { + if (!b) { + return; + } + if (_sha) { + FastParser.fixed_data(b, 32, _sha); + return; + } else { + return FastParser.fixed_data(b, 32); + } + } + }, { + key: 'time_point_sec', + value: function time_point_sec(b, epoch) { + if (epoch) { + epoch = Math.ceil(epoch / 1000); + b.writeInt32(epoch); + return; + } else { + epoch = b.readInt32(); // fc::time_point_sec + return new Date(epoch * 1000); + } + } + }]); + + return FastParser; +}(); + +module.exports = FastParser; \ No newline at end of file diff --git a/dist/serializer/src/SerializerValidation.js b/dist/serializer/src/SerializerValidation.js new file mode 100644 index 0000000..334d8c7 --- /dev/null +++ b/dist/serializer/src/SerializerValidation.js @@ -0,0 +1,363 @@ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _require = require('bytebuffer'), + Long = _require.Long; + +var ChainTypes = require('../../chain/src/ChainTypes'); + +var MAX_SAFE_INT = 9007199254740991; +var MIN_SAFE_INT = -9007199254740991; + +/** + Most validations are skipped and the value returned unchanged when an empty string, null, or undefined is encountered (except "required"). + + Validations support a string format for dealing with large numbers. +*/ +var _my = { + + is_empty: function is_empty(value) { + return value === null || value === undefined; + }, + + required: function required(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + throw new Error('value required ' + field_name + ' ' + value); + } + return value; + }, + require_long: function require_long(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (!Long.isLong(value)) { + throw new Error('Long value required ' + field_name + ' ' + value); + } + return value; + }, + string: function string(value) { + if (this.is_empty(value)) { + return value; + } + if (typeof value !== "string") { + throw new Error('string required: ' + value); + } + return value; + }, + number: function number(value) { + if (this.is_empty(value)) { + return value; + } + if (typeof value !== "number") { + throw new Error('number required: ' + value); + } + return value; + }, + whole_number: function whole_number(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + return value; + } + if (/\./.test(value)) { + throw new Error('whole number required ' + field_name + ' ' + value); + } + return value; + }, + unsigned: function unsigned(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + return value; + } + if (/-/.test(value)) { + throw new Error('unsigned required ' + field_name + ' ' + value); + } + return value; + }, + + + is_digits: function is_digits(value) { + if (typeof value === "numeric") { + return true; + } + return (/^[0-9]+$/.test(value) + ); + }, + + to_number: function to_number(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + return value; + } + this.no_overflow53(value, field_name); + var int_value = function () { + if (typeof value === "number") { + return value; + } else { + return parseInt(value); + } + }(); + return int_value; + }, + + to_long: function to_long(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + return value; + } + if (Long.isLong(value)) { + return value; + } + + this.no_overflow64(value, field_name); + if (typeof value === "number") { + value = "" + value; + } + return Long.fromString(value); + }, + to_ulong: function to_ulong(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + return value; + } + if (Long.isLong(value)) { + return value; + } + + this.no_overflow64(value, field_name, true); + if (typeof value === "number") { + value = "" + value; + } + return Long.fromString(value, true); + }, + to_string: function to_string(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (this.is_empty(value)) { + return value; + } + if (typeof value === "string") { + return value; + } + if (typeof value === "number") { + this.no_overflow53(value, field_name); + return "" + value; + } + if (Long.isLong(value)) { + return value.toString(); + } + throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value; + }, + require_test: function require_test(regex, value) { + var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; + + if (this.is_empty(value)) { + return value; + } + if (!regex.test(value)) { + throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); + } + return value; + }, + + + require_match: function require_match(regex, value) { + var field_name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; + + if (this.is_empty(value)) { + return value; + } + var match = value.match(regex); + if (match === null) { + throw new Error('unmatched ' + regex + ' ' + field_name + ' ' + value); + } + return match; + }, + + require_object_id: function require_object_id(value, field_name) { + return require_match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/, value, field_name); + }, + + // Does not support over 53 bits + require_range: function require_range(min, max, value) { + var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ""; + + if (this.is_empty(value)) { + return value; + } + var number = this.to_number(value); + if (value < min || value > max) { + throw new Error('out of range ' + value + ' ' + field_name + ' ' + value); + } + return value; + }, + + + require_object_type: function require_object_type() { + var reserved_spaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var type = arguments[1]; + var value = arguments[2]; + var field_name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ""; + + if (this.is_empty(value)) { + return value; + } + var object_type = ChainTypes.object_type[type]; + if (!object_type) { + throw new Error('Unknown object type ' + type + ' ' + field_name + ' ' + value); + } + var re = new RegExp(reserved_spaces + '.' + object_type + '.[0-9]+$'); + if (!re.test(value)) { + throw new Error('Expecting ' + type + ' in format ' + (reserved_spaces + '.' + object_type + '.[0-9]+ ') + ('instead of ' + value + ' ' + field_name + ' ' + value)); + } + return value; + }, + + get_instance: function get_instance(reserve_spaces, type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(reserve_spaces, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + + require_relative_type: function require_relative_type(type, value, field_name) { + this.require_object_type(0, type, value, field_name); + return value; + }, + + get_relative_instance: function get_relative_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(0, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + + require_protocol_type: function require_protocol_type(type, value, field_name) { + this.require_object_type(1, type, value, field_name); + return value; + }, + + get_protocol_instance: function get_protocol_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(1, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + + get_protocol_type: function get_protocol_type(value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_id(value, field_name); + var values = value.split('.'); + return this.to_number(values[1]); + }, + + get_protocol_type_name: function get_protocol_type_name(value, field_name) { + if (this.is_empty(value)) { + return value; + } + var type_id = this.get_protocol_type(value, field_name); + return Object.keys(ChainTypes.object_type)[type_id]; + }, + + + require_implementation_type: function require_implementation_type(type, value, field_name) { + this.require_object_type(2, type, value, field_name); + return value; + }, + + get_implementation_instance: function get_implementation_instance(type, value, field_name) { + if (this.is_empty(value)) { + return value; + } + this.require_object_type(2, type, value, field_name); + return this.to_number(value.split('.')[2]); + }, + + // signed / unsigned decimal + no_overflow53: function no_overflow53(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + + if (typeof value === "number") { + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + if (typeof value === "string") { + var int = parseInt(value); + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + if (Long.isLong(value)) { + // typeof value.toInt() is 'number' + this.no_overflow53(value.toInt(), field_name); + return; + } + throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value; + }, + + + // signed / unsigned whole numbers only + no_overflow64: function no_overflow64(value) { + var field_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + var unsigned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + // https://github.com/dcodeIO/Long.js/issues/20 + if (Long.isLong(value)) { + return; + } + + // BigInteger#isBigInteger https://github.com/cryptocoinjs/bigi/issues/20 + if (value.t !== undefined && value.s !== undefined) { + this.no_overflow64(value.toString(), field_name, unsigned); + + return; + } + + if (typeof value === "string") { + // remove leading zeros, will cause a false positive + value = value.replace(/^0+/, ''); + // remove trailing zeros + while (/0$/.test(value)) { + value = value.substring(0, value.length - 1); + } + if (/\.$/.test(value)) { + // remove trailing dot + value = value.substring(0, value.length - 1); + } + if (value === "") { + value = "0"; + } + + var long_string = Long.fromString(value, unsigned).toString(); + + if (long_string !== value.trim()) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + if (typeof value === "number") { + if (value > MAX_SAFE_INT || value < MIN_SAFE_INT) { + throw new Error('overflow ' + field_name + ' ' + value); + } + return; + } + + throw 'unsupported type ' + field_name + ': (' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + ') ' + value; + } +}; + +module.exports = _my; \ No newline at end of file diff --git a/dist/serializer/src/convert.js b/dist/serializer/src/convert.js new file mode 100644 index 0000000..e9b43ef --- /dev/null +++ b/dist/serializer/src/convert.js @@ -0,0 +1,37 @@ +'use strict'; + +var ByteBuffer = require('bytebuffer'); + +module.exports = function (type) { + + return { + fromHex: function fromHex(hex) { + var b = ByteBuffer.fromHex(hex, ByteBuffer.LITTLE_ENDIAN); + return type.fromByteBuffer(b); + }, + toHex: function toHex(object) { + var b = toByteBuffer(type, object); + return b.toHex(); + }, + fromBuffer: function fromBuffer(buffer) { + var b = ByteBuffer.fromBinary(buffer.toString(), ByteBuffer.LITTLE_ENDIAN); + return type.fromByteBuffer(b); + }, + toBuffer: function toBuffer(object) { + return new Buffer(toByteBuffer(type, object).toBinary(), 'binary'); + }, + fromBinary: function fromBinary(string) { + var b = ByteBuffer.fromBinary(string, ByteBuffer.LITTLE_ENDIAN); + return type.fromByteBuffer(b); + }, + toBinary: function toBinary(object) { + return toByteBuffer(type, object).toBinary(); + } + }; +}; + +var toByteBuffer = function toByteBuffer(type, object) { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + type.appendByteBuffer(b, object); + return b.copy(0, b.offset); +}; \ No newline at end of file diff --git a/dist/serializer/src/error_with_cause.js b/dist/serializer/src/error_with_cause.js new file mode 100644 index 0000000..e36aa85 --- /dev/null +++ b/dist/serializer/src/error_with_cause.js @@ -0,0 +1,42 @@ +"use strict"; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** Exception nesting. */ +var ErrorWithCause = function () { + function ErrorWithCause(message, cause) { + _classCallCheck(this, ErrorWithCause); + + this.message = message; + if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) { + this.message = "cause\t" + cause.message + "\t" + this.message; + } + + var stack = ""; //(new Error).stack + if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) { + stack = "caused by\n\t" + cause.stack + "\t" + stack; + } + + this.stack = this.message + "\n" + stack; + } + + _createClass(ErrorWithCause, null, [{ + key: "throw", + value: function _throw(message, cause) { + var msg = message; + if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) { + msg += "\t cause: " + cause.message + " "; + } + if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) { + msg += "\n stack: " + cause.stack + " "; + } + throw new Error(msg); + } + }]); + + return ErrorWithCause; +}(); + +module.exports = ErrorWithCause; \ No newline at end of file diff --git a/dist/serializer/src/operations.js b/dist/serializer/src/operations.js new file mode 100644 index 0000000..1c82d8c --- /dev/null +++ b/dist/serializer/src/operations.js @@ -0,0 +1,709 @@ +"use strict"; + +var types = require("./types"); +var SerializerImpl = require("./serializer"); + +var uint8 = types.uint8, + uint16 = types.uint16, + uint32 = types.uint32, + int64 = types.int64, + uint64 = types.uint64, + string = types.string, + bytes = types.bytes, + bool = types.bool, + array = types.array, + fixed_array = types.fixed_array, + protocol_id_type = types.protocol_id_type, + object_id_type = types.object_id_type, + vote_id = types.vote_id, + future_extensions = types.future_extensions, + static_variant = types.static_variant, + map = types.map, + set = types.set, + public_key = types.public_key, + address = types.address, + time_point_sec = types.time_point_sec, + optional = types.optional, + variant = types.variant, + variant_object = types.variant_object, + enumeration = types.enumeration, + sha256 = types.sha256; + + +future_extensions = types.void; + +/* +When updating generated code +Replace: operation = static_variant [ +with: operation.st_operations = [ + +Delete: +public_key = new Serializer( + "public_key" + key_data: bytes 33 +) + +*/ +// Place-holder, their are dependencies on "operation" .. The final list of +// operations is not avialble until the very end of the generated code. +// See: operation.st_operations = ... +var operation = static_variant(); +module.exports["operation"] = operation; + +// For module.exports +var Serializer = function Serializer(operation_name, serilization_types_object) { + var s = new SerializerImpl(operation_name, serilization_types_object); + return module.exports[operation_name] = s; +}; + +// Custom-types follow Generated code: + +// ## Generated code follows +// # programs/js_operation_serializer > npm i -g decaffeinate +// ## ------------------------------- +var transfer_operation_fee_parameters = new Serializer("transfer_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var limit_order_create_operation_fee_parameters = new Serializer("limit_order_create_operation_fee_parameters", { fee: uint64 }); + +var limit_order_cancel_operation_fee_parameters = new Serializer("limit_order_cancel_operation_fee_parameters", { fee: uint64 }); + +var call_order_update_operation_fee_parameters = new Serializer("call_order_update_operation_fee_parameters", { fee: uint64 }); + +var fill_order_operation_fee_parameters = new Serializer("fill_order_operation_fee_parameters"); + +var account_create_operation_fee_parameters = new Serializer("account_create_operation_fee_parameters", { basic_fee: uint64, + premium_fee: uint64, + price_per_kbyte: uint32 }); + +var account_update_operation_fee_parameters = new Serializer("account_update_operation_fee_parameters", { fee: int64, + price_per_kbyte: uint32 }); + +var account_whitelist_operation_fee_parameters = new Serializer("account_whitelist_operation_fee_parameters", { fee: int64 }); + +var account_upgrade_operation_fee_parameters = new Serializer("account_upgrade_operation_fee_parameters", { membership_annual_fee: uint64, + membership_lifetime_fee: uint64 }); + +var account_transfer_operation_fee_parameters = new Serializer("account_transfer_operation_fee_parameters", { fee: uint64 }); + +var asset_create_operation_fee_parameters = new Serializer("asset_create_operation_fee_parameters", { symbol3: uint64, + symbol4: uint64, + long_symbol: uint64, + price_per_kbyte: uint32 }); + +var asset_update_operation_fee_parameters = new Serializer("asset_update_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var asset_update_bitasset_operation_fee_parameters = new Serializer("asset_update_bitasset_operation_fee_parameters", { fee: uint64 }); + +var asset_update_feed_producers_operation_fee_parameters = new Serializer("asset_update_feed_producers_operation_fee_parameters", { fee: uint64 }); + +var asset_issue_operation_fee_parameters = new Serializer("asset_issue_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var asset_reserve_operation_fee_parameters = new Serializer("asset_reserve_operation_fee_parameters", { fee: uint64 }); + +var asset_fund_fee_pool_operation_fee_parameters = new Serializer("asset_fund_fee_pool_operation_fee_parameters", { fee: uint64 }); + +var asset_settle_operation_fee_parameters = new Serializer("asset_settle_operation_fee_parameters", { fee: uint64 }); + +var asset_global_settle_operation_fee_parameters = new Serializer("asset_global_settle_operation_fee_parameters", { fee: uint64 }); + +var asset_publish_feed_operation_fee_parameters = new Serializer("asset_publish_feed_operation_fee_parameters", { fee: uint64 }); + +var witness_create_operation_fee_parameters = new Serializer("witness_create_operation_fee_parameters", { fee: uint64 }); + +var witness_update_operation_fee_parameters = new Serializer("witness_update_operation_fee_parameters", { fee: int64 }); + +var proposal_create_operation_fee_parameters = new Serializer("proposal_create_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var proposal_update_operation_fee_parameters = new Serializer("proposal_update_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var proposal_delete_operation_fee_parameters = new Serializer("proposal_delete_operation_fee_parameters", { fee: uint64 }); + +var withdraw_permission_create_operation_fee_parameters = new Serializer("withdraw_permission_create_operation_fee_parameters", { fee: uint64 }); + +var withdraw_permission_update_operation_fee_parameters = new Serializer("withdraw_permission_update_operation_fee_parameters", { fee: uint64 }); + +var withdraw_permission_claim_operation_fee_parameters = new Serializer("withdraw_permission_claim_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var withdraw_permission_delete_operation_fee_parameters = new Serializer("withdraw_permission_delete_operation_fee_parameters", { fee: uint64 }); + +var committee_member_create_operation_fee_parameters = new Serializer("committee_member_create_operation_fee_parameters", { fee: uint64 }); + +var committee_member_update_operation_fee_parameters = new Serializer("committee_member_update_operation_fee_parameters", { fee: uint64 }); + +var committee_member_update_global_parameters_operation_fee_parameters = new Serializer("committee_member_update_global_parameters_operation_fee_parameters", { fee: uint64 }); + +var vesting_balance_create_operation_fee_parameters = new Serializer("vesting_balance_create_operation_fee_parameters", { fee: uint64 }); + +var vesting_balance_withdraw_operation_fee_parameters = new Serializer("vesting_balance_withdraw_operation_fee_parameters", { fee: uint64 }); + +var worker_create_operation_fee_parameters = new Serializer("worker_create_operation_fee_parameters", { fee: uint64 }); + +var custom_operation_fee_parameters = new Serializer("custom_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var assert_operation_fee_parameters = new Serializer("assert_operation_fee_parameters", { fee: uint64 }); + +var balance_claim_operation_fee_parameters = new Serializer("balance_claim_operation_fee_parameters"); + +var override_transfer_operation_fee_parameters = new Serializer("override_transfer_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var transfer_to_blind_operation_fee_parameters = new Serializer("transfer_to_blind_operation_fee_parameters", { fee: uint64, + price_per_output: uint32 }); + +var blind_transfer_operation_fee_parameters = new Serializer("blind_transfer_operation_fee_parameters", { fee: uint64, + price_per_output: uint32 }); + +var transfer_from_blind_operation_fee_parameters = new Serializer("transfer_from_blind_operation_fee_parameters", { fee: uint64 }); + +var asset_settle_cancel_operation_fee_parameters = new Serializer("asset_settle_cancel_operation_fee_parameters"); + +var asset_claim_fees_operation_fee_parameters = new Serializer("asset_claim_fees_operation_fee_parameters", { fee: uint64 }); + +var fba_distribute_operation_fee_parameters = new Serializer("fba_distribute_operation_fee_parameters", {}); + +var tournament_create_operation_fee_parameters = new Serializer("tournament_create_operation_fee_parameters", { fee: uint64, + price_per_kbyte: uint32 }); + +var tournament_join_operation_fee_parameters = new Serializer("tournament_join_operation_fee_parameters", { fee: uint64 }); + +var fee_parameters = static_variant([transfer_operation_fee_parameters, limit_order_create_operation_fee_parameters, limit_order_cancel_operation_fee_parameters, call_order_update_operation_fee_parameters, fill_order_operation_fee_parameters, account_create_operation_fee_parameters, account_update_operation_fee_parameters, account_whitelist_operation_fee_parameters, account_upgrade_operation_fee_parameters, account_transfer_operation_fee_parameters, asset_create_operation_fee_parameters, asset_update_operation_fee_parameters, asset_update_bitasset_operation_fee_parameters, asset_update_feed_producers_operation_fee_parameters, asset_issue_operation_fee_parameters, asset_reserve_operation_fee_parameters, asset_fund_fee_pool_operation_fee_parameters, asset_settle_operation_fee_parameters, asset_global_settle_operation_fee_parameters, asset_publish_feed_operation_fee_parameters, witness_create_operation_fee_parameters, witness_update_operation_fee_parameters, proposal_create_operation_fee_parameters, proposal_update_operation_fee_parameters, proposal_delete_operation_fee_parameters, withdraw_permission_create_operation_fee_parameters, withdraw_permission_update_operation_fee_parameters, withdraw_permission_claim_operation_fee_parameters, withdraw_permission_delete_operation_fee_parameters, committee_member_create_operation_fee_parameters, committee_member_update_operation_fee_parameters, committee_member_update_global_parameters_operation_fee_parameters, vesting_balance_create_operation_fee_parameters, vesting_balance_withdraw_operation_fee_parameters, worker_create_operation_fee_parameters, custom_operation_fee_parameters, assert_operation_fee_parameters, balance_claim_operation_fee_parameters, override_transfer_operation_fee_parameters, transfer_to_blind_operation_fee_parameters, blind_transfer_operation_fee_parameters, transfer_from_blind_operation_fee_parameters, asset_settle_cancel_operation_fee_parameters, asset_claim_fees_operation_fee_parameters, fba_distribute_operation_fee_parameters, tournament_create_operation_fee_parameters, tournament_join_operation_fee_parameters]); + +var fee_schedule = new Serializer("fee_schedule", { parameters: set(fee_parameters), + scale: uint32 }); + +var void_result = new Serializer("void_result"); + +var asset = new Serializer("asset", { amount: int64, + asset_id: protocol_id_type("asset") }); + +var operation_result = static_variant([void_result, object_id_type, asset]); + +var processed_transaction = new Serializer("processed_transaction", { ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions), + signatures: array(bytes(65)), + operation_results: array(operation_result) }); + +var signed_block = new Serializer("signed_block", { previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type("witness"), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions), + witness_signature: bytes(65), + transactions: array(processed_transaction) }); + +var block_header = new Serializer("block_header", { previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type("witness"), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions) }); + +var signed_block_header = new Serializer("signed_block_header", { previous: bytes(20), + timestamp: time_point_sec, + witness: protocol_id_type("witness"), + transaction_merkle_root: bytes(20), + extensions: set(future_extensions), + witness_signature: bytes(65) }); + +var memo_data = new Serializer("memo_data", { from: public_key, + to: public_key, + nonce: uint64, + message: bytes() }); + +var transfer = new Serializer("transfer", { fee: asset, + from: protocol_id_type("account"), + to: protocol_id_type("account"), + amount: asset, + memo: optional(memo_data), + extensions: set(future_extensions) }); + +var limit_order_create = new Serializer("limit_order_create", { fee: asset, + seller: protocol_id_type("account"), + amount_to_sell: asset, + min_to_receive: asset, + expiration: time_point_sec, + fill_or_kill: bool, + extensions: set(future_extensions) }); + +var limit_order_cancel = new Serializer("limit_order_cancel", { fee: asset, + fee_paying_account: protocol_id_type("account"), + order: protocol_id_type("limit_order"), + extensions: set(future_extensions) }); + +var call_order_update = new Serializer("call_order_update", { fee: asset, + funding_account: protocol_id_type("account"), + delta_collateral: asset, + delta_debt: asset, + extensions: set(future_extensions) }); + +var fill_order = new Serializer("fill_order", { fee: asset, + order_id: object_id_type, + account_id: protocol_id_type("account"), + pays: asset, + receives: asset }); + +var authority = new Serializer("authority", { weight_threshold: uint32, + account_auths: map(protocol_id_type("account"), uint16), + key_auths: map(public_key, uint16), + address_auths: map(address, uint16) }); + +var account_options = new Serializer("account_options", { memo_key: public_key, + voting_account: protocol_id_type("account"), + num_witness: uint16, + num_committee: uint16, + votes: set(vote_id), + extensions: set(future_extensions) }); + +var account_create = new Serializer("account_create", { fee: asset, + registrar: protocol_id_type("account"), + referrer: protocol_id_type("account"), + referrer_percent: uint16, + name: string, + owner: authority, + active: authority, + options: account_options, + extensions: set(future_extensions) }); + +var account_update = new Serializer("account_update", { fee: asset, + account: protocol_id_type("account"), + owner: optional(authority), + active: optional(authority), + new_options: optional(account_options), + extensions: set(future_extensions) }); + +var account_whitelist = new Serializer("account_whitelist", { fee: asset, + authorizing_account: protocol_id_type("account"), + account_to_list: protocol_id_type("account"), + new_listing: uint8, + extensions: set(future_extensions) }); + +var account_upgrade = new Serializer("account_upgrade", { fee: asset, + account_to_upgrade: protocol_id_type("account"), + upgrade_to_lifetime_member: bool, + extensions: set(future_extensions) }); + +var account_transfer = new Serializer("account_transfer", { fee: asset, + account_id: protocol_id_type("account"), + new_owner: protocol_id_type("account"), + extensions: set(future_extensions) }); + +var price = new Serializer("price", { base: asset, + quote: asset }); + +var asset_options = new Serializer("asset_options", { max_supply: int64, + market_fee_percent: uint16, + max_market_fee: int64, + issuer_permissions: uint16, + flags: uint16, + core_exchange_rate: price, + whitelist_authorities: set(protocol_id_type("account")), + blacklist_authorities: set(protocol_id_type("account")), + whitelist_markets: set(protocol_id_type("asset")), + blacklist_markets: set(protocol_id_type("asset")), + description: string, + extensions: set(future_extensions) }); + +var bitasset_options = new Serializer("bitasset_options", { feed_lifetime_sec: uint32, + minimum_feeds: uint8, + force_settlement_delay_sec: uint32, + force_settlement_offset_percent: uint16, + maximum_force_settlement_volume: uint16, + short_backing_asset: protocol_id_type("asset"), + extensions: set(future_extensions) }); + +var asset_create = new Serializer("asset_create", { fee: asset, + issuer: protocol_id_type("account"), + symbol: string, + precision: uint8, + common_options: asset_options, + bitasset_opts: optional(bitasset_options), + is_prediction_market: bool, + extensions: set(future_extensions) }); + +var asset_update = new Serializer("asset_update", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_issuer: optional(protocol_id_type("account")), + new_options: asset_options, + extensions: set(future_extensions) }); + +var asset_update_bitasset = new Serializer("asset_update_bitasset", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_options: bitasset_options, + extensions: set(future_extensions) }); + +var asset_update_feed_producers = new Serializer("asset_update_feed_producers", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_feed_producers: set(protocol_id_type("account")), + extensions: set(future_extensions) }); + +var asset_issue = new Serializer("asset_issue", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_issue: asset, + issue_to_account: protocol_id_type("account"), + memo: optional(memo_data), + extensions: set(future_extensions) }); + +var asset_reserve = new Serializer("asset_reserve", { fee: asset, + payer: protocol_id_type("account"), + amount_to_reserve: asset, + extensions: set(future_extensions) }); + +var asset_fund_fee_pool = new Serializer("asset_fund_fee_pool", { fee: asset, + from_account: protocol_id_type("account"), + asset_id: protocol_id_type("asset"), + amount: int64, + extensions: set(future_extensions) }); + +var asset_settle = new Serializer("asset_settle", { fee: asset, + account: protocol_id_type("account"), + amount: asset, + extensions: set(future_extensions) }); + +var asset_global_settle = new Serializer("asset_global_settle", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_settle: protocol_id_type("asset"), + settle_price: price, + extensions: set(future_extensions) }); + +var price_feed = new Serializer("price_feed", { settlement_price: price, + maintenance_collateral_ratio: uint16, + maximum_short_squeeze_ratio: uint16, + core_exchange_rate: price }); + +var asset_publish_feed = new Serializer("asset_publish_feed", { fee: asset, + publisher: protocol_id_type("account"), + asset_id: protocol_id_type("asset"), + feed: price_feed, + extensions: set(future_extensions) }); + +var witness_create = new Serializer("witness_create", { fee: asset, + witness_account: protocol_id_type("account"), + url: string, + block_signing_key: public_key }); + +var witness_update = new Serializer("witness_update", { fee: asset, + witness: protocol_id_type("witness"), + witness_account: protocol_id_type("account"), + new_url: optional(string), + new_signing_key: optional(public_key) }); + +var op_wrapper = new Serializer("op_wrapper", { op: operation }); + +var proposal_create = new Serializer("proposal_create", { fee: asset, + fee_paying_account: protocol_id_type("account"), + expiration_time: time_point_sec, + proposed_ops: array(op_wrapper), + review_period_seconds: optional(uint32), + extensions: set(future_extensions) }); + +var proposal_update = new Serializer("proposal_update", { fee: asset, + fee_paying_account: protocol_id_type("account"), + proposal: protocol_id_type("proposal"), + active_approvals_to_add: set(protocol_id_type("account")), + active_approvals_to_remove: set(protocol_id_type("account")), + owner_approvals_to_add: set(protocol_id_type("account")), + owner_approvals_to_remove: set(protocol_id_type("account")), + key_approvals_to_add: set(public_key), + key_approvals_to_remove: set(public_key), + extensions: set(future_extensions) }); + +var proposal_delete = new Serializer("proposal_delete", { fee: asset, + fee_paying_account: protocol_id_type("account"), + using_owner_authority: bool, + proposal: protocol_id_type("proposal"), + extensions: set(future_extensions) }); + +var withdraw_permission_create = new Serializer("withdraw_permission_create", { fee: asset, + withdraw_from_account: protocol_id_type("account"), + authorized_account: protocol_id_type("account"), + withdrawal_limit: asset, + withdrawal_period_sec: uint32, + periods_until_expiration: uint32, + period_start_time: time_point_sec }); + +var withdraw_permission_update = new Serializer("withdraw_permission_update", { fee: asset, + withdraw_from_account: protocol_id_type("account"), + authorized_account: protocol_id_type("account"), + permission_to_update: protocol_id_type("withdraw_permission"), + withdrawal_limit: asset, + withdrawal_period_sec: uint32, + period_start_time: time_point_sec, + periods_until_expiration: uint32 }); + +var withdraw_permission_claim = new Serializer("withdraw_permission_claim", { fee: asset, + withdraw_permission: protocol_id_type("withdraw_permission"), + withdraw_from_account: protocol_id_type("account"), + withdraw_to_account: protocol_id_type("account"), + amount_to_withdraw: asset, + memo: optional(memo_data) }); + +var withdraw_permission_delete = new Serializer("withdraw_permission_delete", { fee: asset, + withdraw_from_account: protocol_id_type("account"), + authorized_account: protocol_id_type("account"), + withdrawal_permission: protocol_id_type("withdraw_permission") }); + +var committee_member_create = new Serializer("committee_member_create", { fee: asset, + committee_member_account: protocol_id_type("account"), + url: string }); + +var committee_member_update = new Serializer("committee_member_update", { fee: asset, + committee_member: protocol_id_type("committee_member"), + committee_member_account: protocol_id_type("account"), + new_url: optional(string) }); + +var chain_parameters = new Serializer("chain_parameters", { current_fees: fee_schedule, + block_interval: uint8, + maintenance_interval: uint32, + maintenance_skip_slots: uint8, + committee_proposal_review_period: uint32, + maximum_transaction_size: uint32, + maximum_block_size: uint32, + maximum_time_until_expiration: uint32, + maximum_proposal_lifetime: uint32, + maximum_asset_whitelist_authorities: uint8, + maximum_asset_feed_publishers: uint8, + maximum_witness_count: uint16, + maximum_committee_count: uint16, + maximum_authority_membership: uint16, + reserve_percent_of_fee: uint16, + network_percent_of_fee: uint16, + lifetime_referrer_percent_of_fee: uint16, + cashback_vesting_period_seconds: uint32, + cashback_vesting_threshold: int64, + count_non_member_votes: bool, + allow_non_member_whitelists: bool, + witness_pay_per_block: int64, + worker_budget_per_day: int64, + max_predicate_opcode: uint16, + fee_liquidation_threshold: int64, + accounts_per_fee_scale: uint16, + account_fee_scale_bitshifts: uint8, + max_authority_depth: uint8, + extensions: set(future_extensions) }); + +var committee_member_update_global_parameters = new Serializer("committee_member_update_global_parameters", { fee: asset, + new_parameters: chain_parameters }); + +var linear_vesting_policy_initializer = new Serializer("linear_vesting_policy_initializer", { begin_timestamp: time_point_sec, + vesting_cliff_seconds: uint32, + vesting_duration_seconds: uint32 }); + +var cdd_vesting_policy_initializer = new Serializer("cdd_vesting_policy_initializer", { start_claim: time_point_sec, + vesting_seconds: uint32 }); + +var vesting_policy_initializer = static_variant([linear_vesting_policy_initializer, cdd_vesting_policy_initializer]); + +var vesting_balance_create = new Serializer("vesting_balance_create", { fee: asset, + creator: protocol_id_type("account"), + owner: protocol_id_type("account"), + amount: asset, + policy: vesting_policy_initializer }); + +var vesting_balance_withdraw = new Serializer("vesting_balance_withdraw", { fee: asset, + vesting_balance: protocol_id_type("vesting_balance"), + owner: protocol_id_type("account"), + amount: asset }); + +var refund_worker_initializer = new Serializer("refund_worker_initializer"); + +var vesting_balance_worker_initializer = new Serializer("vesting_balance_worker_initializer", { pay_vesting_period_days: uint16 }); + +var burn_worker_initializer = new Serializer("burn_worker_initializer"); + +var worker_initializer = static_variant([refund_worker_initializer, vesting_balance_worker_initializer, burn_worker_initializer]); + +var worker_create = new Serializer("worker_create", { fee: asset, + owner: protocol_id_type("account"), + work_begin_date: time_point_sec, + work_end_date: time_point_sec, + daily_pay: int64, + name: string, + url: string, + initializer: worker_initializer }); + +var custom = new Serializer("custom", { fee: asset, + payer: protocol_id_type("account"), + required_auths: set(protocol_id_type("account")), + id: uint16, + data: bytes() }); + +var account_name_eq_lit_predicate = new Serializer("account_name_eq_lit_predicate", { account_id: protocol_id_type("account"), + name: string }); + +var asset_symbol_eq_lit_predicate = new Serializer("asset_symbol_eq_lit_predicate", { asset_id: protocol_id_type("asset"), + symbol: string }); + +var block_id_predicate = new Serializer("block_id_predicate", { id: bytes(20) }); + +var predicate = static_variant([account_name_eq_lit_predicate, asset_symbol_eq_lit_predicate, block_id_predicate]); + +var assert = new Serializer("assert", { fee: asset, + fee_paying_account: protocol_id_type("account"), + predicates: array(predicate), + required_auths: set(protocol_id_type("account")), + extensions: set(future_extensions) }); + +var balance_claim = new Serializer("balance_claim", { fee: asset, + deposit_to_account: protocol_id_type("account"), + balance_to_claim: protocol_id_type("balance"), + balance_owner_key: public_key, + total_claimed: asset }); + +var override_transfer = new Serializer("override_transfer", { fee: asset, + issuer: protocol_id_type("account"), + from: protocol_id_type("account"), + to: protocol_id_type("account"), + amount: asset, + memo: optional(memo_data), + extensions: set(future_extensions) }); + +var stealth_confirmation = new Serializer("stealth_confirmation", { one_time_key: public_key, + to: optional(public_key), + encrypted_memo: bytes() }); + +var blind_output = new Serializer("blind_output", { commitment: bytes(33), + range_proof: bytes(), + owner: authority, + stealth_memo: optional(stealth_confirmation) }); + +var transfer_to_blind = new Serializer("transfer_to_blind", { fee: asset, + amount: asset, + from: protocol_id_type("account"), + blinding_factor: bytes(32), + outputs: array(blind_output) }); + +var blind_input = new Serializer("blind_input", { commitment: bytes(33), + owner: authority }); + +var blind_transfer = new Serializer("blind_transfer", { fee: asset, + inputs: array(blind_input), + outputs: array(blind_output) }); + +var transfer_from_blind = new Serializer("transfer_from_blind", { fee: asset, + amount: asset, + to: protocol_id_type("account"), + blinding_factor: bytes(32), + inputs: array(blind_input) }); + +var asset_settle_cancel = new Serializer("asset_settle_cancel", { fee: asset, + settlement: protocol_id_type("force_settlement"), + account: protocol_id_type("account"), + amount: asset, + extensions: set(future_extensions) }); + +var asset_claim_fees = new Serializer("asset_claim_fees", { fee: asset, + issuer: protocol_id_type("account"), + amount_to_claim: asset, + extensions: set(future_extensions) }); + +var fba_distribute = new Serializer("fba_distribute", { fee: asset, + account_id: protocol_id_type("account"), + fba_id: protocol_id_type("fba_accumulator"), + amount: int64 }); + +var dividend_asset_options = new Serializer("dividend_asset_options", { next_payout_time: optional(time_point_sec), + payout_interval: optional(uint32), + minimum_fee_percentage: uint64, + minimum_distribution_interval: optional(uint32), + extensions: set(future_extensions) }); + +var asset_update_dividend = new Serializer("asset_update_dividend", { fee: asset, + issuer: protocol_id_type("account"), + asset_to_update: protocol_id_type("asset"), + new_options: dividend_asset_options, + extensions: set(future_extensions) }); + +var rock_paper_scissors_game_options = new Serializer("rock_paper_scissors_game_options", { insurance_enabled: bool, + time_per_commit_move: uint32, + time_per_reveal_move: uint32, + number_of_gestures: uint8 }); + +var game_specific_details = static_variant([rock_paper_scissors_game_options]); + +var tournament_options = new Serializer("tournament_options", { + type_of_game: uint16, + registration_deadline: time_point_sec, + number_of_players: uint32, + buy_in: asset, + whitelist: set(protocol_id_type("account")), + start_time: optional(time_point_sec), + start_delay: optional(uint32), + round_delay: uint32, + number_of_wins: uint32, + meta: variant_object, + game_options: game_specific_details +}); + +var tournament_create = new Serializer("tournament_create", { fee: asset, + creator: protocol_id_type("account"), + options: tournament_options, + extensions: set(future_extensions) }); + +var tournament_join = new Serializer("tournament_join", { fee: asset, + payer_account_id: protocol_id_type("account"), + player_account_id: protocol_id_type("account"), + tournament_id: protocol_id_type("tournament"), + buy_in: asset, + extensions: set(future_extensions) }); + +var rock_paper_scissors_gesture = enumeration(["rock", "paper", "scissors", "spock", "lizard"]); + +var rock_paper_scissors_throw_commit = new Serializer("rock_paper_scissors_throw_commit", { nonce1: uint64, + throw_hash: sha256 }); + +var rock_paper_scissors_throw_reveal = new Serializer("rock_paper_scissors_throw_reveal", { nonce2: uint64, + gesture: rock_paper_scissors_gesture }); + +var game_specific_moves = static_variant([rock_paper_scissors_throw_commit, rock_paper_scissors_throw_reveal]); + +var game_move = new Serializer("game_move", { fee: asset, + game_id: protocol_id_type("game"), + player_account_id: protocol_id_type("account"), + move: game_specific_moves, + extensions: set(future_extensions) }); + +operation.st_operations = [transfer, limit_order_create, limit_order_cancel, call_order_update, fill_order, account_create, account_update, account_whitelist, account_upgrade, account_transfer, asset_create, asset_update, asset_update_bitasset, asset_update_feed_producers, asset_issue, asset_reserve, asset_fund_fee_pool, asset_settle, asset_global_settle, asset_publish_feed, witness_create, witness_update, proposal_create, proposal_update, proposal_delete, withdraw_permission_create, withdraw_permission_update, withdraw_permission_claim, withdraw_permission_delete, committee_member_create, committee_member_update, committee_member_update_global_parameters, vesting_balance_create, vesting_balance_withdraw, worker_create, custom, assert, balance_claim, override_transfer, transfer_to_blind, blind_transfer, transfer_from_blind, asset_settle_cancel, asset_claim_fees, fba_distribute, tournament_create, tournament_join, game_move, asset_update_dividend]; + +var transaction = new Serializer("transaction", { ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions) }); + +var signed_transaction = new Serializer("signed_transaction", { ref_block_num: uint16, + ref_block_prefix: uint32, + expiration: time_point_sec, + operations: array(operation), + extensions: set(future_extensions), + signatures: array(bytes(65)) }); +//# ------------------------------- +//# Generated code end +//# ------------------------------- + +// Custom Types + +var stealth_memo_data = new Serializer("stealth_memo_data", { + from: optional(public_key), + amount: asset, + blinding_factor: bytes(32), + commitment: bytes(33), + check: uint32 +}); +// var stealth_confirmation = new Serializer( +// "stealth_confirmation", { +// one_time_key: public_key, +// to: optional( public_key ), +// encrypted_memo: stealth_memo_data +// }) \ No newline at end of file diff --git a/dist/serializer/src/precision.js b/dist/serializer/src/precision.js new file mode 100644 index 0000000..81e7ab3 --- /dev/null +++ b/dist/serializer/src/precision.js @@ -0,0 +1,95 @@ +'use strict'; + +var _my; +var _internal; +var v = require('./SerializerValidation'); +var BigInteger = require('bigi'); + +module.exports = _my = + +// Result may be used for int64 types (like transfer amount). Asset's +// precision is used to convert the number to a whole number with an implied +// decimal place. + +// "1.01" with a precision of 2 returns long 101 +// See http://cryptocoinjs.com/modules/misc/bigi/#example +{ + to_bigint64: function to_bigint64(number_or_string, precision) { + var error_info = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; + + var long = _internal.to_long64(number_or_string, precision, error_info); + return BigInteger(long.toString()); + }, + + + // 101 string or long with a precision of 2 returns "1.01" + to_string64: function to_string64(number_or_string, precision) { + var error_info = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; + + v.required(number_or_string, error_info); + v.number(precision, error_info); + var number_long = v.to_long(number_or_string, error_info); + var string64 = _internal.decimal_precision_string(number_long, precision, error_info); + v.no_overflow64(string64, error_info); + return string64; + } +}; + +// _internal is for low-level transaction code +module.exports._internal = _internal = + +// Warning: Long operations may over-flow without detection +{ + to_long64: function to_long64(number_or_string, precision) { + var error_info = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; + + v.required(number_or_string, "number_or_string " + error_info); + v.required(precision, "precision " + error_info); + return v.to_long(_internal.decimal_precision_string(number_or_string, precision, error_info)); + }, + decimal_precision_string: function decimal_precision_string(number, precision) { + var error_info = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ""; + + v.required(number, "number " + error_info); + v.required(precision, "precision " + error_info); + + var number_string = v.to_string(number); + number_string = number_string.trim(); + precision = v.to_number(precision); + + // remove leading zeros (not suffixing) + var number_parts = number_string.match(/^-?0*([0-9]*)\.?([0-9]*)$/); + if (!number_parts) { + throw new Error('Invalid number: ' + number_string + ' ' + error_info); + } + + var sign = number_string.charAt(0) === '-' ? '-' : ''; + var int_part = number_parts[1]; + var decimal_part = number_parts[2]; + if (!decimal_part) { + decimal_part = ""; + } + + // remove trailing zeros + while (/0$/.test(decimal_part)) { + decimal_part = decimal_part.substring(0, decimal_part.length - 1); + } + + var zero_pad_count = precision - decimal_part.length; + if (zero_pad_count < 0) { + throw new Error('overflow, up to ' + precision + ' decimals may be used ' + error_info); + } + + if (sign === "-" && !/[1-9]/.test(int_part + decimal_part)) { + sign = ""; + } + if (int_part === "") { + int_part = "0"; + } + for (var i = 0; 0 < zero_pad_count ? i < zero_pad_count : i > zero_pad_count; 0 < zero_pad_count ? i++ : i++) { + decimal_part += "0"; + } + + return sign + int_part + decimal_part; + } +}; \ No newline at end of file diff --git a/dist/serializer/src/serializer.js b/dist/serializer/src/serializer.js new file mode 100644 index 0000000..161ca14 --- /dev/null +++ b/dist/serializer/src/serializer.js @@ -0,0 +1,207 @@ +'use strict'; + +var _createClass = 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; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var ByteBuffer = require('bytebuffer'); +var EC = require('./error_with_cause'); + +var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; + +var Serializer = function () { + function Serializer(operation_name, types) { + _classCallCheck(this, Serializer); + + this.operation_name = operation_name; + this.types = types; + if (this.types) this.keys = Object.keys(this.types); + + Serializer.printDebug = true; + } + + _createClass(Serializer, [{ + key: 'fromByteBuffer', + value: function fromByteBuffer(b) { + var object = {}; + var field = null; + try { + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + try { + if (HEX_DUMP) { + if (type.operation_name) { + console.error(type.operation_name); + } else { + var o1 = b.offset; + type.fromByteBuffer(b); + var o2 = b.offset; + b.offset = o1; + //b.reset() + var _b = b.copy(o1, o2); + console.error(this.operation_name + '.' + field + '\t', _b.toHex()); + } + } + object[field] = type.fromByteBuffer(b); + } catch (e) { + if (Serializer.printDebug) { + console.error('Error reading ' + this.operation_name + '.' + field + ' in data:'); + b.printDebug(); + } + throw e; + } + } + } catch (error) { + EC.throw(this.operation_name + '.' + field, error); + } + + return object; + } + }, { + key: 'appendByteBuffer', + value: function appendByteBuffer(b, object) { + var field = null; + try { + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + type.appendByteBuffer(b, object[field]); + } + } catch (error) { + try { + EC.throw(this.operation_name + '.' + field + " = " + JSON.stringify(object[field]), error); + } catch (e) { + // circular ref + EC.throw(this.operation_name + '.' + field + " = " + object[field], error); + } + } + return; + } + }, { + key: 'fromObject', + value: function fromObject(serialized_object) { + var result = {}; + var field = null; + try { + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + var value = serialized_object[field]; + //DEBUG value = value.resolve if value.resolve + //DEBUG console.log('... value',field,value) + var object = type.fromObject(value); + result[field] = object; + } + } catch (error) { + EC.throw(this.operation_name + '.' + field, error); + } + + return result; + } + + /** + @arg {boolean} [debug.use_default = false] - more template friendly + @arg {boolean} [debug.annotate = false] - add user-friendly information + */ + + }, { + key: 'toObject', + value: function toObject() { + var serialized_object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { use_default: false, annotate: false }; + + var result = {}; + var field = null; + try { + if (!this.types) return result; + + var iterable = this.keys; + for (var i = 0, field; i < iterable.length; i++) { + field = iterable[i]; + var type = this.types[field]; + var object = type.toObject(typeof serialized_object !== "undefined" && serialized_object !== null ? serialized_object[field] : undefined, debug); + result[field] = object; + if (HEX_DUMP) { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + type.appendByteBuffer(b, typeof serialized_object !== "undefined" && serialized_object !== null ? serialized_object[field] : undefined); + b = b.copy(0, b.offset); + console.error(this.operation_name + '.' + field, b.toHex()); + } + } + } catch (error) { + EC.throw(this.operation_name + '.' + field, error); + } + + return result; + } + + /** Sort by the first element in a operation */ + + }, { + key: 'compare', + value: function compare(a, b) { + + var first_key = this.keys[0]; + var first_type = this.types[first_key]; + + var valA = a[first_key]; + var valB = b[first_key]; + + if (first_type.compare) return first_type.compare(valA, valB); + + if (typeof valA === "number" && typeof valB === "number") return valA - valB; + + var encoding = void 0; + if (Buffer.isBuffer(valA) && Buffer.isBuffer(valB)) { + // A binary string compare does not work. If localeCompare is well supported that could replace HEX. Performanance is very good so comparing HEX works. + encoding = "hex"; + } + + var strA = valA.toString(encoding); + var strB = valB.toString(encoding); + return strA > strB ? 1 : strA < strB ? -1 : 0; + } + + // + + }, { + key: 'fromHex', + value: function fromHex(hex) { + var b = ByteBuffer.fromHex(hex, ByteBuffer.LITTLE_ENDIAN); + return this.fromByteBuffer(b); + } + }, { + key: 'fromBuffer', + value: function fromBuffer(buffer) { + var b = ByteBuffer.fromBinary(buffer.toString("binary"), ByteBuffer.LITTLE_ENDIAN); + return this.fromByteBuffer(b); + } + }, { + key: 'toHex', + value: function toHex(object) { + // return this.toBuffer(object).toString("hex") + var b = this.toByteBuffer(object); + return b.toHex(); + } + }, { + key: 'toByteBuffer', + value: function toByteBuffer(object) { + var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN); + this.appendByteBuffer(b, object); + return b.copy(0, b.offset); + } + }, { + key: 'toBuffer', + value: function toBuffer(object) { + return new Buffer(this.toByteBuffer(object).toBinary(), 'binary'); + } + }]); + + return Serializer; +}(); + +module.exports = Serializer; \ No newline at end of file diff --git a/dist/serializer/src/template.js b/dist/serializer/src/template.js new file mode 100644 index 0000000..d1e5d0d --- /dev/null +++ b/dist/serializer/src/template.js @@ -0,0 +1,17 @@ +"use strict"; + +/** Console print any transaction object with zero default values. */ +module.exports = function template(op) { + + var object = op.toObject(void 0, { use_default: true, annotate: true }); + + // visual (with descriptions) + console.error(JSON.stringify(object, null, 4)); + + // usable in a copy-paste + + object = op.toObject(void 0, { use_default: true, annotate: false }); + + // copy-paste one-lineer + console.error(JSON.stringify(object)); +}; \ No newline at end of file diff --git a/dist/serializer/src/types.js b/dist/serializer/src/types.js new file mode 100644 index 0000000..45a0225 --- /dev/null +++ b/dist/serializer/src/types.js @@ -0,0 +1,1024 @@ +'use strict'; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +// Low-level types that make up operations + +var v = require('./SerializerValidation'); +var fp = require('./FastParser'); + +var ChainTypes = require("../../chain/src/ChainTypes"); +var ObjectId = require("../../chain/src/ObjectId"); + +var _require = require("../../ecc"), + PublicKey = _require.PublicKey, + Address = _require.Address; + +var _require2 = require("peerplaysjs-ws"), + ChainConfig = _require2.ChainConfig; + +var Types = {}; +module.exports = Types; + +var HEX_DUMP = process.env.npm_config__graphene_serializer_hex_dump; + +Types.uint8 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint8(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(0, 0xFF, object, 'uint8 ' + object); + b.writeUint8(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(0, 0xFF, object, 'uint8 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(0, 0xFF, object, 'uint8 ' + object); + return parseInt(object); + } +}; + +Types.uint16 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint16(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(0, 0xFFFF, object, 'uint16 ' + object); + b.writeUint16(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(0, 0xFFFF, object, 'uint16 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(0, 0xFFFF, object, 'uint16 ' + object); + return parseInt(object); + } +}; + +Types.uint32 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object); + b.writeUint32(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(0, 0xFFFFFFFF, object, 'uint32 ' + object); + return parseInt(object); + } +}; + +var MIN_SIGNED_32 = -1 * Math.pow(2, 31); +var MAX_SIGNED_32 = Math.pow(2, 31) - 1; + +Types.varint32 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readVarint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + b.writeVarint32(object); + return; + }, + fromObject: function fromObject(object) { + v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return 0; + } + v.require_range(MIN_SIGNED_32, MAX_SIGNED_32, object, 'uint32 ' + object); + return parseInt(object); + } +}; + +Types.int64 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readInt64(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + b.writeInt64(v.to_long(object)); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + return v.to_long(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return "0"; + } + v.required(object); + return v.to_long(object).toString(); + } +}; + +Types.uint64 = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint64(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + b.writeUint64(v.to_ulong(v.unsigned(object))); + return; + }, + fromObject: function fromObject(object) { + return v.to_ulong(v.unsigned(object)); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return "0"; + } + return v.to_ulong(object).toString(); + } +}; + +Types.string = { + fromByteBuffer: function fromByteBuffer(b) { + var b_copy; + var len = b.readVarint32(); + b_copy = b.copy(b.offset, b.offset + len), b.skip(len); + return new Buffer(b_copy.toBinary(), 'binary'); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + b.writeVarint32(object.length); + b.append(object.toString('binary'), 'binary'); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + return new Buffer(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return ""; + } + return object.toString(); + } +}; + +Types.bytes = function (size) { + return { + fromByteBuffer: function fromByteBuffer(b) { + if (size === undefined) { + var b_copy; + var len = b.readVarint32(); + b_copy = b.copy(b.offset, b.offset + len), b.skip(len); + return new Buffer(b_copy.toBinary(), 'binary'); + } else { + b_copy = b.copy(b.offset, b.offset + size), b.skip(size); + return new Buffer(b_copy.toBinary(), 'binary'); + } + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + if (typeof object === "string") object = new Buffer(object, "hex"); + + if (size === undefined) { + b.writeVarint32(object.length); + } + b.append(object.toString('binary'), 'binary'); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + if (Buffer.isBuffer(object)) return object; + + return new Buffer(object, 'hex'); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + var zeros = function zeros(num) { + return new Array(num).join("00"); + }; + return zeros(size); + } + v.required(object); + return object.toString('hex'); + } + }; +}; + +Types.bool = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint8() === 1; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + // supports boolean or integer + b.writeUint8(JSON.parse(object) ? 1 : 0); + return; + }, + fromObject: function fromObject(object) { + return JSON.parse(object) ? true : false; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return false; + } + return JSON.parse(object) ? true : false; + } +}; + +Types.void = { + fromByteBuffer: function fromByteBuffer(b) { + throw new Error("(void) undefined type"); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + throw new Error("(void) undefined type"); + }, + fromObject: function fromObject(object) { + throw new Error("(void) undefined type"); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return undefined; + } + throw new Error("(void) undefined type"); + } +}; + +Types.array = function (st_operation) { + return { + fromByteBuffer: function fromByteBuffer(b) { + var size = b.readVarint32(); + if (HEX_DUMP) { + console.log("varint32 size = " + size.toString(16)); + } + var result = []; + for (var i = 0; 0 < size ? i < size : i > size; 0 < size ? i++ : i++) { + result.push(st_operation.fromByteBuffer(b)); + } + return sortOperation(result, st_operation); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + object = sortOperation(object, st_operation); + b.writeVarint32(object.length); + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + st_operation.appendByteBuffer(b, o); + } + }, + fromObject: function fromObject(object) { + v.required(object); + object = sortOperation(object, st_operation); + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.fromObject(o)); + } + return result; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [st_operation.toObject(object, debug)]; + } + v.required(object); + object = sortOperation(object, st_operation); + + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.toObject(o, debug)); + } + return result; + } + }; +}; + +Types.time_point_sec = { + fromByteBuffer: function fromByteBuffer(b) { + return b.readUint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (typeof object !== "number") object = Types.time_point_sec.fromObject(object); + + b.writeUint32(object); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + + if (typeof object === "number") return object; + + if (object.getTime) return Math.floor(object.getTime() / 1000); + + if (typeof object !== "string") throw new Error("Unknown date type: " + object); + + // if(typeof object === "string" && !/Z$/.test(object)) + // object = object + "Z" + + return Math.floor(new Date(object).getTime() / 1000); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) return new Date(0).toISOString().split('.')[0]; + + v.required(object); + + if (typeof object === "string") return object; + + if (object.getTime) return object.toISOString().split('.')[0]; + + var int = parseInt(object); + v.require_range(0, 0xFFFFFFFF, int, 'uint32 ' + object); + return new Date(int * 1000).toISOString().split('.')[0]; + } +}; + +Types.set = function (st_operation) { + return { + validate: function validate(array) { + var dup_map = {}; + for (var i = 0, o; i < array.length; i++) { + o = array[i]; + var ref; + if (ref = typeof o === 'undefined' ? 'undefined' : _typeof(o), ['string', 'number'].indexOf(ref) >= 0) { + if (dup_map[o] !== undefined) { + throw new Error("duplicate (set)"); + } + dup_map[o] = true; + } + } + return sortOperation(array, st_operation); + }, + fromByteBuffer: function fromByteBuffer(b) { + var size = b.readVarint32(); + if (HEX_DUMP) { + console.log("varint32 size = " + size.toString(16)); + } + return this.validate(function () { + var result = []; + for (var i = 0; 0 < size ? i < size : i > size; 0 < size ? i++ : i++) { + result.push(st_operation.fromByteBuffer(b)); + } + return result; + }()); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (!object) { + object = []; + } + b.writeVarint32(object.length); + var iterable = this.validate(object); + for (var i = 0, o; i < iterable.length; i++) { + o = iterable[i]; + st_operation.appendByteBuffer(b, o); + } + return; + }, + fromObject: function fromObject(object) { + if (!object) { + object = []; + } + return this.validate(function () { + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.fromObject(o)); + } + return result; + }()); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [st_operation.toObject(object, debug)]; + } + if (!object) { + object = []; + } + return this.validate(function () { + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push(st_operation.toObject(o, debug)); + } + return result; + }()); + } + }; +}; + +// global_parameters_update_operation current_fees +Types.fixed_array = function (count, st_operation) { + return { + fromByteBuffer: function fromByteBuffer(b) { + var i, j, ref, results; + results = []; + for (i = j = 0, ref = count; j < ref; i = j += 1) { + results.push(st_operation.fromByteBuffer(b)); + } + return sortOperation(results, st_operation); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + var i, j, ref; + if (count !== 0) { + v.required(object); + object = sortOperation(object, st_operation); + } + for (i = j = 0, ref = count; j < ref; i = j += 1) { + st_operation.appendByteBuffer(b, object[i]); + } + }, + fromObject: function fromObject(object) { + var i, j, ref, results; + if (count !== 0) { + v.required(object); + } + results = []; + for (i = j = 0, ref = count; j < ref; i = j += 1) { + results.push(st_operation.fromObject(object[i])); + } + return results; + }, + toObject: function toObject(object, debug) { + var i, j, k, ref, ref1, results, results1; + if (debug == null) { + debug = {}; + } + if (debug.use_default && object === void 0) { + results = []; + for (i = j = 0, ref = count; j < ref; i = j += 1) { + results.push(st_operation.toObject(void 0, debug)); + } + return results; + } + if (count !== 0) { + v.required(object); + } + results1 = []; + for (i = k = 0, ref1 = count; k < ref1; i = k += 1) { + results1.push(st_operation.toObject(object[i], debug)); + } + return results1; + } + }; +}; + +/* Supports instance numbers (11) or object types (1.2.11). Object type +Validation is enforced when an object type is used. */ +var id_type = function id_type(reserved_spaces, object_type) { + v.required(reserved_spaces, "reserved_spaces"); + v.required(object_type, "object_type"); + return { + fromByteBuffer: function fromByteBuffer(b) { + return b.readVarint32(); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + // convert 1.2.n into just n + if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { + object = v.get_instance(reserved_spaces, object_type, object); + } + b.writeVarint32(v.to_number(object)); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + if (v.is_digits(object)) { + return v.to_number(object); + } + return v.get_instance(reserved_spaces, object_type, object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var object_type_id = ChainTypes.object_type[object_type]; + if (debug.use_default && object === undefined) { + return reserved_spaces + '.' + object_type_id + '.0'; + } + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(object)) { + object = v.get_instance(reserved_spaces, object_type, object); + } + + return reserved_spaces + '.' + object_type_id + '.' + object; + } + }; +}; + +Types.protocol_id_type = function (name) { + v.required(name, "name"); + return id_type(ChainTypes.reserved_spaces.protocol_ids, name); +}; + +Types.object_id_type = { + fromByteBuffer: function fromByteBuffer(b) { + return ObjectId.fromByteBuffer(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + object = ObjectId.fromString(object); + object.appendByteBuffer(b); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + return ObjectId.fromString(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return "0.0.0"; + } + v.required(object); + if (object.resolve !== undefined) { + object = object.resolve; + } + object = ObjectId.fromString(object); + return object.toString(); + } +}; + +Types.vote_id = { TYPE: 0x000000FF, + ID: 0xFFFFFF00, + fromByteBuffer: function fromByteBuffer(b) { + var value = b.readUint32(); + return { + type: value & this.TYPE, + id: value & this.ID + }; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + if (object === "string") object = Types.vote_id.fromObject(object); + + var value = object.id << 8 | object.type; + b.writeUint32(value); + return; + }, + fromObject: function fromObject(object) { + v.required(object, "(type vote_id)"); + if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === "object") { + v.required(object.type, "type"); + v.required(object.id, "id"); + return object; + } + v.require_test(/^[0-9]+:[0-9]+$/, object, 'vote_id format ' + object); + + var _object$split = object.split(':'), + _object$split2 = _slicedToArray(_object$split, 2), + type = _object$split2[0], + id = _object$split2[1]; + + v.require_range(0, 0xff, type, 'vote type ' + object); + v.require_range(0, 0xffffff, id, 'vote id ' + object); + return { type: type, id: id }; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return "0:0"; + } + v.required(object); + if (typeof object === "string") object = Types.vote_id.fromObject(object); + + return object.type + ":" + object.id; + }, + compare: function compare(a, b) { + if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== "object") a = Types.vote_id.fromObject(a); + if ((typeof b === 'undefined' ? 'undefined' : _typeof(b)) !== "object") b = Types.vote_id.fromObject(b); + return parseInt(a.id) - parseInt(b.id); + } +}; + +Types.optional = function (st_operation) { + v.required(st_operation, "st_operation"); + return { + fromByteBuffer: function fromByteBuffer(b) { + if (!(b.readUint8() === 1)) { + return undefined; + } + return st_operation.fromByteBuffer(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (object !== null && object !== undefined) { + b.writeUint8(1); + st_operation.appendByteBuffer(b, object); + } else { + b.writeUint8(0); + } + return; + }, + fromObject: function fromObject(object) { + if (object === undefined) { + return undefined; + } + return st_operation.fromObject(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + // toObject is only null save if use_default is true + var result_object = function () { + if (!debug.use_default && object === undefined) { + return undefined; + } else { + return st_operation.toObject(object, debug); + } + }(); + + if (debug.annotate) { + if ((typeof result_object === 'undefined' ? 'undefined' : _typeof(result_object)) === "object") { + result_object.__optional = "parent is optional"; + } else { + result_object = { __optional: result_object }; + } + } + return result_object; + } + }; +}; + +Types.static_variant = function (_st_operations) { + return { + nosort: true, + st_operations: _st_operations, + fromByteBuffer: function fromByteBuffer(b) { + var type_id = b.readVarint32(); + var st_operation = this.st_operations[type_id]; + if (HEX_DUMP) { + console.error('static_variant id 0x' + type_id.toString(16) + ' (' + type_id + ')'); + } + v.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.fromByteBuffer(b)]; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + v.required(st_operation, 'operation ' + type_id); + b.writeVarint32(type_id); + st_operation.appendByteBuffer(b, object[1]); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + v.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.fromObject(object[1])]; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [0, this.st_operations[0].toObject(undefined, debug)]; + } + v.required(object); + var type_id = object[0]; + var st_operation = this.st_operations[type_id]; + v.required(st_operation, 'operation ' + type_id); + return [type_id, st_operation.toObject(object[1], debug)]; + } + }; +}; + +Types.map = function (key_st_operation, value_st_operation) { + return { + validate: function validate(array) { + if (!Array.isArray(array)) { + throw new Error("expecting array"); + } + var dup_map = {}; + for (var i = 0, o; i < array.length; i++) { + o = array[i]; + var ref; + if (!(o.length === 2)) { + throw new Error("expecting two elements"); + } + if (ref = _typeof(o[0]), ['number', 'string'].indexOf(ref) >= 0) { + if (dup_map[o[0]] !== undefined) { + throw new Error("duplicate (map)"); + } + dup_map[o[0]] = true; + } + } + return sortOperation(array, key_st_operation); + }, + fromByteBuffer: function fromByteBuffer(b) { + var result = []; + var end = b.readVarint32(); + for (var i = 0; 0 < end ? i < end : i > end; 0 < end ? i++ : i++) { + result.push([key_st_operation.fromByteBuffer(b), value_st_operation.fromByteBuffer(b)]); + } + return this.validate(result); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + this.validate(object); + b.writeVarint32(object.length); + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + key_st_operation.appendByteBuffer(b, o[0]); + value_st_operation.appendByteBuffer(b, o[1]); + } + return; + }, + fromObject: function fromObject(object) { + v.required(object); + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push([key_st_operation.fromObject(o[0]), value_st_operation.fromObject(o[1])]); + } + return this.validate(result); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return [[key_st_operation.toObject(undefined, debug), value_st_operation.toObject(undefined, debug)]]; + } + v.required(object); + object = this.validate(object); + var result = []; + for (var i = 0, o; i < object.length; i++) { + o = object[i]; + result.push([key_st_operation.toObject(o[0], debug), value_st_operation.toObject(o[1], debug)]); + } + return result; + } + }; +}; + +Types.public_key = { + toPublic: function toPublic(object) { + if (object.resolve !== undefined) { + object = object.resolve; + } + + if (object instanceof PublicKey) { + return object; + } + + return object == null ? object : object.Q ? object : PublicKey.fromStringOrThrow(object); + }, + fromByteBuffer: function fromByteBuffer(b) { + return fp.public_key(b); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + v.required(object); + fp.public_key(b, Types.public_key.toPublic(object)); + return; + }, + fromObject: function fromObject(object) { + v.required(object); + if (object.Q) { + return object; + } + return Types.public_key.toPublic(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return ChainConfig.address_prefix + "859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM"; + } + v.required(object); + return object.toString(); + }, + compare: function compare(a, b) { + return strCmp(a.toAddressString(), b.toAddressString()); + } +}; + +Types.address = { + _to_address: function _to_address(object) { + v.required(object); + if (object.addy) { + return object; + } + return Address.fromString(object); + }, + fromByteBuffer: function fromByteBuffer(b) { + return new Address(fp.ripemd160(b)); + }, + appendByteBuffer: function appendByteBuffer(b, object) { + fp.ripemd160(b, Types.address._to_address(object).toBuffer()); + return; + }, + fromObject: function fromObject(object) { + return Types.address._to_address(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return ChainConfig.address_prefix + "664KmHxSuQyDsfwo4WEJvWpzg1QKdg67S"; + } + return Types.address._to_address(object).toString(); + }, + compare: function compare(a, b) { + return strCmp(a.toString(), b.toString()); + } +}; + +Types.variant = { + fromByteBuffer: function fromByteBuffer(b) { + var type = b.readUint8(); + switch (type) { + case 0: + return null; + case 1: + return Types.int64.fromByteBuffer(b); + case 2: + return Types.uint64.fromByteBuffer(b); + case 3: + return b.readDouble(); + case 4: + return Types.bool.fromByteBuffer(b); + case 5: + return Types.string.fromByteBuffer(b); + case 6: + return Types.array(Types.variant).fromByteBuffer(b); + case 7: + default: + return Types.variant_object.fromByteBuffer(b); + }; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + if (typeof object == 'number') { + if (Number.isInteger(object)) { + if (object >= 0) { + b.writeUint8(2); + Types.uint64.appendByteBuffer(b, object); + } else { + b.writeUint8(1); + Types.int64.appendByteBuffer(b, object); + } + } else { + b.writeUint8(3); + b.writeDouble(Number.parseFloat(object)); + } + } else if (typeof object == 'boolean') { + b.writeUint8(4); + Types.bool.appendByteBuffer(b, object); + } else if (typeof object == 'string') { + b.writeUint8(5); + Types.string.appendByteBuffer(b, object); + } else if (typeof object == 'array') { + b.writeUint8(6); + Types.array(Types.variant).appendByteBuffer(b, object); + } else { + b.writeUint8(7); + Types.variant_object.appendByteBuffer(b, object); + } + }, + fromObject: function fromObject(object) { + return JSON.parse(object); + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + return null; + } + return JSON.parse(object); + } +}; + +Types.variant_object = { + fromByteBuffer: function fromByteBuffer(b) { + var count = b.readVarint32(); + var result = {}; + for (var i = 0; i < count; ++i) { + var key = Types.string.fromByteBuffer(b); + result[key] = Types.variant.fromByteBuffer(b); + } + return result; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + var count = 0; + for (var key in object) { + if (object.hasOwnProperty(key)) ++count; + }b.writeVarint32(count); // number of key/value pairs + for (var key in object) { + if (object.hasOwnProperty(key)) { + Types.string.appendByteBuffer(b, key); + Types.variant.appendByteBuffer(b, object[key]); + } + }return; + }, + fromObject: function fromObject(object) { + var newObject = {}; + for (var key in object) { + if (object.hasOwnProperty(key)) newObject[key] = object[key]; + }return newObject; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var newObject = {}; + for (var key in object) { + if (object.hasOwnProperty(key)) newObject[key] = object[key]; + }return newObject; + } +}; + +Types.enumeration = function (values) { + return { + fromByteBuffer: function fromByteBuffer(b) { + return values[b.readVarint32ZigZag()]; + }, + appendByteBuffer: function appendByteBuffer(b, object) { + b.writeVarint32ZigZag(values.indexOf(object)); + return; + }, + fromObject: function fromObject(object) { + return object; + }, + toObject: function toObject(object) { + var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (debug.use_default && object === undefined) { + values[0]; + } + return object; + } + }; +}; + +Types.sha256 = Types.bytes(32); + +var strCmp = function strCmp(a, b) { + return a > b ? 1 : a < b ? -1 : 0; +}; +var firstEl = function firstEl(el) { + return Array.isArray(el) ? el[0] : el; +}; +var sortOperation = function sortOperation(array, st_operation) { + return st_operation.nosort ? array : st_operation.compare ? array.sort(function (a, b) { + return st_operation.compare(firstEl(a), firstEl(b)); + }) : // custom compare operation + array.sort(function (a, b) { + return typeof firstEl(a) === "number" && typeof firstEl(b) === "number" ? firstEl(a) - firstEl(b) : + // A binary string compare does not work. Performanance is very good so HEX is used.. localeCompare is another option. + Buffer.isBuffer(firstEl(a)) && Buffer.isBuffer(firstEl(b)) ? strCmp(firstEl(a).toString("hex"), firstEl(b).toString("hex")) : strCmp(firstEl(a).toString(), firstEl(b).toString()); + }); +}; \ No newline at end of file From b42ece9a953aebb246d85920fe31814767f7be95 Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 16:00:09 -0400 Subject: [PATCH 10/15] Update get all witnesses function. --- dist/chain/src/ChainStore.js | 7 +++---- lib/chain/src/ChainStore.js | 7 +++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js index a00b15e..eeb79ca 100644 --- a/dist/chain/src/ChainStore.js +++ b/dist/chain/src/ChainStore.js @@ -812,7 +812,6 @@ var ChainStore = function () { }, { key: "fetchWitnessAccounts", value: function fetchWitnessAccounts() { - var _this24 = this; return new Promise(function (resolve, reject) { Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then(function (w) { if (w) { @@ -822,9 +821,9 @@ var ChainStore = function () { witnessArr.push(w[i][1]); // ids only } - _this24.witnesses = _this24.witnesses.merge(witnessArr); - _this24._updateObject(witnessArr, true); - resolve(_this24.witnesses); + this.witnesses = this.witnesses.merge(witnessArr); + this._updateObject(witnessArr, true); + resolve(this.witnesses); } else { resolve(null); } diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index 180b156..c8d5640 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -742,7 +742,6 @@ class ChainStore { * @memberof ChainStore */ fetchWitnessAccounts() { - var _this24 = this; return new Promise((resolve, reject) => { Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then(function (w) { if (w) { @@ -752,9 +751,9 @@ class ChainStore { witnessArr.push(w[i][1]); // ids only } - _this24.witnesses = _this24.witnesses.merge(witnessArr); - _this24._updateObject(witnessArr, true); - resolve(_this24.witnesses); + this.witnesses = this.witnesses.merge(witnessArr); + this._updateObject(witnessArr, true); + resolve(this.witnesses); } else { resolve(null); } From 9cb0c63d75a4940e73c8aa3240f84c0b24d3180a Mon Sep 17 00:00:00 2001 From: mseaward Date: Fri, 1 Feb 2019 16:14:52 -0400 Subject: [PATCH 11/15] Rebuild --- dist/chain/src/ChainStore.js | 6 +++--- lib/chain/src/ChainStore.js | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js index eeb79ca..a700bea 100644 --- a/dist/chain/src/ChainStore.js +++ b/dist/chain/src/ChainStore.js @@ -821,9 +821,9 @@ var ChainStore = function () { witnessArr.push(w[i][1]); // ids only } - this.witnesses = this.witnesses.merge(witnessArr); - this._updateObject(witnessArr, true); - resolve(this.witnesses); + this.witnesses = this.witnesses.set(witnessArr); + var witnesses_object = this._updateObject(witnessArr, true); + resolve(witnesses_object); } else { resolve(null); } diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index c8d5640..f5bcf22 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -751,9 +751,9 @@ class ChainStore { witnessArr.push(w[i][1]); // ids only } - this.witnesses = this.witnesses.merge(witnessArr); - this._updateObject(witnessArr, true); - resolve(this.witnesses); + this.witnesses = this.witnesses.set(witnessArr); + let witnesses_object = this._updateObject(witnessArr, true); + resolve(witnesses_object); } else { resolve(null); } From 877a0ce59f0eac7dacca4b626f34e740a50e02a6 Mon Sep 17 00:00:00 2001 From: mseaward Date: Mon, 4 Feb 2019 09:13:04 -0400 Subject: [PATCH 12/15] Rebuild --- dist/chain/src/ChainStore.js | 149 ++++++++++++++++++----------------- lib/chain/src/ChainStore.js | 5 +- 2 files changed, 79 insertions(+), 75 deletions(-) diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js index a700bea..a8cfec2 100644 --- a/dist/chain/src/ChainStore.js +++ b/dist/chain/src/ChainStore.js @@ -97,6 +97,7 @@ var ChainStore = function () { this.get_account_refs_of_keys_calls = Immutable.Set(); this.account_history_requests = new Map(); ///< tracks pending history requests this.witness_by_account_id = new Map(); + this.witnesses = new Map(); this.account_by_witness_id = new Map(); this.committee_by_account_id = new Map(); this.objects_by_vote_id = new Map(); @@ -812,6 +813,8 @@ var ChainStore = function () { }, { key: "fetchWitnessAccounts", value: function fetchWitnessAccounts() { + var _this13 = this; + return new Promise(function (resolve, reject) { Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then(function (w) { if (w) { @@ -821,8 +824,8 @@ var ChainStore = function () { witnessArr.push(w[i][1]); // ids only } - this.witnesses = this.witnesses.set(witnessArr); - var witnesses_object = this._updateObject(witnessArr, true); + _this13.witnesses = _this13.witnesses.set(witnessArr); + var witnesses_object = _this13._updateObject(witnessArr, true); resolve(witnesses_object); } else { resolve(null); @@ -839,17 +842,17 @@ var ChainStore = function () { }, { key: "fetchWitnessByAccount", value: function fetchWitnessByAccount(account_id) { - var _this13 = this; + var _this14 = this; return new Promise(function (resolve, reject) { Apis.instance().db_api().exec("get_witness_by_account", [account_id]).then(function (optional_witness_object) { if (optional_witness_object) { - _this13.witness_by_account_id = _this13.witness_by_account_id.set(optional_witness_object.witness_account, optional_witness_object.id); - var witness_object = _this13._updateObject(optional_witness_object, true); + _this14.witness_by_account_id = _this14.witness_by_account_id.set(optional_witness_object.witness_account, optional_witness_object.id); + var witness_object = _this14._updateObject(optional_witness_object, true); resolve(witness_object); } else { - _this13.witness_by_account_id = _this13.witness_by_account_id.set(account_id, null); - _this13.notifySubscribers(); + _this14.witness_by_account_id = _this14.witness_by_account_id.set(account_id, null); + _this14.notifySubscribers(); resolve(null); } }, reject); @@ -864,17 +867,17 @@ var ChainStore = function () { }, { key: "fetchCommitteeMemberByAccount", value: function fetchCommitteeMemberByAccount(account_id) { - var _this14 = this; + var _this15 = this; return new Promise(function (resolve, reject) { Apis.instance().db_api().exec("get_committee_member_by_account", [account_id]).then(function (optional_committee_object) { if (optional_committee_object) { - _this14.committee_by_account_id = _this14.committee_by_account_id.set(optional_committee_object.committee_member_account, optional_committee_object.id); - var committee_object = _this14._updateObject(optional_committee_object, true); + _this15.committee_by_account_id = _this15.committee_by_account_id.set(optional_committee_object.committee_member_account, optional_committee_object.id); + var committee_object = _this15._updateObject(optional_committee_object, true); resolve(committee_object); } else { - _this14.committee_by_account_id = _this14.committee_by_account_id.set(account_id, null); - _this14.notifySubscribers(); + _this15.committee_by_account_id = _this15.committee_by_account_id.set(account_id, null); + _this15.notifySubscribers(); resolve(null); } }, reject); @@ -894,7 +897,7 @@ var ChainStore = function () { }, { key: "fetchFullAccount", value: function fetchFullAccount(name_or_id) { - var _this15 = this; + var _this16 = this; if (DEBUG) console.log("Fetch full account: ", name_or_id); @@ -917,8 +920,8 @@ var ChainStore = function () { Apis.instance().db_api().exec("get_full_accounts", [[name_or_id], true]).then(function (results) { if (results.length === 0) { if (ChainValidation.is_object_id(name_or_id)) { - _this15.objects_by_id = _this15.objects_by_id.set(name_or_id, null); - _this15.notifySubscribers(); + _this16.objects_by_id = _this16.objects_by_id.set(name_or_id, null); + _this16.notifySubscribers(); } return; } @@ -938,7 +941,7 @@ var ChainStore = function () { proposals = full_account.proposals; - _this15.accounts_by_name = _this15.accounts_by_name.set(account.name, account.id); + _this16.accounts_by_name = _this16.accounts_by_name.set(account.name, account.id); account.referrer_name = referrer_name; account.lifetime_referrer_name = lifetime_referrer_name; account.registrar_name = registrar_name; @@ -951,57 +954,57 @@ var ChainStore = function () { account.proposals = new Immutable.Set(); account.vesting_balances = account.vesting_balances.withMutations(function (set) { vesting_balances.forEach(function (vb) { - _this15._updateObject(vb, false); + _this16._updateObject(vb, false); set.add(vb.id); }); }); votes.forEach(function (v) { - return _this15._updateObject(v, false); + return _this16._updateObject(v, false); }); account.balances = account.balances.withMutations(function (map) { full_account.balances.forEach(function (b) { - _this15._updateObject(b, false); + _this16._updateObject(b, false); map.set(b.asset_type, b.id); }); }); account.orders = account.orders.withMutations(function (set) { limit_orders.forEach(function (order) { - _this15._updateObject(order, false); + _this16._updateObject(order, false); set.add(order.id); }); }); account.pending_dividend_payments = account.pending_dividend_payments.withMutations(function (set) { pending_dividend_payments.forEach(function (payments) { - _this15._updateObject(payments, false); + _this16._updateObject(payments, false); set.add(payments); }); }); account.call_orders = account.call_orders.withMutations(function (set) { call_orders.forEach(function (co) { - _this15._updateObject(co, false); + _this16._updateObject(co, false); set.add(co.id); }); }); account.proposals = account.proposals.withMutations(function (set) { proposals.forEach(function (p) { - _this15._updateObject(p, false); + _this16._updateObject(p, false); set.add(p.id); }); }); - _this15._updateObject(statistics, false); - var updated_account = _this15._updateObject(account, false); - _this15.fetchRecentHistory(updated_account); - _this15.notifySubscribers(); + _this16._updateObject(statistics, false); + var updated_account = _this16._updateObject(account, false); + _this16.fetchRecentHistory(updated_account); + _this16.notifySubscribers(); }, function (error) { console.log("Error: ", error); - if (ChainValidation.is_object_id(name_or_id)) _this15.objects_by_id = _this15.objects_by_id.delete(name_or_id);else _this15.accounts_by_name = _this15.accounts_by_name.delete(name_or_id); + if (ChainValidation.is_object_id(name_or_id)) _this16.objects_by_id = _this16.objects_by_id.delete(name_or_id);else _this16.accounts_by_name = _this16.accounts_by_name.delete(name_or_id); }); } return undefined; @@ -1044,7 +1047,7 @@ var ChainStore = function () { }, { key: "fetchRecentHistory", value: function fetchRecentHistory(account) { - var _this16 = this; + var _this17 = this; var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100; @@ -1076,7 +1079,7 @@ var ChainStore = function () { pending_request.promise = new Promise(function (resolve, reject) { Apis.instance().history_api().exec("get_account_history", [account_id, most_recent, limit, start]).then(function (operations) { - var current_account = _this16.objects_by_id.get(account_id); + var current_account = _this17.objects_by_id.get(account_id); var current_history = current_account.get('history'); if (!current_history) current_history = Immutable.List(); var updated_history = Immutable.fromJS(operations); @@ -1086,18 +1089,18 @@ var ChainStore = function () { } }); var updated_account = current_account.set('history', updated_history); - _this16.objects_by_id = _this16.objects_by_id.set(account_id, updated_account); + _this17.objects_by_id = _this17.objects_by_id.set(account_id, updated_account); //if( current_history != updated_history ) // this._notifyAccountSubscribers( account_id ) - var pending_request = _this16.account_history_requests.get(account_id); - _this16.account_history_requests.delete(account_id); + var pending_request = _this17.account_history_requests.get(account_id); + _this17.account_history_requests.delete(account_id); if (pending_request.requests > 0) { // it looks like some more history may have come in while we were // waiting on the result, lets fetch anything new before we resolve // this query. - _this16.fetchRecentHistory(updated_account, limit).then(resolve, reject); + _this17.fetchRecentHistory(updated_account, limit).then(resolve, reject); } else resolve(updated_account); }); // end then }); @@ -1403,7 +1406,7 @@ var ChainStore = function () { }, { key: "getTournaments", value: function getTournaments(last_tournament_id) { - var _this17 = this; + var _this18 = this; var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5; var start_tournament_id = arguments[2]; @@ -1412,17 +1415,17 @@ var ChainStore = function () { return Apis.instance().db_api().exec("get_tournaments", [last_tournament_id, limit, start_tournament_id]).then(function (tournaments) { var list = Immutable.List(); - _this17.setLastTournamentId(null); + _this18.setLastTournamentId(null); if (tournaments && tournaments.length) { list = list.withMutations(function (l) { tournaments.forEach(function (tournament) { - if (!_this17.objects_by_id.has(tournament.id)) { - _this17._updateObject(tournament, false); + if (!_this18.objects_by_id.has(tournament.id)) { + _this18._updateObject(tournament, false); } - l.unshift(_this17.objects_by_id.get(tournament.id)); + l.unshift(_this18.objects_by_id.get(tournament.id)); }); }); } @@ -1433,34 +1436,34 @@ var ChainStore = function () { }, { key: "getLastTournamentId", value: function getLastTournamentId() { - var _this18 = this; + var _this19 = this; return new Promise(function (resolve, reject) { - if (_this18.last_tournament_id === undefined) { + if (_this19.last_tournament_id === undefined) { Apis.instance().db_api().exec("get_tournaments", [tournament_prefix + '0', 1, tournament_prefix + '0']).then(function (tournaments) { - _this18.setLastTournamentId(null); + _this19.setLastTournamentId(null); if (tournaments && tournaments.length) { tournaments.forEach(function (tournament) { - _this18._updateObject(tournament, false); + _this19._updateObject(tournament, false); }); } - resolve(_this18.last_tournament_id); + resolve(_this19.last_tournament_id); }); } else { - resolve(_this18.last_tournament_id); + resolve(_this19.last_tournament_id); } }); } }, { key: "getObjectsByVoteIds", value: function getObjectsByVoteIds(vote_ids) { - var _this19 = this; + var _this20 = this; var result = []; var missing = []; @@ -1479,7 +1482,7 @@ var ChainStore = function () { console.log("vote objects ===========> ", vote_obj_array); for (var _i2 = 0; _i2 < vote_obj_array.length; ++_i2) { if (vote_obj_array[_i2]) { - _this19._updateObject(vote_obj_array[_i2]); + _this20._updateObject(vote_obj_array[_i2]); } } }, function (error) { @@ -1513,17 +1516,17 @@ var ChainStore = function () { }, { key: "addProposalData", value: function addProposalData(approvals, objectId) { - var _this20 = this; + var _this21 = this; approvals.forEach(function (id) { - var impactedAccount = _this20.objects_by_id.get(id); + var impactedAccount = _this21.objects_by_id.get(id); if (impactedAccount) { var proposals = impactedAccount.get("proposals"); if (!proposals.includes(objectId)) { proposals = proposals.add(objectId); impactedAccount = impactedAccount.set("proposals", proposals); - _this20._updateObject(impactedAccount.toJS(), false); + _this21._updateObject(impactedAccount.toJS(), false); } } }); @@ -1540,16 +1543,16 @@ var ChainStore = function () { }, { key: "__getBlocksForScan", value: function __getBlocksForScan(lastBlock) { - var _this21 = this; + var _this22 = this; var db_api = Apis.instance().db_api(); return new Promise(function (success, fail) { - var scanToBlock = _this21.last_processed_block; + var scanToBlock = _this22.last_processed_block; if (lastBlock) return success({ lastBlock: lastBlock, scanToBlock: scanToBlock }); db_api.exec("get_dynamic_global_properties", []).then(function (globalProperties) { - lastBlock = _this21.last_processed_block = globalProperties['head_block_number']; + lastBlock = _this22.last_processed_block = globalProperties['head_block_number']; scanToBlock = globalProperties['head_block_number'] - 2000; scanToBlock = scanToBlock < 0 ? 1 : scanToBlock; return success({ lastBlock: lastBlock, scanToBlock: scanToBlock }); @@ -1559,7 +1562,7 @@ var ChainStore = function () { }, { key: "__bindBlock", value: function __bindBlock(lastBlock, scanToBlock, isInit) { - var _this22 = this; + var _this23 = this; var db_api = Apis.instance().db_api(); return new Promise(function (success, fail) { @@ -1567,22 +1570,22 @@ var ChainStore = function () { block.id = lastBlock; if (typeof block.timestamp === "string") block.timestamp += "+00:00"; block.timestamp = new Date(block.timestamp); - _this22.getWitnessAccount(block.witness).then(function (witness) { + _this23.getWitnessAccount(block.witness).then(function (witness) { block.witness_account_name = witness.name; - if (!_this22.recent_blocks_by_id.get(lastBlock)) { + if (!_this23.recent_blocks_by_id.get(lastBlock)) { - _this22.recent_blocks_by_id = _this22.recent_blocks_by_id.set(lastBlock, block); + _this23.recent_blocks_by_id = _this23.recent_blocks_by_id.set(lastBlock, block); - if (_this22.last_processed_block < lastBlock) _this22.last_processed_block = lastBlock; + if (_this23.last_processed_block < lastBlock) _this23.last_processed_block = lastBlock; if (!isInit) { - _this22.recent_blocks = _this22.recent_blocks.unshift(block); - if (_this22.recent_blocks.size > block_stack_size) { - _this22.recent_blocks = _this22.recent_blocks.pop(); + _this23.recent_blocks = _this23.recent_blocks.unshift(block); + if (_this23.recent_blocks.size > block_stack_size) { + _this23.recent_blocks = _this23.recent_blocks.pop(); } - } else if (_this22.recent_blocks.size < block_stack_size) { - _this22.recent_blocks = _this22.recent_blocks.push(block); + } else if (_this23.recent_blocks.size < block_stack_size) { + _this23.recent_blocks = _this23.recent_blocks.push(block); } block.transactions.forEach(function (tx) { @@ -1590,17 +1593,17 @@ var ChainStore = function () { op[1].block_id = lastBlock; op[1].created_at = block.timestamp; if (!isInit) { - _this22.recent_operations = _this22.recent_operations.unshift(op); + _this23.recent_operations = _this23.recent_operations.unshift(op); } else { - if (_this22.recent_operations.size < operations_stack_size) { - _this22.recent_operations = _this22.recent_operations.push(op); + if (_this23.recent_operations.size < operations_stack_size) { + _this23.recent_operations = _this23.recent_operations.push(op); } - if (_this22.recent_operations.size >= operations_stack_size && _this22.recent_blocks.size >= block_stack_size) { + if (_this23.recent_operations.size >= operations_stack_size && _this23.recent_blocks.size >= block_stack_size) { scanToBlock = lastBlock; } } - if (_this22.recent_operations.size > operations_stack_size) { - _this22.recent_operations = _this22.recent_operations.pop(); + if (_this23.recent_operations.size > operations_stack_size) { + _this23.recent_operations = _this23.recent_operations.pop(); } }); }); @@ -1609,7 +1612,7 @@ var ChainStore = function () { if (lastBlock <= scanToBlock) { return success(); } - _this22.__bindBlock(lastBlock, scanToBlock, isInit).then(function () { + _this23.__bindBlock(lastBlock, scanToBlock, isInit).then(function () { return success(); }); }); @@ -1619,7 +1622,7 @@ var ChainStore = function () { }, { key: "fetchRecentOperations", value: function fetchRecentOperations() { - var _this23 = this; + var _this24 = this; var lastBlock = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; @@ -1630,9 +1633,9 @@ var ChainStore = function () { var lastBlock = _ref.lastBlock, scanToBlock = _ref.scanToBlock; - _this23.__bindBlock(lastBlock, scanToBlock, isInit).then(function () { + _this24.__bindBlock(lastBlock, scanToBlock, isInit).then(function () { if (isInit) { - _this23.store_initialized = true; + _this24.store_initialized = true; } }); }); diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index f5bcf22..d399a59 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -75,7 +75,8 @@ class ChainStore { this.balance_objects_by_address = Immutable.Map(); this.get_account_refs_of_keys_calls = Immutable.Set(); this.account_history_requests = new Map(); ///< tracks pending history requests - this.witness_by_account_id = new Map(); + this.witness_by_account_id = new Map(); + this.witnesses = new Map(); this.account_by_witness_id = new Map(); this.committee_by_account_id = new Map(); this.objects_by_vote_id = new Map(); @@ -743,7 +744,7 @@ class ChainStore { */ fetchWitnessAccounts() { return new Promise((resolve, reject) => { - Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then(function (w) { + Apis.instance().db_api().exec("lookup_witness_accounts", [0, 1000]).then((w) => { if (w) { let witnessArr = []; From 251ecfb3e32a101f182a318fa88190720b7d25c5 Mon Sep 17 00:00:00 2001 From: mseaward Date: Mon, 4 Feb 2019 09:22:26 -0400 Subject: [PATCH 13/15] Update to merge instead of set. --- dist/chain/src/ChainStore.js | 2 +- lib/chain/src/ChainStore.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js index a8cfec2..870f2c5 100644 --- a/dist/chain/src/ChainStore.js +++ b/dist/chain/src/ChainStore.js @@ -824,7 +824,7 @@ var ChainStore = function () { witnessArr.push(w[i][1]); // ids only } - _this13.witnesses = _this13.witnesses.set(witnessArr); + _this13.witnesses = _this13.witnesses.merge(witnessArr); var witnesses_object = _this13._updateObject(witnessArr, true); resolve(witnesses_object); } else { diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index d399a59..cd3a3f4 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -752,7 +752,7 @@ class ChainStore { witnessArr.push(w[i][1]); // ids only } - this.witnesses = this.witnesses.set(witnessArr); + this.witnesses = this.witnesses.merge(witnessArr); let witnesses_object = this._updateObject(witnessArr, true); resolve(witnesses_object); } else { From 92c367adfd8d9ef0c6be900d32efc104c36582a9 Mon Sep 17 00:00:00 2001 From: mseaward Date: Mon, 4 Feb 2019 10:17:51 -0400 Subject: [PATCH 14/15] Change witnesses to Immutable Set instead of a Map --- dist/chain/src/ChainStore.js | 2 +- lib/chain/src/ChainStore.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js index 870f2c5..58a11bd 100644 --- a/dist/chain/src/ChainStore.js +++ b/dist/chain/src/ChainStore.js @@ -97,7 +97,7 @@ var ChainStore = function () { this.get_account_refs_of_keys_calls = Immutable.Set(); this.account_history_requests = new Map(); ///< tracks pending history requests this.witness_by_account_id = new Map(); - this.witnesses = new Map(); + this.witnesses = Immutable.Set(); this.account_by_witness_id = new Map(); this.committee_by_account_id = new Map(); this.objects_by_vote_id = new Map(); diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index cd3a3f4..f6bc7f1 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -76,7 +76,7 @@ class ChainStore { this.get_account_refs_of_keys_calls = Immutable.Set(); this.account_history_requests = new Map(); ///< tracks pending history requests this.witness_by_account_id = new Map(); - this.witnesses = new Map(); + this.witnesses = Immutable.Set(); this.account_by_witness_id = new Map(); this.committee_by_account_id = new Map(); this.objects_by_vote_id = new Map(); From e3e296a5e689031cf98a96466901d4666acd2e7e Mon Sep 17 00:00:00 2001 From: mseaward Date: Mon, 4 Feb 2019 10:25:00 -0400 Subject: [PATCH 15/15] Update object updating after retrieving the list of all witnesses. --- dist/chain/src/ChainStore.js | 4 ++-- lib/chain/src/ChainStore.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dist/chain/src/ChainStore.js b/dist/chain/src/ChainStore.js index 58a11bd..7cd3a6e 100644 --- a/dist/chain/src/ChainStore.js +++ b/dist/chain/src/ChainStore.js @@ -825,8 +825,8 @@ var ChainStore = function () { } _this13.witnesses = _this13.witnesses.merge(witnessArr); - var witnesses_object = _this13._updateObject(witnessArr, true); - resolve(witnesses_object); + _this13._updateObject(witnessArr, true); + resolve(_this13.witnesses); } else { resolve(null); } diff --git a/lib/chain/src/ChainStore.js b/lib/chain/src/ChainStore.js index f6bc7f1..7a21360 100644 --- a/lib/chain/src/ChainStore.js +++ b/lib/chain/src/ChainStore.js @@ -753,8 +753,8 @@ class ChainStore { } this.witnesses = this.witnesses.merge(witnessArr); - let witnesses_object = this._updateObject(witnessArr, true); - resolve(witnesses_object); + this._updateObject(witnessArr, true); + resolve(this.witnesses); } else { resolve(null); }