From 5c81669478a5bd557c30633fc53cbc05cc1e2601 Mon Sep 17 00:00:00 2001 From: Chris Troutner Date: Tue, 21 May 2019 07:42:39 -0700 Subject: [PATCH] Forked from rest.bitcoin.com commit 50f5c6ed1bd8d10b72bb8851972446240604eee6 5-3-2019 --- .editorconfig | 30 + .eslintrc.json | 54 + .gitignore | 12 + .npmrc | 1 + .travis.yml | 27 + LICENSE | 21 + README.md | 133 + dist/app.js | 234 + dist/middleware/auth.js | 78 + dist/middleware/route-ratelimit.js | 81 + dist/public/bitcoin-com-mainnet-rest-v2.json | 3099 +++ dist/public/bitcoin-com-rest-v1.json | 4181 +++ dist/public/bitcoin-com-testnet-rest-v2.json | 3099 +++ dist/public/favicon.png | Bin 0 -> 4385 bytes dist/public/logo.png | Bin 0 -> 4900 bytes dist/public/swagger-ui-bundle.js | 16468 ++++++++++++ dist/public/swagger-ui-standalone-preset.js | 5524 ++++ dist/public/swagger-ui-v2.css | 1726 ++ dist/public/swagger-ui.css | 3 + dist/util/winston-logging.js | 45 + dist/views/swagger-v2.jade | 64 + dist/views/swagger.jade | 57 + gulpfile.js | 261 + package-lock.json | 22248 ++++++++++++++++ package.json | 98 + src/app.ts | 302 + src/middleware/auth.js | 101 + src/middleware/route-ratelimit.ts | 113 + src/public/bitcoin-com-rest-v1.json | 4181 +++ src/public/favicon.png | Bin 0 -> 4385 bytes src/public/logo.png | Bin 0 -> 4900 bytes src/public/swagger-ui-bundle.js | 93 + src/public/swagger-ui-standalone-preset.js | 13 + src/public/swagger-ui-v2.css | 1726 ++ src/public/swagger-ui.css | 3 + src/routes/v1/address.js | 318 + src/routes/v1/block.js | 90 + src/routes/v1/blockchain.js | 721 + src/routes/v1/control.js | 106 + src/routes/v1/dataRetrieval.js | 529 + src/routes/v1/generating.js | 75 + src/routes/v1/health-check.js | 27 + src/routes/v1/index.js | 35 + src/routes/v1/mining.js | 145 + src/routes/v1/network.js | 202 + src/routes/v1/payloadCreation.js | 480 + src/routes/v1/rawtransactions.js | 511 + src/routes/v1/slp.js | 213 + src/routes/v1/transaction.js | 93 + src/routes/v1/util.js | 70 + src/routes/v2/address.ts | 869 + src/routes/v2/block.ts | 300 + src/routes/v2/blockchain.ts | 958 + src/routes/v2/control.ts | 98 + src/routes/v2/generating.js | 51 + src/routes/v2/health-check.js | 11 + src/routes/v2/index.js | 15 + src/routes/v2/interfaces/IRequestConfig.ts | 13 + src/routes/v2/interfaces/IResponse.ts | 6 + src/routes/v2/logging.js | 51 + src/routes/v2/mining.ts | 182 + src/routes/v2/network.ts | 175 + src/routes/v2/rawtransactions.ts | 646 + src/routes/v2/route-utils.js | 139 + src/routes/v2/services/bitbox.ts | 7 + src/routes/v2/services/requestUtils.ts | 25 + src/routes/v2/slp.ts | 1455 + src/routes/v2/transaction.ts | 200 + src/routes/v2/util.ts | 190 + src/util/winston-logging.js | 56 + src/views/swagger-v2.jade | 64 + src/views/swagger.jade | 57 + swaggerJSONFiles/components.json | 1097 + .../fixtures/mainnet/components.json | 76 + swaggerJSONFiles/fixtures/mainnet/info.json | 6 + swaggerJSONFiles/fixtures/mainnet/paths.json | 152 + .../fixtures/testnet/components.json | 76 + swaggerJSONFiles/fixtures/testnet/info.json | 6 + swaggerJSONFiles/fixtures/testnet/paths.json | 152 + swaggerJSONFiles/info.json | 12 + swaggerJSONFiles/paths.json | 1791 ++ swaggerJSONFiles/servers.json | 7 + swaggerJSONFiles/tags.json | 68 + swaggerJSONFilesBuilt/mainnet/components.json | 1115 + swaggerJSONFilesBuilt/mainnet/info.json | 12 + swaggerJSONFilesBuilt/mainnet/paths.json | 1905 ++ swaggerJSONFilesBuilt/mainnet/servers.json | 7 + swaggerJSONFilesBuilt/mainnet/tags.json | 68 + swaggerJSONFilesBuilt/testnet/components.json | 1115 + swaggerJSONFilesBuilt/testnet/info.json | 12 + swaggerJSONFilesBuilt/testnet/paths.json | 1905 ++ swaggerJSONFilesBuilt/testnet/servers.json | 7 + swaggerJSONFilesBuilt/testnet/tags.json | 68 + test/v1/RawTransactions.js | 287 + test/v1/address.js | 203 + test/v1/block.js | 101 + test/v1/blockchain.js | 593 + test/v1/control.js | 64 + test/v1/dataRetrieval.js | 485 + test/v1/generating.js | 44 + test/v1/health-check.js | 24 + test/v1/mining.js | 114 + test/v1/network.js | 120 + test/v1/payloadCreation.js | 308 + test/v1/slp.js | 191 + test/v1/transaction.js | 96 + test/v1/util.js | 53 + test/v2/address.js | 1373 + test/v2/block.js | 610 + test/v2/blockchain.js | 1148 + test/v2/control.js | 140 + test/v2/e2e/address.js | 60 + test/v2/helpers/panda.js | 29 + test/v2/integration/README.md | 7 + test/v2/integration/rate-limits.js | 94 + test/v2/integration/raw-transactions.js | 191 + test/v2/mining.js | 176 + test/v2/mocks/address-mock.js | 160 + test/v2/mocks/block-mock.js | 42 + test/v2/mocks/blockchain-mock.js | 271 + test/v2/mocks/control-mock.js | 27 + test/v2/mocks/express-mocks.js | 88 + test/v2/mocks/mining-mocks.js | 22 + test/v2/mocks/raw-transactions-mocks.js | 157 + test/v2/mocks/slp-mocks.js | 327 + test/v2/mocks/slpjs-mocks.js | 71 + test/v2/mocks/transaction-mocks.js | 74 + test/v2/mocks/util-mocks.js | 18 + test/v2/rate-limits.js | 164 + test/v2/raw-transactions.js | 807 + test/v2/slp.js | 971 + test/v2/transaction.js | 333 + test/v2/util.js | 300 + tsconfig.json | 15 + 134 files changed, 93274 insertions(+) create mode 100644 .editorconfig create mode 100644 .eslintrc.json create mode 100644 .gitignore create mode 100644 .npmrc create mode 100644 .travis.yml create mode 100644 LICENSE create mode 100644 README.md create mode 100644 dist/app.js create mode 100644 dist/middleware/auth.js create mode 100644 dist/middleware/route-ratelimit.js create mode 100644 dist/public/bitcoin-com-mainnet-rest-v2.json create mode 100644 dist/public/bitcoin-com-rest-v1.json create mode 100644 dist/public/bitcoin-com-testnet-rest-v2.json create mode 100644 dist/public/favicon.png create mode 100755 dist/public/logo.png create mode 100644 dist/public/swagger-ui-bundle.js create mode 100644 dist/public/swagger-ui-standalone-preset.js create mode 100644 dist/public/swagger-ui-v2.css create mode 100644 dist/public/swagger-ui.css create mode 100644 dist/util/winston-logging.js create mode 100644 dist/views/swagger-v2.jade create mode 100644 dist/views/swagger.jade create mode 100644 gulpfile.js create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 src/app.ts create mode 100644 src/middleware/auth.js create mode 100644 src/middleware/route-ratelimit.ts create mode 100644 src/public/bitcoin-com-rest-v1.json create mode 100644 src/public/favicon.png create mode 100755 src/public/logo.png create mode 100644 src/public/swagger-ui-bundle.js create mode 100644 src/public/swagger-ui-standalone-preset.js create mode 100644 src/public/swagger-ui-v2.css create mode 100644 src/public/swagger-ui.css create mode 100644 src/routes/v1/address.js create mode 100644 src/routes/v1/block.js create mode 100644 src/routes/v1/blockchain.js create mode 100644 src/routes/v1/control.js create mode 100644 src/routes/v1/dataRetrieval.js create mode 100644 src/routes/v1/generating.js create mode 100644 src/routes/v1/health-check.js create mode 100644 src/routes/v1/index.js create mode 100644 src/routes/v1/mining.js create mode 100644 src/routes/v1/network.js create mode 100644 src/routes/v1/payloadCreation.js create mode 100644 src/routes/v1/rawtransactions.js create mode 100644 src/routes/v1/slp.js create mode 100644 src/routes/v1/transaction.js create mode 100644 src/routes/v1/util.js create mode 100644 src/routes/v2/address.ts create mode 100644 src/routes/v2/block.ts create mode 100644 src/routes/v2/blockchain.ts create mode 100644 src/routes/v2/control.ts create mode 100644 src/routes/v2/generating.js create mode 100644 src/routes/v2/health-check.js create mode 100644 src/routes/v2/index.js create mode 100644 src/routes/v2/interfaces/IRequestConfig.ts create mode 100644 src/routes/v2/interfaces/IResponse.ts create mode 100644 src/routes/v2/logging.js create mode 100644 src/routes/v2/mining.ts create mode 100644 src/routes/v2/network.ts create mode 100644 src/routes/v2/rawtransactions.ts create mode 100644 src/routes/v2/route-utils.js create mode 100644 src/routes/v2/services/bitbox.ts create mode 100644 src/routes/v2/services/requestUtils.ts create mode 100644 src/routes/v2/slp.ts create mode 100644 src/routes/v2/transaction.ts create mode 100644 src/routes/v2/util.ts create mode 100644 src/util/winston-logging.js create mode 100644 src/views/swagger-v2.jade create mode 100644 src/views/swagger.jade create mode 100644 swaggerJSONFiles/components.json create mode 100644 swaggerJSONFiles/fixtures/mainnet/components.json create mode 100644 swaggerJSONFiles/fixtures/mainnet/info.json create mode 100644 swaggerJSONFiles/fixtures/mainnet/paths.json create mode 100644 swaggerJSONFiles/fixtures/testnet/components.json create mode 100644 swaggerJSONFiles/fixtures/testnet/info.json create mode 100644 swaggerJSONFiles/fixtures/testnet/paths.json create mode 100644 swaggerJSONFiles/info.json create mode 100644 swaggerJSONFiles/paths.json create mode 100644 swaggerJSONFiles/servers.json create mode 100644 swaggerJSONFiles/tags.json create mode 100644 swaggerJSONFilesBuilt/mainnet/components.json create mode 100644 swaggerJSONFilesBuilt/mainnet/info.json create mode 100644 swaggerJSONFilesBuilt/mainnet/paths.json create mode 100644 swaggerJSONFilesBuilt/mainnet/servers.json create mode 100644 swaggerJSONFilesBuilt/mainnet/tags.json create mode 100644 swaggerJSONFilesBuilt/testnet/components.json create mode 100644 swaggerJSONFilesBuilt/testnet/info.json create mode 100644 swaggerJSONFilesBuilt/testnet/paths.json create mode 100644 swaggerJSONFilesBuilt/testnet/servers.json create mode 100644 swaggerJSONFilesBuilt/testnet/tags.json create mode 100644 test/v1/RawTransactions.js create mode 100644 test/v1/address.js create mode 100644 test/v1/block.js create mode 100644 test/v1/blockchain.js create mode 100644 test/v1/control.js create mode 100644 test/v1/dataRetrieval.js create mode 100644 test/v1/generating.js create mode 100644 test/v1/health-check.js create mode 100644 test/v1/mining.js create mode 100644 test/v1/network.js create mode 100644 test/v1/payloadCreation.js create mode 100644 test/v1/slp.js create mode 100644 test/v1/transaction.js create mode 100644 test/v1/util.js create mode 100644 test/v2/address.js create mode 100644 test/v2/block.js create mode 100644 test/v2/blockchain.js create mode 100644 test/v2/control.js create mode 100644 test/v2/e2e/address.js create mode 100644 test/v2/helpers/panda.js create mode 100644 test/v2/integration/README.md create mode 100644 test/v2/integration/rate-limits.js create mode 100644 test/v2/integration/raw-transactions.js create mode 100644 test/v2/mining.js create mode 100644 test/v2/mocks/address-mock.js create mode 100644 test/v2/mocks/block-mock.js create mode 100644 test/v2/mocks/blockchain-mock.js create mode 100644 test/v2/mocks/control-mock.js create mode 100644 test/v2/mocks/express-mocks.js create mode 100644 test/v2/mocks/mining-mocks.js create mode 100644 test/v2/mocks/raw-transactions-mocks.js create mode 100644 test/v2/mocks/slp-mocks.js create mode 100644 test/v2/mocks/slpjs-mocks.js create mode 100644 test/v2/mocks/transaction-mocks.js create mode 100644 test/v2/mocks/util-mocks.js create mode 100644 test/v2/rate-limits.js create mode 100644 test/v2/raw-transactions.js create mode 100644 test/v2/slp.js create mode 100644 test/v2/transaction.js create mode 100644 test/v2/util.js create mode 100644 tsconfig.json diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..90913b4 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,30 @@ +# http://editorconfig.org + +# A special property that should be specified at the top of the file outside of +# any sections. Set to true to stop .editor config file search on current file +root = true + +[*] +# Indentation style +# Possible values - tab, space +indent_style = space + +# Indentation size in single-spaced characters +# Possible values - an integer, tab +indent_size = 2 + +# Line ending file format +# Possible values - lf, crlf, cr +end_of_line = lf + +# File character encoding +# Possible values - latin1, utf-8, utf-16be, utf-16le +charset = utf-8 + +# Denotes whether to trim whitespace at the end of lines +# Possible values - true, false +trim_trailing_whitespace = true + +# Denotes whether file should end with a newline +# Possible values - true, false +insert_final_newline = true diff --git a/.eslintrc.json b/.eslintrc.json new file mode 100644 index 0000000..f2e6532 --- /dev/null +++ b/.eslintrc.json @@ -0,0 +1,54 @@ +{ + "root": true, + "parserOptions": { + "ecmaVersion": 2018 + }, + "plugins": ["prettier"], + "rules": { + "no-debugger": ["warn"], + "no-regex-spaces": ["error"], + "no-unsafe-negation": ["error"], + "curly": ["error", "multi-or-nest", "consistent"], + "dot-location": ["error", "property"], + "dot-notation": ["error"], + "eqeqeq": ["error", "smart"], + "no-else-return": ["error"], + "no-extra-bind": ["error"], + "no-extra-label": ["error"], + "no-floating-decimal": ["error"], + "no-implicit-coercion": ["error", { "allow": ["!!"] }], + "wrap-iife": ["error", "inside"], + "strict": ["error", "global"], + "func-call-spacing": ["error", "never"], + "comma-style": ["error", "last"], + "keyword-spacing": ["error"], + "linebreak-style": ["error", "unix"], + "new-parens": ["error"], + "no-lonely-if": ["error"], + "no-multiple-empty-lines": ["error", { "max": 2, "maxEOF": 1 }], + "no-whitespace-before-property": ["error"], + "semi": ["error", "never"], + "arrow-body-style": ["error", "as-needed"], + "arrow-parens": ["error", "as-needed"], + "arrow-spacing": ["error"], + "no-useless-computed-key": ["error"], + "no-useless-rename": ["error"], + "no-var": ["off"], + "prefer-spread": ["error"], + "prefer-template": ["error"], + "rest-spread-spacing": ["error", "never"], + "prefer-const": ["warn", { "destructuring": "all" }], + "no-unreachable": ["warn"], + "no-unused-vars": ["off"], + + "prettier/prettier": [ + "warn", + { + "printWidth": 80, + "trailingComma": "none", + "singleQuote": false, + "semi": false + } + ] + } +} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1ab1b59 --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +node_modules/ +.nyc_output/* +.env +start-local-server +test-local-server +coverage +start-my-infra +dist/routes/** +test-v1 +nohup.out +slp-tx-db/ +logs/ diff --git a/.npmrc b/.npmrc new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/.npmrc @@ -0,0 +1 @@ + diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..7706fc3 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,27 @@ +language: node_js + +node_js: + - "10" + +dist: trusty + +sudo: required + +services: + - docker + +script: "npm run test" + +after_success: + - npm run coverage + +notifications: + slack: + secure: OUK3/iI5CNePVCmOKjcrUiqCDHClew81paGXPo/E4KCYJYDLURZFzPmG70aRxEWJwilN0frmcKmdVqLWt1+yTR1DBjJQr0MT2aOmt/STUb9sRmVs49kHpwh9uAzmAKNp71YW+vkunVv9yfys+N+F8I3ky5DSRtRGA0tiqC9TQo7wM5c/LvZqVloPwhbx0435OUg6hNQJYIJ1bJi8gR33kRq9rH6QlHIPcrzhDugQhIweDZxevHIXNrAtA2alrWC0DMu5CSHWkDrNH9iJ5b7PMl9uA6/TJdeM4lt3NaTBp9oNTr+gORSx9OXatAudqdKwZ6GSj8Gc3CxWpNSgrV7SZ7Z4VCiuYsZB3sMZE+qsLiFqR65MvvSWZrdljQ9hvoAr435JTdXUJjgVenDM++MUZ2R1l2X9MT7rJ6SKJo+ZH4pHQ+rIYzQUv4dO4Ym+lVXaxGC9+yykebctq20e4uQnbX368LpWU+ReRo7AEzz050hKlpl81gEfL9/3vJSHXZsDU2id0f0U/Ce409xtjLf7oOQcs5cDxD77iYJeGvwcmDKgQBZQnzyYQIamozZOdTAeWV5HyIGgdmyn5LBOMaNhqL9ZSCEwj50dsqehqKEafmDtr+scNs+R1x80RrQSu/COZg/Pjo35SFjmTahPWqo2xeNDLUNlGxS1ANBBy6LYZnc= + +deploy: + provider: script + skip_cleanup: true + script: + - npx semantic-release + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..4d6a2eb --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 EARTH + +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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..a590180 --- /dev/null +++ b/README.md @@ -0,0 +1,133 @@ +[![Coverage Status](https://coveralls.io/repos/github/Bitcoin-com/rest.bitcoin.com/badge.svg?branch=ct-coveralls)](https://coveralls.io/github/Bitcoin-com/rest.bitcoin.com?branch=ct-coveralls) + +## REST + +[rest.bitcoin.com](https://rest.bitcoin.com) is the REST layer for Bitcoin.com's Cloud. + +More info: [developer.bitcoin.com](https://developer.bitcoin.com). Chatroom [http://geni.us/CashDev](geni.us/CashDev) + +Testnet available at [trest.bitcoin.com](https://trest.bitcoin.com) + +## Usage + +You can also run an instance of REST for your own full node. + +### Prerequisites + +#### NodeJS + +Install nodejs's LTS. 8.11.4 at the time of writing. + +https://nodejs.org/en/ + +#### build-essential package + +If you encounter + +``` +gyp ERR! build error +gyp ERR! stack Error: not found: make +``` + +For Ubuntu + +``` +sudo apt-get install build-essential +``` + +For CENTOS + +``` +RUN yum install -y make gcc* +``` + +### Full node + +Fire up a full Bitcoin Cash node and add the following to your `bitcoin.conf`. + +``` +# Accept command line and JSON-RPC commands. +server=1 + +# Username for JSON-RPC connections +rpcuser=rpcUsername + +# Password for JSON-RPC connections +rpcpassword=rpcPasssword + +# If you're running REST on a different host than bitcoind's localhost +# rpcallowip=* +# Or you can restrict by IP or range of IPs +# rpcallowip=192.168.1.* + +# Enable zeromq for real-time data +zmqpubrawtx=tcp://your.nodes.ip.address:28332 +zmqpubrawblock=tcp://your.nodes.ip.address:28332 +zmqpubhashtx=tcp://your.nodes.ip.address:28332 +zmqpubhashblock=tcp://your.nodes.ip.address:28332 +``` + +Also allow tcp requests on port `28332` + +``` +sudo ufw allow 28332 +``` + +### Clone the repo + +Next clone the rest.bitcoin.com repo. + +``` +git clone https://github.com/Bitcoin-com/rest.bitcoin.com.git +``` + +#### Install dependencies + +`cd` into the newly cloned directory and install the dependencies. + +``` +cd rest.bitcoin.com +npm install +``` + +#### Build REST + +```bash +npm run build +``` + +#### Start REST + +Now you need to start REST and pass in the following environment variables + +- BITCOINCOM_BASEURL - On rest.bitcoin.com this env var is to our internal insight API. You can use insight's public API. +- RPC_BASEURL - The IP address of your full BCH node +- RPC_PASSWORD - The rpc password of your full BCH node +- RPC_USERNAME - The rpc username of your full BCH node +- ZEROMQ_PORT - The port on which you enabled ZeroMQ +- ZEROMQ_URL - The IP address of your full BCH node +- NETWORK - mainnet or testnet depending on which network you're using +- BITDB_URL - mainnet or testnet BITDB URL +- SLPDB_URL - mainnet or testnet SLPDB URL +- RATE_LIMIT_MAX_REQUESTS (optional) - Rate limit per route per minute. Defaults to 60. Set to 0 to disable rate limit. +- NON_JS_FRAMEWORK (optional) - enables endpoints to create, mint, send, burn and burnAll SLP tokens + +Here's how the final command would look + +``` +BITCOINCOM_BASEURL=https://bch-insight.bitpay.com/api/ RPC_BASEURL=http://your.nodes.ip.address:8332/ RPC_PASSWORD=rpcPasssword RPC_USERNAME=rpcUsername ZEROMQ_PORT=28332 ZEROMQ_URL=your.nodes.ip.address BITDB_URL=https://bitdb.bitcoin.com/ SLPDB_URL=https://slpdb.bitcoin.com/ NETWORK=mainnet npm run dev +``` + +Starting in the regtest mode (partly working since the bitcoincom_baseurl does not work with local nodes): + +```bash +PORT=3000 BITCOINCOM_BASEURL=http://localhost:3000/api/ RPC_BASEURL=http://localhost:18332/ RPC_PASSWORD=regtest RPC_USERNAME=regtest ZEROMQ_PORT=0 ZEROMQ_URL=0 NETWORK=local npm start +``` + +#### View in browser + +Finally open `http://localhost:3000/` and confirm you see the GUI + +[![Greenkeeper badge](https://badges.greenkeeper.io/Bitcoin.com/rest.bitcoin.com.svg)](https://greenkeeper.io/) + +deploy diff --git a/dist/app.js b/dist/app.js new file mode 100644 index 0000000..bf5d694 --- /dev/null +++ b/dist/app.js @@ -0,0 +1,234 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var express = require("express"); +// Middleware +var route_ratelimit_1 = require("./middleware/route-ratelimit"); +var path = require("path"); +var logger = require("morgan"); +var wlogger = require("./util/winston-logging"); +var cookieParser = require("cookie-parser"); +var bodyParser = require("body-parser"); +var basicAuth = require("express-basic-auth"); +var helmet = require("helmet"); +var debug = require("debug")("rest-cloud:server"); +var http = require("http"); +var cors = require("cors"); +var AuthMW = require("./middleware/auth"); +var BitcoinCashZMQDecoder = require("bitcoincash-zmq-decoder"); +var zmq = require("zeromq"); +var sock = zmq.socket("sub"); +var swStats = require("swagger-stats"); +var apiSpec; +if (process.env.NETWORK === "mainnet") { + apiSpec = require("./public/bitcoin-com-mainnet-rest-v2.json"); +} +else { + apiSpec = require("./public/bitcoin-com-testnet-rest-v2.json"); +} +// v1 +var indexV1 = require("./routes/v1/index"); +var healthCheckV1 = require("./routes/v1/health-check"); +var addressV1 = require("./routes/v1/address"); +var blockV1 = require("./routes/v1/block"); +var blockchainV1 = require("./routes/v1/blockchain"); +var controlV1 = require("./routes/v1/control"); +var generatingV1 = require("./routes/v1/generating"); +var miningV1 = require("./routes/v1/mining"); +var networkV1 = require("./routes/v1/network"); +var rawtransactionsV1 = require("./routes/v1/rawtransactions"); +var transactionV1 = require("./routes/v1/transaction"); +var utilV1 = require("./routes/v1/util"); +var dataRetrievalV1 = require("./routes/v1/dataRetrieval"); +var payloadCreationV1 = require("./routes/v1/payloadCreation"); +var slpV1 = require("./routes/v1/slp"); +// v2 +var indexV2 = require("./routes/v2/index"); +var healthCheckV2 = require("./routes/v2/health-check"); +var addressV2 = require("./routes/v2/address"); +var blockV2 = require("./routes/v2/block"); +var blockchainV2 = require("./routes/v2/blockchain"); +var controlV2 = require("./routes/v2/control"); +var generatingV2 = require("./routes/v2/generating"); +var miningV2 = require("./routes/v2/mining"); +var networkV2 = require("./routes/v2/network"); +var rawtransactionsV2 = require("./routes/v2/rawtransactions"); +var transactionV2 = require("./routes/v2/transaction"); +var utilV2 = require("./routes/v2/util"); +var slpV2 = require("./routes/v2/slp"); +require("dotenv").config(); +var app = express(); +app.locals.env = process.env; +app.use(swStats.getMiddleware({ swaggerSpec: apiSpec })); +app.use(helmet()); +app.use(cors()); +app.enable("trust proxy"); +// view engine setup +app.set("views", path.join(__dirname, "views")); +app.set("view engine", "jade"); +app.use("/public", express.static(__dirname + "/public")); +app.use(logger("dev")); +app.use(bodyParser.json()); +app.use(bodyParser.urlencoded({ extended: false })); +app.use(cookieParser()); +app.use(express.static(path.join(__dirname, "public"))); +// Make io accessible to our router +app.use(function (req, res, next) { + req.io = io; + next(); +}); +var v1prefix = "v1"; +var v2prefix = "v2"; +app.use("/", indexV1); +app.use("/" + v1prefix + "/" + "health-check", healthCheckV1); +app.use("/" + v1prefix + "/" + "address", addressV1); +app.use("/" + v1prefix + "/" + "blockchain", blockchainV1); +app.use("/" + v1prefix + "/" + "block", blockV1); +app.use("/" + v1prefix + "/" + "control", controlV1); +app.use("/" + v1prefix + "/" + "generating", generatingV1); +app.use("/" + v1prefix + "/" + "mining", miningV1); +app.use("/" + v1prefix + "/" + "network", networkV1); +app.use("/" + v1prefix + "/" + "rawtransactions", rawtransactionsV1); +app.use("/" + v1prefix + "/" + "transaction", transactionV1); +app.use("/" + v1prefix + "/" + "util", utilV1); +app.use("/" + v1prefix + "/" + "dataRetrieval", dataRetrievalV1); +app.use("/" + v1prefix + "/" + "payloadCreation", payloadCreationV1); +app.use("/" + v1prefix + "/" + "slp", slpV1); +// Instantiate the authorization middleware, used to implement pro-tier rate limiting. +var auth = new AuthMW(); +app.use("/" + v2prefix + "/", auth.mw()); +// Rate limit on all v2 routes +app.use("/" + v2prefix + "/", route_ratelimit_1.routeRateLimit); +app.use("/", indexV2); +app.use("/" + v2prefix + "/" + "health-check", healthCheckV2); +app.use("/" + v2prefix + "/" + "address", addressV2.router); +app.use("/" + v2prefix + "/" + "blockchain", blockchainV2.router); +app.use("/" + v2prefix + "/" + "block", blockV2.router); +app.use("/" + v2prefix + "/" + "control", controlV2.router); +app.use("/" + v2prefix + "/" + "generating", generatingV2); +app.use("/" + v2prefix + "/" + "mining", miningV2.router); +app.use("/" + v2prefix + "/" + "network", networkV2); +app.use("/" + v2prefix + "/" + "rawtransactions", rawtransactionsV2.router); +app.use("/" + v2prefix + "/" + "transaction", transactionV2.router); +app.use("/" + v2prefix + "/" + "util", utilV2.router); +app.use("/" + v2prefix + "/" + "slp", slpV2.router); +// catch 404 and forward to error handler +app.use(function (req, res, next) { + var err = { + message: "Not Found", + status: 404 + }; + next(err); +}); +// error handler +app.use(function (err, req, res, next) { + var status = err.status || 500; + // set locals, only providing error in development + res.locals.message = err.message; + res.locals.error = req.app.get("env") === "development" ? err : {}; + // render the error page + res.status(status); + res.json({ + status: status, + message: err.message + }); +}); +/** + * Get port from environment and store in Express. + */ +var port = normalizePort(process.env.PORT || "3000"); +app.set("port", port); +console.log("rest.bitcoin.com started on port " + port); +/** + * Create HTTP server. + */ +var server = http.createServer(app); +var io = require("socket.io").listen(server); +io.on("connection", function (socket) { + console.log("Socket Connected"); + socket.on("disconnect", function () { + console.log("Socket Disconnected"); + }); +}); +/** + * Setup ZMQ connections if ZMQ URL and port provided + */ +if (process.env.ZEROMQ_URL && process.env.ZEROMQ_PORT) { + console.log("Connecting to BCH ZMQ at " + process.env.ZEROMQ_URL + ":" + process.env.ZEROMQ_PORT); + var bitcoincashZmqDecoder_1 = new BitcoinCashZMQDecoder(process.env.NETWORK); + sock.connect("tcp://" + process.env.ZEROMQ_URL + ":" + process.env.ZEROMQ_PORT); + sock.subscribe("raw"); + sock.on("message", function (topic, message) { + try { + var decoded = topic.toString("ascii"); + if (decoded === "rawtx") { + var txd = bitcoincashZmqDecoder_1.decodeTransaction(message); + io.emit("transactions", JSON.stringify(txd, null, 2)); + } + else if (decoded === "rawblock") { + var blck = bitcoincashZmqDecoder_1.decodeBlock(message); + io.emit("blocks", JSON.stringify(blck, null, 2)); + } + } + catch (error) { + var errorMessage = 'Error processing ZMQ message'; + console.log(errorMessage, error); + wlogger.error(errorMessage, error); + } + }); +} +else { + console.log("ZEROMQ_URL and ZEROMQ_PORT env vars missing. Skipping ZMQ connection."); +} +/** + * Listen on provided port, on all network interfaces. + */ +server.listen(port); +server.on("error", onError); +server.on("listening", onListening); +// Set the time before a timeout error is generated. This impacts testing and +// the handling of timeout errors. Is 10 seconds too agressive? +server.setTimeout(30 * 1000); +/** + * Normalize a port into a number, string, or false. + */ +function normalizePort(val) { + var port = parseInt(val, 10); + if (isNaN(port)) { + // named pipe + return val; + } + if (port >= 0) { + // port number + return port; + } + return false; +} +/** + * Event listener for HTTP server "error" event. + */ +function onError(error) { + if (error.syscall !== "listen") + throw error; + var bind = typeof port === "string" ? "Pipe " + port : "Port " + port; + // handle specific listen errors with friendly messages + switch (error.code) { + case "EACCES": + console.error(bind + " requires elevated privileges"); + process.exit(1); + break; + case "EADDRINUSE": + console.error(bind + " is already in use"); + process.exit(1); + break; + default: + throw error; + } +} +/** + * Event listener for HTTP server "listening" event. + */ +function onListening() { + var addr = server.address(); + var bind = typeof addr === "string" ? "pipe " + addr : "port " + addr.port; + debug("Listening on " + bind); +} diff --git a/dist/middleware/auth.js b/dist/middleware/auth.js new file mode 100644 index 0000000..82e1190 --- /dev/null +++ b/dist/middleware/auth.js @@ -0,0 +1,78 @@ +/* + Handle authorization for bypassing rate limits. + + This file uses the passport npm library to check the header of each REST API + call for the prescence of a Basic authorization header: + https://en.wikipedia.org/wiki/Basic_access_authentication + + If the header is found and validated, the req.locals.proLimit Boolean value + is set and passed to the route-ratelimits.ts middleware. +*/ +"use strict"; +var passport = require("passport"); +var BasicStrategy = require("passport-http").BasicStrategy; +var AnonymousStrategy = require("passport-anonymous"); +var wlogger = require("../util/winston-logging"); +// Used for debugging and iterrogating JS objects. +var util = require("util"); +util.inspect.defaultOptions = { depth: 1 }; +var _this; +// Set default rate limit value for testing +var PRO_PASSes = process.env.PRO_PASS ? process.env.PRO_PASS : "BITBOX"; +// Convert the pro-tier password string into an array split by ':'. +var PRO_PASS = PRO_PASSes.split(":"); +//wlogger.verbose(`PRO_PASS set to: ${PRO_PASS}`) +// Auth Middleware +var AuthMW = /** @class */ (function () { + function AuthMW() { + _this = this; + // Initialize passport for 'anonymous' authentication. + /* + passport.use( + new AnonymousStrategy({ passReqToCallback: true }, function( + req, + username, + password, + done + ) { + console.log(`anonymous auth handler triggered.`) + }) + ) + */ + passport.use(new AnonymousStrategy()); + // Initialize passport for 'basic' authentication. + passport.use(new BasicStrategy({ passReqToCallback: true }, function (req, username, password, done) { + //console.log(`req: ${util.inspect(req)}`) + //console.log(`username: ${username}`) + //console.log(`password: ${password}`) + // Create the req.locals property if it does not yet exist. + if (!req.locals) + req.locals = {}; + // Set pro-tier rate limit to flag to false by default. + req.locals.proLimit = false; + // Evaluate the username and password and set the rate limit accordingly. + //if (username === "BITBOX" && password === PRO_PASS) { + if (username === "BITBOX") { + for (var i = 0; i < PRO_PASS.length; i++) { + var thisPass = PRO_PASS[i]; + if (password === thisPass) { + wlogger.verbose(req.url + " called by " + password.slice(0, 6)); + // Success + req.locals.proLimit = true; + break; + } + } + } + //console.log(`req.locals: ${util.inspect(req.locals)}`) + return done(null, true); + })); + } + // Middleware called by the route. + AuthMW.prototype.mw = function () { + return passport.authenticate(["basic", "anonymous"], { + session: false + }); + }; + return AuthMW; +}()); +module.exports = AuthMW; diff --git a/dist/middleware/route-ratelimit.js b/dist/middleware/route-ratelimit.js new file mode 100644 index 0000000..c5bab78 --- /dev/null +++ b/dist/middleware/route-ratelimit.js @@ -0,0 +1,81 @@ +"use strict"; +/* + This file controls the request-per-minute (RPM) rate limits. + + It is assumed that this middleware is run AFTER the auth.js middleware which + checks for Basic auth. If the user adds the correct Basic auth to the header + of their API request, they will get pro-tier rate limits. By default, the + freemium rate limits apply. +*/ +Object.defineProperty(exports, "__esModule", { value: true }); +var RateLimit = require("express-rate-limit"); +// Set max requests per minute +var maxRequests = process.env.RATE_LIMIT_MAX_REQUESTS + ? parseInt(process.env.RATE_LIMIT_MAX_REQUESTS) + : 60; +// Pro-tier rate limits are 10x the freemium limits. +var PRO_RPM = 10 * maxRequests; +// Unique route mapped to its rate limit +var uniqueRateLimits = {}; +var routeRateLimit = function (req, res, next) { + // Create a res.locals object if not passed in. + if (!req.locals) + req.locals = {}; + // Disable rate limiting if 0 passed from RATE_LIMIT_MAX_REQUESTS + if (maxRequests === 0) + return next(); + // Current route + var rateLimitTier = req.locals.proLimit ? "PRO" : "BASIC"; + var path = req.baseUrl + req.path; + var route = rateLimitTier + + req.method + + path + .split("/") + .slice(0, 4) + .join("/"); + // This boolean value is passed from the auth.js middleware. + var proRateLimits = req.locals.proLimit; + // Pro level rate limits + if (proRateLimits) { + // TODO: replace the console.logs with calls to our logging system. + //console.log(`applying pro-rate limits`) + // Create new RateLimit if none exists for this route + if (!uniqueRateLimits[route]) { + uniqueRateLimits[route] = new RateLimit({ + windowMs: 60 * 1000, + delayMs: 0, + max: PRO_RPM, + handler: function (req, res /*next*/) { + //console.log(`pro-tier rate-handler triggered.`) + res.status(429); // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330 + return res.json({ + error: "Too many requests. Limits are " + PRO_RPM + " requests per minute." + }); + } + }); + } + // Freemium level rate limits + } + else { + // TODO: replace the console.logs with calls to our logging system. + //console.log(`applying freemium limits`) + // Create new RateLimit if none exists for this route + if (!uniqueRateLimits[route]) { + uniqueRateLimits[route] = new RateLimit({ + windowMs: 60 * 1000, + delayMs: 0, + max: maxRequests, + handler: function (req, res /*next*/) { + //console.log(`freemium rate-handler triggered.`) + res.status(429); // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330 + return res.json({ + error: "Too many requests. Limits are " + maxRequests + " requests per minute." + }); + } + }); + } + } + // Call rate limit for this route + uniqueRateLimits[route](req, res, next); +}; +exports.routeRateLimit = routeRateLimit; diff --git a/dist/public/bitcoin-com-mainnet-rest-v2.json b/dist/public/bitcoin-com-mainnet-rest-v2.json new file mode 100644 index 0000000..dcf9ca2 --- /dev/null +++ b/dist/public/bitcoin-com-mainnet-rest-v2.json @@ -0,0 +1,3099 @@ +{ + "components": { + "schemas": { + "Address": { + "type": "string" + }, + "Hash": { + "type": "string" + }, + "Txid": { + "type": "string" + }, + "SLPConvert": { + "type": "object", + "properties": { + "addresses": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SLPConvert" + }, + "example": [] + } + } + }, + "SLPTxid": { + "type": "string" + }, + "RawTxid": { + "type": "string" + }, + "Hex": { + "type": "string" + }, + "Height": { + "type": "number" + }, + "Proof": { + "type": "string" + }, + "Addresses": { + "type": "object", + "properties": { + "addresses": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Address" + }, + "example": [ + "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "bitcoincash:qrehqueqhw629p6e57994436w730t4rzasnly00ht0" + ] + } + } + }, + "Hashes": { + "type": "object", + "properties": { + "hashes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Hash" + }, + "example": [ + "000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201", + "00000000000000000568f0a96bf4348847bc84e455cbfec389f27311037a20f3" + ] + }, + "verbose": { + "type": "boolean", + "example": true + } + } + }, + "BlockHashes": { + "type": "object", + "properties": { + "hashes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Hash" + }, + "example": [] + } + } + }, + "BlockHeights": { + "type": "object", + "properties": { + "heights": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Heights" + }, + "example": [] + } + } + }, + "Heights": { + "type": "object", + "properties": { + "heights": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Heights" + }, + "example": [] + } + } + }, + "Hexes": { + "type": "object", + "properties": { + "hexes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Hex" + }, + "example": [ + "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000", + "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000" + ] + } + } + }, + "Txids": { + "type": "object", + "properties": { + "txids": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Txid" + }, + "example": [ + "a5f972572ee1753e2fd2457dd61ce5f40fa2f8a30173d417e49feef7542c96a1", + "5165dc531aad05d1149bb0f0d9b7bda99c73e2f05e314bcfb5b4bb9ca5e1af5e" + ] + } + } + }, + "SLPListBulk": { + "type": "object", + "properties": { + "tokenIds": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SLPListBulk" + }, + "example": [] + } + } + }, + "SLPTxids": { + "type": "object", + "properties": { + "txids": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SLPTxid" + }, + "example": [ + "88b121101d71b73599dfc7d79eead599031912b2c48298bf5c1f37f4dd743ffa", + "fb0eeaa501a6e1acb721669c62a3f70741f48ae0fd7f4b8e1d72088785c51952" + ] + } + } + }, + "RawTxids": { + "type": "object", + "properties": { + "txids": { + "type": "array", + "items": { + "$ref": "#/components/schemas/RawTxid" + }, + "example": [ + "a5f972572ee1753e2fd2457dd61ce5f40fa2f8a30173d417e49feef7542c96a1", + "5165dc531aad05d1149bb0f0d9b7bda99c73e2f05e314bcfb5b4bb9ca5e1af5e" + ] + }, + "verbose": { + "type": "boolean", + "example": true + } + } + }, + "Proofs": { + "type": "object", + "properties": { + "proofs": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Proof" + }, + "example": [ + "010000007de867cc8adc5cc8fb6b898ca4462cf9fd667d7830a275277447e60800000000338f121232e169d3100edd82004dc2a1f0e1f030c6c488fa61eafa930b0528fe021f7449ffff001d36b4af9a0100000001338f121232e169d3100edd82004dc2a1f0e1f030c6c488fa61eafa930b0528fe0101", + "000000202cbe31a32f4ad5b42877a9ccf9ff6edb3f5ab29ff73ec9000000000000000000069061a8809fed6557fa87eeb5aa7ac9e6720dcb2e2f401b40b7d83be5b4cb4f20a1e95b8c8d01188ca7c098e20100000a3705adb29177f22766afb07d46eb1d3f16a68fdd01c1ede671fcb954899ffed4c161c0a33aa8f6e562e40b1e0124818663e063004720d8d7e9074808a1f16ca56ba218571cb8069bc45bc8c6496ad9611b35d412e2545211ba85438be487d6dc39cd0ae63a41be9a89c4ed823fa6eceb0ceffe13638defa01109a514e639b89e5eafe1a59cbbb4b5cf4b315ef0e2739ca9bdb7d9f0b09b14d105ad1a53dc655176895cacc3f897d5088b004113f886df266edd1ff797f4550885f32380c8fb575be00072239baa70ccf354882e8c50a1d01e81ab2c85146d9e8c3c75140eca2d9d5640af739a86047493e24b1393745914a75fdfe19f081626a5846353c67b45ccf2dd6a753ba118e89239b7916be2ee06e34dc85257228edeaaca06efa0a565580872eff1787360bdf7ff274bb49437bef6a368ab578e34b739ddcc16088a8603ad3700" + ] + } + } + }, + "AddressDetails": { + "type": "object", + "properties": { + "balance": { + "type": "number", + "format": "float" + }, + "balanceSat": { + "type": "number", + "format": "float" + }, + "totalReceived": { + "type": "number", + "format": "float" + }, + "totalReceivedSat": { + "type": "number", + "format": "float" + }, + "totalSent": { + "type": "number", + "format": "float" + }, + "totalSentSat": { + "type": "number", + "format": "float" + }, + "unconfirmedBalance": { + "type": "number", + "format": "float" + }, + "unconfirmedBalanceSat": { + "type": "number", + "format": "float" + }, + "unconfirmedTxAppearances": { + "type": "number", + "format": "float" + }, + "txAppearances": { + "type": "number" + }, + "transactions": { + "type": "array", + "items": { + "type": "string" + } + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "AddressDetailsArray": { + "type": "array", + "items": { + "$ref": "#/components/schemas/AddressDetails" + } + }, + "AddressUtxo": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Utxo" + } + }, + "AddressUtxoArray": { + "type": "array", + "items": { + "$ref": "#/components/schemas/AddressUtxo" + }, + "example": [] + }, + "Utxo": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptPubKey": { + "type": "string" + }, + "amount": { + "type": "number", + "format": "float" + }, + "satoshis": { + "type": "number" + }, + "height": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "AddressUnconfirmed": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Unconfirmed" + } + }, + "AddressUnconfirmedArray": { + "type": "array", + "items": { + "$ref": "#/components/schemas/AddressUnconfirmed" + }, + "example": [] + }, + "Unconfirmed": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptPubKey": { + "type": "string" + }, + "amount": { + "type": "number", + "format": "float" + }, + "satoshis": { + "type": "number" + }, + "height": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "BlockDetails": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "merkleroot": { + "type": "string" + }, + "tx": { + "type": "array", + "items": { + "type": "string" + } + }, + "time": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + }, + "reward": { + "type": "number", + "format": "float" + }, + "isMainChain": { + "type": "boolean" + }, + "poolInfo": { + "type": "object", + "properties": { + "poolName": "string", + "url": "string" + } + } + } + }, + "BestBlockHash": { + "type": "string" + }, + "Block": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "size": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "versionHex": { + "type": "string" + }, + "merkleroot": { + "type": "string" + }, + "tx": { + "type": "array", + "items": { + "type": "string" + } + }, + "time": { + "type": "number" + }, + "mediantime": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + } + } + }, + "BlockchainInfo": { + "type": "object", + "properties": { + "chain": { + "type": "string" + }, + "blocks": { + "type": "number" + }, + "headers": { + "type": "number" + }, + "bestblockhash": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "mediantime": { + "type": "number" + }, + "verificationprogress": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "pruned": { + "type": "boolean" + }, + "softforks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": "string", + "version": "number", + "reject": { + "type": "object", + "properties": { + "status": "boolean" + } + } + } + } + }, + "bip9_softforks": { + "type": "object", + "properties": { + "status": "string", + "startTime": "number", + "timeout": "number", + "since": "number" + } + } + } + }, + "BlockCount": { + "type": "number" + }, + "BlockHash": { + "type": "string" + }, + "BlockHeader": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "versionHex": { + "type": "string" + }, + "merkleroot": { + "type": "string" + }, + "time": { + "type": "number" + }, + "mediantime": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + } + } + }, + "Difficulty": { + "type": "number", + "format": "float" + }, + "MempoolInfo": { + "type": "object", + "properties": { + "size": { + "type": "number" + }, + "bytes": { + "type": "number" + }, + "usage": { + "type": "number" + }, + "maxmempool": { + "type": "number" + }, + "mempoolminfee": { + "type": "number" + } + } + }, + "RawMempool": { + "type": "array", + "items": { + "type": "string" + } + }, + "DecodeRawTransaction": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "version": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + } + } + }, + "sequence": { + "type": "string" + } + } + } + }, + "vout": { + "type": "array", + "items": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "reqSigs": { + "type": "number" + }, + "type": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + } + } + } + } + } + } + } + }, + "DecodeScript": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "type": { + "type": "string" + }, + "p2sh": { + "type": "string" + } + } + }, + "GetRawTransaction": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "txid": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "version": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "sequence": { + "type": "string" + } + } + } + } + } + }, + "vout": { + "type": "array", + "items": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "reqSigs": { + "type": "number" + }, + "type": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + } + } + } + } + } + }, + "blockhash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "time": { + "type": "number" + }, + "blocktime": { + "type": "number" + } + } + }, + "TransactionDetails": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "version": { + "type": "number" + }, + "locktime": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "sequence": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + }, + "value": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + } + } + } + }, + "vout": { + "type": "array", + "items": { + "objects": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + }, + "type": { + "type": "string" + } + } + }, + "spentTxId": { + "type": "string" + }, + "spentIndex": { + "type": "number" + }, + "spentHeight": { + "type": "number" + } + } + }, + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + } + } + }, + "spentTxId": { + "type": "string" + }, + "spentIndex": { + "type": "number" + }, + "spentHeight": { + "type": "number" + } + } + } + }, + "blockhash": { + "type": "string" + }, + "blockheight": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "time": { + "type": "number" + }, + "valueOut": { + "type": "number" + }, + "size": { + "type": "number" + }, + "valueIn": { + "type": "number" + }, + "fees": { + "type": "number" + } + } + }, + "ValidateAddress": { + "type": "object", + "properties": { + "isvalid": { + "type": "boolean" + }, + "address": { + "type": "string" + }, + "scriptPubKey": { + "type": "string" + }, + "ismine": { + "type": "boolean" + }, + "iswatchonly": { + "type": "boolean" + }, + "isscript": { + "type": "boolean" + } + } + }, + "Info": { + "type": "object", + "properties": { + "version": { + "type": "number" + }, + "protocolversion": { + "type": "number" + }, + "blocks": { + "type": "number" + }, + "timeoffset": { + "type": "number" + }, + "connections": { + "type": "number" + }, + "proxy": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "paytxfee": { + "type": "number" + }, + "relayfee": { + "type": "number", + "format": "float" + }, + "errors": { + "type": "string" + } + } + }, + "MemoryInfo": { + "type": "object", + "properties": { + "locked": { + "type": "object", + "properties": { + "used": { + "type": "number" + }, + "free": { + "type": "number" + }, + "total": { + "type": "number" + }, + "locked": { + "type": "number" + }, + "chunks_used": { + "type": "number" + }, + "chunks_free": { + "type": "number" + } + } + } + } + }, + "MiningInfo": { + "type": "object", + "properties": { + "blocks": { + "type": "number" + }, + "currentblocksize": { + "type": "number" + }, + "currentblocktx": { + "type": "number" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "blockprioritypercentage": { + "type": "number" + }, + "errors": { + "type": "string" + }, + "networkhashps": { + "type": "number" + }, + "pooledtx": { + "type": "number" + }, + "chain": { + "type": "string" + } + } + }, + "NetworkHashps": { + "type": "number" + }, + "ConnectionCount": { + "type": "number" + }, + "MempoolAncestors": { + "type": "array", + "items": { + "type": "string" + } + }, + "MempoolDescendants": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "openapi": "3.0.0", + "info": { + "description": "rest.bitcoin.com is the REST layer for Bitcoin.com's Cloud. More info: [developer.bitcoin.com/rest](https://developer.bitcoin.com/rest). Chatroom [geni.us/CashDev](http://geni.us/CashDev)", + "version": "3.3.8", + "title": "REST", + "license": { + "name": "MIT", + "url": "https://opensource.org/licenses/MIT" + } + }, + "paths": { + "/address/details/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Address details single", + "description": "Returns the details of an address including balance", + "operationId": "detailsSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressDetails" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/details": { + "post": { + "tags": [ + "address" + ], + "summary": "Address details bulk", + "description": "Returns the details of multiple addresses", + "operationId": "detailsBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressDetailsArray" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/utxo/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Address utxos single", + "description": "Returns the list of utxo for an address", + "operationId": "utxoSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or an array of addresses in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxo" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/utxo": { + "post": { + "tags": [ + "address" + ], + "summary": "Address utxo bulk", + "description": "Returns the utxo of multiple addresses", + "operationId": "utxoBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxoArray" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/unconfirmed/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Unconfirmed transactions for an address", + "description": "Returns the list of unconfirmed transactions for an address", + "operationId": "unconfirmedSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or an array of addresses in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUnconfirmed" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/unconfirmed": { + "post": { + "tags": [ + "address" + ], + "summary": "Unconfirmed transactions for array of addresses", + "description": "Returns the list of unconfirmed transactions for an array of addresses", + "operationId": "unconfirmedBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxoArray" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/transactions/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Transactions for an address", + "description": "Returns the list of transactions for an address", + "operationId": "transactionsSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/address/transactions": { + "post": { + "tags": [ + "address" + ], + "summary": "Transactions for an array of addresses", + "description": "Returns the list of transactions for an array of addresses", + "operationId": "transactionsBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/fromXPub/{xpub}": { + "get": { + "tags": [ + "address" + ], + "summary": "Address from extended public key and hdpath", + "description": "Returns an address for an extended public key and hdpath", + "operationId": "fromXPubSingle", + "parameters": [ + { + "name": "xpub", + "in": "path", + "description": "the extended public key", + "required": true, + "example": "xpub661MyMwAqRbcG4CnhNYoK1r1TKLwQQ1UdC3LHoWFK61rsnzh7Hx35qQ9Z53ucYcE5WvA7GEDXhqqKjSY2e6Y8n7WNVLYHpXCuuX945VPuYn", + "schema": { + "type": "string" + } + }, + { + "name": "hdPath", + "in": "query", + "description": "The HDPath. Defaults to the first BIP44 external change address", + "required": false, + "example": "", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/block/detailsByHash/{hash}": { + "get": { + "tags": [ + "block" + ], + "summary": "Block details single", + "description": "Details about a single block by hash", + "operationId": "detailsHashSingle", + "parameters": [ + { + "name": "hash", + "in": "path", + "description": "Block hash", + "required": true, + "example": "000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block hash.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block hash." + } + } + } + } + } + } + }, + "/block/detailsByHash": { + "post": { + "tags": [ + "block" + ], + "summary": "Block details bulk", + "description": "Details about multiple blocks by hashes", + "operationId": "detailsHashBulk", + "requestBody": { + "description": "Array of hashes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHashes" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block hash.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block hash." + } + } + } + } + } + } + }, + "/block/detailsByHeight/{height}": { + "get": { + "tags": [ + "block" + ], + "summary": "Block details single", + "description": "Details about a single block by height", + "operationId": "detailsHeightSingle", + "parameters": [ + { + "name": "height", + "in": "path", + "description": "Block height", + "required": true, + "example": "500000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/block/detailsByHeight": { + "post": { + "tags": [ + "block" + ], + "summary": "Block details bulk", + "description": "Bulk details about blocks by heights", + "operationId": "detailsHeightBulk", + "requestBody": { + "description": "Array of heights", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeights" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/blockchain/getBestBlockHash": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Hash of the best block in the longest blockchain.", + "description": "Returns the hash of the best (tip) block in the longest blockchain.", + "operationId": "getBestBlockHash", + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BestBlockHash" + } + } + } + } + } + } + }, + "/blockchain/getBlockchainInfo": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Info regarding blockchain processing", + "description": "Returns an object containing various state info regarding blockchain processing.", + "operationId": "getBlockchainInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockchainInfo" + } + } + } + } + } + } + }, + "/blockchain/getBlockCount": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Number of blocks in the longest blockchain.", + "description": "Returns the number of blocks in the longest blockchain.", + "operationId": "getBlockCount", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockCount" + } + } + } + } + } + } + }, + "/blockchain/getBlockHeader/{hash}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Information about blockheader hash", + "description": "If verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'. If verbose is true, returns an Object with information about blockheader hash.", + "operationId": "getBlockHeaderSingle", + "parameters": [ + { + "name": "hash", + "in": "path", + "description": "the block hash", + "required": true, + "example": "000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201", + "schema": { + "type": "string" + } + }, + { + "name": "verbose", + "in": "query", + "description": "true for a json object, false for the hex encoded data", + "required": false, + "example": true, + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeader" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getBlockHeader": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Bulk information about blockheader hash", + "description": "Bulk information about blockheader hash", + "operationId": "getBlockHeaderBulk", + "requestBody": { + "description": "Array of hashes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hashes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeader" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getChainTips": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Information about all known tips in the block tree", + "description": "Return information about all known tips in the block tree, including the main chain as well as orphaned branches.", + "operationId": "getChainTips", + "responses": { + "200": { + "description": "successful operation" + } + } + } + }, + "/blockchain/getDifficulty": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Proof-of-work difficulty", + "description": "Returns the proof-of-work difficulty as a multiple of the minimum difficulty.", + "operationId": "getDifficulty", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Difficulty" + } + } + } + } + } + } + }, + "/blockchain/getMempoolEntry/{txid}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Mempool data for transaction", + "description": "Returns mempool data for given transaction", + "operationId": "getMempoolEntrySingle", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id (must be in mempool)", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolEntry": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Mempool data for transaction", + "description": "Returns mempool data for given transaction", + "operationId": "getMempoolEntryBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Txids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolInfo": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "The active state of the TX memory pool.", + "description": "Returns details on the active state of the TX memory pool.", + "operationId": "getMempoolInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MempoolInfo" + } + } + } + } + } + } + }, + "/blockchain/getRawMempool": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "All transaction ids in memory pool.", + "description": "Returns all transaction ids in memory pool as a json array of string transaction ids.", + "operationId": "getRawMempool", + "parameters": [ + { + "name": "verbose", + "in": "query", + "description": "True for a json object, false for array of transaction ids", + "required": false, + "example": true, + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/RawMempool" + } + } + } + } + } + } + }, + "/blockchain/getTxOut/{txid}/{n}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Details about unspent transaction output.", + "description": "Returns details about an unspent transaction output.", + "operationId": "getTxOut", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + }, + { + "name": "n", + "in": "path", + "description": "vout number", + "required": true, + "example": 0, + "schema": { + "type": "number", + "default": 0 + } + }, + { + "name": "mempool", + "in": "query", + "description": "Whether to include the mempool", + "required": false, + "example": "false", + "schema": { + "type": "boolean", + "default": false + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/blockchain/getTxOutProof/{txid}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Hex-encoded proof that single txid was included.", + "description": "Returns a hex-encoded proof that 'txid' was included in a block.", + "operationId": "getTxOutProofSingle", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "a txid string", + "example": "bbda45af0ba57e28866995c67a53c225336fddd14eb3dc87f2f3500fd61c8585", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/getTxOutProof": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Hex-encoded proof that multiple txids wwere included.", + "description": "Returns a hex-encoded proof that multiple txids were included in a block.", + "operationId": "getTxOutProofBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Txids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/verifyTxOutProof/{proof}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Verify that a single proof points to a transaction in a block", + "description": "Verifies that a proof points to a transaction in a block, returning the transaction it commits to and throwing an RPC error if the block is not in our best chain", + "operationId": "verifyTxOutProofSingle", + "parameters": [ + { + "name": "proof", + "in": "path", + "description": "The hex-encoded proof generated by gettxoutproof", + "example": "010000007de867cc8adc5cc8fb6b898ca4462cf9fd667d7830a275277447e60800000000338f121232e169d3100edd82004dc2a1f0e1f030c6c488fa61eafa930b0528fe021f7449ffff001d36b4af9a0100000001338f121232e169d3100edd82004dc2a1f0e1f030c6c488fa61eafa930b0528fe0101", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/verifyTxOutProof": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Verify that bulk proofs point to transactions in a block", + "description": "Verifies that bulk proofs point to transactions in a block", + "operationId": "verifyTxOutProofBulk", + "requestBody": { + "description": "Array of proofs", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Proofs" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/control/getInfo": { + "get": { + "tags": [ + "control" + ], + "summary": "Various state info.", + "description": "Returns an object containing various state info.", + "operationId": "getInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Info" + } + } + } + } + } + } + }, + "/mining/getMiningInfo": { + "get": { + "tags": [ + "mining" + ], + "summary": "Returns a json object containing mining-related information.", + "description": "", + "operationId": "getMiningInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MiningInfo" + } + } + } + } + } + } + }, + "/mining/getNetworkHashps": { + "get": { + "tags": [ + "mining" + ], + "summary": "Estimated network hashes per second", + "description": "Returns the estimated network hashes per second based on the last n blocks. Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change. Pass in [height] to estimate the network speed at the time when a certain block was found.", + "operationId": "getNetworkHashps", + "parameters": [ + { + "in": "query", + "name": "nblocks", + "description": "the number of blocks, or -1 for blocks since last difficulty change.", + "required": false, + "example": 120, + "schema": { + "type": "number" + } + }, + { + "in": "query", + "name": "height", + "description": "to estimate at the time of the given height.", + "required": false, + "example": -1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/NetworkHashps" + } + } + } + } + } + } + }, + "/rawtransactions/decodeRawTransaction/{hex}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Return the hex encoded transaction.", + "description": "Return a JSON object representing the serialized, hex-encoded transaction.", + "operationId": "decodeRawTransactionSingle", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The transaction hex string", + "required": true, + "example": "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeRawTransaction" + } + } + } + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/decodeRawTransaction": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Return bulk hex encoded transaction.", + "description": "Return bulk hex encoded transaction.", + "operationId": "decodeRawTransactionBulk", + "requestBody": { + "description": "Array of hexes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hexes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeRawTransaction" + } + } + } + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/decodeScript/{hex}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Decode a hex-encoded script.", + "description": "Decode a hex-encoded script.", + "operationId": "decodeScriptSingle", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The hex encoded script", + "required": true, + "example": "4830450221009a51e00ec3524a7389592bc27bea4af5104a59510f5f0cfafa64bbd5c164ca2e02206c2a8bbb47eabdeed52f17d7df668d521600286406930426e3a9415fe10ed592012102e6e1423f7abde8b70bca3e78a7d030e5efabd3eb35c19302542b5fe7879c1a16", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeScript" + } + } + } + }, + "400": { + "description": "Argument must be hexadecimal string" + } + } + } + }, + "/rawtransactions/decodeScript": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Decode multiple hex-encoded scripts.", + "description": "Decode multiple hex-encoded scripts.", + "operationId": "decodeScriptBulk", + "requestBody": { + "description": "Array of hexes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hexes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/getRawTransaction/{txid}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Return the raw transaction data.", + "description": "return the raw transaction data. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.", + "operationId": "getRawTransactionSingle", + "parameters": [ + { + "in": "path", + "name": "txid", + "description": "The transaction id", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + }, + { + "in": "query", + "name": "verbose", + "description": "If false, return a string, otherwise return a json object", + "required": true, + "example": true, + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GetRawTransaction" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/getRawTransaction": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Return raw transaction data for multiple transactions.", + "description": "Return the raw transaction data for multiple transactions. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.", + "operationId": "getRawTransactionBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/RawTxids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/sendRawTransaction/{hex}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Submits single raw transactions to local node and network.", + "description": "Submits single raw transaction (serialized, hex-encoded) to local node and network.", + "operationId": "sendRawTransactionSingle", + "parameters": [ + { + "name": "hex", + "in": "path", + "description": "the raw transaction hex", + "required": true, + "example": "", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/sendRawTransaction": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Submits multiple raw transactions to local node and network.", + "description": "Submits multiple raw transaction (serialized, hex-encoded) to local node and network.", + "operationId": "sendRawTransactionBulk", + "requestBody": { + "description": "Array of raw tx hexes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hexes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/transaction/details/{txid}": { + "get": { + "tags": [ + "transaction" + ], + "summary": "Transaction details single", + "description": "Details about a single transaction", + "operationId": "transactionDetailsSingle", + "parameters": [ + { + "in": "path", + "name": "txid", + "description": "single txid or url encoded array of txids", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TransactionDetails" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/transaction/details": { + "post": { + "tags": [ + "transaction" + ], + "summary": "Transaction details bulk", + "description": "Bulk Details about a transaction", + "operationId": "transactionDetailsBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Txids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TransactionDetails" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/util/validateAddress/{address}": { + "get": { + "tags": [ + "util" + ], + "summary": "Information about single bitcoin cash address.", + "description": "Return information about single bitcoin cash address.", + "operationId": "validateAddressSingle", + "parameters": [ + { + "in": "path", + "name": "address", + "description": "The bitcoin address to validate", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidateAddress" + } + } + } + }, + "400": { + "description": "Invalid Address" + } + } + } + }, + "/util/validateAddress": { + "post": { + "tags": [ + "util" + ], + "summary": "Information about bulk bitcoin cash addresses.", + "description": "Return information about bulk bitcoin cash addresses.", + "operationId": "validateAddressBulk", + "requestBody": { + "description": "Array of Addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidateAddress" + } + } + } + }, + "400": { + "description": "Invalid Address" + } + } + } + }, + "/slp/list": { + "get": { + "tags": [ + "slp" + ], + "summary": "list", + "description": "List all SLP tokens", + "operationId": "listAll", + "responses": { + "200": { + "description": "successful response" + } + } + }, + "post": { + "tags": [ + "slp" + ], + "summary": "list token information", + "description": "List multiple SLP tokens by id", + "operationId": "listBulk", + "requestBody": { + "description": "", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SLPListBulk" + } + } + } + }, + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/list/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list token", + "description": "List single SLP token by id", + "operationId": "listSingle", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "259908ae44f46ef585edef4bcc1e50dc06e4c391ac4be929fae27235b8158cf1", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/convert/{address}": { + "get": { + "tags": [ + "slp" + ], + "summary": "convert address to slpAddr, cashAddr and legacy", + "description": "convert address to slpAddr, cashAddr and legacy", + "operationId": "convert", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/convert": { + "post": { + "tags": [ + "slp" + ], + "summary": "convert address to slpAddr, cashAddr and legacy", + "description": "convert address to slpAddr, cashAddr and legacy", + "operationId": "convertBulk", + "requestBody": { + "description": "", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SLPConvert" + } + } + } + }, + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balancesForAddress/{address}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list slp balances for address", + "description": "List SLP token balances for address", + "operationId": "balancesForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "simpleledger:qz9tzs6d5097ejpg279rg0rnlhz546q4fsnck9wh5m", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balancesForToken/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list SLP addresses and balances for tokenId", + "description": "List SLP addresses and balances for tokenId", + "operationId": "balancesForTokenSingle", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The slp tokenId", + "required": true, + "example": "df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balance/{address}/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list single slp token balance for address", + "description": "List single SLP token balance for address", + "operationId": "singleBalanceForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "simpleledger:qz9tzs6d5097ejpg279rg0rnlhz546q4fsnck9wh5m", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "1cda254d0a995c713b7955298ed246822bee487458cd9747a91d9e81d9d28125", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/validateTxid/{txid}": { + "get": { + "tags": [ + "slp" + ], + "summary": "Validate single txid", + "description": "Validate single txid", + "operationId": "validateTxidSingle", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The txid", + "required": true, + "example": "1cda254d0a995c713b7955298ed246822bee487458cd9747a91d9e81d9d28125", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/validateTxid": { + "post": { + "tags": [ + "slp" + ], + "summary": "Validate multiple txids", + "description": "Validate multiple txids", + "operationId": "validateTxidBulk", + "requestBody": { + "description": "", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SLPTxids" + } + } + } + }, + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/tokenStats/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "List stats for a single slp token", + "description": "List stats for a single slp token", + "operationId": "singleTokenStats", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/txDetails/{txid}": { + "get": { + "tags": [ + "slp" + ], + "summary": "SLP transaction details", + "description": "Transaction details on a token transfer.", + "operationId": "txDetails", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The BCH transaction ID", + "required": true, + "example": "8ab4ac5dea3f9024e3954ee5b61452955d659a34561f79ef62ac44e133d0980e", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/transactions/{tokenId}/{address}": { + "get": { + "tags": [ + "slp" + ], + "summary": "SLP transactions by tokenId and address", + "description": "Transactions by tokenId and address.", + "operationId": "txsTokenIdAddressSingle", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The BCH tokenId", + "required": true, + "example": "495322b37d6b2eae81f045eda612b95870a0c2b6069c58f70cf8ef4e6a9fd43a", + "schema": { + "type": "string" + } + }, + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "qrhvcy5xlegs858fjqf8ssl6a4f7wpstaqlsy4gusz", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + } + }, + "servers": [ + { + "url": "/v2" + } + ], + "tags": [ + { + "name": "address", + "description": "Address details and utxo", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/address" + } + }, + { + "name": "block", + "description": "Block Details", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/block" + } + }, + { + "name": "blockchain", + "description": "Interacting w/ the BCH Blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/blockchain" + } + }, + { + "name": "control", + "description": "Control your blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/control" + } + }, + { + "name": "mining", + "description": "Mining w/ the BCH Blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/mining" + } + }, + { + "name": "rawtransactions", + "description": "Create transactions to be transmitted to the network.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/rawtransactions" + } + }, + { + "name": "transaction", + "description": "Transaction details.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/rawtransactions" + } + }, + { + "name": "util", + "description": "Bitcoin Cash utilities.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/util" + } + } + ] +} \ No newline at end of file diff --git a/dist/public/bitcoin-com-rest-v1.json b/dist/public/bitcoin-com-rest-v1.json new file mode 100644 index 0000000..57397a2 --- /dev/null +++ b/dist/public/bitcoin-com-rest-v1.json @@ -0,0 +1,4181 @@ +{ + "openapi": "3.0.0", + "info": { + "description": "rest.bitcoin.com is the REST layer for Bitcoin.com's Cloud. More info: [developer.bitcoin.com](https://developer.bitcoin.com). Chatroom [geni.us/CashDev](http://geni.us/CashDev)", + "version": "1.5.10", + "title": "REST", + "license": { + "name": "MIT", + "url": "https://opensource.org/licenses/MIT" + } + }, + "tags": [ + { + "name": "address", + "description": "Address details and utxo", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/address" + } + }, + { + "name": "block", + "description": "Block Details", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/block" + } + }, + { + "name": "blockchain", + "description": "Interacting w/ the BCH Blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/blockchain" + } + }, + { + "name": "control", + "description": "Control your blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/control" + } + }, + { + "name": "mining", + "description": "Mining w/ the BCH Blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/mining" + } + }, + { + "name": "rawtransactions", + "description": "Create transactions to be transmitted to the network.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/rawtransactions" + } + }, + { + "name": "transaction", + "description": "Transaction details.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/rawtransactions" + } + }, + { + "name": "util", + "description": "Bitcoin Cash utilities.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/bitbox/docs/util" + } + }, + { + "name": "dataRetrieval", + "description": "dataRetrieval", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/wormhole/docs/dataRetrieval" + } + }, + { + "name": "payloadCreation", + "description": "payloadCreation", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/wormhole/docs/payloadCreation" + } + } + ], + "paths": { + "/address/details/{address}": { + "get": { + "tags": ["address"], + "summary": "Address details", + "description": "Returns the details of an address including balance", + "operationId": "details", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or array of addresses in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressDetails" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/utxo/{address}": { + "get": { + "tags": ["address"], + "summary": "Address utxos", + "description": "Returns the list of utxo for an address", + "operationId": "utxo", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or an array of addresses in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzstp4swtxg40rkn0j769vta3vkwyw4jj5fmdl2vtm", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxo" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/unconfirmed/{address}": { + "get": { + "tags": ["address"], + "summary": "Unconfirmed transactions for an address", + "description": "Returns the list of unconfirmed transactions for an address", + "operationId": "unconfirmed", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or an array of addresses in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUnconfirmed" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/transactions/{address}": { + "get": { + "tags": ["address"], + "summary": "Transactions for an address", + "description": "Returns the list of transactions for an address", + "operationId": "transactions", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address in cashAddr or legacy", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/block/details/{id}": { + "get": { + "tags": ["block"], + "summary": "Block details", + "description": "Details about a block", + "operationId": "blockDetails", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "Block hash/height", + "required": true, + "example": "500000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/blockchain/getBestBlockHash": { + "get": { + "tags": ["blockchain"], + "summary": "Hash of the best block in the longest blockchain.", + "description": "Returns the hash of the best (tip) block in the longest blockchain.", + "operationId": "getBestBlockHash", + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BestBlockHash" + } + } + } + } + } + } + }, + "/blockchain/getBlock/{hash}": { + "get": { + "tags": ["blockchain"], + "summary": "Information about block hash.", + "description": "If verbose is false, returns a string that is serialized, hex-encoded data for block 'hash'. If verbose is true, returns an Object with information about block hash. The list of transactions hashes can be omitted from the object by setting txs to false", + "operationId": "getBlock", + "parameters": [ + { + "name": "hash", + "in": "path", + "description": "the block hash", + "required": true, + "example": "00000000000000000046056a2d6728bc757862e7924a755125a519a2fec43c79", + "schema": { + "type": "string" + } + }, + { + "name": "verbose", + "in": "query", + "description": "true for a json object, false for the hex encoded data", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + }, + { + "name": "txs", + "in": "query", + "description": "true to return list of tx hashes, false to omit list of tx hashes", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Block" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getBlockchainInfo": { + "get": { + "tags": ["blockchain"], + "summary": "Info regarding blockchain processing", + "description": "Returns an object containing various state info regarding blockchain processing.", + "operationId": "getBlockchainInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockchainInfo" + } + } + } + } + } + } + }, + "/blockchain/getBlockCount": { + "get": { + "tags": ["blockchain"], + "summary": "Number of blocks in the longest blockchain.", + "description": "Returns the number of blocks in the longest blockchain.", + "operationId": "getBlockCount", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockCount" + } + } + } + } + } + } + }, + "/blockchain/getBlockHash/{height}": { + "get": { + "tags": ["blockchain"], + "summary": "Hash of block in best-block-chain at height provided.", + "description": "Returns hash of block in best-block-chain at height provided.", + "operationId": "getBlockHash", + "parameters": [ + { + "name": "height", + "in": "path", + "description": "the height index", + "required": true, + "example": 500000, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHash" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getBlockHeader/{hash}": { + "get": { + "tags": ["blockchain"], + "summary": "Information about blockheader hash", + "description": "If verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'. If verbose is true, returns an Object with information about blockheader hash.", + "operationId": "getBlockHeader", + "parameters": [ + { + "name": "hash", + "in": "path", + "description": "the block hash", + "required": true, + "example": "000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201", + "schema": { + "type": "string" + } + }, + { + "name": "verbose", + "in": "query", + "description": "true for a json object, false for the hex encoded data", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeader" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getChainTips": { + "get": { + "tags": ["blockchain"], + "summary": "Information about all known tips in the block tree", + "description": "Return information about all known tips in the block tree, including the main chain as well as orphaned branches.", + "operationId": "getChainTips", + "responses": { + "200": { + "description": "successful operation" + } + } + } + }, + "/blockchain/getDifficulty": { + "get": { + "tags": ["blockchain"], + "summary": "Proof-of-work difficulty", + "description": "Returns the proof-of-work difficulty as a multiple of the minimum difficulty.", + "operationId": "getDifficulty", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Difficulty" + } + } + } + } + } + } + }, + "/blockchain/getMempoolAncestors/{txid}": { + "get": { + "tags": ["blockchain"], + "summary": "Returns all in-mempool ancestors.", + "description": "If txid is in the mempool, returns all in-mempool ancestors.", + "operationId": "getMempoolAncestors", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id (must be in mempool)", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + }, + { + "name": "verbose", + "in": "query", + "description": "True for a json object, false for array of transaction ids", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MempoolAncestors" + } + } + } + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolDescendants/{txid}": { + "get": { + "tags": ["blockchain"], + "summary": "Returns all in-mempool descendants.", + "description": "If txid is in the mempool, returns all in-mempool descendants.", + "operationId": "getMempoolDescendants", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id (must be in mempool)", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + }, + { + "name": "verbose", + "in": "query", + "description": "True for a json object, false for array of transaction ids", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MempoolDescendants" + } + } + } + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolEntry/{txid}": { + "get": { + "tags": ["blockchain"], + "summary": "Mempool data for transaction", + "description": "Returns mempool data for given transaction", + "operationId": "getMempoolEntry", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id (must be in mempool)", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolInfo": { + "get": { + "tags": ["blockchain"], + "summary": "The active state of the TX memory pool.", + "description": "Returns details on the active state of the TX memory pool.", + "operationId": "getMempoolInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MempoolInfo" + } + } + } + } + } + } + }, + "/blockchain/getRawMempool": { + "get": { + "tags": ["blockchain"], + "summary": "All transaction ids in memory pool.", + "description": "Returns all transaction ids in memory pool as a json array of string transaction ids.", + "operationId": "getRawMempool", + "parameters": [ + { + "name": "verbose", + "in": "query", + "description": "True for a json object, false for array of transaction ids", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/RawMempool" + } + } + } + } + } + } + }, + "/blockchain/getTxOut/{txid}/{n}": { + "get": { + "tags": ["blockchain"], + "summary": "Details about unspent transaction output.", + "description": "Returns details about an unspent transaction output.", + "operationId": "getTxOut", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + }, + { + "name": "n", + "in": "path", + "description": "vout number", + "required": true, + "schema": { + "type": "number", + "default": 0 + } + }, + { + "name": "verbose", + "in": "query", + "description": "Whether to include the mempool", + "required": false, + "schema": { + "type": "boolean", + "default": true + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/blockchain/getTxOutProof/{txids}": { + "get": { + "tags": ["blockchain"], + "summary": "Hex-encoded proof that 'txid' was included.", + "description": "Returns a hex-encoded proof that 'txid' was included in a block.", + "operationId": "getTxOutProof", + "parameters": [ + { + "name": "txids", + "in": "path", + "description": "a json array of txids to filter [ 'txid' string A transaction hash ,... ]", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "blockhash", + "in": "query", + "description": "if specified, looks for txid in the block with this hash", + "required": false, + "schema": { + "type": "string" + } + }, + { + "name": "data", + "in": "query", + "description": "a string that is a serialized, hex-encoded data for the proof.", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/verifyTxOutProof/{proof}": { + "get": { + "tags": ["blockchain"], + "summary": "Verify that a proof points to a transaction in a block", + "description": "Verifies that a proof points to a transaction in a block, returning the transaction it commits to and throwing an RPC error if the block is not in our best chain", + "operationId": "verifyTxOutProof", + "parameters": [ + { + "name": "proof", + "in": "path", + "description": "The hex-encoded proof generated by gettxoutproof", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/control/getInfo": { + "get": { + "tags": ["control"], + "summary": "Various state info.", + "description": "Returns an object containing various state info.", + "operationId": "getInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Info" + } + } + } + } + } + } + }, + "/mining/getMiningInfo": { + "get": { + "tags": ["mining"], + "summary": "Returns a json object containing mining-related information.", + "description": "", + "operationId": "getMiningInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MiningInfo" + } + } + } + } + } + } + }, + "/mining/getNetworkHashps": { + "get": { + "tags": ["mining"], + "summary": "Estimated network hashes per second", + "description": "Returns the estimated network hashes per second based on the last n blocks. Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change. Pass in [height] to estimate the network speed at the time when a certain block was found.", + "operationId": "getNetworkHashps", + "parameters": [ + { + "in": "query", + "name": "nblocks", + "description": "the number of blocks, or -1 for blocks since last difficulty change.", + "required": false, + "schema": { + "type": "number", + "default": 120 + } + }, + { + "in": "query", + "name": "height", + "description": "to estimate at the time of the given height.", + "required": false, + "schema": { + "type": "number", + "default": 1 + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/NetworkHashps" + } + } + } + } + } + } + }, + "/rawtransactions/decodeRawTransaction/{hex}": { + "get": { + "tags": ["rawtransactions"], + "summary": "Return the hex encoded transaction.", + "description": "Return a JSON object representing the serialized, hex-encoded transaction.", + "operationId": "decodeRawTransaction", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The transaction hex string", + "required": true, + "example": "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeRawTransaction" + } + } + } + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/decodeScript/{hex}": { + "get": { + "tags": ["rawtransactions"], + "summary": "Decode a hex-encoded script.", + "description": "Decode a hex-encoded script.", + "operationId": "decodeScript", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The hex encoded script", + "required": true, + "example": "4830450221009a51e00ec3524a7389592bc27bea4af5104a59510f5f0cfafa64bbd5c164ca2e02206c2a8bbb47eabdeed52f17d7df668d521600286406930426e3a9415fe10ed592012102e6e1423f7abde8b70bca3e78a7d030e5efabd3eb35c19302542b5fe7879c1a16", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeScript" + } + } + } + }, + "400": { + "description": "Argument must be hexadecimal string" + } + } + } + }, + "/rawtransactions/getRawTransaction/{txid}": { + "get": { + "tags": ["rawtransactions"], + "summary": "Return the raw transaction data.", + "description": "return the raw transaction data. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.", + "operationId": "getRawTransaction", + "parameters": [ + { + "in": "path", + "name": "txid", + "description": "The transaction id", + "required": true, + "example": "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098", + "schema": { + "type": "string" + } + }, + { + "in": "query", + "name": "verbose", + "description": "If false, return a string, otherwise return a json object", + "required": true, + "schema": { + "type": "boolean", + "default": false + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GetRawTransaction" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/sendRawTransaction/{hex}": { + "post": { + "tags": ["rawtransactions"], + "summary": "Submits raw transaction to local node and network.", + "description": "Submits raw transaction (serialized, hex-encoded) to local node and network. Also see createrawtransaction and signrawtransaction calls.", + "operationId": "sendRawTransaction", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The hex string of the raw transaction", + "required": true, + "example": "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/transaction/details/{txid}": { + "get": { + "tags": ["transaction"], + "summary": "Transaction details", + "description": "Details about a transaction", + "operationId": "transactionDetails", + "parameters": [ + { + "in": "path", + "name": "txid", + "description": "single txid or url encoded array of txids", + "required": true, + "example": "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TransactionDetails" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/util/validateAddress/{address}": { + "get": { + "tags": ["util"], + "summary": "Information about the given bitcoin address.", + "description": "Return information about the given bitcoin address.", + "operationId": "validateAddress", + "parameters": [ + { + "in": "path", + "name": "address", + "description": "The bitcoin address to validate", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidateAddress" + } + } + } + }, + "400": { + "description": "Invalid Address" + } + } + } + }, + "/rawtransactions/create/{inputs}/{outputs}": { + "post": { + "tags": ["rawtransactions"], + "summary": "createRawTxChange", + "description": "Create a transaction spending the given inputs and creating new outputs. API Reference: https://developer.bitcoin.com/wormhole/docs/rawTransactions", + "operationId": "rawTransactionsCreate", + "parameters": [ + { + "name": "inputs", + "in": "path", + "description": "A json array of json objects", + "required": true, + "example": "[{\"txid\":\"myid\",\"vout\":0}]", + "schema": { + "type": "string" + } + }, + { + "name": "outputs", + "in": "path", + "description": "A json object with outputs", + "required": true, + "example": "{}", + "schema": { + "type": "string" + } + }, + { + "name": "locktime", + "in": "query", + "description": "Raw locktime. Non-0 value also locktime-activates inputs", + "required": false, + "example": 0, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/rawtransactions/change/{rawTx}/{prevTxs}/{destination}/{fee}": { + "post": { + "tags": ["rawtransactions"], + "summary": "createRawTxChange", + "description": "Adds a change output to the transaction.API Reference: https://developer.bitcoin.com/wormhole/docs/rawTransactions", + "operationId": "rawTransactionsChange", + "parameters": [ + { + "name": "rawTx", + "in": "path", + "description": "The raw transaction to extend", + "required": true, + "example": "0100000001b15ee60431ef57ec682790dec5a3c0d83a0c360633ea8308fbf6d5fc10a779670400000000ffffffff025c0d00000000000047512102f3e471222bb57a7d416c82bf81c627bfcd2bdc47f36e763ae69935bba4601ece21021580b888ff56feb27f17f08802ebed26258c23697d6a462d43fc13b565fda2dd52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000", + "schema": { + "type": "string" + } + }, + { + "name": "prevTxs", + "in": "path", + "description": "A JSON array of transaction inputs", + "required": true, + "example": "[{\"txid\":\"6779a710fcd5f6fb0883ea3306360c3ad8c0a3c5de902768ec57ef3104e65eb1\",\"vout\":4,\"scriptPubKey\":\"76a9147b25205fd98d462880a3e5b0541235831ae959e588ac\",\"value\":0.00068257}]", + "schema": { + "type": "string" + } + }, + { + "name": "destination", + "in": "path", + "description": "The destination for the change", + "required": true, + "example": "bchtest:qq2j9gp97gm9a6lwvhxc4zu28qvqm0x4j5e72v7ejg", + "schema": { + "type": "string" + } + }, + { + "name": "fee", + "in": "path", + "description": "The desired transaction fees", + "required": true, + "example": 0.000035, + "schema": { + "type": "number" + } + }, + { + "name": "position", + "in": "query", + "description": "The position of the change output (default: first position)", + "required": false, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/rawtransactions/input/{rawTx}/{txid}/{n}": { + "post": { + "tags": ["rawtransactions"], + "summary": "createRawTxInput", + "description": "Adds a transaction input to the transaction.API Reference: https://developer.bitcoin.com/wormhole/docs/rawTransactions", + "operationId": "rawTransactionsInput", + "parameters": [ + { + "name": "rawTx", + "in": "path", + "description": "The raw transaction to extend", + "required": true, + "example": "01000000000000000000", + "schema": { + "type": "string" + } + }, + { + "name": "txid", + "in": "path", + "description": "The hash of the input transaction", + "required": true, + "example": "b006729017df05eda586df9ad3f8ccfee5be340aadf88155b784d1fc0e8342ee", + "schema": { + "type": "string" + } + }, + { + "name": "n", + "in": "path", + "description": "The index of the transaction output used as input", + "required": true, + "example": 0, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/rawtransactions/opReturn/{rawTx}/{payload}": { + "post": { + "tags": ["rawtransactions"], + "summary": "createRawTxOpReturn", + "description": "Adds a payload with class C (op-return) encoding to the transaction.API Reference: https://developer.bitcoin.com/wormhole/docs/rawTransactions", + "operationId": "rawTransactionsOpReturn", + "parameters": [ + { + "name": "rawTx", + "in": "path", + "description": "The raw transaction to extend", + "required": true, + "example": "01000000000000000000", + "schema": { + "type": "string" + } + }, + { + "name": "payload", + "in": "path", + "description": "The hex-encoded payload to add", + "required": true, + "example": "00000000000000020000000006dac2c0", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/rawtransactions/reference/{rawTx}/{destination}": { + "post": { + "tags": ["rawtransactions"], + "summary": "createRawTxReference", + "description": "Adds a reference output to the transaction. API Reference: https://developer.bitcoin.com/wormhole/docs/rawTransactions", + "operationId": "rawTransactionsReference", + "parameters": [ + { + "name": "rawTx", + "in": "path", + "description": "The raw transaction to extend", + "required": true, + "example": "0100000001a7a9402ecd77f3c9f745793c9ec805bfa2e14b89877581c734c774864247e6f50400000000ffffffff03aa0a0000000000001976a9146d18edfe073d53f84dd491dae1379f8fb0dfe5d488ac5c0d0000000000004751210252ce4bdd3ce38b4ebbc5a6e1343608230da508ff12d23d85b58c964204c4cef3210294cc195fc096f87d0f813a337ae7e5f961b1c8a18f1f8604a909b3a5121f065b52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000", + "schema": { + "type": "string" + } + }, + { + "name": "destination", + "in": "path", + "description": "The reference address or destination", + "required": true, + "example": "bchtest:qq2j9gp97gm9a6lwvhxc4zu28qvqm0x4j5e72v7ejg", + "schema": { + "type": "string" + } + }, + { + "name": "amount", + "in": "query", + "description": "The optional reference amount (minimal by default)", + "required": false, + "example": 0.005, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/rawtransactions/decodeTransaction/{rawTx}": { + "get": { + "tags": ["rawtransactions"], + "summary": "decodeTransaction", + "description": "Decodes an Omni transaction. API Reference: https://developer.bitcoin.com/wormhole/docs/rawTransactions", + "operationId": "rawTransactionsDecodeTransaction", + "parameters": [ + { + "name": "rawTx", + "in": "path", + "description": "The raw transaction to decode", + "required": true, + "example": "010000000163af14ce6d477e1c793507e32a5b7696288fa89705c0d02a3f66beb3c5b8afee0100000000ffffffff02ac020000000000004751210261ea979f6a06f9dafe00fb1263ea0aca959875a7073556a088cdfadcd494b3752102a3fd0a8a067e06941e066f78d930bfc47746f097fcd3f7ab27db8ddf37168b6b52ae22020000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000", + "schema": { + "type": "string" + } + }, + { + "name": "prevTxs", + "in": "query", + "description": "A JSON array of transaction inputs (default: none)", + "required": false, + "example": "[{\"txid\":\"6779a710fcd5f6fb0883ea3306360c3ad8c0a3c5de902768ec57ef3104e65eb1\",\"vout\":4,\"scriptPubKey\":\"76a9147b25205fd98d462880a3e5b0541235831ae959e588ac\",\"value\":0.00068257}]", + "schema": { + "type": "string" + } + }, + { + "name": "height", + "in": "query", + "description": "The parsing block height (default: 0 for chain height)", + "required": false, + "example": 0, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/balance/{address}/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "balance", + "description": "Returns the token balance for a given address and property.", + "operationId": "dataRetrievalBalance", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The address", + "required": true, + "example": "bchtest:qq2j9gp97gm9a6lwvhxc4zu28qvqm0x4j5e72v7ejg", + "schema": { + "type": "string" + } + }, + { + "name": "propertyId", + "in": "path", + "description": "The property identifier", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Invalid address. Note: use cashAddress" + } + } + } + }, + "/dataRetrieval/balancesForAddress/{address}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "balancesForAddress", + "description": "Returns a list of all token balances for a given address. API reference: https://developer.bitcoin.com/wormhole/docs/dataRetrieval", + "operationId": "dataRetrievalBalancesForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The address", + "required": true, + "example": "bchtest:qq2j9gp97gm9a6lwvhxc4zu28qvqm0x4j5e72v7ejg", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Invalid address. Note: use cashAddress" + } + } + } + }, + "/dataRetrieval/balancesForId/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "balanceForId", + "description": "Returns a list of token balances for a given currency or property identifier. API Reference: https://developer.bitcoin.com/wormhole/docs/dataRetrieval", + "operationId": "dataRetrievalBalancesForId", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The property identifier", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Invalid address. Note: use cashAddress" + } + } + } + }, + "/dataRetrieval/balancesHash/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "balancesHash", + "description": "Returns a hash of the balances for the property.", + "operationId": "dataRetrievalBalancesHash", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The property to hash balances for", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected" + } + } + } + }, + "/dataRetrieval/crowdSale/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "crowdSale", + "description": "Returns information about a crowdsale.", + "operationId": "dataRetrievalCrowdSale", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the crowdsale", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + }, + { + "name": "verbose", + "in": "query", + "description": "List crowdsale participants (default: false)", + "required": false, + "type": "boolean", + "default": false + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected" + } + } + } + }, + "/dataRetrieval/currentConsensusHash": { + "get": { + "tags": ["dataRetrieval"], + "summary": "currentConsensusHash", + "description": "Returns the consensus hash for all balances for the current block.", + "operationId": "dataRetrievalCurrentConsensusHash", + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/grants/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "grants", + "description": "Returns information about granted and revoked units of managed tokens.", + "operationId": "dataRetrievalGrants", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the managed tokens to lookup", + "required": true, + "example": 220, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected" + } + } + } + }, + "/dataRetrieval/info": { + "get": { + "tags": ["dataRetrieval"], + "summary": "info", + "description": "Returns various state information of the client and protocol.", + "operationId": "dataRetrievalInfo", + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/payload/{txid}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "payload", + "description": "Get the payload for an Omni transaction.", + "operationId": "dataRetrievalPayload", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The hash of the transaction to retrieve payload", + "required": true, + "example": "d7dbbd16350ca13a1ce7fc67eb7fb411debca23ce01c3ae0e3e44498f1f6c3d0", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Received an invalid txid as input." + } + } + } + }, + "/dataRetrieval/property/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "property", + "description": "Returns details for about the tokens or smart property to lookup.", + "operationId": "dataRetrievalProperty", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens or property", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected" + } + } + } + }, + "/dataRetrieval/seedBlocks/{startBlock}/{endBlock}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "seedBlocks", + "description": "Returns a list of blocks containing Omni transactions for use in seed block filtering.", + "operationId": "dataRetrievalSeedBlocks", + "parameters": [ + { + "name": "startBlock", + "in": "path", + "description": "The first block to look for Omni transactions (inclusive)", + "required": true, + "example": 290000, + "schema": { + "type": "number" + } + }, + { + "name": "endBlock", + "in": "path", + "description": "The last block to look for Omni transactions (inclusive)", + "required": true, + "example": 300000, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected" + } + } + } + }, + "/dataRetrieval/STO/{txid}/{recipientFilter}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "STO", + "description": "Get information and recipients of a send-to-owners transaction.", + "operationId": "dataRetrievalSto", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The hash of the transaction to lookup", + "required": true, + "example": "fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33", + "schema": { + "type": "string" + } + }, + { + "name": "recipientFilter", + "in": "path", + "description": "A filter for recipients (wallet by default, '*' for all)", + "required": true, + "example": "*", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Invalid address. Note: use cashAddress" + } + } + } + }, + "/dataRetrieval/transaction/{txid}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "transaction", + "description": "Get detailed information about an Omni transaction.", + "operationId": "dataRetrievalTransaction", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The hash of the transaction to lookup", + "required": true, + "example": "d7dbbd16350ca13a1ce7fc67eb7fb411debca23ce01c3ae0e3e44498f1f6c3d0", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "No information available about transaction" + } + } + } + }, + "/dataRetrieval/blockTransactions/{index}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "blockTransactions", + "description": "Lists all Omni transactions in a block.", + "operationId": "dataRetrievalBlockTransactions", + "parameters": [ + { + "name": "index", + "in": "path", + "description": "The block height or block index", + "required": true, + "example": 279007, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected" + } + } + } + }, + "/dataRetrieval/pendingTransactions": { + "get": { + "tags": ["dataRetrieval"], + "summary": "pendingTransactions", + "description": "Returns a list of unconfirmed Omni transactions, pending in the memory pool.", + "operationId": "dataRetrievalPendingTransactions", + "parameters": [ + { + "name": "address", + "in": "query", + "description": "Address filter (default: '' for no filter)", + "required": false, + "example": "bchtest:qq2j9gp97gm9a6lwvhxc4zu28qvqm0x4j5e72v7ejg", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Invalid address. Note: use cashAddress" + } + } + } + }, + "/dataRetrieval/properties": { + "get": { + "tags": ["dataRetrieval"], + "summary": "properties", + "description": "Lists all tokens or smart properties.", + "operationId": "dataRetrievalProperties", + "parameters": [ + { + "name": "address", + "in": "query", + "description": "address filter (default: '*')", + "required": false, + "example": "*", + "schema": { + "type": "string" + } + }, + { + "name": "count", + "in": "query", + "description": "show at most n transactions (default: 10)", + "required": false, + "example": 10, + "schema": { + "type": "number" + } + }, + { + "name": "skip", + "in": "query", + "description": "skip the first n transactions (default: 0)", + "required": false, + "example": 0, + "schema": { + "type": "number" + } + }, + { + "name": "startBlock", + "in": "query", + "description": "first block to begin the search (default: 0)", + "required": false, + "example": 0, + "schema": { + "type": "number" + } + }, + { + "name": "endBlock", + "in": "query", + "description": "last block to include in the search (default: 9999999)", + "required": false, + "example": 9999999, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/frozenBalance/{address}/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "frozenBalance", + "description": "Returns the frozen token balance for a given address and property.", + "operationId": "dataRetrievalFrozenBalance", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address", + "required": true, + "example": "qqxyplcfuxnm9z4usma2wmnu4kw9mexeug580mc3lx", + "schema": { + "type": "string" + } + }, + { + "name": "propertyId", + "in": "path", + "description": "the property identifier", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/frozenBalanceForAddress/{address}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "frozenBalanceForAddress", + "description": "Returns the frozen token balance for a given address and property.", + "operationId": "dataRetrievalFrozenBalanceForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address", + "required": true, + "example": "qqxyplcfuxnm9z4usma2wmnu4kw9mexeug580mc3lx", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/frozenBalanceForId/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "frozenBalanceForId", + "description": "Returns the frozen token balance for a given property.", + "operationId": "dataRetrievalFrozenBalanceForId", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "the Property ID", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/ERC721AddressTokens/{address}/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "ERC721AddressTokens", + "description": "Returns details for about the tokens or smart property to lookup.", + "operationId": "dataRetrievalERC721AddressTokens", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address of the query", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + }, + { + "name": "propertyId", + "in": "path", + "description": "the identifier of the ERC721 property", + "required": true, + "example": "0x01", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/ERC721PropertyDestroyTokens/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "ERC721PropertyDestroyTokens", + "description": "Returns details for about the destroy tokens to lookup.", + "operationId": "dataRetrievalERC721PropertyDestroyTokens", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "the identifier of the ERC721 property", + "required": true, + "example": "0x01", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/ERC721PropertyNews/{propertyId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "ERC721PropertyNews", + "description": "Returns details for about the tokens or smart property to lookup.", + "operationId": "dataRetrievalERC721PropertyNews", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "the identifier of the ERC721 property", + "required": true, + "example": "0x01", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/ERC721TokenNews/{propertyId}/{tokenId}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "ERC721TokenNews", + "description": "Returns details for about the tokens or smart property to lookup.", + "operationId": "dataRetrievalERC721TokenNews", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "the identifier of the ERC721 property", + "required": true, + "example": "0x03", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "the identifier of the ERC721 token", + "required": true, + "example": "0x01", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/dataRetrieval/ownerOfERC721Token/{propertyId}/{tokenId}/{address}": { + "get": { + "tags": ["dataRetrieval"], + "summary": "ownerOfERC721Token", + "description": "Query whether the Token's owner is the specified address.", + "operationId": "dataRetrievalOwnerOfERC721Token", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "the identifier of the ERC721 property", + "required": true, + "example": "0x03", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "the identifier of the ERC721 token", + "required": true, + "example": "0x01", + "schema": { + "type": "string" + } + }, + { + "name": "address", + "in": "path", + "description": "query address for the specified ERC721 Token", + "required": true, + "example": "bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/burnBCH": { + "get": { + "tags": ["payloadCreation"], + "summary": "burnBCH", + "description": "Creates the payload to burn bch to get whc.", + "operationId": "payloadCreationBurnBCH", + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/changeIssuer/{propertyId}": { + "post": { + "tags": ["payloadCreation"], + "summary": "changeIssuer", + "description": "Creates the payload to change the issuer on record of the given tokens.", + "operationId": "payloadCreationChangeIssuer", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens", + "required": true, + "example": 3, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "500": { + "description": "Not Found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Not Found." + } + } + } + } + } + } + }, + "/payloadCreation/closeCrowdSale/{propertyId}": { + "post": { + "tags": ["payloadCreation"], + "summary": "closeCrowdSale", + "description": "Creates the payload to manually close a crowdsale.", + "operationId": "payloadCreationCloseCrowdSale", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the crowdsale to close", + "required": true, + "example": 70, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "JSON value is not an integer as expected", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "JSON value is not an integer as expected" + } + } + } + } + } + } + }, + "/payloadCreation/grant/{propertyId}/{amount}": { + "post": { + "tags": ["payloadCreation"], + "summary": "grant", + "description": "Creates the payload to issue or grant new units of managed tokens.", + "operationId": "payloadCreationGrant", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens to grant", + "required": true, + "example": 220, + "schema": { + "type": "number" + } + }, + { + "name": "amount", + "in": "path", + "description": "The amount of tokens to create", + "required": true, + "example": "7000", + "schema": { + "type": "string" + } + }, + { + "name": "memo", + "in": "query", + "description": "A text note attached to this transaction (none by default)", + "required": false, + "example": "Hello BITBOX", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Not Found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Not Found" + } + } + } + } + } + } + }, + "/payloadCreation/crowdsale/{ecosystem}/{propertyPrecision}/{previousId}/{category}/{subcategory}/{name}/{url}/{data}/{propertyIdDesired}/{tokensPerUnit}/{deadline}/{earlyBonus}/{undefine}/{totalNumber}": { + "post": { + "tags": ["payloadCreation"], + "summary": "crowdsale", + "description": "Creates the payload for a new tokens issuance with crowdsale.", + "operationId": "payloadCreationCrowdsale", + "parameters": [ + { + "name": "ecosystem", + "in": "path", + "description": "The ecosystem to create the tokens in, must be 1", + "required": true, + "example": "1", + "schema": { + "type": "string" + } + }, + { + "name": "propertyPrecision", + "in": "path", + "description": "The precision of the tokens to create:[0, 8]", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + }, + { + "name": "previousId", + "in": "path", + "description": "An identifier of a predecessor token (0 for new crowdsales)", + "required": true, + "example": 0, + "schema": { + "type": "number" + } + }, + { + "name": "category", + "in": "path", + "description": "A category for the new tokens", + "required": true, + "example": "Companies", + "schema": { + "type": "string" + } + }, + { + "name": "subcategory", + "in": "path", + "description": "A subcategory for the new tokens", + "required": true, + "example": "Bitcoin Mining", + "schema": { + "type": "string" + } + }, + { + "name": "name", + "in": "path", + "description": "The name of the new tokens to create", + "required": true, + "example": "Quantum Miner", + "schema": { + "type": "string" + } + }, + { + "name": "url", + "in": "path", + "description": "An URL for further information about the new tokens", + "required": true, + "example": "www.example.com", + "schema": { + "type": "string" + } + }, + { + "name": "data", + "in": "path", + "description": "A description for the new tokens", + "required": true, + "example": "Quantum Miner Tokens", + "schema": { + "type": "string" + } + }, + { + "name": "propertyIdDesired", + "in": "path", + "description": "The identifier of a token eligible to participate in the crowdsale", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + }, + { + "name": "tokensPerUnit", + "in": "path", + "description": "The amount of tokens granted per unit invested in the crowdsale", + "required": true, + "example": "100", + "schema": { + "type": "string" + } + }, + { + "name": "deadline", + "in": "path", + "description": "The deadline of the crowdsale as Unix timestamp", + "required": true, + "example": 1483228800, + "schema": { + "type": "number" + } + }, + { + "name": "earlyBonus", + "in": "path", + "description": "An early bird bonus for participants in percent per week", + "required": true, + "example": 30, + "schema": { + "type": "number" + } + }, + { + "name": "undefine", + "in": "path", + "description": "The value must be 0", + "required": true, + "example": 0, + "schema": { + "type": "number" + } + }, + { + "name": "totalNumber", + "in": "path", + "description": "The number of tokens to create", + "required": true, + "example": "192978657", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/fixed/{ecosystem}/{propertyPrecision}/{previousId}/{category}/{subcategory}/{name}/{url}/{data}/{amount}": { + "post": { + "tags": ["payloadCreation"], + "summary": "fixed", + "description": "Creates the payload for a new tokens issuance with fixed supply.", + "operationId": "payloadCreationFixed", + "parameters": [ + { + "name": "ecosystem", + "in": "path", + "description": "The ecosystem to create the tokens in, must be 1", + "required": true, + "example": "1", + "schema": { + "type": "string" + } + }, + { + "name": "propertyPrecision", + "in": "path", + "description": "The precision of the tokens to create:[0, 8]", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + }, + { + "name": "previousId", + "in": "path", + "description": "An identifier of a predecessor token (use 0 for new tokens)", + "required": true, + "example": 0, + "schema": { + "type": "number" + } + }, + { + "name": "category", + "in": "path", + "description": "A category for the new tokens", + "required": true, + "example": "Companies", + "schema": { + "type": "string" + } + }, + { + "name": "subcategory", + "in": "path", + "description": "A subcategory for the new tokens", + "required": true, + "example": "Bitcoin Mining", + "schema": { + "type": "string" + } + }, + { + "name": "name", + "in": "path", + "description": "The name of the new tokens to create", + "required": true, + "example": "Quantum Miner", + "schema": { + "type": "string" + } + }, + { + "name": "url", + "in": "path", + "description": "An URL for further information about the new tokens", + "required": true, + "example": "www.example.com", + "schema": { + "type": "string" + } + }, + { + "name": "data", + "in": "path", + "description": "A description for the new tokens", + "required": true, + "example": "Quantum Miner Tokens", + "schema": { + "type": "string" + } + }, + { + "name": "amount", + "in": "path", + "description": "The number of tokens to create", + "required": true, + "example": "1000000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/managed/{ecosystem}/{propertyPrecision}/{previousId}/{category}/{subcategory}/{name}/{url}/{data}": { + "post": { + "tags": ["payloadCreation"], + "summary": "managed", + "description": "Creates the payload for a new tokens issuance with manageable supply.", + "operationId": "payloadCreationManaged", + "parameters": [ + { + "name": "ecosystem", + "in": "path", + "description": "The ecosystem to create the tokens in, must be 1", + "required": true, + "example": "1", + "schema": { + "type": "string" + } + }, + { + "name": "propertyPrecision", + "in": "path", + "description": "The precision of the tokens to create:[0, 8]", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + }, + { + "name": "previousId", + "in": "path", + "description": "An identifier of a predecessor token (use 0 for new tokens)", + "required": true, + "example": 0, + "schema": { + "type": "number" + } + }, + { + "name": "category", + "in": "path", + "description": "A category for the new tokens", + "required": true, + "example": "Companies", + "schema": { + "type": "string" + } + }, + { + "name": "subcategory", + "in": "path", + "description": "A subcategory for the new tokens", + "required": true, + "example": "Bitcoin Mining", + "schema": { + "type": "string" + } + }, + { + "name": "name", + "in": "path", + "description": "The name of the new tokens to create", + "required": true, + "example": "Quantum Miner", + "schema": { + "type": "string" + } + }, + { + "name": "url", + "in": "path", + "description": "An URL for further information about the new tokens", + "required": true, + "example": "www.example.com", + "schema": { + "type": "string" + } + }, + { + "name": "data", + "in": "path", + "description": "A description for the new tokens", + "required": true, + "example": "Quantum Miner Tokens", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input." + } + } + } + }, + "/payloadCreation/participateCrowdSale/{amount}": { + "post": { + "tags": ["payloadCreation"], + "summary": "participateCrowdSale", + "description": "Create the payload for a participate crowdsale transaction", + "operationId": "payloadCreationParticipateCrowdSale", + "parameters": [ + { + "name": "amount", + "in": "path", + "description": "The amount of WHC to participateCrowdSale", + "required": true, + "example": "100.0", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/revoke/{propertyId}/{amount}": { + "post": { + "tags": ["payloadCreation"], + "summary": "revoke", + "description": "Creates the payload to revoke units of managed tokens.", + "operationId": "payloadCreationRevoke", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens to revoke", + "required": true, + "example": 51, + "schema": { + "type": "number" + } + }, + { + "name": "amount", + "in": "path", + "description": "The amount of tokens to revoke", + "required": true, + "example": "100", + "schema": { + "type": "string" + } + }, + { + "name": "memo", + "in": "query", + "description": "A text note attached to this transaction (none by default)", + "required": false, + "example": "Goodbye BITBOX", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/sendAll/{ecosystem}": { + "post": { + "tags": ["payloadCreation"], + "summary": "sendAll", + "description": "Create the payload for a send all transaction.", + "operationId": "payloadCreationSendAll", + "parameters": [ + { + "name": "ecosystem", + "in": "path", + "description": "The ecosystem of the tokens to send (1 for main ecosystem, 2 for test ecosystem)", + "required": true, + "example": 2, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/simpleSend/{propertyId}/{amount}": { + "post": { + "tags": ["payloadCreation"], + "summary": "simpleSend", + "description": "Create the payload for a simple send transaction.", + "operationId": "payloadCreationSimpleSend", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens to send", + "required": true, + "example": 1, + "schema": { + "type": "number" + } + }, + { + "name": "amount", + "in": "path", + "description": "The amount to send", + "required": true, + "example": "100.0", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/STO/{propertyId}/{amount}": { + "post": { + "tags": ["payloadCreation"], + "summary": "STO", + "description": "Creates the payload for a send-to-owners transaction", + "operationId": "payloadCreationSTO", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens to distribute", + "required": true, + "example": 3, + "schema": { + "type": "number" + } + }, + { + "name": "amount", + "in": "path", + "description": "The amount to distribute", + "required": true, + "example": "5000", + "schema": { + "type": "string" + } + }, + { + "name": "distributionProperty", + "in": "query", + "description": "The identifier of the property holders to distribute to", + "required": false, + "example": 1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/freeze/{toAddress}/{propertyId}": { + "post": { + "tags": ["payloadCreation"], + "summary": "freeze", + "description": "Creates the payload for a freeze transaction", + "operationId": "payloadCreationFreeze", + "parameters": [ + { + "name": "toAddress", + "in": "path", + "description": "The to address", + "required": true, + "example": 3, + "schema": { + "type": "string" + } + }, + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens to freeze", + "required": true, + "example": 3, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/unfreeze/{toAddress}/{propertyId}": { + "post": { + "tags": ["payloadCreation"], + "summary": "unfreeze", + "description": "Creates the payload for an unfreeze transaction", + "operationId": "payloadCreationUnfreeze", + "parameters": [ + { + "name": "toAddress", + "in": "path", + "description": "The to address", + "required": true, + "example": 3, + "schema": { + "type": "string" + } + }, + { + "name": "propertyId", + "in": "path", + "description": "The identifier of the tokens to unfreeze", + "required": true, + "example": 3, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/issueERC721Property/{name}/{symbol}/{data}/{url}/{totalNumber}": { + "post": { + "tags": ["payloadCreation"], + "summary": "issueERC721Property", + "description": "Creates the payload to issue ERC721 property", + "operationId": "payloadIssueERC721Property", + "parameters": [ + { + "name": "name", + "in": "path", + "description": "The name of created property", + "required": true, + "example": "CryptoBadgers", + "schema": { + "type": "string" + } + }, + { + "name": "symbol", + "in": "path", + "description": "The symbol of created property", + "required": true, + "example": "CRYPTOBADGER", + "schema": { + "type": "string" + } + }, + { + "name": "data", + "in": "path", + "description": "The Data of created property", + "required": true, + "example": "Collect and breed digital Honey Badgers!", + "schema": { + "type": "string" + } + }, + { + "name": "url", + "in": "path", + "description": "The URL of created property", + "required": true, + "example": "example.com", + "schema": { + "type": "string" + } + }, + { + "name": "totalNumber", + "in": "path", + "description": "The number of token that created property will issued in the future", + "required": true, + "example": "10000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/issueERC721Token/{propertyId}/{tokenId}/{attributes}/{url}": { + "post": { + "tags": ["payloadCreation"], + "summary": "issueERC721Token", + "description": "Creates the payload to issue ERC721 token", + "operationId": "payloadIssueERC721Token", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The ID of the special property that will be issued token", + "required": true, + "example": "CryptoBadgers", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "The tokenID that will be issued, if you don't want to skip this parament, wormhole system will automatic tokenID", + "required": true, + "example": "CRYPTOBADGER", + "schema": { + "type": "string" + } + }, + { + "name": "attributes", + "in": "path", + "description": "The Attributes of the new created token", + "required": true, + "example": "Collect and breed digital Honey Badgers!", + "schema": { + "type": "string" + } + }, + { + "name": "url", + "in": "path", + "description": "The URL of the new created token", + "required": true, + "example": "example.com", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/transferERC721Token/{owner}/{receiver}/{propertyId}/{tokenId}": { + "post": { + "tags": ["payloadCreation"], + "summary": "transferERC721Token", + "description": "Creates the payload to transfer ERC721 token", + "operationId": "payloadTransferERC721Token", + "parameters": [ + { + "name": "owner", + "in": "path", + "description": "The ID of the special property that will be issued token", + "required": true, + "example": "CryptoBadgers", + "schema": { + "type": "string" + } + }, + { + "name": "receiver", + "in": "path", + "description": "The tokenID that will be issued, if you don't want to skip this parament, wormhole system will automatic tokenID", + "required": true, + "example": "CRYPTOBADGER", + "schema": { + "type": "string" + } + }, + { + "name": "propertyId", + "in": "path", + "description": "The Attributes of the new created token", + "required": true, + "example": "Collect and breed digital Honey Badgers!", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "The URL of the new created token", + "required": true, + "example": "example.com", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/payloadCreation/destroyERC721Token/{propertyId}/{tokenId}": { + "post": { + "tags": ["payloadCreation"], + "summary": "destroyERC721Token", + "description": "Creates all ERC721 tokens", + "operationId": "payloadDestroyERC721Token", + "parameters": [ + { + "name": "propertyId", + "in": "path", + "description": "The propertyId of the token that will be destroy", + "required": true, + "example": "0x02", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "The tokenid that will be destroyed", + "required": true, + "example": "0x01", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/list": { + "get": { + "tags": ["slp"], + "summary": "list", + "description": "List all SLP tokens", + "operationId": "slpList", + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/list/{tokenId}": { + "get": { + "tags": ["slp"], + "summary": "list token", + "description": "List single SLP token by id", + "operationId": "slpListToken", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "259908ae44f46ef585edef4bcc1e50dc06e4c391ac4be929fae27235b8158cf1", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balancesForAddress/{address}": { + "get": { + "tags": ["slp"], + "summary": "list slp balances for address", + "description": "List SLP token balances for address", + "operationId": "slpListBalancesForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "simpleledger:qz9tzs6d5097ejpg279rg0rnlhz546q4fsnck9wh5m", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balance/{address}/{tokenId}": { + "get": { + "tags": ["slp"], + "summary": "list single slp token balance for address", + "description": "List single SLP token balance for address", + "operationId": "slpListSingleBalanceForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "simpleledger:qz9tzs6d5097ejpg279rg0rnlhz546q4fsnck9wh5m", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "1cda254d0a995c713b7955298ed246822bee487458cd9747a91d9e81d9d28125", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/address/convert/{address}": { + "get": { + "tags": ["slp"], + "summary": "convert address to slpAddr, cashAddr and legacy", + "description": "convert address to slpAddr, cashAddr and legacy", + "operationId": "slpAddressConvert", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "simpleledger:qz9tzs6d5097ejpg279rg0rnlhz546q4fsnck9wh5m", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balancesForToken/{tokenId}": { + "get": { + "tags": ["slp"], + "summary": "list slp balances for all holders of a token", + "description": "List SLP token balances for all holders of a token", + "operationId": "slpListBalancesForToken", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The slp token id", + "required": true, + "example": "d7c32d972a21b664f60b5fc422900179d8883dec7bd61418434aa12b09b99c12", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + } + }, + "servers": [ + { + "url": "/v1" + } + ], + "components": { + "schemas": { + "AddressDetails": { + "type": "object", + "properties": { + "balance": { + "type": "number", + "format": "float" + }, + "balanceSat": { + "type": "number", + "format": "float" + }, + "totalReceived": { + "type": "number", + "format": "float" + }, + "totalReceivedSat": { + "type": "number", + "format": "float" + }, + "totalSent": { + "type": "number", + "format": "float" + }, + "totalSentSat": { + "type": "number", + "format": "float" + }, + "unconfirmedBalance": { + "type": "number", + "format": "float" + }, + "unconfirmedBalanceSat": { + "type": "number", + "format": "float" + }, + "unconfirmedTxAppearances": { + "type": "number", + "format": "float" + }, + "txAppearances": { + "type": "number" + }, + "transactions": { + "type": "array", + "items": { + "type": "string" + } + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "AddressUtxo": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Utxo" + } + }, + "Utxo": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptPubKey": { + "type": "string" + }, + "amount": { + "type": "number", + "format": "float" + }, + "satoshis": { + "type": "number" + }, + "height": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "AddressUnconfirmed": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Unconfirmed" + } + }, + "Unconfirmed": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptPubKey": { + "type": "string" + }, + "amount": { + "type": "number", + "format": "float" + }, + "satoshis": { + "type": "number" + }, + "height": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "BlockDetails": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "merkleroot": { + "type": "string" + }, + "tx": { + "type": "array", + "items": { + "type": "string" + } + }, + "time": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + }, + "reward": { + "type": "number", + "format": "float" + }, + "isMainChain": { + "type": "boolean" + }, + "poolInfo": { + "type": "object", + "properties": { + "poolName": "string", + "url": "string" + } + } + } + }, + "BestBlockHash": { + "type": "string" + }, + "Block": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "size": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "versionHex": { + "type": "string" + }, + "merkleroot": { + "type": "string" + }, + "tx": { + "type": "array", + "items": { + "type": "string" + } + }, + "time": { + "type": "number" + }, + "mediantime": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + } + } + }, + "BlockchainInfo": { + "type": "object", + "properties": { + "chain": { + "type": "string" + }, + "blocks": { + "type": "number" + }, + "headers": { + "type": "number" + }, + "bestblockhash": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "mediantime": { + "type": "number" + }, + "verificationprogress": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "pruned": { + "type": "boolean" + }, + "softforks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": "string", + "version": "number", + "reject": { + "type": "object", + "properties": { + "status": "boolean" + } + } + } + } + }, + "bip9_softforks": { + "type": "object", + "properties": { + "status": "string", + "startTime": "number", + "timeout": "number", + "since": "number" + } + } + } + }, + "BlockCount": { + "type": "number" + }, + "BlockHash": { + "type": "string" + }, + "BlockHeader": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "versionHex": { + "type": "string" + }, + "merkleroot": { + "type": "string" + }, + "time": { + "type": "number" + }, + "mediantime": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + } + } + }, + "Difficulty": { + "type": "number", + "format": "float" + }, + "MempoolInfo": { + "type": "object", + "properties": { + "size": { + "type": "number" + }, + "bytes": { + "type": "number" + }, + "usage": { + "type": "number" + }, + "maxmempool": { + "type": "number" + }, + "mempoolminfee": { + "type": "number" + } + } + }, + "RawMempool": { + "type": "array", + "items": { + "type": "string" + } + }, + "DecodeRawTransaction": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "version": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + } + } + }, + "sequence": { + "type": "string" + } + } + } + }, + "vout": { + "type": "array", + "items": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "reqSigs": { + "type": "number" + }, + "type": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + } + } + } + } + } + } + } + }, + "DecodeScript": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "type": { + "type": "string" + }, + "p2sh": { + "type": "string" + } + } + }, + "GetRawTransaction": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "txid": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "version": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "sequence": { + "type": "string" + } + } + } + } + } + }, + "vout": { + "type": "array", + "items": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "reqSigs": { + "type": "number" + }, + "type": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + } + } + } + } + } + }, + "blockhash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "time": { + "type": "number" + }, + "blocktime": { + "type": "number" + } + } + }, + "TransactionDetails": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "version": { + "type": "number" + }, + "locktime": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "sequence": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + }, + "value": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + } + } + } + }, + "vout": { + "type": "array", + "items": { + "objects": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + }, + "type": { + "type": "string" + } + } + }, + "spentTxId": { + "type": "string" + }, + "spentIndex": { + "type": "number" + }, + "spentHeight": { + "type": "number" + } + } + }, + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + } + } + }, + "spentTxId": { + "type": "string" + }, + "spentIndex": { + "type": "number" + }, + "spentHeight": { + "type": "number" + } + } + } + }, + "blockhash": { + "type": "string" + }, + "blockheight": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "time": { + "type": "number" + }, + "valueOut": { + "type": "number" + }, + "size": { + "type": "number" + }, + "valueIn": { + "type": "number" + }, + "fees": { + "type": "number" + } + } + }, + "ValidateAddress": { + "type": "object", + "properties": { + "isvalid": { + "type": "boolean" + }, + "address": { + "type": "string" + }, + "scriptPubKey": { + "type": "string" + }, + "ismine": { + "type": "boolean" + }, + "iswatchonly": { + "type": "boolean" + }, + "isscript": { + "type": "boolean" + } + } + }, + "Info": { + "type": "object", + "properties": { + "version": { + "type": "number" + }, + "protocolversion": { + "type": "number" + }, + "blocks": { + "type": "number" + }, + "timeoffset": { + "type": "number" + }, + "connections": { + "type": "number" + }, + "proxy": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "paytxfee": { + "type": "number" + }, + "relayfee": { + "type": "number", + "format": "float" + }, + "errors": { + "type": "string" + } + } + }, + "MemoryInfo": { + "type": "object", + "properties": { + "locked": { + "type": "object", + "properties": { + "used": { + "type": "number" + }, + "free": { + "type": "number" + }, + "total": { + "type": "number" + }, + "locked": { + "type": "number" + }, + "chunks_used": { + "type": "number" + }, + "chunks_free": { + "type": "number" + } + } + } + } + }, + "MiningInfo": { + "type": "object", + "properties": { + "blocks": { + "type": "number" + }, + "currentblocksize": { + "type": "number" + }, + "currentblocktx": { + "type": "number" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "blockprioritypercentage": { + "type": "number" + }, + "errors": { + "type": "string" + }, + "networkhashps": { + "type": "number" + }, + "pooledtx": { + "type": "number" + }, + "chain": { + "type": "string" + } + } + }, + "NetworkHashps": { + "type": "number" + }, + "ConnectionCount": { + "type": "number" + }, + "MempoolAncestors": { + "type": "array", + "items": { + "type": "string" + } + }, + "MempoolDescendants": { + "type": "array", + "items": { + "type": "string" + } + } + } + } +} diff --git a/dist/public/bitcoin-com-testnet-rest-v2.json b/dist/public/bitcoin-com-testnet-rest-v2.json new file mode 100644 index 0000000..38bb064 --- /dev/null +++ b/dist/public/bitcoin-com-testnet-rest-v2.json @@ -0,0 +1,3099 @@ +{ + "components": { + "schemas": { + "Address": { + "type": "string" + }, + "Hash": { + "type": "string" + }, + "Txid": { + "type": "string" + }, + "SLPConvert": { + "type": "object", + "properties": { + "addresses": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SLPConvert" + }, + "example": [] + } + } + }, + "SLPTxid": { + "type": "string" + }, + "RawTxid": { + "type": "string" + }, + "Hex": { + "type": "string" + }, + "Height": { + "type": "number" + }, + "Proof": { + "type": "string" + }, + "Addresses": { + "type": "object", + "properties": { + "addresses": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Address" + }, + "example": [ + "bchtest:qzjtnzcvzxx7s0na88yrg3zl28wwvfp97538sgrrmr", + "bchtest:qp6hgvevf4gzz6l7pgcte3gaaud9km0l459fa23dul" + ] + } + } + }, + "Hashes": { + "type": "object", + "properties": { + "hashes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Hash" + }, + "example": [ + "000000000000014c11d5a6fd30e03e56e55d516f193ff0768c9c81177858d12a", + "000000000001a7c0aaa2630fbb2c0e476aafffc60f82177375b2aaa22209f606" + ] + }, + "verbose": { + "type": "boolean", + "example": true + } + } + }, + "BlockHashes": { + "type": "object", + "properties": { + "hashes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Hash" + }, + "example": [] + } + } + }, + "BlockHeights": { + "type": "object", + "properties": { + "heights": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Heights" + }, + "example": [] + } + } + }, + "Heights": { + "type": "object", + "properties": { + "heights": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Heights" + }, + "example": [] + } + } + }, + "Hexes": { + "type": "object", + "properties": { + "hexes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Hex" + }, + "example": [ + "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000", + "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000" + ] + } + } + }, + "Txids": { + "type": "object", + "properties": { + "txids": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Txid" + }, + "example": [ + "3ea2767c91d087d14dda8faef736cd39d6c6ebbd5f7d2c7e8de0df3360436bfb", + "cce4e8eb4b3160b93ceecb0956cde405d85b42cbcb3fa1b4e9a9bedaf3476f05" + ] + } + } + }, + "SLPListBulk": { + "type": "object", + "properties": { + "tokenIds": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SLPListBulk" + }, + "example": [] + } + } + }, + "SLPTxids": { + "type": "object", + "properties": { + "txids": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SLPTxid" + }, + "example": [ + "3ea2767c91d087d14dda8faef736cd39d6c6ebbd5f7d2c7e8de0df3360436bfb", + "cce4e8eb4b3160b93ceecb0956cde405d85b42cbcb3fa1b4e9a9bedaf3476f05" + ] + } + } + }, + "RawTxids": { + "type": "object", + "properties": { + "txids": { + "type": "array", + "items": { + "$ref": "#/components/schemas/RawTxid" + }, + "example": [ + "3ea2767c91d087d14dda8faef736cd39d6c6ebbd5f7d2c7e8de0df3360436bfb", + "cce4e8eb4b3160b93ceecb0956cde405d85b42cbcb3fa1b4e9a9bedaf3476f05" + ] + }, + "verbose": { + "type": "boolean", + "example": true + } + } + }, + "Proofs": { + "type": "object", + "properties": { + "proofs": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Proof" + }, + "example": [ + "000000207fd83434a2e506e874567d0468e051a1e1a56ae29672db125500ad100000000097833baeefae6471fa1f1040c911d1cf9781b1e0c890ed7a2179eb7361ff4607d237fd5bffff001d11d727fe120000000694897b6e79132eb38bc5eededa7c31876261dc42cb81597b90dbf0c0178c0d2292c8178f0211f94185828b8dee76e0a8169840fd372d38ff3bd835081e308c46fb6b436033dfe08d7e2c7d5fbdebc6d639cd36f7ae8fda4dd187d0917c76a23e8957429343eb39d015012cc6841844ee75b2b1db162ac21c7bcb2113fb9fd04a8d7105af6ff5d10fce215fccf60d28e8c4cc477f9747e11460f1e9db9cf2321ff1358b92e35ccead57f5db006a3a9d07b4a33c8153230bef4935a04f42715a1402d700", + "00000020f5bcc14625b1a1ce0959465e9002f7e0a02f23039d0759440217000000000000db067508838ed35f03f0a5e6e258b4f0886daaf0729361c70f11ad3f3ced3b693a9ba45b9726021a1d5b3b561b000000065e312e41a47a2874e3eac76a42b8bf6749cd0501dced7365bd5afdc27a89ec013e4dc7f75491345447c16b985a18ff3ef6d38eb5b5562dae3e95a03a36ea3818056f47f3dabea9e9b4a13fcbcb425bd805e4cd5609cbee3cb960314bebe8e4ccc85c3fc0283f706f4708ee14d559d5b3184d9974145d6ad4ade702c8eb8579166b4fa9137e19341f5a6bc3f018c49e3325f625307242fc60811b815f56509cdd74b81f7aa0b43545bbf6e512c47ec90d350c0c655ad2abe9ef72df112845504102d700" + ] + } + } + }, + "AddressDetails": { + "type": "object", + "properties": { + "balance": { + "type": "number", + "format": "float" + }, + "balanceSat": { + "type": "number", + "format": "float" + }, + "totalReceived": { + "type": "number", + "format": "float" + }, + "totalReceivedSat": { + "type": "number", + "format": "float" + }, + "totalSent": { + "type": "number", + "format": "float" + }, + "totalSentSat": { + "type": "number", + "format": "float" + }, + "unconfirmedBalance": { + "type": "number", + "format": "float" + }, + "unconfirmedBalanceSat": { + "type": "number", + "format": "float" + }, + "unconfirmedTxAppearances": { + "type": "number", + "format": "float" + }, + "txAppearances": { + "type": "number" + }, + "transactions": { + "type": "array", + "items": { + "type": "string" + } + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "AddressDetailsArray": { + "type": "array", + "items": { + "$ref": "#/components/schemas/AddressDetails" + } + }, + "AddressUtxo": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Utxo" + } + }, + "AddressUtxoArray": { + "type": "array", + "items": { + "$ref": "#/components/schemas/AddressUtxo" + }, + "example": [] + }, + "Utxo": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptPubKey": { + "type": "string" + }, + "amount": { + "type": "number", + "format": "float" + }, + "satoshis": { + "type": "number" + }, + "height": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "AddressUnconfirmed": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Unconfirmed" + } + }, + "AddressUnconfirmedArray": { + "type": "array", + "items": { + "$ref": "#/components/schemas/AddressUnconfirmed" + }, + "example": [] + }, + "Unconfirmed": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptPubKey": { + "type": "string" + }, + "amount": { + "type": "number", + "format": "float" + }, + "satoshis": { + "type": "number" + }, + "height": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + }, + "BlockDetails": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "merkleroot": { + "type": "string" + }, + "tx": { + "type": "array", + "items": { + "type": "string" + } + }, + "time": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + }, + "reward": { + "type": "number", + "format": "float" + }, + "isMainChain": { + "type": "boolean" + }, + "poolInfo": { + "type": "object", + "properties": { + "poolName": "string", + "url": "string" + } + } + } + }, + "BestBlockHash": { + "type": "string" + }, + "Block": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "size": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "versionHex": { + "type": "string" + }, + "merkleroot": { + "type": "string" + }, + "tx": { + "type": "array", + "items": { + "type": "string" + } + }, + "time": { + "type": "number" + }, + "mediantime": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + } + } + }, + "BlockchainInfo": { + "type": "object", + "properties": { + "chain": { + "type": "string" + }, + "blocks": { + "type": "number" + }, + "headers": { + "type": "number" + }, + "bestblockhash": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "mediantime": { + "type": "number" + }, + "verificationprogress": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "pruned": { + "type": "boolean" + }, + "softforks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": "string", + "version": "number", + "reject": { + "type": "object", + "properties": { + "status": "boolean" + } + } + } + } + }, + "bip9_softforks": { + "type": "object", + "properties": { + "status": "string", + "startTime": "number", + "timeout": "number", + "since": "number" + } + } + } + }, + "BlockCount": { + "type": "number" + }, + "BlockHash": { + "type": "string" + }, + "BlockHeader": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "height": { + "type": "number" + }, + "version": { + "type": "number" + }, + "versionHex": { + "type": "string" + }, + "merkleroot": { + "type": "string" + }, + "time": { + "type": "number" + }, + "mediantime": { + "type": "number" + }, + "nonce": { + "type": "number" + }, + "bits": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "chainwork": { + "type": "string" + }, + "previousblockhash": { + "type": "string" + }, + "nextblockhash": { + "type": "string" + } + } + }, + "Difficulty": { + "type": "number", + "format": "float" + }, + "MempoolInfo": { + "type": "object", + "properties": { + "size": { + "type": "number" + }, + "bytes": { + "type": "number" + }, + "usage": { + "type": "number" + }, + "maxmempool": { + "type": "number" + }, + "mempoolminfee": { + "type": "number" + } + } + }, + "RawMempool": { + "type": "array", + "items": { + "type": "string" + } + }, + "DecodeRawTransaction": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "version": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + } + } + }, + "sequence": { + "type": "string" + } + } + } + }, + "vout": { + "type": "array", + "items": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "reqSigs": { + "type": "number" + }, + "type": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + } + } + } + } + } + } + } + }, + "DecodeScript": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "type": { + "type": "string" + }, + "p2sh": { + "type": "string" + } + } + }, + "GetRawTransaction": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "txid": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "size": { + "type": "number" + }, + "version": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "sequence": { + "type": "string" + } + } + } + } + } + }, + "vout": { + "type": "array", + "items": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "asm": { + "type": "string" + }, + "hex": { + "type": "string" + }, + "reqSigs": { + "type": "number" + }, + "type": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + } + } + } + } + } + }, + "blockhash": { + "type": "string" + }, + "confirmations": { + "type": "number" + }, + "time": { + "type": "number" + }, + "blocktime": { + "type": "number" + } + } + }, + "TransactionDetails": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "version": { + "type": "number" + }, + "locktime": { + "type": "number" + }, + "vin": { + "type": "array", + "items": { + "type": "object", + "properties": { + "txid": { + "type": "string" + }, + "vout": { + "type": "number" + }, + "sequence": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptSig": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + }, + "value": { + "type": "number" + }, + "legacyAddress": { + "type": "string" + }, + "cashAddress": { + "type": "string" + } + } + } + } + } + }, + "vout": { + "type": "array", + "items": { + "objects": { + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + }, + "addresses": { + "type": "array", + "items": { + "address": { + "type": "string" + } + } + }, + "type": { + "type": "string" + } + } + }, + "spentTxId": { + "type": "string" + }, + "spentIndex": { + "type": "number" + }, + "spentHeight": { + "type": "number" + } + } + }, + "type": "object", + "properties": { + "value": { + "type": "number" + }, + "n": { + "type": "number" + }, + "scriptPubkey": { + "type": "object", + "properties": { + "hex": { + "type": "string" + }, + "asm": { + "type": "string" + } + } + }, + "spentTxId": { + "type": "string" + }, + "spentIndex": { + "type": "number" + }, + "spentHeight": { + "type": "number" + } + } + } + }, + "blockhash": { + "type": "string" + }, + "blockheight": { + "type": "number" + }, + "confirmations": { + "type": "number" + }, + "time": { + "type": "number" + }, + "valueOut": { + "type": "number" + }, + "size": { + "type": "number" + }, + "valueIn": { + "type": "number" + }, + "fees": { + "type": "number" + } + } + }, + "ValidateAddress": { + "type": "object", + "properties": { + "isvalid": { + "type": "boolean" + }, + "address": { + "type": "string" + }, + "scriptPubKey": { + "type": "string" + }, + "ismine": { + "type": "boolean" + }, + "iswatchonly": { + "type": "boolean" + }, + "isscript": { + "type": "boolean" + } + } + }, + "Info": { + "type": "object", + "properties": { + "version": { + "type": "number" + }, + "protocolversion": { + "type": "number" + }, + "blocks": { + "type": "number" + }, + "timeoffset": { + "type": "number" + }, + "connections": { + "type": "number" + }, + "proxy": { + "type": "string" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "paytxfee": { + "type": "number" + }, + "relayfee": { + "type": "number", + "format": "float" + }, + "errors": { + "type": "string" + } + } + }, + "MemoryInfo": { + "type": "object", + "properties": { + "locked": { + "type": "object", + "properties": { + "used": { + "type": "number" + }, + "free": { + "type": "number" + }, + "total": { + "type": "number" + }, + "locked": { + "type": "number" + }, + "chunks_used": { + "type": "number" + }, + "chunks_free": { + "type": "number" + } + } + } + } + }, + "MiningInfo": { + "type": "object", + "properties": { + "blocks": { + "type": "number" + }, + "currentblocksize": { + "type": "number" + }, + "currentblocktx": { + "type": "number" + }, + "difficulty": { + "type": "number", + "format": "float" + }, + "blockprioritypercentage": { + "type": "number" + }, + "errors": { + "type": "string" + }, + "networkhashps": { + "type": "number" + }, + "pooledtx": { + "type": "number" + }, + "chain": { + "type": "string" + } + } + }, + "NetworkHashps": { + "type": "number" + }, + "ConnectionCount": { + "type": "number" + }, + "MempoolAncestors": { + "type": "array", + "items": { + "type": "string" + } + }, + "MempoolDescendants": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "openapi": "3.0.0", + "info": { + "description": "trest.bitcoin.com is the REST layer for Bitcoin.com's Cloud. More info: [developer.bitcoin.com/rest](https://developer.bitcoin.com/rest). Chatroom [geni.us/CashDev](http://geni.us/CashDev)", + "version": "3.3.8", + "title": "REST", + "license": { + "name": "MIT", + "url": "https://opensource.org/licenses/MIT" + } + }, + "paths": { + "/address/details/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Address details single", + "description": "Returns the details of an address including balance", + "operationId": "detailsSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address in cashAddr or legacy", + "required": true, + "example": "bchtest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2svtllzmlf", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressDetails" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/details": { + "post": { + "tags": [ + "address" + ], + "summary": "Address details bulk", + "description": "Returns the details of multiple addresses", + "operationId": "detailsBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressDetailsArray" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/utxo/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Address utxos single", + "description": "Returns the list of utxo for an address", + "operationId": "utxoSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or an array of addresses in cashAddr or legacy", + "required": true, + "example": "bchtest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2svtllzmlf", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxo" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/utxo": { + "post": { + "tags": [ + "address" + ], + "summary": "Address utxo bulk", + "description": "Returns the utxo of multiple addresses", + "operationId": "utxoBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxoArray" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/unconfirmed/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Unconfirmed transactions for an address", + "description": "Returns the list of unconfirmed transactions for an address", + "operationId": "unconfirmedSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address or an array of addresses in cashAddr or legacy", + "required": true, + "example": "bchtest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2svtllzmlf", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUnconfirmed" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/unconfirmed": { + "post": { + "tags": [ + "address" + ], + "summary": "Unconfirmed transactions for array of addresses", + "description": "Returns the list of unconfirmed transactions for an array of addresses", + "operationId": "unconfirmedBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/AddressUtxoArray" + } + } + } + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/transactions/{address}": { + "get": { + "tags": [ + "address" + ], + "summary": "Transactions for an address", + "description": "Returns the list of transactions for an address", + "operationId": "transactionsSingle", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "the address in cashAddr or legacy", + "required": true, + "example": "bchtest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2svtllzmlf", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/address/transactions": { + "post": { + "tags": [ + "address" + ], + "summary": "Transactions for an array of addresses", + "description": "Returns the list of transactions for an array of addresses", + "operationId": "transactionsBulk", + "requestBody": { + "description": "Array of addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Received an invalid Bitcoin Cash address as input.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid Bitcoin Cash address as input." + } + } + } + } + } + } + }, + "/address/fromXPub/{xpub}": { + "get": { + "tags": [ + "address" + ], + "summary": "Address from extended public key and hdpath", + "description": "Returns an address for an extended public key and hdpath", + "operationId": "fromXPubSingle", + "parameters": [ + { + "name": "xpub", + "in": "path", + "description": "the extended public key", + "required": true, + "example": "tpubDHTK2jqg73w3GwoiHfAMbMYML1HN8FhrUxD9rFgbSgHXdwwrY6pAFqKDfUHhqw7vreaZty5hPGjb1S7ZPQeMmu6TFHAKfY9tJpYbvaGjPRM", + "schema": { + "type": "string" + } + }, + { + "name": "hdPath", + "in": "query", + "description": "The HDPath. Defaults to the first BIP44 external change address", + "required": false, + "example": "", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/block/detailsByHash/{hash}": { + "get": { + "tags": [ + "block" + ], + "summary": "Block details single", + "description": "Details about a single block by hash", + "operationId": "detailsHashSingle", + "parameters": [ + { + "name": "hash", + "in": "path", + "description": "Block hash", + "required": true, + "example": "0000000000262e9a70fae6c38cc9a91af2819b04521d2e9e99b7ae0328ee429d", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block hash.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block hash." + } + } + } + } + } + } + }, + "/block/detailsByHash": { + "post": { + "tags": [ + "block" + ], + "summary": "Block details bulk", + "description": "Details about multiple blocks by hashes", + "operationId": "detailsHashBulk", + "requestBody": { + "description": "Array of hashes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHashes" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block hash.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block hash." + } + } + } + } + } + } + }, + "/block/detailsByHeight/{height}": { + "get": { + "tags": [ + "block" + ], + "summary": "Block details single", + "description": "Details about a single block by height", + "operationId": "detailsHeightSingle", + "parameters": [ + { + "name": "height", + "in": "path", + "description": "Block height", + "required": true, + "example": "500000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/block/detailsByHeight": { + "post": { + "tags": [ + "block" + ], + "summary": "Block details bulk", + "description": "Bulk details about blocks by heights", + "operationId": "detailsHeightBulk", + "requestBody": { + "description": "Array of heights", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeights" + } + } + } + }, + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDetails" + } + } + } + }, + "400": { + "description": "Received an invalid block height.", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Received an invalid block height." + } + } + } + } + } + } + }, + "/blockchain/getBestBlockHash": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Hash of the best block in the longest blockchain.", + "description": "Returns the hash of the best (tip) block in the longest blockchain.", + "operationId": "getBestBlockHash", + "responses": { + "200": { + "description": "successful response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BestBlockHash" + } + } + } + } + } + } + }, + "/blockchain/getBlockchainInfo": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Info regarding blockchain processing", + "description": "Returns an object containing various state info regarding blockchain processing.", + "operationId": "getBlockchainInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockchainInfo" + } + } + } + } + } + } + }, + "/blockchain/getBlockCount": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Number of blocks in the longest blockchain.", + "description": "Returns the number of blocks in the longest blockchain.", + "operationId": "getBlockCount", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockCount" + } + } + } + } + } + } + }, + "/blockchain/getBlockHeader/{hash}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Information about blockheader hash", + "description": "If verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'. If verbose is true, returns an Object with information about blockheader hash.", + "operationId": "getBlockHeaderSingle", + "parameters": [ + { + "name": "hash", + "in": "path", + "description": "the block hash", + "required": true, + "example": "0000000000262e9a70fae6c38cc9a91af2819b04521d2e9e99b7ae0328ee429d", + "schema": { + "type": "string" + } + }, + { + "name": "verbose", + "in": "query", + "description": "true for a json object, false for the hex encoded data", + "required": false, + "example": true, + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeader" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getBlockHeader": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Bulk information about blockheader hash", + "description": "Bulk information about blockheader hash", + "operationId": "getBlockHeaderBulk", + "requestBody": { + "description": "Array of hashes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hashes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockHeader" + } + } + } + }, + "400": { + "description": "Block not found", + "content": { + "application/json": { + "schema": { + "status": 500, + "message": "Block not found" + } + } + } + } + } + } + }, + "/blockchain/getChainTips": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Information about all known tips in the block tree", + "description": "Return information about all known tips in the block tree, including the main chain as well as orphaned branches.", + "operationId": "getChainTips", + "responses": { + "200": { + "description": "successful operation" + } + } + } + }, + "/blockchain/getDifficulty": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Proof-of-work difficulty", + "description": "Returns the proof-of-work difficulty as a multiple of the minimum difficulty.", + "operationId": "getDifficulty", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Difficulty" + } + } + } + } + } + } + }, + "/blockchain/getMempoolEntry/{txid}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Mempool data for transaction", + "description": "Returns mempool data for given transaction", + "operationId": "getMempoolEntrySingle", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id (must be in mempool)", + "required": true, + "example": "40112ab9d2b5f98427839272d7a1e23dd2afc6c8355626f373e076c2ab5c2f72", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolEntry": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Mempool data for transaction", + "description": "Returns mempool data for given transaction", + "operationId": "getMempoolEntryBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Txids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not in mempool" + } + } + } + }, + "/blockchain/getMempoolInfo": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "The active state of the TX memory pool.", + "description": "Returns details on the active state of the TX memory pool.", + "operationId": "getMempoolInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MempoolInfo" + } + } + } + } + } + } + }, + "/blockchain/getRawMempool": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "All transaction ids in memory pool.", + "description": "Returns all transaction ids in memory pool as a json array of string transaction ids.", + "operationId": "getRawMempool", + "parameters": [ + { + "name": "verbose", + "in": "query", + "description": "True for a json object, false for array of transaction ids", + "required": false, + "example": true, + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/RawMempool" + } + } + } + } + } + } + }, + "/blockchain/getTxOut/{txid}/{n}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Details about unspent transaction output.", + "description": "Returns details about an unspent transaction output.", + "operationId": "getTxOut", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "the transaction id", + "required": true, + "example": "40112ab9d2b5f98427839272d7a1e23dd2afc6c8355626f373e076c2ab5c2f72", + "schema": { + "type": "string" + } + }, + { + "name": "n", + "in": "path", + "description": "vout number", + "required": true, + "example": 0, + "schema": { + "type": "number", + "default": 0 + } + }, + { + "name": "mempool", + "in": "query", + "description": "Whether to include the mempool", + "required": false, + "example": "false", + "schema": { + "type": "boolean", + "default": false + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid value/s - Null" + } + } + } + }, + "/blockchain/getTxOutProof/{txid}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Hex-encoded proof that single txid was included.", + "description": "Returns a hex-encoded proof that 'txid' was included in a block.", + "operationId": "getTxOutProofSingle", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "a txid string", + "example": "40112ab9d2b5f98427839272d7a1e23dd2afc6c8355626f373e076c2ab5c2f72", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/getTxOutProof": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Hex-encoded proof that multiple txids wwere included.", + "description": "Returns a hex-encoded proof that multiple txids were included in a block.", + "operationId": "getTxOutProofBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Txids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/verifyTxOutProof/{proof}": { + "get": { + "tags": [ + "blockchain" + ], + "summary": "Verify that a single proof points to a transaction in a block", + "description": "Verifies that a proof points to a transaction in a block, returning the transaction it commits to and throwing an RPC error if the block is not in our best chain", + "operationId": "verifyTxOutProofSingle", + "parameters": [ + { + "name": "proof", + "in": "path", + "description": "The hex-encoded proof generated by gettxoutproof", + "example": "00000020166b6d1080a6d0a48a6c3556e275e86606ae217d7f9c53723b03000000000000a7b3c46a4c4b46cce03ebfe8b7cc32759e4f0dece66a20fb7d79577aadc8edf69425185cffff001d2261092aff00000009e8bfb50fb37d3f40b53eb8229f031a30e897aa9880d6b4db37cbb7c2b83b1e4f609b5095caa6d37d0a374b92e197fd424540f66999c0b6b50681a9ccf2e05ff2722f5cabc276e073f3265635c8c6afd23de2a1d77292832784f9b5d2b92a11408e66784a2e2183a898b03267c115da1b78cf0cd275d83c3cc22bb96940635c41669843b5c9211b26604659ad5943cf2b33217f69f6d67d728ee34bda219ede0a626804059d2540cd7f50114794c6ff18b6a790c671ba488525819c13fd32101932fd3506c9305134c6839c2945b8239ba52a60ac10577d6dc6b158e3c179bb91a7911dc11f8c5f052f808ef76c25ed638aaca31eb045a35ef00718718a0ad914607937c8c3dcee995ac145476cb4d83a4250f46c46990df568b6ee0796b3995f03bb0700", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/blockchain/verifyTxOutProof": { + "post": { + "tags": [ + "blockchain" + ], + "summary": "Verify that bulk proofs point to transactions in a block", + "description": "Verifies that bulk proofs point to transactions in a block", + "operationId": "verifyTxOutProofBulk", + "requestBody": { + "description": "Array of proofs", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Proofs" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Invalid tag value" + } + } + } + }, + "/control/getInfo": { + "get": { + "tags": [ + "control" + ], + "summary": "Various state info.", + "description": "Returns an object containing various state info.", + "operationId": "getInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Info" + } + } + } + } + } + } + }, + "/mining/getMiningInfo": { + "get": { + "tags": [ + "mining" + ], + "summary": "Returns a json object containing mining-related information.", + "description": "", + "operationId": "getMiningInfo", + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MiningInfo" + } + } + } + } + } + } + }, + "/mining/getNetworkHashps": { + "get": { + "tags": [ + "mining" + ], + "summary": "Estimated network hashes per second", + "description": "Returns the estimated network hashes per second based on the last n blocks. Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change. Pass in [height] to estimate the network speed at the time when a certain block was found.", + "operationId": "getNetworkHashps", + "parameters": [ + { + "in": "query", + "name": "nblocks", + "description": "the number of blocks, or -1 for blocks since last difficulty change.", + "required": false, + "example": 120, + "schema": { + "type": "number" + } + }, + { + "in": "query", + "name": "height", + "description": "to estimate at the time of the given height.", + "required": false, + "example": -1, + "schema": { + "type": "number" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/NetworkHashps" + } + } + } + } + } + } + }, + "/rawtransactions/decodeRawTransaction/{hex}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Return the hex encoded transaction.", + "description": "Return a JSON object representing the serialized, hex-encoded transaction.", + "operationId": "decodeRawTransactionSingle", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The transaction hex string", + "required": true, + "example": "02000000010e991f7ccec410f27d333f737f149b5d3be6728687da81072e638aed0063a176010000006b483045022100cd20443b0af090053450bc4ab00d563d4ac5955bb36e0135b00b8a96a19f233302205047f2c70a08c6ef4b76f2d198b33a31d17edfaa7e1e9e865894da0d396009354121024d4e7f522f67105b7bf5f9dbe557e7b2244613fdfcd6fe09304f93877328f6beffffffff02a0860100000000001976a9140ee020c07f39526ac5505c54fa1ab98490979b8388acb5f0f70b000000001976a9143a9b2b0c12fe722fcf653b6ef5dcc38732d6ff5188ac00000000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeRawTransaction" + } + } + } + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/decodeRawTransaction": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Return bulk hex encoded transaction.", + "description": "Return bulk hex encoded transaction.", + "operationId": "decodeRawTransactionBulk", + "requestBody": { + "description": "Array of hexes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hexes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeRawTransaction" + } + } + } + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/decodeScript/{hex}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Decode a hex-encoded script.", + "description": "Decode a hex-encoded script.", + "operationId": "decodeScriptSingle", + "parameters": [ + { + "in": "path", + "name": "hex", + "description": "The hex encoded script", + "required": true, + "example": "02000000012d2ec73b12ecb96fbf104fa0325e39bc4e49818709594ba2128635aedfb820a1010000006a47304402203c63866eab7ffca27ed6437a028de9b2cc83dd1ed96f0f496742cf70c6ca50b8022007f3c7fc8729f52d8d0e626c6328012691fa6b3a317c66408e2ccc84a6538e9741210360cfc66fdacb650bc4c83b4e351805181ee696b7d5ab4667c57b2786f51c413dffffffff036a929800000000001976a914eb4b180def88e3f5625b2d8ae2c098ff7d85f66488ac00000000000000006a6a4c67087768630000003201000800000000426974636f696e2e636f6d00426974636f696e20466978656420546f6b656e20546573740054535400646576656c6f7065722e626974636f696e2e636f6d004d616465207769746820424954424f5800000000174876e80022020000000000001976a914eb4b180def88e3f5625b2d8ae2c098ff7d85f66488ac00000000", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DecodeScript" + } + } + } + }, + "400": { + "description": "Argument must be hexadecimal string" + } + } + } + }, + "/rawtransactions/decodeScript": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Decode multiple hex-encoded scripts.", + "description": "Decode multiple hex-encoded scripts.", + "operationId": "decodeScriptBulk", + "requestBody": { + "description": "Array of hexes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hexes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "TX decode failed" + } + } + } + }, + "/rawtransactions/getRawTransaction/{txid}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Return the raw transaction data.", + "description": "return the raw transaction data. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.", + "operationId": "getRawTransactionSingle", + "parameters": [ + { + "in": "path", + "name": "txid", + "description": "The transaction id", + "required": true, + "example": "40112ab9d2b5f98427839272d7a1e23dd2afc6c8355626f373e076c2ab5c2f72", + "schema": { + "type": "string" + } + }, + { + "in": "query", + "name": "verbose", + "description": "If false, return a string, otherwise return a json object", + "required": true, + "example": true, + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GetRawTransaction" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/getRawTransaction": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Return raw transaction data for multiple transactions.", + "description": "Return the raw transaction data for multiple transactions. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.", + "operationId": "getRawTransactionBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/RawTxids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/sendRawTransaction/{hex}": { + "get": { + "tags": [ + "rawtransactions" + ], + "summary": "Submits single raw transactions to local node and network.", + "description": "Submits single raw transaction (serialized, hex-encoded) to local node and network.", + "operationId": "sendRawTransactionSingle", + "parameters": [ + { + "name": "hex", + "in": "path", + "description": "the raw transaction hex", + "required": true, + "example": "", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/rawtransactions/sendRawTransaction": { + "post": { + "tags": [ + "rawtransactions" + ], + "summary": "Submits multiple raw transactions to local node and network.", + "description": "Submits multiple raw transaction (serialized, hex-encoded) to local node and network.", + "operationId": "sendRawTransactionBulk", + "requestBody": { + "description": "Array of raw tx hexes", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Hexes" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation" + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/transaction/details/{txid}": { + "get": { + "tags": [ + "transaction" + ], + "summary": "Transaction details single", + "description": "Details about a single transaction", + "operationId": "transactionDetailsSingle", + "parameters": [ + { + "in": "path", + "name": "txid", + "description": "single txid or url encoded array of txids", + "required": true, + "example": "40112ab9d2b5f98427839272d7a1e23dd2afc6c8355626f373e076c2ab5c2f72", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TransactionDetails" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/transaction/details": { + "post": { + "tags": [ + "transaction" + ], + "summary": "Transaction details bulk", + "description": "Bulk Details about a transaction", + "operationId": "transactionDetailsBulk", + "requestBody": { + "description": "Array of txids", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Txids" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TransactionDetails" + } + } + } + }, + "400": { + "description": "Transaction not found" + } + } + } + }, + "/util/validateAddress/{address}": { + "get": { + "tags": [ + "util" + ], + "summary": "Information about single bitcoin cash address.", + "description": "Return information about single bitcoin cash address.", + "operationId": "validateAddressSingle", + "parameters": [ + { + "in": "path", + "name": "address", + "description": "The bitcoin address to validate", + "required": true, + "example": "bchtest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2svtllzmlf", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidateAddress" + } + } + } + }, + "400": { + "description": "Invalid Address" + } + } + } + }, + "/util/validateAddress": { + "post": { + "tags": [ + "util" + ], + "summary": "Information about bulk bitcoin cash addresses.", + "description": "Return information about bulk bitcoin cash addresses.", + "operationId": "validateAddressBulk", + "requestBody": { + "description": "Array of Addresses", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Addresses" + } + } + } + }, + "responses": { + "200": { + "description": "successful operation", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidateAddress" + } + } + } + }, + "400": { + "description": "Invalid Address" + } + } + } + }, + "/slp/list": { + "get": { + "tags": [ + "slp" + ], + "summary": "list", + "description": "List all SLP tokens", + "operationId": "listAll", + "responses": { + "200": { + "description": "successful response" + } + } + }, + "post": { + "tags": [ + "slp" + ], + "summary": "list token information", + "description": "List multiple SLP tokens by id", + "operationId": "listBulk", + "requestBody": { + "description": "", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SLPListBulk" + } + } + } + }, + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/list/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list token", + "description": "List single SLP token by id", + "operationId": "listSingle", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "650dea14c77f4d749608e36e375450c9ac91deb8b1b53e50cb0de2059a52d19a", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/convert/{address}": { + "get": { + "tags": [ + "slp" + ], + "summary": "convert address to slpAddr, cashAddr and legacy", + "description": "convert address to slpAddr, cashAddr and legacy", + "operationId": "convert", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/convert": { + "post": { + "tags": [ + "slp" + ], + "summary": "convert address to slpAddr, cashAddr and legacy", + "description": "convert address to slpAddr, cashAddr and legacy", + "operationId": "convertBulk", + "requestBody": { + "description": "", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SLPConvert" + } + } + } + }, + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balancesForAddress/{address}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list slp balances for address", + "description": "List SLP token balances for address", + "operationId": "balancesForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "slptest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2shlcycvd5", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balancesForToken/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list SLP addresses and balances for tokenId", + "description": "List SLP addresses and balances for tokenId", + "operationId": "balancesForTokenSingle", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The slp tokenId", + "required": true, + "example": "df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/balance/{address}/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "list single slp token balance for address", + "description": "List single SLP token balance for address", + "operationId": "singleBalanceForAddress", + "parameters": [ + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "simpleledger:qz9tzs6d5097ejpg279rg0rnlhz546q4fsnck9wh5m", + "schema": { + "type": "string" + } + }, + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "1cda254d0a995c713b7955298ed246822bee487458cd9747a91d9e81d9d28125", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/validateTxid/{txid}": { + "get": { + "tags": [ + "slp" + ], + "summary": "Validate single txid", + "description": "Validate single txid", + "operationId": "validateTxidSingle", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The txid", + "required": true, + "example": "1cda254d0a995c713b7955298ed246822bee487458cd9747a91d9e81d9d28125", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/validateTxid": { + "post": { + "tags": [ + "slp" + ], + "summary": "Validate multiple txids", + "description": "Validate multiple txids", + "operationId": "validateTxidBulk", + "requestBody": { + "description": "", + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SLPTxids" + } + } + } + }, + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/tokenStats/{tokenId}": { + "get": { + "tags": [ + "slp" + ], + "summary": "List stats for a single slp token", + "description": "List stats for a single slp token", + "operationId": "singleTokenStats", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The token id", + "required": true, + "example": "df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/txDetails/{txid}": { + "get": { + "tags": [ + "slp" + ], + "summary": "SLP transaction details", + "description": "Transaction details on a token transfer.", + "operationId": "txDetails", + "parameters": [ + { + "name": "txid", + "in": "path", + "description": "The BCH transaction ID", + "required": true, + "example": "57b3082a2bf269b3d6f40fee7fb9c664e8256a88ca5ee2697c05b9457822d446", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + }, + "/slp/transactions/{tokenId}/{address}": { + "get": { + "tags": [ + "slp" + ], + "summary": "SLP transactions by tokenId and address", + "description": "Transactions by tokenId and address.", + "operationId": "txsTokenIdAddressSingle", + "parameters": [ + { + "name": "tokenId", + "in": "path", + "description": "The BCH tokenId", + "required": true, + "example": "495322b37d6b2eae81f045eda612b95870a0c2b6069c58f70cf8ef4e6a9fd43a", + "schema": { + "type": "string" + } + }, + { + "name": "address", + "in": "path", + "description": "The slp address", + "required": true, + "example": "qrhvcy5xlegs858fjqf8ssl6a4f7wpstaqlsy4gusz", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "successful response" + } + } + } + } + }, + "servers": [ + { + "url": "/v2" + } + ], + "tags": [ + { + "name": "address", + "description": "Address details and utxo", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/address" + } + }, + { + "name": "block", + "description": "Block Details", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/block" + } + }, + { + "name": "blockchain", + "description": "Interacting w/ the BCH Blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/blockchain" + } + }, + { + "name": "control", + "description": "Control your blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/control" + } + }, + { + "name": "mining", + "description": "Mining w/ the BCH Blockchain", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/mining" + } + }, + { + "name": "rawtransactions", + "description": "Create transactions to be transmitted to the network.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/rawtransactions" + } + }, + { + "name": "transaction", + "description": "Transaction details.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/rawtransactions" + } + }, + { + "name": "util", + "description": "Bitcoin Cash utilities.", + "externalDocs": { + "description": "Find out more", + "url": "https://developer.bitcoin.com/rest/docs/util" + } + } + ] +} \ No newline at end of file diff --git a/dist/public/favicon.png b/dist/public/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..29d6814ad6aebd8a0f14bdb4e3917edc1512762e GIT binary patch literal 4385 zcmV++5#H{JP)xM4G<1^+D6_^DDJ01^oRDSRm}8vr>9fL!K@B{Bf4004}a$i!p37XVn2 zgv2BOtaXgj$GK~aQ^r~GttKYQ9{_s`K%#NEl5_ytSTA-CFI@&eV*`Mlh%XQU(8l_D z@iMr40NO?Xn3kQrXpBz)fJMsRbkhGrGexP%<)$lnd@tXE6d;g_h1|Surw<=Y_i5*nU~0; zlryJEf|PsAmQK#b<4*RHWyFL`&XAy-ho2e{sLYFEmGxqopHfpSjGUZb7_7`obE1`N zWs(?WK9d_7IjIw=JRk4}0f-12OdnbUg`#Ao)-`x3j&k#-0WG=TIz>5Tc)lcSRfKf3` z%n-A|Trqzv0!zZuFbTE-E5^#P8mtj(!#c4Wm;!r=eZ&!POdK0$gY&?J;9_w+++y4c z+%$GR?W zk_<==q##lfNkm#rDktqHog!T)Jtd8h8DvwkJ2`^PC+Cq%$$QCdLKbyY9I9@O`T>%^QXs=j298DmaL}HKd`gF+(FxBUhtJtOEnK`-q!pyMQ@7ll+-EfrZi5uKIOgER4pH^RIOsICaqgqpS0Q9f!bNxo3vZB zAL`(AtaRq+EYaDeb6)4=RMu3Fsl2JhQx8wQr;F-Z=|<@;)!n1pr8}&ruNSN**4wUk zR_~?0roNAUrv4WFQ~HAjOam_ifx#Ao(+1Dk8f;&-kX^w(#~w1&H4HJ78}2sjHXJcB zH;Oe{ZPaA+(3oQEYMf@g#kj+G$i%>8mdP@c29tZHWK&nu4AX62%+2D>)|$1L zJu}xb=a}c4H<&-Lpj&ubEVihzxM@kSbhXT~+-Z5u3bk^w%CM@kx@wJDJ6j8^cUt#M z!%uUYCYn|=t=EQT<7<;+(_qtQt7#id_RSq{D>5f5;D;--MU(c|fkve17j5|(Dr&&&GojRPpIJ-DYoEx17 zT})h(U3R$iy0Tm&UDvx_bi=#(xvg|N;r7wp*lH{T|O|n$Jv~xp!v2 zr;#VubGN6$i|v){^`n=<+t8cqUE}@O$JmGOQ|t58*U~rB_kiy!KRZ8(-!Z@U{_g(E z{o4bufZ%}QfbKx`z}Udbz(+wwLFqvaK|{e#!ApbNL+~MCA)7*aIeHu(r=Bwu>Jqv< z^jsJ%EIO<*>~XkNxFo!77CI|**5+9cW}D6y&2EW+2u{T2h=-Bpk&7dLnM0TpIj3sQ zlPLSBWl^2c%;<&D`=j5*_{EgQ+>f=0mB)6(sm9HVtB-ph9}r&_uSl4lusq>PqE4b9 zu{DX96qi(+G(0zO?$)^j^PJ`t&AUC{e17iyOAB-s2p61OsJf85@JKQ~IX-!R@@H-Y zw}v~M!b#bYGQ{)eZR5S*`|!8$2U9&$%Tk}Fd8U=6JxljY-<&>};hj;Q@lxO~s1&@; z49Tp{e4iDOwJ&Q_7%yzfCS@mQ9~Y^MvP9<==`YG%)FZYQ7l{>%-4}0NJR}K|)JhTQ zd}*tUB@@fK44181 z*0ZT@?;46! ziX=t7YdzLhe~$93D+eJ$n}UoNpLDKGiFp11z;5B5J){4ly9Z9{jdbLp;) zgpHz&w>Nojsw-0~%P;HSJZp3F7WS6nEpN9j+vogv8@GS1 z%&5FoWXx ze{%h)zE-EUr1r}`(LP08RNc9Hm-_nsy8BBT&<1(K;DLDut{n_G*xG2*xVuTSspJqG zk{^2hbMnu(4~HG@IO2Mw@u=z19mkl*ikp$5HBhPh4`pbo{dG<(4bXSDL$=x{m$o^y{&1=kDgKE>~Nxxm|1Pnb~vdy7%=nHv(>4 zxXHPB<<{(5J-1_T-|3y#tGL6z^X#th?(2Iw_eSm)JitFFe#m%O{z&&x&2N^!H7T4G zC;I~Wx*kVAzTeO5fAPEY_s;``Pv}p|pBg-^f9CM)#9+|iwdZr654;e+7&?M*Gdaw=>>$3`Y(>dYAofTlr;u%{hh%(ijb0k*dTm=*vq+5sYc0AhRqb#zod{|;%Iqrg{fq8UZ_nx!OJ-4Mr8Ev77lbnyauf5J% zd#}9@F*E+ppIPn(5BC6OB{;cnt$XP4H=sO&Vl5r!+^uUwd}+};`uvOX*oSw442b%h z-lW*#hefCX>h$-Za3d(z0mN^*&e9Ok(pq(4#KYC;on>2 ziBB2A1n2v%15g9u)TonRwyJ@z0lOL?|C2NY3>5n3!yT@Go1PWmWI$LfqRq?I;Jz%o z8Ak_W&);##Xjr!tZc4(<3?sySFv5AL(tiS=ayd}^YFR(ntB1Zn`V7I}J(R})k8P8T zVCO6qKqazby`p;Q9!jiunas)#QManB1mywjZkGD1!UBXd0)hdVhXzG7j%pscW{fNX zWD&6AX|rkbMx*)u-B8}-0C)!`m#kQ7-1}5+v*yKnXcV0324{|r;FVD6E*N#!15PbC+ub-?Ib=9z zAe>WE1Aw7m*nkL)^9N`{@^iqyCL(hxWa{uHEs-pM;!E~Z?aJ&F0AQbf0i$Bf7shn) z^T6QTi6-~>Coic?*L=;o8FkI3El-ht=TZQWF0}-w54Qs(F943gu)S05v*D&IeU`|G zoHQ3~+fMN%KLhF#0cf+478jFO{b%0#j>nQkqIEaLuH30h)UTFHmp~{8^E8M?xEDOm zju}J(%++wyCWJ+@f6u)t)754zd440s79F}Y0KV0lktBs1S|PJ3t*;TmIeTTv57c z^|DZ@j=+?J4VL+o2C2Jc(Y}aYz-5C|RSS%!Er1mTlteHm_JfK^i1-0zh^hSmlCA=e*zrP;3#*<_Cg$_i|%a>@$%c07tWaMb@aH1MBr1p-K>ure7z= zKzIg(6$K~v=g%?0t`dp1lreWJ#s<}K24fZj!zm0zz3x|D<6Lip{?7%7hFjm66adxx z`DUoXES2tP)jl8aQpH~OS=qg#;E!A9cWdEmE;!wp;C$a|&K+B*gL_$snq>!!#`Pae zZYutAUJ1&zG|l5XpHI0?x-xd{4<_h zd5ll20Yn%mo*LkE=Ubw21E_K?koqNHN}nOr z#U0HkG#&mJtz$V literal 0 HcmV?d00001 diff --git a/dist/public/logo.png b/dist/public/logo.png new file mode 100755 index 0000000000000000000000000000000000000000..182e10d3a6aed47958349beacb6704ce64d3e525 GIT binary patch literal 4900 zcmV+<6Wi>GP)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 zVoOIv00000008+zyMF)x010qNS#tmY3labT3lag+-G2N401}8vL_t(|+U=crxD?fu zz<&p%6&1my-7sp5g8Pz1MaPMsIzE%AFd8%NsF{q>Z&Zvr6GcHybdro3OeFZ9tEZX zp8@X!D}V*S)47h~>uGdaRd)k+cK!bhm@XnOwDU%O*-+I!nAu`oSF{4SQ$#*&ci%EH z%9IBMw&*&(^r-4(z*$wr_lU@MlgP`+ zXa=qRMBN(U}~w5 zUo+;ps|U(^x9M8GtoZbh=^&$9Q6AtvYg7CC12@DxCuHOKwBCuTx~8g*SJjtQ^%Yfp zPE}89)3txm@#&$i4l*)YN!bQBgwBf!zs433s`=*_veyI#0NVlw0o&B5dql3IcuN$a zsyY~W3Y!I%Sq5w?A`9!B`vYJ?Rq;o_S|aj!DtGitf~sB&Tu@a!PDGAwci%EH%80M9 zRLIW;cBwAUbrhwZz<@jfjs~s=`g*F&1Gdj~6eBHmsOr~%9bNxF2WE=Mn-R_%feqf( ztScf*8@`)gB2={(W``@UqJ988AR^f;E~DF!#K<2TH*k$974o0Zbp{1C%NqjxJ&HUL zc?o!_RW~W4D{jX7aJ&1Fkx`45E;8ggiZ=s)4IJLD-8Um6Bco^0j#bogf%08qNy*5_ z$f!d*2Do{F^7YzzBQi2FdLAvY!Bw#&P@ZT3qr0N28(?+5E;PUq_bd$Hqj@xxvFl6Wf$53*ueGaO)SmYG!gkYhO9xD8EZ@IIamg~13V2p zEF#N&=e1*i>lY|5M!e7*a3gRamY(SYV6upu8mNCPu&=w;?E_-3Rn<~e*;3$I5qUo9 zg{kUVSbXmBMDyx@S5+sub{IC{08tlU~5IC3_MC6%-ZGIj2J*IO7<^#h;QO4>XO{|jt^P}LQ#`Uq_+*y~`H>NC@+8BR}*r(pA`eRjH z+(28CRdusC_tLd{YJ=@gP}MEswCmcQ5chtm>TZEPtXolMu&Pc^a2+ItDvfz0QUjc0qZx=)==PSRXsdPWwpWZA>f(@+x-FXl&T&T^E_X+ znYHSi)4x`^s_qNSAX!Z7!N3?*ZMvz$>HJ>O(fO0A`u&LQZVEhr&4M>*pxv_0kBxcW zCZ4jq>)V>Zoxo3t7qYhpFuqc6ZjhQqe9wx_fT?Px0-(hMT&a*h3I8X@>|952Ruh_B z(ct+tr@LzQp}%9Fz-iDQ__M06UaOLO03O9`Q)$o-7^@bY&=yp6PvCA~od(1V1OBDS z{oES(8|k?OfBMJy%ZAe`P*bsKCD-zcH1O@UvQ z|EDE3I2Xxq686UP@gGfU`axha_E7W&*1#Vm{vKvisAM^CVMwrho8Cv~JbKkE0PX^2 z0*hQ58)1t82jf@bGHh>)P`g_J_v7B20p?_B#xPY@VrRo1B1u zb~?k!TIyu|6PBIG$8oAUQbZQU8sJKW{Jt?SegL+bcLebDK%L8T9mRW--P_u@u%VUl zv#NR_Fxpdfi#VZL?u|8;@Zk0$W*EIa5aW7-n!)`rY!Ka{;@G(%W4WsK1*Q-l+@=HP zh)Bqp`U*FFKg<2~@zl9URp*Gvl!UiE3Fp%F^JfZhsff(*+=qdzT4<_fM^)Xi+VI^d z6*}KCP$jC)hXNO4p@wD73&lb^olhn_xXr*8ccul7U!k_jTGn~aQ)jf(`E3bqOT9HbJVHN*g0h}Nr!Q=}f@`kD&3OtT~Wqb%WlSz}437aCu13wgz4{8Z;I=@X- z?_`zE3nKErHBK9aZSdsdQf%e0p3dI^&T~4Sf?wyqSJg*c-8dXb=h^fq5&2o59|~Nf zs@r3OQ#I9N!D!%Tz8Ai`msdNJ!5JP|djQw9D<9kvEQ83IQ3LF|3#z&{_6GLxC*Zg^ zX}d+_6A}59hEWq?o&1TTvUA6WACY1{L+e(FeBP(aE zW_X}{gou39j0WARs?WWq1T>VeQ$+p(O!ORD130o7*Aw8OI-lphzAwQRAF4_Fc{)B& z{*xx^ybpeze*&D|$e=1B_mjTP&xx5TtJVNFGES5Ow!l)&IuL&q^{SZldt+1IT?qS> z4Z~8G@0;r=mZA!72dcU;{>73fMWiVUC5|EZXN}|B8>~?-!xn<7IT-V~Y6VGGZWm#$ z0hRPiBFKlT=J9*cKO-VheK(V^7ykI{aU$|c3i5x6U+0HlzLjx!A;I$>vh^**?1XW6 z+f%mM%KtnIK*>|1tfsgU13y2Q3HI8Z*lP3`_QmXzA~l8yG$nBijy zxvv`s{|^e3M+)O>fRN6o#gbAR-}AFJ&VChxhZ3|M+9Dv$>ubFYF4s}K2y;)UrZ?Sx z1{VqwOSH#p3^w(YEfkUWQ*2{?pgbQ-N-~~oK^sXK7$|?G$?f`{wM8QGUTjHWLOS0t zrkpgRkY=VRt8I%6p{4O7T+~B%C1kvAw!fHfB`uB-HVUC@=pRc;GV1Q9(MCc6{As>i zeE1x4BfB3(B=mV7$A-Bij$2d&-fmpPD%vu@`J-VQfd>rhR8mBr2Bj<7m-iWyufz4iOdO< z4~`|JwJZ&kr|oxDjqk0ti3{UNi%{5EtD+gYD@z0AvCZ^hB#ZA7p z5UKCa+|B_mbQ1@(u}}2~?c}w4liPj4Qzq0&1{o7yilUEzSDSoo-JKT$;C2X}3s4wmZ2w<0?+r7*Cbz%}>{;LX7?b2@!b-2<7h@sj8#m?hBx*8>#9< z;C)psxIpXbcAp?TdmI<{fp=LW3i$0XA7Q&9WdI`bGH^rS@OcS!zF~#V@2jEnu>ld| zR5g|j)@6s83heAT{4qUH=PeuHN`<_X3i;!J+wpHo@h+C7wP`qq#7Tj}m#ONtE){t_ z&L!-ScoA@yGvd}nRr{*y2rL^ydE=1-fqxC0@{>TjeSt};dQ}wrjH(_2%qF}NIMNN| zJrY&D#O=Ve)cws>)q490jKpt$1=IOG5p}-0N9X$k{}wpqO#C`u9k^9he-lIJa|p-Q zp6^mA^(a;YC>8SCVyVT;cn#O3LVj3G`GRG^7z7+j?Om#Vn(HXW%_f?JOM#>C53;9V zIkBF^a!gIf_L1zgvMVA*RXqkX$oi)G-vQ>i%&n8Lnd2MSr|r5}R^9`#)HJ@ZnBjQ# zuMm-is(K{wmq5Fx11G5J7;FQVIheP4A1tVPA1wddZiJZ#{JI5tXbW!UdR|p=e{28? zE~<#gVyE*0{(Ij+XPwW)_GkDEb70>Q+ehF?{OQM!!;{5BL>8&-4SIi|-P5pzhqBI} z#3lO-&P3!9%vjv$vi?iJ_eA83m=2!47{q!y2nL84VCMD+T~pP}!5_{PL_}0Xt^~g3`r|XIe@=w_R3h@4h#ZRT`#70+(HPHT zx%aoKv%8Y7-J*ybi`iGkVymA~c^sQHZ0`o?xQwA|KzO~xpO4ek&+!$)5h76-M^_h) zTKl5Dg+C8ktOS-KvOq+JVm7YZh^O-xFjuLqL?qV2n$!7lm>qQt@pL{1_z|#OLY<&Zp`CY^7{FESK3@*qd<~7FYQg@Suo1mqL5%VnOEuyeT4!BAnA3 zGk%x*HNVje5>@?p-EECnt9~ymxj=a_t?oGy`Y-^y_j_UqBL-ropR&$h#(o>k(E0wD zv--B!v(~M2UPD$t%mmaMSS%v1Hy~>*EP23cz`JFCKCkaisgR$IO@%v=>nKV^oqh4| zlX_Jnsm(JoGBVPloi@0PjEsz?k_~Vf85up6&;WOLgtDjT>bp|{?rZl&Wn^Sz0Q^7a WcA$9TmHA5m0000>> 0; + if ("" + n !== t || 4294967295 === n) + return NaN; + t = n; + } return t < 0 ? d(e) + t : t; } + function v() { return !0; } + function g(e, t, n) { return (0 === e || void 0 !== n && e <= -n) && (void 0 === t || void 0 !== n && t >= n); } + function y(e, t) { return b(e, t, 0); } + function _(e, t) { return b(e, t, t); } + function b(e, t, n) { return void 0 === e ? n : e < 0 ? Math.max(0, t + e) : void 0 === t ? e : Math.min(t, e); } + function x(e) { this.next = e; } + function w(e, t, n, r) { var i = 0 === e ? t : 1 === e ? n : [t, n]; return r ? r.value = i : r = { value: i, done: !1 }, r; } + function k() { return { value: void 0, done: !0 }; } + function E(e) { return !!A(e); } + function S(e) { return e && "function" == typeof e.next; } + function C(e) { var t = A(e); return t && t.call(e); } + function A(e) { var t = e && (wn && e[wn] || e[kn]); if ("function" == typeof t) + return t; } + function D(e) { return e && "number" == typeof e.length; } + function O(e) { return null === e || void 0 === e ? B() : o(e) ? e.toSeq() : z(e); } + function M(e) { return null === e || void 0 === e ? B().toKeyedSeq() : o(e) ? a(e) ? e.toSeq() : e.fromEntrySeq() : L(e); } + function T(e) { return null === e || void 0 === e ? B() : o(e) ? a(e) ? e.entrySeq() : e.toIndexedSeq() : q(e); } + function P(e) { return (null === e || void 0 === e ? B() : o(e) ? a(e) ? e.entrySeq() : e : q(e)).toSetSeq(); } + function I(e) { this._array = e, this.size = e.length; } + function R(e) { var t = Object.keys(e); this._object = e, this._keys = t, this.size = t.length; } + function j(e) { this._iterable = e, this.size = e.length || e.size; } + function N(e) { this._iterator = e, this._iteratorCache = []; } + function F(e) { return !(!e || !e[Sn]); } + function B() { return Cn || (Cn = new I([])); } + function L(e) { var t = Array.isArray(e) ? new I(e).fromEntrySeq() : S(e) ? new N(e).fromEntrySeq() : E(e) ? new j(e).fromEntrySeq() : "object" == typeof e ? new R(e) : void 0; if (!t) + throw new TypeError("Expected Array or iterable object of [k, v] entries, or keyed object: " + e); return t; } + function q(e) { var t = U(e); if (!t) + throw new TypeError("Expected Array or iterable object of values: " + e); return t; } + function z(e) { var t = U(e) || "object" == typeof e && new R(e); if (!t) + throw new TypeError("Expected Array or iterable object of values, or keyed object: " + e); return t; } + function U(e) { return D(e) ? new I(e) : S(e) ? new N(e) : E(e) ? new j(e) : void 0; } + function W(e, t, n, r) { var i = e._cache; if (i) { + for (var o = i.length - 1, a = 0; a <= o; a++) { + var s = i[n ? o - a : a]; + if (!1 === t(s[1], r ? s[0] : a, e)) + return a + 1; + } + return a; + } return e.__iterateUncached(t, n); } + function V(e, t, n, r) { var i = e._cache; if (i) { + var o = i.length - 1, a = 0; + return new x(function () { var e = i[n ? o - a : a]; return a++ > o ? k() : w(t, r ? e[0] : a - 1, e[1]); }); + } return e.__iteratorUncached(t, n); } + function H(e, t) { return t ? J(t, e, "", { "": e }) : G(e); } + function J(e, t, n, r) { return Array.isArray(t) ? e.call(r, n, T(t).map(function (n, r) { return J(e, n, r, t); })) : Y(t) ? e.call(r, n, M(t).map(function (n, r) { return J(e, n, r, t); })) : t; } + function G(e) { return Array.isArray(e) ? T(e).map(G).toList() : Y(e) ? M(e).map(G).toMap() : e; } + function Y(e) { return e && (e.constructor === Object || void 0 === e.constructor); } + function K(e, t) { if (e === t || e !== e && t !== t) + return !0; if (!e || !t) + return !1; if ("function" == typeof e.valueOf && "function" == typeof t.valueOf) { + if (e = e.valueOf(), t = t.valueOf(), e === t || e !== e && t !== t) + return !0; + if (!e || !t) + return !1; + } return !("function" != typeof e.equals || "function" != typeof t.equals || !e.equals(t)); } + function X(e, t) { if (e === t) + return !0; if (!o(t) || void 0 !== e.size && void 0 !== t.size && e.size !== t.size || void 0 !== e.__hash && void 0 !== t.__hash && e.__hash !== t.__hash || a(e) !== a(t) || s(e) !== s(t) || l(e) !== l(t)) + return !1; if (0 === e.size && 0 === t.size) + return !0; var n = !u(e); if (l(e)) { + var r = e.entries(); + return t.every(function (e, t) { var i = r.next().value; return i && K(i[1], e) && (n || K(i[0], t)); }) && r.next().done; + } var i = !1; if (void 0 === e.size) + if (void 0 === t.size) + "function" == typeof e.cacheResult && e.cacheResult(); + else { + i = !0; + var c = e; + e = t, t = c; + } var p = !0, f = t.__iterate(function (t, r) { if (n ? !e.has(t) : i ? !K(t, e.get(r, vn)) : !K(e.get(r, vn), t)) + return p = !1, !1; }); return p && e.size === f; } + function $(e, t) { if (!(this instanceof $)) + return new $(e, t); if (this._value = e, this.size = void 0 === t ? 1 / 0 : Math.max(0, t), 0 === this.size) { + if (An) + return An; + An = this; + } } + function Z(e, t) { if (!e) + throw new Error(t); } + function Q(e, t, n) { if (!(this instanceof Q)) + return new Q(e, t, n); if (Z(0 !== n, "Cannot step a Range by 0"), e = e || 0, void 0 === t && (t = 1 / 0), n = void 0 === n ? 1 : Math.abs(n), t < e && (n = -n), this._start = e, this._end = t, this._step = n, this.size = Math.max(0, Math.ceil((t - e) / n - 1) + 1), 0 === this.size) { + if (Dn) + return Dn; + Dn = this; + } } + function ee() { throw TypeError("Abstract"); } + function te() { } + function ne() { } + function re() { } + function ie(e) { return e >>> 1 & 1073741824 | 3221225471 & e; } + function oe(e) { if (!1 === e || null === e || void 0 === e) + return 0; if ("function" == typeof e.valueOf && (!1 === (e = e.valueOf()) || null === e || void 0 === e)) + return 0; if (!0 === e) + return 1; var t = typeof e; if ("number" === t) { + if (e !== e || e === 1 / 0) + return 0; + var n = 0 | e; + for (n !== e && (n ^= 4294967295 * e); e > 4294967295;) + e /= 4294967295, n ^= e; + return ie(n); + } if ("string" === t) + return e.length > Nn ? ae(e) : se(e); if ("function" == typeof e.hashCode) + return e.hashCode(); if ("object" === t) + return ue(e); if ("function" == typeof e.toString) + return se(e.toString()); throw new Error("Value type " + t + " cannot be hashed."); } + function ae(e) { var t = Ln[e]; return void 0 === t && (t = se(e), Bn === Fn && (Bn = 0, Ln = {}), Bn++, Ln[e] = t), t; } + function se(e) { for (var t = 0, n = 0; n < e.length; n++) + t = 31 * t + e.charCodeAt(n) | 0; return ie(t); } + function ue(e) { var t; if (In && void 0 !== (t = On.get(e))) + return t; if (void 0 !== (t = e[jn])) + return t; if (!Pn) { + if (void 0 !== (t = e.propertyIsEnumerable && e.propertyIsEnumerable[jn])) + return t; + if (void 0 !== (t = le(e))) + return t; + } if (t = ++Rn, 1073741824 & Rn && (Rn = 0), In) + On.set(e, t); + else { + if (void 0 !== Tn && !1 === Tn(e)) + throw new Error("Non-extensible objects are not allowed as keys."); + if (Pn) + Object.defineProperty(e, jn, { enumerable: !1, configurable: !1, writable: !1, value: t }); + else if (void 0 !== e.propertyIsEnumerable && e.propertyIsEnumerable === e.constructor.prototype.propertyIsEnumerable) + e.propertyIsEnumerable = function () { return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments); }, e.propertyIsEnumerable[jn] = t; + else { + if (void 0 === e.nodeType) + throw new Error("Unable to set a non-enumerable property on object."); + e[jn] = t; + } + } return t; } + function le(e) { if (e && e.nodeType > 0) + switch (e.nodeType) { + case 1: return e.uniqueID; + case 9: return e.documentElement && e.documentElement.uniqueID; + } } + function ce(e) { Z(e !== 1 / 0, "Cannot perform this action with an infinite size."); } + function pe(e) { return null === e || void 0 === e ? we() : fe(e) && !l(e) ? e : we().withMutations(function (t) { var r = n(e); ce(r.size), r.forEach(function (e, n) { return t.set(n, e); }); }); } + function fe(e) { return !(!e || !e[qn]); } + function he(e, t) { this.ownerID = e, this.entries = t; } + function de(e, t, n) { this.ownerID = e, this.bitmap = t, this.nodes = n; } + function me(e, t, n) { this.ownerID = e, this.count = t, this.nodes = n; } + function ve(e, t, n) { this.ownerID = e, this.keyHash = t, this.entries = n; } + function ge(e, t, n) { this.ownerID = e, this.keyHash = t, this.entry = n; } + function ye(e, t, n) { this._type = t, this._reverse = n, this._stack = e._root && be(e._root); } + function _e(e, t) { return w(e, t[0], t[1]); } + function be(e, t) { return { node: e, index: 0, __prev: t }; } + function xe(e, t, n, r) { var i = Object.create(zn); return i.size = e, i._root = t, i.__ownerID = n, i.__hash = r, i.__altered = !1, i; } + function we() { return Un || (Un = xe(0)); } + function ke(e, t, n) { var r, i; if (e._root) { + var o = c(gn), a = c(yn); + if (r = Ee(e._root, e.__ownerID, 0, void 0, t, n, o, a), !a.value) + return e; + i = e.size + (o.value ? n === vn ? -1 : 1 : 0); + } + else { + if (n === vn) + return e; + i = 1, r = new he(e.__ownerID, [[t, n]]); + } return e.__ownerID ? (e.size = i, e._root = r, e.__hash = void 0, e.__altered = !0, e) : r ? xe(i, r) : we(); } + function Ee(e, t, n, r, i, o, a, s) { return e ? e.update(t, n, r, i, o, a, s) : o === vn ? e : (p(s), p(a), new ge(t, r, [i, o])); } + function Se(e) { return e.constructor === ge || e.constructor === ve; } + function Ce(e, t, n, r, i) { if (e.keyHash === r) + return new ve(t, r, [e.entry, i]); var o, a = (0 === n ? e.keyHash : e.keyHash >>> n) & mn, s = (0 === n ? r : r >>> n) & mn; return new de(t, 1 << a | 1 << s, a === s ? [Ce(e, t, n + hn, r, i)] : (o = new ge(t, r, i), a < s ? [e, o] : [o, e])); } + function Ae(e, t, n, r) { e || (e = new f); for (var i = new ge(e, oe(n), [n, r]), o = 0; o < t.length; o++) { + var a = t[o]; + i = i.update(e, 0, void 0, a[0], a[1]); + } return i; } + function De(e, t, n, r) { for (var i = 0, o = 0, a = new Array(n), s = 0, u = 1, l = t.length; s < l; s++, u <<= 1) { + var c = t[s]; + void 0 !== c && s !== r && (i |= u, a[o++] = c); + } return new de(e, i, a); } + function Oe(e, t, n, r, i) { for (var o = 0, a = new Array(dn), s = 0; 0 !== n; s++, n >>>= 1) + a[s] = 1 & n ? t[o++] : void 0; return a[r] = i, new me(e, o + 1, a); } + function Me(e, t, r) { for (var i = [], a = 0; a < r.length; a++) { + var s = r[a], u = n(s); + o(s) || (u = u.map(function (e) { return H(e); })), i.push(u); + } return Ie(e, t, i); } + function Te(e, t, n) { return e && e.mergeDeep && o(t) ? e.mergeDeep(t) : K(e, t) ? e : t; } + function Pe(e) { return function (t, n, r) { if (t && t.mergeDeepWith && o(n)) + return t.mergeDeepWith(e, n); var i = e(t, n, r); return K(t, i) ? t : i; }; } + function Ie(e, t, n) { return n = n.filter(function (e) { return 0 !== e.size; }), 0 === n.length ? e : 0 !== e.size || e.__ownerID || 1 !== n.length ? e.withMutations(function (e) { for (var r = t ? function (n, r) { e.update(r, vn, function (e) { return e === vn ? n : t(e, n, r); }); } : function (t, n) { e.set(n, t); }, i = 0; i < n.length; i++) + n[i].forEach(r); }) : e.constructor(n[0]); } + function Re(e, t, n, r) { var i = e === vn, o = t.next(); if (o.done) { + var a = i ? n : e, s = r(a); + return s === a ? e : s; + } Z(i || e && e.set, "invalid keyPath"); var u = o.value, l = i ? vn : e.get(u, vn), c = Re(l, t, n, r); return c === l ? e : c === vn ? e.remove(u) : (i ? we() : e).set(u, c); } + function je(e) { return e -= e >> 1 & 1431655765, e = (858993459 & e) + (e >> 2 & 858993459), e = e + (e >> 4) & 252645135, e += e >> 8, 127 & (e += e >> 16); } + function Ne(e, t, n, r) { var i = r ? e : h(e); return i[t] = n, i; } + function Fe(e, t, n, r) { var i = e.length + 1; if (r && t + 1 === i) + return e[t] = n, e; for (var o = new Array(i), a = 0, s = 0; s < i; s++) + s === t ? (o[s] = n, a = -1) : o[s] = e[s + a]; return o; } + function Be(e, t, n) { var r = e.length - 1; if (n && t === r) + return e.pop(), e; for (var i = new Array(r), o = 0, a = 0; a < r; a++) + a === t && (o = 1), i[a] = e[a + o]; return i; } + function Le(e) { var t = Ve(); if (null === e || void 0 === e) + return t; if (qe(e)) + return e; var n = r(e), i = n.size; return 0 === i ? t : (ce(i), i > 0 && i < dn ? We(0, i, hn, null, new ze(n.toArray())) : t.withMutations(function (e) { e.setSize(i), n.forEach(function (t, n) { return e.set(n, t); }); })); } + function qe(e) { return !(!e || !e[Jn]); } + function ze(e, t) { this.array = e, this.ownerID = t; } + function Ue(e, t) { function n(e, t, n) { return 0 === t ? r(e, n) : i(e, t, n); } function r(e, n) { var r = n === s ? u && u.array : e && e.array, i = n > o ? 0 : o - n, l = a - n; return l > dn && (l = dn), function () { if (i === l) + return Kn; var e = t ? --l : i++; return r && r[e]; }; } function i(e, r, i) { var s, u = e && e.array, l = i > o ? 0 : o - i >> r, c = 1 + (a - i >> r); return c > dn && (c = dn), function () { for (;;) { + if (s) { + var e = s(); + if (e !== Kn) + return e; + s = null; + } + if (l === c) + return Kn; + var o = t ? --c : l++; + s = n(u && u[o], r - hn, i + (o << r)); + } }; } var o = e._origin, a = e._capacity, s = $e(a), u = e._tail; return n(e._root, e._level, 0); } + function We(e, t, n, r, i, o, a) { var s = Object.create(Gn); return s.size = t - e, s._origin = e, s._capacity = t, s._level = n, s._root = r, s._tail = i, s.__ownerID = o, s.__hash = a, s.__altered = !1, s; } + function Ve() { return Yn || (Yn = We(0, 0, hn)); } + function He(e, t, n) { if ((t = m(e, t)) !== t) + return e; if (t >= e.size || t < 0) + return e.withMutations(function (e) { t < 0 ? Ke(e, t).set(0, n) : Ke(e, 0, t + 1).set(t, n); }); t += e._origin; var r = e._tail, i = e._root, o = c(yn); return t >= $e(e._capacity) ? r = Je(r, e.__ownerID, 0, t, n, o) : i = Je(i, e.__ownerID, e._level, t, n, o), o.value ? e.__ownerID ? (e._root = i, e._tail = r, e.__hash = void 0, e.__altered = !0, e) : We(e._origin, e._capacity, e._level, i, r) : e; } + function Je(e, t, n, r, i, o) { var a = r >>> n & mn, s = e && a < e.array.length; if (!s && void 0 === i) + return e; var u; if (n > 0) { + var l = e && e.array[a], c = Je(l, t, n - hn, r, i, o); + return c === l ? e : (u = Ge(e, t), u.array[a] = c, u); + } return s && e.array[a] === i ? e : (p(o), u = Ge(e, t), void 0 === i && a === u.array.length - 1 ? u.array.pop() : u.array[a] = i, u); } + function Ge(e, t) { return t && e && t === e.ownerID ? e : new ze(e ? e.array.slice() : [], t); } + function Ye(e, t) { if (t >= $e(e._capacity)) + return e._tail; if (t < 1 << e._level + hn) { + for (var n = e._root, r = e._level; n && r > 0;) + n = n.array[t >>> r & mn], r -= hn; + return n; + } } + function Ke(e, t, n) { void 0 !== t && (t |= 0), void 0 !== n && (n |= 0); var r = e.__ownerID || new f, i = e._origin, o = e._capacity, a = i + t, s = void 0 === n ? o : n < 0 ? o + n : i + n; if (a === i && s === o) + return e; if (a >= s) + return e.clear(); for (var u = e._level, l = e._root, c = 0; a + c < 0;) + l = new ze(l && l.array.length ? [void 0, l] : [], r), u += hn, c += 1 << u; c && (a += c, i += c, s += c, o += c); for (var p = $e(o), h = $e(s); h >= 1 << u + hn;) + l = new ze(l && l.array.length ? [l] : [], r), u += hn; var d = e._tail, m = h < p ? Ye(e, s - 1) : h > p ? new ze([], r) : d; if (d && h > p && a < o && d.array.length) { + l = Ge(l, r); + for (var v = l, g = u; g > hn; g -= hn) { + var y = p >>> g & mn; + v = v.array[y] = Ge(v.array[y], r); + } + v.array[p >>> hn & mn] = d; + } if (s < o && (m = m && m.removeAfter(r, 0, s)), a >= h) + a -= h, s -= h, u = hn, l = null, m = m && m.removeBefore(r, 0, a); + else if (a > i || h < p) { + for (c = 0; l;) { + var _ = a >>> u & mn; + if (_ !== h >>> u & mn) + break; + _ && (c += (1 << u) * _), u -= hn, l = l.array[_]; + } + l && a > i && (l = l.removeBefore(r, u, a - c)), l && h < p && (l = l.removeAfter(r, u, h - c)), c && (a -= c, s -= c); + } return e.__ownerID ? (e.size = s - a, e._origin = a, e._capacity = s, e._level = u, e._root = l, e._tail = m, e.__hash = void 0, e.__altered = !0, e) : We(a, s, u, l, m); } + function Xe(e, t, n) { for (var i = [], a = 0, s = 0; s < n.length; s++) { + var u = n[s], l = r(u); + l.size > a && (a = l.size), o(u) || (l = l.map(function (e) { return H(e); })), i.push(l); + } return a > e.size && (e = e.setSize(a)), Ie(e, t, i); } + function $e(e) { return e < dn ? 0 : e - 1 >>> hn << hn; } + function Ze(e) { return null === e || void 0 === e ? tt() : Qe(e) ? e : tt().withMutations(function (t) { var r = n(e); ce(r.size), r.forEach(function (e, n) { return t.set(n, e); }); }); } + function Qe(e) { return fe(e) && l(e); } + function et(e, t, n, r) { var i = Object.create(Ze.prototype); return i.size = e ? e.size : 0, i._map = e, i._list = t, i.__ownerID = n, i.__hash = r, i; } + function tt() { return Xn || (Xn = et(we(), Ve())); } + function nt(e, t, n) { var r, i, o = e._map, a = e._list, s = o.get(t), u = void 0 !== s; if (n === vn) { + if (!u) + return e; + a.size >= dn && a.size >= 2 * o.size ? (i = a.filter(function (e, t) { return void 0 !== e && s !== t; }), r = i.toKeyedSeq().map(function (e) { return e[0]; }).flip().toMap(), e.__ownerID && (r.__ownerID = i.__ownerID = e.__ownerID)) : (r = o.remove(t), i = s === a.size - 1 ? a.pop() : a.set(s, void 0)); + } + else if (u) { + if (n === a.get(s)[1]) + return e; + r = o, i = a.set(s, [t, n]); + } + else + r = o.set(t, a.size), i = a.set(a.size, [t, n]); return e.__ownerID ? (e.size = r.size, e._map = r, e._list = i, e.__hash = void 0, e) : et(r, i); } + function rt(e, t) { this._iter = e, this._useKeys = t, this.size = e.size; } + function it(e) { this._iter = e, this.size = e.size; } + function ot(e) { this._iter = e, this.size = e.size; } + function at(e) { this._iter = e, this.size = e.size; } + function st(e) { var t = Dt(e); return t._iter = e, t.size = e.size, t.flip = function () { return e; }, t.reverse = function () { var t = e.reverse.apply(this); return t.flip = function () { return e.reverse(); }, t; }, t.has = function (t) { return e.includes(t); }, t.includes = function (t) { return e.has(t); }, t.cacheResult = Ot, t.__iterateUncached = function (t, n) { var r = this; return e.__iterate(function (e, n) { return !1 !== t(n, e, r); }, n); }, t.__iteratorUncached = function (t, n) { if (t === xn) { + var r = e.__iterator(t, n); + return new x(function () { var e = r.next(); if (!e.done) { + var t = e.value[0]; + e.value[0] = e.value[1], e.value[1] = t; + } return e; }); + } return e.__iterator(t === bn ? _n : bn, n); }, t; } + function ut(e, t, n) { var r = Dt(e); return r.size = e.size, r.has = function (t) { return e.has(t); }, r.get = function (r, i) { var o = e.get(r, vn); return o === vn ? i : t.call(n, o, r, e); }, r.__iterateUncached = function (r, i) { var o = this; return e.__iterate(function (e, i, a) { return !1 !== r(t.call(n, e, i, a), i, o); }, i); }, r.__iteratorUncached = function (r, i) { var o = e.__iterator(xn, i); return new x(function () { var i = o.next(); if (i.done) + return i; var a = i.value, s = a[0]; return w(r, s, t.call(n, a[1], s, e), i); }); }, r; } + function lt(e, t) { var n = Dt(e); return n._iter = e, n.size = e.size, n.reverse = function () { return e; }, e.flip && (n.flip = function () { var t = st(e); return t.reverse = function () { return e.flip(); }, t; }), n.get = function (n, r) { return e.get(t ? n : -1 - n, r); }, n.has = function (n) { return e.has(t ? n : -1 - n); }, n.includes = function (t) { return e.includes(t); }, n.cacheResult = Ot, n.__iterate = function (t, n) { var r = this; return e.__iterate(function (e, n) { return t(e, n, r); }, !n); }, n.__iterator = function (t, n) { return e.__iterator(t, !n); }, n; } + function ct(e, t, n, r) { var i = Dt(e); return r && (i.has = function (r) { var i = e.get(r, vn); return i !== vn && !!t.call(n, i, r, e); }, i.get = function (r, i) { var o = e.get(r, vn); return o !== vn && t.call(n, o, r, e) ? o : i; }), i.__iterateUncached = function (i, o) { var a = this, s = 0; return e.__iterate(function (e, o, u) { if (t.call(n, e, o, u)) + return s++, i(e, r ? o : s - 1, a); }, o), s; }, i.__iteratorUncached = function (i, o) { var a = e.__iterator(xn, o), s = 0; return new x(function () { for (;;) { + var o = a.next(); + if (o.done) + return o; + var u = o.value, l = u[0], c = u[1]; + if (t.call(n, c, l, e)) + return w(i, r ? l : s++, c, o); + } }); }, i; } + function pt(e, t, n) { var r = pe().asMutable(); return e.__iterate(function (i, o) { r.update(t.call(n, i, o, e), 0, function (e) { return e + 1; }); }), r.asImmutable(); } + function ft(e, t, n) { var r = a(e), i = (l(e) ? Ze() : pe()).asMutable(); e.__iterate(function (o, a) { i.update(t.call(n, o, a, e), function (e) { return e = e || [], e.push(r ? [a, o] : o), e; }); }); var o = At(e); return i.map(function (t) { return Et(e, o(t)); }); } + function ht(e, t, n, r) { var i = e.size; if (void 0 !== t && (t |= 0), void 0 !== n && (n === 1 / 0 ? n = i : n |= 0), g(t, n, i)) + return e; var o = y(t, i), a = _(n, i); if (o !== o || a !== a) + return ht(e.toSeq().cacheResult(), t, n, r); var s, u = a - o; u === u && (s = u < 0 ? 0 : u); var l = Dt(e); return l.size = 0 === s ? s : e.size && s || void 0, !r && F(e) && s >= 0 && (l.get = function (t, n) { return t = m(this, t), t >= 0 && t < s ? e.get(t + o, n) : n; }), l.__iterateUncached = function (t, n) { var i = this; if (0 === s) + return 0; if (n) + return this.cacheResult().__iterate(t, n); var a = 0, u = !0, l = 0; return e.__iterate(function (e, n) { if (!u || !(u = a++ < o)) + return l++, !1 !== t(e, r ? n : l - 1, i) && l !== s; }), l; }, l.__iteratorUncached = function (t, n) { if (0 !== s && n) + return this.cacheResult().__iterator(t, n); var i = 0 !== s && e.__iterator(t, n), a = 0, u = 0; return new x(function () { for (; a++ < o;) + i.next(); if (++u > s) + return k(); var e = i.next(); return r || t === bn ? e : t === _n ? w(t, u - 1, void 0, e) : w(t, u - 1, e.value[1], e); }); }, l; } + function dt(e, t, n) { var r = Dt(e); return r.__iterateUncached = function (r, i) { var o = this; if (i) + return this.cacheResult().__iterate(r, i); var a = 0; return e.__iterate(function (e, i, s) { return t.call(n, e, i, s) && ++a && r(e, i, o); }), a; }, r.__iteratorUncached = function (r, i) { var o = this; if (i) + return this.cacheResult().__iterator(r, i); var a = e.__iterator(xn, i), s = !0; return new x(function () { if (!s) + return k(); var e = a.next(); if (e.done) + return e; var i = e.value, u = i[0], l = i[1]; return t.call(n, l, u, o) ? r === xn ? e : w(r, u, l, e) : (s = !1, k()); }); }, r; } + function mt(e, t, n, r) { var i = Dt(e); return i.__iterateUncached = function (i, o) { var a = this; if (o) + return this.cacheResult().__iterate(i, o); var s = !0, u = 0; return e.__iterate(function (e, o, l) { if (!s || !(s = t.call(n, e, o, l))) + return u++, i(e, r ? o : u - 1, a); }), u; }, i.__iteratorUncached = function (i, o) { var a = this; if (o) + return this.cacheResult().__iterator(i, o); var s = e.__iterator(xn, o), u = !0, l = 0; return new x(function () { var e, o, c; do { + if (e = s.next(), e.done) + return r || i === bn ? e : i === _n ? w(i, l++, void 0, e) : w(i, l++, e.value[1], e); + var p = e.value; + o = p[0], c = p[1], u && (u = t.call(n, c, o, a)); + } while (u); return i === xn ? e : w(i, o, c, e); }); }, i; } + function vt(e, t) { var r = a(e), i = [e].concat(t).map(function (e) { return o(e) ? r && (e = n(e)) : e = r ? L(e) : q(Array.isArray(e) ? e : [e]), e; }).filter(function (e) { return 0 !== e.size; }); if (0 === i.length) + return e; if (1 === i.length) { + var u = i[0]; + if (u === e || r && a(u) || s(e) && s(u)) + return u; + } var l = new I(i); return r ? l = l.toKeyedSeq() : s(e) || (l = l.toSetSeq()), l = l.flatten(!0), l.size = i.reduce(function (e, t) { if (void 0 !== e) { + var n = t.size; + if (void 0 !== n) + return e + n; + } }, 0), l; } + function gt(e, t, n) { var r = Dt(e); return r.__iterateUncached = function (r, i) { function a(e, l) { var c = this; e.__iterate(function (e, i) { return (!t || l < t) && o(e) ? a(e, l + 1) : !1 === r(e, n ? i : s++, c) && (u = !0), !u; }, i); } var s = 0, u = !1; return a(e, 0), s; }, r.__iteratorUncached = function (r, i) { var a = e.__iterator(r, i), s = [], u = 0; return new x(function () { for (; a;) { + var e = a.next(); + if (!1 === e.done) { + var l = e.value; + if (r === xn && (l = l[1]), t && !(s.length < t) || !o(l)) + return n ? e : w(r, u++, l, e); + s.push(a), a = l.__iterator(r, i); + } + else + a = s.pop(); + } return k(); }); }, r; } + function yt(e, t, n) { var r = At(e); return e.toSeq().map(function (i, o) { return r(t.call(n, i, o, e)); }).flatten(!0); } + function _t(e, t) { var n = Dt(e); return n.size = e.size && 2 * e.size - 1, n.__iterateUncached = function (n, r) { var i = this, o = 0; return e.__iterate(function (e, r) { return (!o || !1 !== n(t, o++, i)) && !1 !== n(e, o++, i); }, r), o; }, n.__iteratorUncached = function (n, r) { var i, o = e.__iterator(bn, r), a = 0; return new x(function () { return (!i || a % 2) && (i = o.next(), i.done) ? i : a % 2 ? w(n, a++, t) : w(n, a++, i.value, i); }); }, n; } + function bt(e, t, n) { t || (t = Mt); var r = a(e), i = 0, o = e.toSeq().map(function (t, r) { return [r, t, i++, n ? n(t, r, e) : t]; }).toArray(); return o.sort(function (e, n) { return t(e[3], n[3]) || e[2] - n[2]; }).forEach(r ? function (e, t) { o[t].length = 2; } : function (e, t) { o[t] = e[1]; }), r ? M(o) : s(e) ? T(o) : P(o); } + function xt(e, t, n) { if (t || (t = Mt), n) { + var r = e.toSeq().map(function (t, r) { return [t, n(t, r, e)]; }).reduce(function (e, n) { return wt(t, e[1], n[1]) ? n : e; }); + return r && r[0]; + } return e.reduce(function (e, n) { return wt(t, e, n) ? n : e; }); } + function wt(e, t, n) { var r = e(n, t); return 0 === r && n !== t && (void 0 === n || null === n || n !== n) || r > 0; } + function kt(e, n, r) { var i = Dt(e); return i.size = new I(r).map(function (e) { return e.size; }).min(), i.__iterate = function (e, t) { for (var n, r = this.__iterator(bn, t), i = 0; !(n = r.next()).done && !1 !== e(n.value, i++, this);) + ; return i; }, i.__iteratorUncached = function (e, i) { var o = r.map(function (e) { return e = t(e), C(i ? e.reverse() : e); }), a = 0, s = !1; return new x(function () { var t; return s || (t = o.map(function (e) { return e.next(); }), s = t.some(function (e) { return e.done; })), s ? k() : w(e, a++, n.apply(null, t.map(function (e) { return e.value; }))); }); }, i; } + function Et(e, t) { return F(e) ? t : e.constructor(t); } + function St(e) { if (e !== Object(e)) + throw new TypeError("Expected [K, V] tuple: " + e); } + function Ct(e) { return ce(e.size), d(e); } + function At(e) { return a(e) ? n : s(e) ? r : i; } + function Dt(e) { return Object.create((a(e) ? M : s(e) ? T : P).prototype); } + function Ot() { return this._iter.cacheResult ? (this._iter.cacheResult(), this.size = this._iter.size, this) : O.prototype.cacheResult.call(this); } + function Mt(e, t) { return e > t ? 1 : e < t ? -1 : 0; } + function Tt(e) { var n = C(e); if (!n) { + if (!D(e)) + throw new TypeError("Expected iterable or array-like: " + e); + n = C(t(e)); + } return n; } + function Pt(e, t) { var n, r = function (o) { if (o instanceof r) + return o; if (!(this instanceof r)) + return new r(o); if (!n) { + n = !0; + var a = Object.keys(e); + jt(i, a), i.size = a.length, i._name = t, i._keys = a, i._defaultValues = e; + } this._map = pe(o); }, i = r.prototype = Object.create($n); return i.constructor = r, r; } + function It(e, t, n) { var r = Object.create(Object.getPrototypeOf(e)); return r._map = t, r.__ownerID = n, r; } + function Rt(e) { return e._name || e.constructor.name || "Record"; } + function jt(e, t) { try { + t.forEach(Nt.bind(void 0, e)); + } + catch (e) { } } + function Nt(e, t) { Object.defineProperty(e, t, { get: function () { return this.get(t); }, set: function (e) { Z(this.__ownerID, "Cannot set on an immutable record."), this.set(t, e); } }); } + function Ft(e) { return null === e || void 0 === e ? zt() : Bt(e) && !l(e) ? e : zt().withMutations(function (t) { var n = i(e); ce(n.size), n.forEach(function (e) { return t.add(e); }); }); } + function Bt(e) { return !(!e || !e[Zn]); } + function Lt(e, t) { return e.__ownerID ? (e.size = t.size, e._map = t, e) : t === e._map ? e : 0 === t.size ? e.__empty() : e.__make(t); } + function qt(e, t) { var n = Object.create(Qn); return n.size = e ? e.size : 0, n._map = e, n.__ownerID = t, n; } + function zt() { return er || (er = qt(we())); } + function Ut(e) { return null === e || void 0 === e ? Ht() : Wt(e) ? e : Ht().withMutations(function (t) { var n = i(e); ce(n.size), n.forEach(function (e) { return t.add(e); }); }); } + function Wt(e) { return Bt(e) && l(e); } + function Vt(e, t) { var n = Object.create(tr); return n.size = e ? e.size : 0, n._map = e, n.__ownerID = t, n; } + function Ht() { return nr || (nr = Vt(tt())); } + function Jt(e) { return null === e || void 0 === e ? Kt() : Gt(e) ? e : Kt().unshiftAll(e); } + function Gt(e) { return !(!e || !e[rr]); } + function Yt(e, t, n, r) { var i = Object.create(ir); return i.size = e, i._head = t, i.__ownerID = n, i.__hash = r, i.__altered = !1, i; } + function Kt() { return or || (or = Yt(0)); } + function Xt(e, t) { var n = function (n) { e.prototype[n] = t[n]; }; return Object.keys(t).forEach(n), Object.getOwnPropertySymbols && Object.getOwnPropertySymbols(t).forEach(n), e; } + function $t(e, t) { return t; } + function Zt(e, t) { return [t, e]; } + function Qt(e) { return function () { return !e.apply(this, arguments); }; } + function en(e) { return function () { return -e.apply(this, arguments); }; } + function tn(e) { return "string" == typeof e ? JSON.stringify(e) : String(e); } + function nn() { return h(arguments); } + function rn(e, t) { return e < t ? 1 : e > t ? -1 : 0; } + function on(e) { if (e.size === 1 / 0) + return 0; var t = l(e), n = a(e), r = t ? 1 : 0; return an(e.__iterate(n ? t ? function (e, t) { r = 31 * r + sn(oe(e), oe(t)) | 0; } : function (e, t) { r = r + sn(oe(e), oe(t)) | 0; } : t ? function (e) { r = 31 * r + oe(e) | 0; } : function (e) { r = r + oe(e) | 0; }), r); } + function an(e, t) { return t = Mn(t, 3432918353), t = Mn(t << 15 | t >>> -15, 461845907), t = Mn(t << 13 | t >>> -13, 5), t = (t + 3864292196 | 0) ^ e, t = Mn(t ^ t >>> 16, 2246822507), t = Mn(t ^ t >>> 13, 3266489909), t = ie(t ^ t >>> 16); } + function sn(e, t) { return e ^ t + 2654435769 + (e << 6) + (e >> 2) | 0; } + var un = Array.prototype.slice; + e(n, t), e(r, t), e(i, t), t.isIterable = o, t.isKeyed = a, t.isIndexed = s, t.isAssociative = u, t.isOrdered = l, t.Keyed = n, t.Indexed = r, t.Set = i; + var ln = "@@__IMMUTABLE_ITERABLE__@@", cn = "@@__IMMUTABLE_KEYED__@@", pn = "@@__IMMUTABLE_INDEXED__@@", fn = "@@__IMMUTABLE_ORDERED__@@", hn = 5, dn = 1 << hn, mn = dn - 1, vn = {}, gn = { value: !1 }, yn = { value: !1 }, _n = 0, bn = 1, xn = 2, wn = "function" == typeof Symbol && Symbol.iterator, kn = "@@iterator", En = wn || kn; + x.prototype.toString = function () { return "[Iterator]"; }, x.KEYS = _n, x.VALUES = bn, x.ENTRIES = xn, x.prototype.inspect = x.prototype.toSource = function () { return this.toString(); }, x.prototype[En] = function () { return this; }, e(O, t), O.of = function () { return O(arguments); }, O.prototype.toSeq = function () { return this; }, O.prototype.toString = function () { return this.__toString("Seq {", "}"); }, O.prototype.cacheResult = function () { return !this._cache && this.__iterateUncached && (this._cache = this.entrySeq().toArray(), this.size = this._cache.length), this; }, O.prototype.__iterate = function (e, t) { return W(this, e, t, !0); }, O.prototype.__iterator = function (e, t) { return V(this, e, t, !0); }, e(M, O), M.prototype.toKeyedSeq = function () { return this; }, e(T, O), T.of = function () { return T(arguments); }, T.prototype.toIndexedSeq = function () { return this; }, T.prototype.toString = function () { return this.__toString("Seq [", "]"); }, T.prototype.__iterate = function (e, t) { return W(this, e, t, !1); }, T.prototype.__iterator = function (e, t) { return V(this, e, t, !1); }, e(P, O), P.of = function () { return P(arguments); }, P.prototype.toSetSeq = function () { return this; }, O.isSeq = F, O.Keyed = M, O.Set = P, O.Indexed = T; + var Sn = "@@__IMMUTABLE_SEQ__@@"; + O.prototype[Sn] = !0, e(I, T), I.prototype.get = function (e, t) { return this.has(e) ? this._array[m(this, e)] : t; }, I.prototype.__iterate = function (e, t) { for (var n = this._array, r = n.length - 1, i = 0; i <= r; i++) + if (!1 === e(n[t ? r - i : i], i, this)) + return i + 1; return i; }, I.prototype.__iterator = function (e, t) { var n = this._array, r = n.length - 1, i = 0; return new x(function () { return i > r ? k() : w(e, i, n[t ? r - i++ : i++]); }); }, e(R, M), R.prototype.get = function (e, t) { return void 0 === t || this.has(e) ? this._object[e] : t; }, R.prototype.has = function (e) { return this._object.hasOwnProperty(e); }, R.prototype.__iterate = function (e, t) { for (var n = this._object, r = this._keys, i = r.length - 1, o = 0; o <= i; o++) { + var a = r[t ? i - o : o]; + if (!1 === e(n[a], a, this)) + return o + 1; + } return o; }, R.prototype.__iterator = function (e, t) { var n = this._object, r = this._keys, i = r.length - 1, o = 0; return new x(function () { var a = r[t ? i - o : o]; return o++ > i ? k() : w(e, a, n[a]); }); }, R.prototype[fn] = !0, e(j, T), j.prototype.__iterateUncached = function (e, t) { if (t) + return this.cacheResult().__iterate(e, t); var n = this._iterable, r = C(n), i = 0; if (S(r)) + for (var o; !(o = r.next()).done && !1 !== e(o.value, i++, this);) + ; return i; }, j.prototype.__iteratorUncached = function (e, t) { if (t) + return this.cacheResult().__iterator(e, t); var n = this._iterable, r = C(n); if (!S(r)) + return new x(k); var i = 0; return new x(function () { var t = r.next(); return t.done ? t : w(e, i++, t.value); }); }, e(N, T), N.prototype.__iterateUncached = function (e, t) { if (t) + return this.cacheResult().__iterate(e, t); for (var n = this._iterator, r = this._iteratorCache, i = 0; i < r.length;) + if (!1 === e(r[i], i++, this)) + return i; for (var o; !(o = n.next()).done;) { + var a = o.value; + if (r[i] = a, !1 === e(a, i++, this)) + break; + } return i; }, N.prototype.__iteratorUncached = function (e, t) { if (t) + return this.cacheResult().__iterator(e, t); var n = this._iterator, r = this._iteratorCache, i = 0; return new x(function () { if (i >= r.length) { + var t = n.next(); + if (t.done) + return t; + r[i] = t.value; + } return w(e, i, r[i++]); }); }; + var Cn; + e($, T), $.prototype.toString = function () { return 0 === this.size ? "Repeat []" : "Repeat [ " + this._value + " " + this.size + " times ]"; }, $.prototype.get = function (e, t) { return this.has(e) ? this._value : t; }, $.prototype.includes = function (e) { return K(this._value, e); }, $.prototype.slice = function (e, t) { var n = this.size; return g(e, t, n) ? this : new $(this._value, _(t, n) - y(e, n)); }, $.prototype.reverse = function () { return this; }, $.prototype.indexOf = function (e) { return K(this._value, e) ? 0 : -1; }, $.prototype.lastIndexOf = function (e) { return K(this._value, e) ? this.size : -1; }, $.prototype.__iterate = function (e, t) { for (var n = 0; n < this.size; n++) + if (!1 === e(this._value, n, this)) + return n + 1; return n; }, $.prototype.__iterator = function (e, t) { var n = this, r = 0; return new x(function () { return r < n.size ? w(e, r++, n._value) : k(); }); }, $.prototype.equals = function (e) { return e instanceof $ ? K(this._value, e._value) : X(e); }; + var An; + e(Q, T), Q.prototype.toString = function () { return 0 === this.size ? "Range []" : "Range [ " + this._start + "..." + this._end + (1 !== this._step ? " by " + this._step : "") + " ]"; }, Q.prototype.get = function (e, t) { return this.has(e) ? this._start + m(this, e) * this._step : t; }, Q.prototype.includes = function (e) { var t = (e - this._start) / this._step; return t >= 0 && t < this.size && t === Math.floor(t); }, Q.prototype.slice = function (e, t) { return g(e, t, this.size) ? this : (e = y(e, this.size), t = _(t, this.size), t <= e ? new Q(0, 0) : new Q(this.get(e, this._end), this.get(t, this._end), this._step)); }, Q.prototype.indexOf = function (e) { var t = e - this._start; if (t % this._step == 0) { + var n = t / this._step; + if (n >= 0 && n < this.size) + return n; + } return -1; }, Q.prototype.lastIndexOf = function (e) { return this.indexOf(e); }, Q.prototype.__iterate = function (e, t) { for (var n = this.size - 1, r = this._step, i = t ? this._start + n * r : this._start, o = 0; o <= n; o++) { + if (!1 === e(i, o, this)) + return o + 1; + i += t ? -r : r; + } return o; }, Q.prototype.__iterator = function (e, t) { var n = this.size - 1, r = this._step, i = t ? this._start + n * r : this._start, o = 0; return new x(function () { var a = i; return i += t ? -r : r, o > n ? k() : w(e, o++, a); }); }, Q.prototype.equals = function (e) { return e instanceof Q ? this._start === e._start && this._end === e._end && this._step === e._step : X(this, e); }; + var Dn; + e(ee, t), e(te, ee), e(ne, ee), e(re, ee), ee.Keyed = te, ee.Indexed = ne, ee.Set = re; + var On, Mn = "function" == typeof Math.imul && -2 === Math.imul(4294967295, 2) ? Math.imul : function (e, t) { e |= 0, t |= 0; var n = 65535 & e, r = 65535 & t; return n * r + ((e >>> 16) * r + n * (t >>> 16) << 16 >>> 0) | 0; }, Tn = Object.isExtensible, Pn = function () { try { + return Object.defineProperty({}, "@", {}), !0; + } + catch (e) { + return !1; + } }(), In = "function" == typeof WeakMap; + In && (On = new WeakMap); + var Rn = 0, jn = "__immutablehash__"; + "function" == typeof Symbol && (jn = Symbol(jn)); + var Nn = 16, Fn = 255, Bn = 0, Ln = {}; + e(pe, te), pe.of = function () { var e = un.call(arguments, 0); return we().withMutations(function (t) { for (var n = 0; n < e.length; n += 2) { + if (n + 1 >= e.length) + throw new Error("Missing value for key: " + e[n]); + t.set(e[n], e[n + 1]); + } }); }, pe.prototype.toString = function () { return this.__toString("Map {", "}"); }, pe.prototype.get = function (e, t) { return this._root ? this._root.get(0, void 0, e, t) : t; }, pe.prototype.set = function (e, t) { return ke(this, e, t); }, pe.prototype.setIn = function (e, t) { return this.updateIn(e, vn, function () { return t; }); }, pe.prototype.remove = function (e) { return ke(this, e, vn); }, pe.prototype.deleteIn = function (e) { return this.updateIn(e, function () { return vn; }); }, pe.prototype.update = function (e, t, n) { return 1 === arguments.length ? e(this) : this.updateIn([e], t, n); }, pe.prototype.updateIn = function (e, t, n) { n || (n = t, t = void 0); var r = Re(this, Tt(e), t, n); return r === vn ? void 0 : r; }, pe.prototype.clear = function () { return 0 === this.size ? this : this.__ownerID ? (this.size = 0, this._root = null, this.__hash = void 0, this.__altered = !0, this) : we(); }, pe.prototype.merge = function () { return Me(this, void 0, arguments); }, pe.prototype.mergeWith = function (e) { return Me(this, e, un.call(arguments, 1)); }, pe.prototype.mergeIn = function (e) { var t = un.call(arguments, 1); return this.updateIn(e, we(), function (e) { return "function" == typeof e.merge ? e.merge.apply(e, t) : t[t.length - 1]; }); }, pe.prototype.mergeDeep = function () { return Me(this, Te, arguments); }, pe.prototype.mergeDeepWith = function (e) { var t = un.call(arguments, 1); return Me(this, Pe(e), t); }, pe.prototype.mergeDeepIn = function (e) { var t = un.call(arguments, 1); return this.updateIn(e, we(), function (e) { return "function" == typeof e.mergeDeep ? e.mergeDeep.apply(e, t) : t[t.length - 1]; }); }, pe.prototype.sort = function (e) { return Ze(bt(this, e)); }, pe.prototype.sortBy = function (e, t) { return Ze(bt(this, t, e)); }, pe.prototype.withMutations = function (e) { var t = this.asMutable(); return e(t), t.wasAltered() ? t.__ensureOwner(this.__ownerID) : this; }, pe.prototype.asMutable = function () { return this.__ownerID ? this : this.__ensureOwner(new f); }, pe.prototype.asImmutable = function () { return this.__ensureOwner(); }, pe.prototype.wasAltered = function () { return this.__altered; }, pe.prototype.__iterator = function (e, t) { return new ye(this, e, t); }, pe.prototype.__iterate = function (e, t) { var n = this, r = 0; return this._root && this._root.iterate(function (t) { return r++, e(t[1], t[0], n); }, t), r; }, pe.prototype.__ensureOwner = function (e) { return e === this.__ownerID ? this : e ? xe(this.size, this._root, e, this.__hash) : (this.__ownerID = e, this.__altered = !1, this); }, pe.isMap = fe; + var qn = "@@__IMMUTABLE_MAP__@@", zn = pe.prototype; + zn[qn] = !0, zn.delete = zn.remove, zn.removeIn = zn.deleteIn, he.prototype.get = function (e, t, n, r) { for (var i = this.entries, o = 0, a = i.length; o < a; o++) + if (K(n, i[o][0])) + return i[o][1]; return r; }, he.prototype.update = function (e, t, n, r, i, o, a) { for (var s = i === vn, u = this.entries, l = 0, c = u.length; l < c && !K(r, u[l][0]); l++) + ; var f = l < c; if (f ? u[l][1] === i : s) + return this; if (p(a), (s || !f) && p(o), !s || 1 !== u.length) { + if (!f && !s && u.length >= Wn) + return Ae(e, u, r, i); + var d = e && e === this.ownerID, m = d ? u : h(u); + return f ? s ? l === c - 1 ? m.pop() : m[l] = m.pop() : m[l] = [r, i] : m.push([r, i]), d ? (this.entries = m, this) : new he(e, m); + } }, de.prototype.get = function (e, t, n, r) { void 0 === t && (t = oe(n)); var i = 1 << ((0 === e ? t : t >>> e) & mn), o = this.bitmap; return 0 == (o & i) ? r : this.nodes[je(o & i - 1)].get(e + hn, t, n, r); }, de.prototype.update = function (e, t, n, r, i, o, a) { void 0 === n && (n = oe(r)); var s = (0 === t ? n : n >>> t) & mn, u = 1 << s, l = this.bitmap, c = 0 != (l & u); if (!c && i === vn) + return this; var p = je(l & u - 1), f = this.nodes, h = c ? f[p] : void 0, d = Ee(h, e, t + hn, n, r, i, o, a); if (d === h) + return this; if (!c && d && f.length >= Vn) + return Oe(e, f, l, s, d); if (c && !d && 2 === f.length && Se(f[1 ^ p])) + return f[1 ^ p]; if (c && d && 1 === f.length && Se(d)) + return d; var m = e && e === this.ownerID, v = c ? d ? l : l ^ u : l | u, g = c ? d ? Ne(f, p, d, m) : Be(f, p, m) : Fe(f, p, d, m); return m ? (this.bitmap = v, this.nodes = g, this) : new de(e, v, g); }, me.prototype.get = function (e, t, n, r) { void 0 === t && (t = oe(n)); var i = (0 === e ? t : t >>> e) & mn, o = this.nodes[i]; return o ? o.get(e + hn, t, n, r) : r; }, me.prototype.update = function (e, t, n, r, i, o, a) { void 0 === n && (n = oe(r)); var s = (0 === t ? n : n >>> t) & mn, u = i === vn, l = this.nodes, c = l[s]; if (u && !c) + return this; var p = Ee(c, e, t + hn, n, r, i, o, a); if (p === c) + return this; var f = this.count; if (c) { + if (!p && --f < Hn) + return De(e, l, f, s); + } + else + f++; var h = e && e === this.ownerID, d = Ne(l, s, p, h); return h ? (this.count = f, this.nodes = d, this) : new me(e, f, d); }, ve.prototype.get = function (e, t, n, r) { for (var i = this.entries, o = 0, a = i.length; o < a; o++) + if (K(n, i[o][0])) + return i[o][1]; return r; }, ve.prototype.update = function (e, t, n, r, i, o, a) { void 0 === n && (n = oe(r)); var s = i === vn; if (n !== this.keyHash) + return s ? this : (p(a), p(o), Ce(this, e, t, n, [r, i])); for (var u = this.entries, l = 0, c = u.length; l < c && !K(r, u[l][0]); l++) + ; var f = l < c; if (f ? u[l][1] === i : s) + return this; if (p(a), (s || !f) && p(o), s && 2 === c) + return new ge(e, this.keyHash, u[1 ^ l]); var d = e && e === this.ownerID, m = d ? u : h(u); return f ? s ? l === c - 1 ? m.pop() : m[l] = m.pop() : m[l] = [r, i] : m.push([r, i]), d ? (this.entries = m, this) : new ve(e, this.keyHash, m); }, ge.prototype.get = function (e, t, n, r) { return K(n, this.entry[0]) ? this.entry[1] : r; }, ge.prototype.update = function (e, t, n, r, i, o, a) { var s = i === vn, u = K(r, this.entry[0]); return (u ? i === this.entry[1] : s) ? this : (p(a), s ? void p(o) : u ? e && e === this.ownerID ? (this.entry[1] = i, this) : new ge(e, this.keyHash, [r, i]) : (p(o), Ce(this, e, t, oe(r), [r, i]))); }, he.prototype.iterate = ve.prototype.iterate = function (e, t) { for (var n = this.entries, r = 0, i = n.length - 1; r <= i; r++) + if (!1 === e(n[t ? i - r : r])) + return !1; }, de.prototype.iterate = me.prototype.iterate = function (e, t) { for (var n = this.nodes, r = 0, i = n.length - 1; r <= i; r++) { + var o = n[t ? i - r : r]; + if (o && !1 === o.iterate(e, t)) + return !1; + } }, ge.prototype.iterate = function (e, t) { return e(this.entry); }, e(ye, x), ye.prototype.next = function () { for (var e = this._type, t = this._stack; t;) { + var n, r = t.node, i = t.index++; + if (r.entry) { + if (0 === i) + return _e(e, r.entry); + } + else if (r.entries) { + if (n = r.entries.length - 1, i <= n) + return _e(e, r.entries[this._reverse ? n - i : i]); + } + else if (n = r.nodes.length - 1, i <= n) { + var o = r.nodes[this._reverse ? n - i : i]; + if (o) { + if (o.entry) + return _e(e, o.entry); + t = this._stack = be(o, t); + } + continue; + } + t = this._stack = this._stack.__prev; + } return k(); }; + var Un, Wn = dn / 4, Vn = dn / 2, Hn = dn / 4; + e(Le, ne), Le.of = function () { return this(arguments); }, Le.prototype.toString = function () { return this.__toString("List [", "]"); }, Le.prototype.get = function (e, t) { if ((e = m(this, e)) >= 0 && e < this.size) { + e += this._origin; + var n = Ye(this, e); + return n && n.array[e & mn]; + } return t; }, Le.prototype.set = function (e, t) { return He(this, e, t); }, Le.prototype.remove = function (e) { return this.has(e) ? 0 === e ? this.shift() : e === this.size - 1 ? this.pop() : this.splice(e, 1) : this; }, Le.prototype.insert = function (e, t) { return this.splice(e, 0, t); }, Le.prototype.clear = function () { return 0 === this.size ? this : this.__ownerID ? (this.size = this._origin = this._capacity = 0, this._level = hn, this._root = this._tail = null, this.__hash = void 0, this.__altered = !0, this) : Ve(); }, Le.prototype.push = function () { var e = arguments, t = this.size; return this.withMutations(function (n) { Ke(n, 0, t + e.length); for (var r = 0; r < e.length; r++) + n.set(t + r, e[r]); }); }, Le.prototype.pop = function () { return Ke(this, 0, -1); }, Le.prototype.unshift = function () { var e = arguments; return this.withMutations(function (t) { Ke(t, -e.length); for (var n = 0; n < e.length; n++) + t.set(n, e[n]); }); }, Le.prototype.shift = function () { return Ke(this, 1); }, Le.prototype.merge = function () { return Xe(this, void 0, arguments); }, Le.prototype.mergeWith = function (e) { return Xe(this, e, un.call(arguments, 1)); }, Le.prototype.mergeDeep = function () { return Xe(this, Te, arguments); }, Le.prototype.mergeDeepWith = function (e) { var t = un.call(arguments, 1); return Xe(this, Pe(e), t); }, Le.prototype.setSize = function (e) { return Ke(this, 0, e); }, Le.prototype.slice = function (e, t) { var n = this.size; return g(e, t, n) ? this : Ke(this, y(e, n), _(t, n)); }, Le.prototype.__iterator = function (e, t) { var n = 0, r = Ue(this, t); return new x(function () { var t = r(); return t === Kn ? k() : w(e, n++, t); }); }, Le.prototype.__iterate = function (e, t) { for (var n, r = 0, i = Ue(this, t); (n = i()) !== Kn && !1 !== e(n, r++, this);) + ; return r; }, Le.prototype.__ensureOwner = function (e) { return e === this.__ownerID ? this : e ? We(this._origin, this._capacity, this._level, this._root, this._tail, e, this.__hash) : (this.__ownerID = e, this); }, Le.isList = qe; + var Jn = "@@__IMMUTABLE_LIST__@@", Gn = Le.prototype; + Gn[Jn] = !0, Gn.delete = Gn.remove, Gn.setIn = zn.setIn, Gn.deleteIn = Gn.removeIn = zn.removeIn, Gn.update = zn.update, Gn.updateIn = zn.updateIn, Gn.mergeIn = zn.mergeIn, Gn.mergeDeepIn = zn.mergeDeepIn, Gn.withMutations = zn.withMutations, Gn.asMutable = zn.asMutable, Gn.asImmutable = zn.asImmutable, Gn.wasAltered = zn.wasAltered, ze.prototype.removeBefore = function (e, t, n) { if (n === t ? 1 << t : 0 === this.array.length) + return this; var r = n >>> t & mn; if (r >= this.array.length) + return new ze([], e); var i, o = 0 === r; if (t > 0) { + var a = this.array[r]; + if ((i = a && a.removeBefore(e, t - hn, n)) === a && o) + return this; + } if (o && !i) + return this; var s = Ge(this, e); if (!o) + for (var u = 0; u < r; u++) + s.array[u] = void 0; return i && (s.array[r] = i), s; }, ze.prototype.removeAfter = function (e, t, n) { if (n === (t ? 1 << t : 0) || 0 === this.array.length) + return this; var r = n - 1 >>> t & mn; if (r >= this.array.length) + return this; var i; if (t > 0) { + var o = this.array[r]; + if ((i = o && o.removeAfter(e, t - hn, n)) === o && r === this.array.length - 1) + return this; + } var a = Ge(this, e); return a.array.splice(r + 1), i && (a.array[r] = i), a; }; + var Yn, Kn = {}; + e(Ze, pe), Ze.of = function () { return this(arguments); }, Ze.prototype.toString = function () { return this.__toString("OrderedMap {", "}"); }, Ze.prototype.get = function (e, t) { var n = this._map.get(e); return void 0 !== n ? this._list.get(n)[1] : t; }, Ze.prototype.clear = function () { return 0 === this.size ? this : this.__ownerID ? (this.size = 0, this._map.clear(), this._list.clear(), this) : tt(); }, Ze.prototype.set = function (e, t) { return nt(this, e, t); }, Ze.prototype.remove = function (e) { return nt(this, e, vn); }, Ze.prototype.wasAltered = function () { return this._map.wasAltered() || this._list.wasAltered(); }, Ze.prototype.__iterate = function (e, t) { var n = this; return this._list.__iterate(function (t) { return t && e(t[1], t[0], n); }, t); }, Ze.prototype.__iterator = function (e, t) { return this._list.fromEntrySeq().__iterator(e, t); }, Ze.prototype.__ensureOwner = function (e) { if (e === this.__ownerID) + return this; var t = this._map.__ensureOwner(e), n = this._list.__ensureOwner(e); return e ? et(t, n, e, this.__hash) : (this.__ownerID = e, this._map = t, this._list = n, this); }, Ze.isOrderedMap = Qe, Ze.prototype[fn] = !0, Ze.prototype.delete = Ze.prototype.remove; + var Xn; + e(rt, M), rt.prototype.get = function (e, t) { return this._iter.get(e, t); }, rt.prototype.has = function (e) { return this._iter.has(e); }, rt.prototype.valueSeq = function () { return this._iter.valueSeq(); }, rt.prototype.reverse = function () { var e = this, t = lt(this, !0); return this._useKeys || (t.valueSeq = function () { return e._iter.toSeq().reverse(); }), t; }, rt.prototype.map = function (e, t) { var n = this, r = ut(this, e, t); return this._useKeys || (r.valueSeq = function () { return n._iter.toSeq().map(e, t); }), r; }, rt.prototype.__iterate = function (e, t) { var n, r = this; return this._iter.__iterate(this._useKeys ? function (t, n) { return e(t, n, r); } : (n = t ? Ct(this) : 0, function (i) { return e(i, t ? --n : n++, r); }), t); }, rt.prototype.__iterator = function (e, t) { if (this._useKeys) + return this._iter.__iterator(e, t); var n = this._iter.__iterator(bn, t), r = t ? Ct(this) : 0; return new x(function () { var i = n.next(); return i.done ? i : w(e, t ? --r : r++, i.value, i); }); }, rt.prototype[fn] = !0, e(it, T), it.prototype.includes = function (e) { return this._iter.includes(e); }, it.prototype.__iterate = function (e, t) { var n = this, r = 0; return this._iter.__iterate(function (t) { return e(t, r++, n); }, t); }, it.prototype.__iterator = function (e, t) { var n = this._iter.__iterator(bn, t), r = 0; return new x(function () { var t = n.next(); return t.done ? t : w(e, r++, t.value, t); }); }, e(ot, P), ot.prototype.has = function (e) { return this._iter.includes(e); }, ot.prototype.__iterate = function (e, t) { var n = this; return this._iter.__iterate(function (t) { return e(t, t, n); }, t); }, ot.prototype.__iterator = function (e, t) { var n = this._iter.__iterator(bn, t); return new x(function () { var t = n.next(); return t.done ? t : w(e, t.value, t.value, t); }); }, e(at, M), at.prototype.entrySeq = function () { return this._iter.toSeq(); }, at.prototype.__iterate = function (e, t) { var n = this; return this._iter.__iterate(function (t) { if (t) { + St(t); + var r = o(t); + return e(r ? t.get(1) : t[1], r ? t.get(0) : t[0], n); + } }, t); }, at.prototype.__iterator = function (e, t) { var n = this._iter.__iterator(bn, t); return new x(function () { for (;;) { + var t = n.next(); + if (t.done) + return t; + var r = t.value; + if (r) { + St(r); + var i = o(r); + return w(e, i ? r.get(0) : r[0], i ? r.get(1) : r[1], t); + } + } }); }, it.prototype.cacheResult = rt.prototype.cacheResult = ot.prototype.cacheResult = at.prototype.cacheResult = Ot, e(Pt, te), Pt.prototype.toString = function () { return this.__toString(Rt(this) + " {", "}"); }, Pt.prototype.has = function (e) { return this._defaultValues.hasOwnProperty(e); }, Pt.prototype.get = function (e, t) { if (!this.has(e)) + return t; var n = this._defaultValues[e]; return this._map ? this._map.get(e, n) : n; }, Pt.prototype.clear = function () { if (this.__ownerID) + return this._map && this._map.clear(), this; var e = this.constructor; return e._empty || (e._empty = It(this, we())); }, Pt.prototype.set = function (e, t) { if (!this.has(e)) + throw new Error('Cannot set unknown key "' + e + '" on ' + Rt(this)); if (this._map && !this._map.has(e)) { + if (t === this._defaultValues[e]) + return this; + } var n = this._map && this._map.set(e, t); return this.__ownerID || n === this._map ? this : It(this, n); }, Pt.prototype.remove = function (e) { if (!this.has(e)) + return this; var t = this._map && this._map.remove(e); return this.__ownerID || t === this._map ? this : It(this, t); }, Pt.prototype.wasAltered = function () { return this._map.wasAltered(); }, Pt.prototype.__iterator = function (e, t) { var r = this; return n(this._defaultValues).map(function (e, t) { return r.get(t); }).__iterator(e, t); }, Pt.prototype.__iterate = function (e, t) { var r = this; return n(this._defaultValues).map(function (e, t) { return r.get(t); }).__iterate(e, t); }, Pt.prototype.__ensureOwner = function (e) { if (e === this.__ownerID) + return this; var t = this._map && this._map.__ensureOwner(e); return e ? It(this, t, e) : (this.__ownerID = e, this._map = t, this); }; + var $n = Pt.prototype; + $n.delete = $n.remove, $n.deleteIn = $n.removeIn = zn.removeIn, $n.merge = zn.merge, $n.mergeWith = zn.mergeWith, $n.mergeIn = zn.mergeIn, $n.mergeDeep = zn.mergeDeep, $n.mergeDeepWith = zn.mergeDeepWith, $n.mergeDeepIn = zn.mergeDeepIn, $n.setIn = zn.setIn, $n.update = zn.update, $n.updateIn = zn.updateIn, $n.withMutations = zn.withMutations, $n.asMutable = zn.asMutable, $n.asImmutable = zn.asImmutable, e(Ft, re), Ft.of = function () { return this(arguments); }, Ft.fromKeys = function (e) { return this(n(e).keySeq()); }, Ft.prototype.toString = function () { return this.__toString("Set {", "}"); }, Ft.prototype.has = function (e) { return this._map.has(e); }, Ft.prototype.add = function (e) { return Lt(this, this._map.set(e, !0)); }, Ft.prototype.remove = function (e) { return Lt(this, this._map.remove(e)); }, Ft.prototype.clear = function () { return Lt(this, this._map.clear()); }, Ft.prototype.union = function () { var e = un.call(arguments, 0); return e = e.filter(function (e) { return 0 !== e.size; }), 0 === e.length ? this : 0 !== this.size || this.__ownerID || 1 !== e.length ? this.withMutations(function (t) { for (var n = 0; n < e.length; n++) + i(e[n]).forEach(function (e) { return t.add(e); }); }) : this.constructor(e[0]); }, Ft.prototype.intersect = function () { var e = un.call(arguments, 0); if (0 === e.length) + return this; e = e.map(function (e) { return i(e); }); var t = this; return this.withMutations(function (n) { t.forEach(function (t) { e.every(function (e) { return e.includes(t); }) || n.remove(t); }); }); }, Ft.prototype.subtract = function () { var e = un.call(arguments, 0); if (0 === e.length) + return this; e = e.map(function (e) { return i(e); }); var t = this; return this.withMutations(function (n) { t.forEach(function (t) { e.some(function (e) { return e.includes(t); }) && n.remove(t); }); }); }, Ft.prototype.merge = function () { return this.union.apply(this, arguments); }, Ft.prototype.mergeWith = function (e) { var t = un.call(arguments, 1); return this.union.apply(this, t); }, Ft.prototype.sort = function (e) { return Ut(bt(this, e)); }, Ft.prototype.sortBy = function (e, t) { return Ut(bt(this, t, e)); }, Ft.prototype.wasAltered = function () { return this._map.wasAltered(); }, Ft.prototype.__iterate = function (e, t) { var n = this; return this._map.__iterate(function (t, r) { return e(r, r, n); }, t); }, Ft.prototype.__iterator = function (e, t) { return this._map.map(function (e, t) { return t; }).__iterator(e, t); }, Ft.prototype.__ensureOwner = function (e) { if (e === this.__ownerID) + return this; var t = this._map.__ensureOwner(e); return e ? this.__make(t, e) : (this.__ownerID = e, this._map = t, this); }, Ft.isSet = Bt; + var Zn = "@@__IMMUTABLE_SET__@@", Qn = Ft.prototype; + Qn[Zn] = !0, Qn.delete = Qn.remove, Qn.mergeDeep = Qn.merge, Qn.mergeDeepWith = Qn.mergeWith, Qn.withMutations = zn.withMutations, Qn.asMutable = zn.asMutable, Qn.asImmutable = zn.asImmutable, Qn.__empty = zt, Qn.__make = qt; + var er; + e(Ut, Ft), Ut.of = function () { return this(arguments); }, Ut.fromKeys = function (e) { return this(n(e).keySeq()); }, Ut.prototype.toString = function () { return this.__toString("OrderedSet {", "}"); }, Ut.isOrderedSet = Wt; + var tr = Ut.prototype; + tr[fn] = !0, tr.__empty = Ht, tr.__make = Vt; + var nr; + e(Jt, ne), Jt.of = function () { return this(arguments); }, Jt.prototype.toString = function () { return this.__toString("Stack [", "]"); }, Jt.prototype.get = function (e, t) { var n = this._head; for (e = m(this, e); n && e--;) + n = n.next; return n ? n.value : t; }, Jt.prototype.peek = function () { return this._head && this._head.value; }, Jt.prototype.push = function () { if (0 === arguments.length) + return this; for (var e = this.size + arguments.length, t = this._head, n = arguments.length - 1; n >= 0; n--) + t = { value: arguments[n], next: t }; return this.__ownerID ? (this.size = e, this._head = t, this.__hash = void 0, this.__altered = !0, this) : Yt(e, t); }, Jt.prototype.pushAll = function (e) { if (e = r(e), 0 === e.size) + return this; ce(e.size); var t = this.size, n = this._head; return e.reverse().forEach(function (e) { t++, n = { value: e, next: n }; }), this.__ownerID ? (this.size = t, this._head = n, this.__hash = void 0, this.__altered = !0, this) : Yt(t, n); }, Jt.prototype.pop = function () { return this.slice(1); }, Jt.prototype.unshift = function () { return this.push.apply(this, arguments); }, Jt.prototype.unshiftAll = function (e) { return this.pushAll(e); }, Jt.prototype.shift = function () { return this.pop.apply(this, arguments); }, Jt.prototype.clear = function () { return 0 === this.size ? this : this.__ownerID ? (this.size = 0, this._head = void 0, this.__hash = void 0, this.__altered = !0, this) : Kt(); }, Jt.prototype.slice = function (e, t) { if (g(e, t, this.size)) + return this; var n = y(e, this.size); if (_(t, this.size) !== this.size) + return ne.prototype.slice.call(this, e, t); for (var r = this.size - n, i = this._head; n--;) + i = i.next; return this.__ownerID ? (this.size = r, this._head = i, this.__hash = void 0, this.__altered = !0, this) : Yt(r, i); }, Jt.prototype.__ensureOwner = function (e) { return e === this.__ownerID ? this : e ? Yt(this.size, this._head, e, this.__hash) : (this.__ownerID = e, this.__altered = !1, this); }, Jt.prototype.__iterate = function (e, t) { if (t) + return this.reverse().__iterate(e); for (var n = 0, r = this._head; r && !1 !== e(r.value, n++, this);) + r = r.next; return n; }, Jt.prototype.__iterator = function (e, t) { if (t) + return this.reverse().__iterator(e); var n = 0, r = this._head; return new x(function () { if (r) { + var t = r.value; + return r = r.next, w(e, n++, t); + } return k(); }); }, Jt.isStack = Gt; + var rr = "@@__IMMUTABLE_STACK__@@", ir = Jt.prototype; + ir[rr] = !0, ir.withMutations = zn.withMutations, ir.asMutable = zn.asMutable, ir.asImmutable = zn.asImmutable, ir.wasAltered = zn.wasAltered; + var or; + t.Iterator = x, Xt(t, { toArray: function () { ce(this.size); var e = new Array(this.size || 0); return this.valueSeq().__iterate(function (t, n) { e[n] = t; }), e; }, toIndexedSeq: function () { return new it(this); }, toJS: function () { return this.toSeq().map(function (e) { return e && "function" == typeof e.toJS ? e.toJS() : e; }).__toJS(); }, toJSON: function () { return this.toSeq().map(function (e) { return e && "function" == typeof e.toJSON ? e.toJSON() : e; }).__toJS(); }, toKeyedSeq: function () { return new rt(this, !0); }, toMap: function () { return pe(this.toKeyedSeq()); }, toObject: function () { ce(this.size); var e = {}; return this.__iterate(function (t, n) { e[n] = t; }), e; }, toOrderedMap: function () { return Ze(this.toKeyedSeq()); }, toOrderedSet: function () { return Ut(a(this) ? this.valueSeq() : this); }, toSet: function () { return Ft(a(this) ? this.valueSeq() : this); }, toSetSeq: function () { return new ot(this); }, toSeq: function () { return s(this) ? this.toIndexedSeq() : a(this) ? this.toKeyedSeq() : this.toSetSeq(); }, toStack: function () { return Jt(a(this) ? this.valueSeq() : this); }, toList: function () { return Le(a(this) ? this.valueSeq() : this); }, toString: function () { return "[Iterable]"; }, __toString: function (e, t) { return 0 === this.size ? e + t : e + " " + this.toSeq().map(this.__toStringMapper).join(", ") + " " + t; }, concat: function () { return Et(this, vt(this, un.call(arguments, 0))); }, includes: function (e) { return this.some(function (t) { return K(t, e); }); }, entries: function () { return this.__iterator(xn); }, every: function (e, t) { ce(this.size); var n = !0; return this.__iterate(function (r, i, o) { if (!e.call(t, r, i, o)) + return n = !1, !1; }), n; }, filter: function (e, t) { return Et(this, ct(this, e, t, !0)); }, find: function (e, t, n) { var r = this.findEntry(e, t); return r ? r[1] : n; }, forEach: function (e, t) { return ce(this.size), this.__iterate(t ? e.bind(t) : e); }, join: function (e) { ce(this.size), e = void 0 !== e ? "" + e : ","; var t = "", n = !0; return this.__iterate(function (r) { n ? n = !1 : t += e, t += null !== r && void 0 !== r ? r.toString() : ""; }), t; }, keys: function () { return this.__iterator(_n); }, map: function (e, t) { return Et(this, ut(this, e, t)); }, reduce: function (e, t, n) { ce(this.size); var r, i; return arguments.length < 2 ? i = !0 : r = t, this.__iterate(function (t, o, a) { i ? (i = !1, r = t) : r = e.call(n, r, t, o, a); }), r; }, reduceRight: function (e, t, n) { var r = this.toKeyedSeq().reverse(); return r.reduce.apply(r, arguments); }, reverse: function () { return Et(this, lt(this, !0)); }, slice: function (e, t) { return Et(this, ht(this, e, t, !0)); }, some: function (e, t) { return !this.every(Qt(e), t); }, sort: function (e) { return Et(this, bt(this, e)); }, values: function () { return this.__iterator(bn); }, butLast: function () { return this.slice(0, -1); }, isEmpty: function () { return void 0 !== this.size ? 0 === this.size : !this.some(function () { return !0; }); }, count: function (e, t) { return d(e ? this.toSeq().filter(e, t) : this); }, countBy: function (e, t) { return pt(this, e, t); }, equals: function (e) { return X(this, e); }, entrySeq: function () { var e = this; if (e._cache) + return new I(e._cache); var t = e.toSeq().map(Zt).toIndexedSeq(); return t.fromEntrySeq = function () { return e.toSeq(); }, t; }, filterNot: function (e, t) { return this.filter(Qt(e), t); }, findEntry: function (e, t, n) { var r = n; return this.__iterate(function (n, i, o) { if (e.call(t, n, i, o)) + return r = [i, n], !1; }), r; }, findKey: function (e, t) { var n = this.findEntry(e, t); return n && n[0]; }, findLast: function (e, t, n) { return this.toKeyedSeq().reverse().find(e, t, n); }, findLastEntry: function (e, t, n) { return this.toKeyedSeq().reverse().findEntry(e, t, n); }, findLastKey: function (e, t) { return this.toKeyedSeq().reverse().findKey(e, t); }, first: function () { return this.find(v); }, flatMap: function (e, t) { return Et(this, yt(this, e, t)); }, flatten: function (e) { return Et(this, gt(this, e, !0)); }, fromEntrySeq: function () { return new at(this); }, get: function (e, t) { return this.find(function (t, n) { return K(n, e); }, void 0, t); }, getIn: function (e, t) { for (var n, r = this, i = Tt(e); !(n = i.next()).done;) { + var o = n.value; + if ((r = r && r.get ? r.get(o, vn) : vn) === vn) + return t; + } return r; }, groupBy: function (e, t) { return ft(this, e, t); }, has: function (e) { return this.get(e, vn) !== vn; }, hasIn: function (e) { return this.getIn(e, vn) !== vn; }, isSubset: function (e) { return e = "function" == typeof e.includes ? e : t(e), this.every(function (t) { return e.includes(t); }); }, isSuperset: function (e) { return e = "function" == typeof e.isSubset ? e : t(e), e.isSubset(this); }, keyOf: function (e) { return this.findKey(function (t) { return K(t, e); }); }, keySeq: function () { return this.toSeq().map($t).toIndexedSeq(); }, last: function () { return this.toSeq().reverse().first(); }, lastKeyOf: function (e) { return this.toKeyedSeq().reverse().keyOf(e); }, max: function (e) { return xt(this, e); }, maxBy: function (e, t) { return xt(this, t, e); }, min: function (e) { return xt(this, e ? en(e) : rn); }, minBy: function (e, t) { return xt(this, t ? en(t) : rn, e); }, rest: function () { return this.slice(1); }, skip: function (e) { return this.slice(Math.max(0, e)); }, skipLast: function (e) { return Et(this, this.toSeq().reverse().skip(e).reverse()); }, skipWhile: function (e, t) { return Et(this, mt(this, e, t, !0)); }, skipUntil: function (e, t) { return this.skipWhile(Qt(e), t); }, sortBy: function (e, t) { return Et(this, bt(this, t, e)); }, take: function (e) { return this.slice(0, Math.max(0, e)); }, takeLast: function (e) { return Et(this, this.toSeq().reverse().take(e).reverse()); }, takeWhile: function (e, t) { return Et(this, dt(this, e, t)); }, takeUntil: function (e, t) { return this.takeWhile(Qt(e), t); }, valueSeq: function () { return this.toIndexedSeq(); }, hashCode: function () { return this.__hash || (this.__hash = on(this)); } }); + var ar = t.prototype; + ar[ln] = !0, ar[En] = ar.values, ar.__toJS = ar.toArray, ar.__toStringMapper = tn, ar.inspect = ar.toSource = function () { return this.toString(); }, ar.chain = ar.flatMap, ar.contains = ar.includes, Xt(n, { flip: function () { return Et(this, st(this)); }, mapEntries: function (e, t) { var n = this, r = 0; return Et(this, this.toSeq().map(function (i, o) { return e.call(t, [o, i], r++, n); }).fromEntrySeq()); }, mapKeys: function (e, t) { var n = this; return Et(this, this.toSeq().flip().map(function (r, i) { return e.call(t, r, i, n); }).flip()); } }); + var sr = n.prototype; + return sr[cn] = !0, sr[En] = ar.entries, sr.__toJS = ar.toObject, sr.__toStringMapper = function (e, t) { return JSON.stringify(t) + ": " + tn(e); }, Xt(r, { toKeyedSeq: function () { return new rt(this, !1); }, filter: function (e, t) { return Et(this, ct(this, e, t, !1)); }, findIndex: function (e, t) { var n = this.findEntry(e, t); return n ? n[0] : -1; }, indexOf: function (e) { var t = this.keyOf(e); return void 0 === t ? -1 : t; }, lastIndexOf: function (e) { var t = this.lastKeyOf(e); return void 0 === t ? -1 : t; }, reverse: function () { return Et(this, lt(this, !1)); }, slice: function (e, t) { return Et(this, ht(this, e, t, !1)); }, splice: function (e, t) { var n = arguments.length; if (t = Math.max(0 | t, 0), 0 === n || 2 === n && !t) + return this; e = y(e, e < 0 ? this.count() : this.size); var r = this.slice(0, e); return Et(this, 1 === n ? r : r.concat(h(arguments, 2), this.slice(e + t))); }, findLastIndex: function (e, t) { var n = this.findLastEntry(e, t); return n ? n[0] : -1; }, first: function () { return this.get(0); }, flatten: function (e) { return Et(this, gt(this, e, !1)); }, get: function (e, t) { return e = m(this, e), e < 0 || this.size === 1 / 0 || void 0 !== this.size && e > this.size ? t : this.find(function (t, n) { return n === e; }, void 0, t); }, has: function (e) { return (e = m(this, e)) >= 0 && (void 0 !== this.size ? this.size === 1 / 0 || e < this.size : -1 !== this.indexOf(e)); }, interpose: function (e) { return Et(this, _t(this, e)); }, interleave: function () { var e = [this].concat(h(arguments)), t = kt(this.toSeq(), T.of, e), n = t.flatten(!0); return t.size && (n.size = t.size * e.length), Et(this, n); }, keySeq: function () { return Q(0, this.size); }, last: function () { return this.get(-1); }, skipWhile: function (e, t) { return Et(this, mt(this, e, t, !1)); }, zip: function () { return Et(this, kt(this, nn, [this].concat(h(arguments)))); }, zipWith: function (e) { var t = h(arguments); return t[0] = this, Et(this, kt(this, e, t)); } }), r.prototype[pn] = !0, r.prototype[fn] = !0, Xt(i, { get: function (e, t) { return this.has(e) ? e : t; }, includes: function (e) { return this.has(e); }, keySeq: function () { return this.valueSeq(); } }), i.prototype.has = ar.includes, i.prototype.contains = i.prototype.includes, Xt(M, n.prototype), Xt(T, r.prototype), Xt(P, i.prototype), Xt(te, n.prototype), Xt(ne, r.prototype), Xt(re, i.prototype), { Iterable: t, Seq: O, Collection: ee, Map: pe, OrderedMap: Ze, List: Le, Stack: Jt, Set: Ft, OrderedSet: Ut, Record: Pt, Range: Q, Repeat: $, is: K, fromJS: H }; + }); }, function (e, t, n) { + "use strict"; + function r(e, t, n, r, o, a, s, u) { if (i(t), !e) { + var l; + if (void 0 === t) + l = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); + else { + var c = [n, r, o, a, s, u], p = 0; + l = new Error(t.replace(/%s/g, function () { return c[p++]; })), l.name = "Invariant Violation"; + } + throw l.framesToPop = 1, l; + } } + var i = function (e) { }; + e.exports = r; + }, function (e, t, n) { + "use strict"; + (function (e) { function r(e) { return e && e.__esModule ? e : { default: e }; } function i(e) { try { + var t = JSON.parse(e); + if (t && "object" === (void 0 === t ? "undefined" : (0, B.default)(t))) + return t; + } + catch (e) { } return !1; } function o(e) { return p(e) ? ae(e) ? e.toObject() : e : {}; } function a(e) { return e ? e.toArray ? e.toArray() : l(e) : []; } function s(e) { return ae(e) ? e : e instanceof ne.default.File ? e : p(e) ? Array.isArray(e) ? q.default.Seq(e).map(s).toList() : q.default.OrderedMap(e).map(s) : e; } function u(e, t) { var n = {}; return (0, N.default)(e).filter(function (t) { return "function" == typeof e[t]; }).forEach(function (r) { return n[r] = e[r].bind(null, t); }), n; } function l(e) { return Array.isArray(e) ? e : [e]; } function c(e) { return "function" == typeof e; } function p(e) { return !!e && "object" === (void 0 === e ? "undefined" : (0, B.default)(e)); } function f(e) { return "function" == typeof e; } function h(e) { return Array.isArray(e); } function d(e, t) { return (0, N.default)(e).reduce(function (n, r) { return n[r] = t(e[r], r), n; }, {}); } function m(e, t) { return (0, N.default)(e).reduce(function (n, r) { var i = t(e[r], r); return i && "object" === (void 0 === i ? "undefined" : (0, B.default)(i)) && (0, R.default)(n, i), n; }, {}); } function v(e) { return function (t) { t.dispatch, t.getState; return function (t) { return function (n) { return "function" == typeof n ? n(e()) : t(n); }; }; }; } function g(e) { var t = e.keySeq(); return t.contains(oe) ? oe : t.filter(function (e) { return "2" === (e + "")[0]; }).sort().first(); } function y(e, t) { if (!q.default.Iterable.isIterable(e)) + return q.default.List(); var n = e.getIn(Array.isArray(t) ? t : [t]); return q.default.List.isList(n) ? n : q.default.List(); } function _(e) { var t = document; if (!e) + return ""; if (e.textContent.length > 5e3) + return e.textContent; return function (e) { for (var n, r, i, o, a, s = e.textContent, u = 0, l = s[0], c = 1, p = e.innerHTML = "", f = 0; r = n, n = f < 7 && "\\" == n ? 1 : c;) { + if (c = l, l = s[++u], o = p.length > 1, !c || f > 8 && "\n" == c || [/\S/.test(c), 1, 1, !/[$\w]/.test(c), ("/" == n || "\n" == n) && o, '"' == n && o, "'" == n && o, s[u - 4] + r + n == "--\x3e", r + n == "*/"][f]) + for (p && (e.appendChild(a = t.createElement("span")).setAttribute("style", ["color: #555; font-weight: bold;", "", "", "color: #555;", ""][f ? f < 3 ? 2 : f > 6 ? 4 : f > 3 ? 3 : +/^(a(bstract|lias|nd|rguments|rray|s(m|sert)?|uto)|b(ase|egin|ool(ean)?|reak|yte)|c(ase|atch|har|hecked|lass|lone|ompl|onst|ontinue)|de(bugger|cimal|clare|f(ault|er)?|init|l(egate|ete)?)|do|double|e(cho|ls?if|lse(if)?|nd|nsure|num|vent|x(cept|ec|p(licit|ort)|te(nds|nsion|rn)))|f(allthrough|alse|inal(ly)?|ixed|loat|or(each)?|riend|rom|unc(tion)?)|global|goto|guard|i(f|mp(lements|licit|ort)|n(it|clude(_once)?|line|out|stanceof|t(erface|ernal)?)?|s)|l(ambda|et|ock|ong)|m(icrolight|odule|utable)|NaN|n(amespace|ative|ext|ew|il|ot|ull)|o(bject|perator|r|ut|verride)|p(ackage|arams|rivate|rotected|rotocol|ublic)|r(aise|e(adonly|do|f|gister|peat|quire(_once)?|scue|strict|try|turn))|s(byte|ealed|elf|hort|igned|izeof|tatic|tring|truct|ubscript|uper|ynchronized|witch)|t(emplate|hen|his|hrows?|ransient|rue|ry|ype(alias|def|id|name|of))|u(n(checked|def(ined)?|ion|less|signed|til)|se|sing)|v(ar|irtual|oid|olatile)|w(char_t|hen|here|hile|ith)|xor|yield)$/.test(p) : 0]), a.appendChild(t.createTextNode(p))), i = f && f < 7 ? f : i, p = "", f = 11; ![1, /[\/{}[(\-+*=<>:;|\\.,?!&@~]/.test(c), /[\])]/.test(c), /[$\w]/.test(c), "/" == c && i < 2 && "<" != n, '"' == c, "'" == c, c + l + s[u + 1] + s[u + 2] == "\x3c!--", c + l == "/*", c + l == "//", "#" == c][--f];) + ; + p += c; + } }(e); } function b(e) { var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "key", n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : q.default.Map(); if (!q.default.Map.isMap(e) || !e.size) + return q.default.List(); if (Array.isArray(t) || (t = [t]), t.length < 1) + return e.merge(n); var r = q.default.List(), i = t[0], o = !0, a = !1, s = void 0; try { + for (var u, l = (0, P.default)(e.entries()); !(o = (u = l.next()).done); o = !0) { + var c = u.value, p = (0, M.default)(c, 2), f = p[0], h = p[1], d = b(h, t.slice(1), n.set(i, f)); + r = q.default.List.isList(d) ? r.concat(d) : r.push(d); + } + } + catch (e) { + a = !0, s = e; + } + finally { + try { + !o && l.return && l.return(); + } + finally { + if (a) + throw s; + } + } return r; } function x(e) { var t = /filename="([^;]*);?"/i.exec(e); return null === t && (t = /filename=([^;]*);?/i.exec(e)), null !== t && t.length > 1 ? t[1] : null; } function w(e) { return (0, H.default)((0, W.default)(e)); } function k(e) { return w(e.replace(/\.[^.\/]*$/, "")); } function E(e) { return "string" != typeof e || "" === e ? "" : (0, z.sanitizeUrl)(e); } function S(e) { if (!q.default.OrderedMap.isOrderedMap(e)) + return null; if (!e.size) + return null; var t = e.find(function (e, t) { return t.startsWith("2") && (0, N.default)(e.get("content") || {}).length > 0; }), n = e.get("default") || q.default.OrderedMap(), r = (n.get("content") || q.default.OrderedMap()).keySeq().toJS(), i = r.length ? n : null; return t || i; } function C(e, t) { var n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : function () { return !0; }; if ("object" !== (void 0 === e ? "undefined" : (0, B.default)(e)) || Array.isArray(e) || !t) + return e; var r = (0, R.default)({}, e); return (0, N.default)(r).forEach(function (e) { if (e === t && n(r[e], e)) + return void delete r[e]; r[e] = C(r[e], t, n); }), r; } Object.defineProperty(t, "__esModule", { value: !0 }), t.getCommonExtensions = t.getExtensions = t.escapeDeepLinkPath = t.createDeepLinkPath = t.shallowEqualKeys = t.buildFormData = t.sorters = t.btoa = t.serializeSearch = t.parseSearch = t.getSampleSchema = t.validateParam = t.validatePattern = t.validateMinLength = t.validateMaxLength = t.validateGuid = t.validateDateTime = t.validateString = t.validateBoolean = t.validateFile = t.validateInteger = t.validateNumber = t.validateMinimum = t.validateMaximum = t.propChecker = t.memoize = t.isImmutable = void 0; var A = n(37), D = r(A), O = n(18), M = r(O), T = n(96), P = r(T), I = n(23), R = r(I), j = n(42), N = r(j), F = n(43), B = r(F); t.isJSONObject = i, t.objectify = o, t.arrayify = a, t.fromJSOrdered = s, t.bindToState = u, t.normalizeArray = l, t.isFn = c, t.isObject = p, t.isFunc = f, t.isArray = h, t.objMap = d, t.objReduce = m, t.systemThunkMiddleware = v, t.defaultStatusCode = g, t.getList = y, t.highlight = _, t.mapToList = b, t.extractFileNameFromContentDispositionHeader = x, t.pascalCase = w, t.pascalCaseFilename = k, t.sanitizeUrl = E, t.getAcceptControllingResponse = S, t.deeplyStripKey = C; var L = n(7), q = r(L), z = n(524), U = n(957), W = r(U), V = n(443), H = r(V), J = n(439), G = r(J), Y = n(229), K = r(Y), X = n(975), $ = r(X), Z = n(118), Q = r(Z), ee = n(175), te = n(36), ne = r(te), re = n(714), ie = r(re), oe = "default", ae = t.isImmutable = function (e) { return q.default.Iterable.isIterable(e); }, se = (t.memoize = G.default, t.propChecker = function (e, t) { var n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [], r = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : []; return (0, N.default)(e).length !== (0, N.default)(t).length || ((0, $.default)(e, function (e, n) { if (r.includes(n)) + return !1; var i = t[n]; return q.default.Iterable.isIterable(e) ? !q.default.is(e, i) : ("object" !== (void 0 === e ? "undefined" : (0, B.default)(e)) || "object" !== (void 0 === i ? "undefined" : (0, B.default)(i))) && e !== i; }) || n.some(function (n) { return !(0, Q.default)(e[n], t[n]); })); }, t.validateMaximum = function (e, t) { if (e > t) + return "Value must be less than Maximum"; }), ue = t.validateMinimum = function (e, t) { if (e < t) + return "Value must be greater than Minimum"; }, le = t.validateNumber = function (e) { if (!/^-?\d+(\.?\d+)?$/.test(e)) + return "Value must be a number"; }, ce = t.validateInteger = function (e) { if (!/^-?\d+$/.test(e)) + return "Value must be an integer"; }, pe = t.validateFile = function (e) { if (e && !(e instanceof ne.default.File)) + return "Value must be a file"; }, fe = t.validateBoolean = function (e) { if ("true" !== e && "false" !== e && !0 !== e && !1 !== e) + return "Value must be a boolean"; }, he = t.validateString = function (e) { if (e && "string" != typeof e) + return "Value must be a string"; }, de = t.validateDateTime = function (e) { if (isNaN(Date.parse(e))) + return "Value must be a DateTime"; }, me = t.validateGuid = function (e) { if (e = e.toString().toLowerCase(), !/^[{(]?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[)}]?$/.test(e)) + return "Value must be a Guid"; }, ve = t.validateMaxLength = function (e, t) { if (e.length > t) + return "Value must be less than MaxLength"; }, ge = t.validateMinLength = function (e, t) { if (e.length < t) + return "Value must be greater than MinLength"; }, ye = t.validatePattern = function (e, t) { if (!new RegExp(t).test(e)) + return "Value must follow pattern " + t; }, _e = (t.validateParam = function (e, t) { var n = arguments.length > 2 && void 0 !== arguments[2] && arguments[2], r = [], i = t && "body" === e.get("in") ? e.get("value_xml") : e.get("value"), o = e.get("required"), a = n ? e.get("schema") : e; if (!a) + return r; var s = a.get("maximum"), u = a.get("minimum"), l = a.get("type"), c = a.get("format"), p = a.get("maxLength"), f = a.get("minLength"), h = a.get("pattern"); if (l && (o || i)) { + var d = "string" === l && i, m = "array" === l && Array.isArray(i) && i.length, v = "array" === l && q.default.List.isList(i) && i.count(), g = "file" === l && i instanceof ne.default.File, y = "boolean" === l && (i || !1 === i), _ = "number" === l && (i || 0 === i), b = "integer" === l && (i || 0 === i); + if (o && !(d || m || v || g || y || _ || b)) + return r.push("Required field is not provided"), r; + if (h) { + var x = ye(i, h); + x && r.push(x); + } + if (p || 0 === p) { + var w = ve(i, p); + w && r.push(w); + } + if (f) { + var k = ge(i, f); + k && r.push(k); + } + if (s || 0 === s) { + var E = se(i, s); + E && r.push(E); + } + if (u || 0 === u) { + var S = ue(i, u); + S && r.push(S); + } + if ("string" === l) { + var C = void 0; + if (!(C = "date-time" === c ? de(i) : "uuid" === c ? me(i) : he(i))) + return r; + r.push(C); + } + else if ("boolean" === l) { + var A = fe(i); + if (!A) + return r; + r.push(A); + } + else if ("number" === l) { + var D = le(i); + if (!D) + return r; + r.push(D); + } + else if ("integer" === l) { + var O = ce(i); + if (!O) + return r; + r.push(O); + } + else if ("array" === l) { + var M = void 0; + if (!v || !i.count()) + return r; + M = a.getIn(["items", "type"]), i.forEach(function (e, t) { var n = void 0; "number" === M ? n = le(e) : "integer" === M ? n = ce(e) : "string" === M && (n = he(e)), n && r.push({ index: t, error: n }); }); + } + else if ("file" === l) { + var T = pe(i); + if (!T) + return r; + r.push(T); + } + } return r; }, t.getSampleSchema = function (e) { var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "", n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}; if (/xml/.test(t)) { + if (!e.xml || !e.xml.name) { + if (e.xml = e.xml || {}, !e.$$ref) + return e.type || e.items || e.properties || e.additionalProperties ? '\n\x3c!-- XML example cannot be generated --\x3e' : null; + var r = e.$$ref.match(/\S*\/(\S+)$/); + e.xml.name = r[1]; + } + return (0, ee.memoizedCreateXMLExample)(e, n); + } return (0, D.default)((0, ee.memoizedSampleFromSchema)(e, n), null, 2); }, t.parseSearch = function () { var e = {}, t = ne.default.location.search; if (!t) + return {}; if ("" != t) { + var n = t.substr(1).split("&"); + for (var r in n) + n.hasOwnProperty(r) && (r = n[r].split("="), e[decodeURIComponent(r[0])] = r[1] && decodeURIComponent(r[1]) || ""); + } return e; }, t.serializeSearch = function (e) { return (0, N.default)(e).map(function (t) { return encodeURIComponent(t) + "=" + encodeURIComponent(e[t]); }).join("&"); }, t.btoa = function (t) { var n = void 0; return n = t instanceof e ? t : new e(t.toString(), "utf-8"), n.toString("base64"); }, t.sorters = { operationsSorter: { alpha: function (e, t) { return e.get("path").localeCompare(t.get("path")); }, method: function (e, t) { return e.get("method").localeCompare(t.get("method")); } }, tagsSorter: { alpha: function (e, t) { return e.localeCompare(t); } } }, t.buildFormData = function (e) { var t = []; for (var n in e) { + var r = e[n]; + void 0 !== r && "" !== r && t.push([n, "=", encodeURIComponent(r).replace(/%20/g, "+")].join("")); + } return t.join("&"); }, t.shallowEqualKeys = function (e, t, n) { return !!(0, K.default)(n, function (n) { return (0, Q.default)(e[n], t[n]); }); }, t.createDeepLinkPath = function (e) { return "string" == typeof e || e instanceof String ? e.trim().replace(/\s/g, "_") : ""; }); t.escapeDeepLinkPath = function (e) { return (0, ie.default)(_e(e)); }, t.getExtensions = function (e) { return e.filter(function (e, t) { return /^x-/.test(t); }); }, t.getCommonExtensions = function (e) { return e.filter(function (e, t) { return /^pattern|maxLength|minLength|maximum|minimum/.test(t); }); }; }).call(t, n(44).Buffer); + }, function (e, t, n) { + "use strict"; + var r = n(33), i = r; + e.exports = i; + }, function (e, t, n) { + "use strict"; + function r(e) { for (var t = arguments.length - 1, n = "Minified React error #" + e + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant=" + e, r = 0; r < t; r++) + n += "&args[]=" + encodeURIComponent(arguments[r + 1]); n += " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; var i = new Error(n); throw i.name = "Invariant Violation", i.framesToPop = 1, i; } + e.exports = r; + }, function (e, t, n) { + "use strict"; + function r(e) { var t = typeof e; return Array.isArray(e) ? "array" : e instanceof RegExp ? "object" : e instanceof b.Iterable ? "Immutable." + e.toSource().split(" ")[0] : t; } + function i(e) { function t(t, n, r, i, o, a) { for (var s = arguments.length, u = Array(s > 6 ? s - 6 : 0), l = 6; l < s; l++) + u[l - 6] = arguments[l]; if (a = a || r, i = i || x, null != n[r]) + return e.apply(void 0, [n, r, i, o, a].concat(u)); var c = o; return t ? new Error("Required " + c + " `" + a + "` was not specified in `" + i + "`.") : void 0; } var n = t.bind(null, !1); return n.isRequired = t.bind(null, !0), n; } + function o(e, t) { function n(n, i, o, a, s) { var u = n[i]; if (!t(u)) { + var l = r(u); + return new Error("Invalid " + a + " `" + s + "` of type `" + l + "` supplied to `" + o + "`, expected `" + e + "`."); + } return null; } return i(n); } + function a(e, t, n) { function o(i, o, a, s, u) { for (var l = arguments.length, c = Array(l > 5 ? l - 5 : 0), p = 5; p < l; p++) + c[p - 5] = arguments[p]; var f = i[o]; if (!n(f)) { + var h = s, d = r(f); + return new Error("Invalid " + h + " `" + u + "` of type `" + d + "` supplied to `" + a + "`, expected an Immutable.js " + t + "."); + } if ("function" != typeof e) + return new Error("Invalid typeChecker supplied to `" + a + "` for propType `" + u + "`, expected a function."); for (var m = f.toArray(), v = 0, g = m.length; v < g; v++) { + var y = e.apply(void 0, [m, v, a, s, u + "[" + v + "]"].concat(c)); + if (y instanceof Error) + return y; + } } return i(o); } + function s(e) { function t(t, n, r, i, o) { for (var a = arguments.length, s = Array(a > 5 ? a - 5 : 0), u = 5; u < a; u++) + s[u - 5] = arguments[u]; var l = t[n]; if ("function" != typeof e) + return new Error("Invalid keysTypeChecker (optional second argument) supplied to `" + r + "` for propType `" + o + "`, expected a function."); for (var c = l.keySeq().toArray(), p = 0, f = c.length; p < f; p++) { + var h = e.apply(void 0, [c, p, r, i, o + " -> key(" + c[p] + ")"].concat(s)); + if (h instanceof Error) + return h; + } } return i(t); } + function u(e) { return a(e, "List", b.List.isList); } + function l(e, t, n, r) { function o() { for (var i = arguments.length, o = Array(i), u = 0; u < i; u++) + o[u] = arguments[u]; return a(e, n, r).apply(void 0, o) || t && s(t).apply(void 0, o); } return i(o); } + function c(e, t) { return l(e, t, "Map", b.Map.isMap); } + function p(e, t) { return l(e, t, "OrderedMap", b.OrderedMap.isOrderedMap); } + function f(e) { return a(e, "Set", b.Set.isSet); } + function h(e) { return a(e, "OrderedSet", b.OrderedSet.isOrderedSet); } + function d(e) { return a(e, "Stack", b.Stack.isStack); } + function m(e) { return a(e, "Iterable", b.Iterable.isIterable); } + function v(e) { function t(t, n, i, o, a) { for (var s = arguments.length, u = Array(s > 5 ? s - 5 : 0), l = 5; l < s; l++) + u[l - 5] = arguments[l]; var c = t[n]; if (!(c instanceof b.Record)) { + var p = r(c), f = o; + return new Error("Invalid " + f + " `" + a + "` of type `" + p + "` supplied to `" + i + "`, expected an Immutable.js Record."); + } for (var h in e) { + var d = e[h]; + if (d) { + var m = c.toObject(), v = d.apply(void 0, [m, h, i, o, a + "." + h].concat(u)); + if (v) + return v; + } + } } return i(t); } + function g(e) { function t(t, i, a, s, u) { for (var l = arguments.length, c = Array(l > 5 ? l - 5 : 0), p = 5; p < l; p++) + c[p - 5] = arguments[p]; var f = t[i]; if (!o(f)) { + var h = r(f), d = s; + return new Error("Invalid " + d + " `" + u + "` of type `" + h + "` supplied to `" + a + "`, expected an Immutable.js " + n + "."); + } var m = f.toObject(); for (var v in e) { + var g = e[v]; + if (g) { + var y = g.apply(void 0, [m, v, a, s, u + "." + v].concat(c)); + if (y) + return y; + } + } } var n = void 0 === arguments[1] ? "Iterable" : arguments[1], o = void 0 === arguments[2] ? b.Iterable.isIterable : arguments[2]; return i(t); } + function y(e) { return g(e); } + function _(e) { return g(e, "Map", b.Map.isMap); } + var b = n(7), x = "<>", w = { listOf: u, mapOf: c, orderedMapOf: p, setOf: f, orderedSetOf: h, stackOf: d, iterableOf: m, recordOf: v, shape: y, contains: y, mapContains: _, list: o("List", b.List.isList), map: o("Map", b.Map.isMap), orderedMap: o("OrderedMap", b.OrderedMap.isOrderedMap), set: o("Set", b.Set.isSet), orderedSet: o("OrderedSet", b.OrderedSet.isOrderedSet), stack: o("Stack", b.Stack.isStack), seq: o("Seq", b.Seq.isSeq), record: o("Record", function (e) { return e instanceof b.Record; }), iterable: o("Iterable", b.Iterable.isIterable) }; + e.exports = w; + }, function (e, t, n) { + "use strict"; + function r(e) { if (null === e || void 0 === e) + throw new TypeError("Object.assign cannot be called with null or undefined"); return Object(e); } /* + object-assign + (c) Sindre Sorhus + @license MIT + */ + var i = Object.getOwnPropertySymbols, o = Object.prototype.hasOwnProperty, a = Object.prototype.propertyIsEnumerable; + e.exports = function () { try { + if (!Object.assign) + return !1; + var e = new String("abc"); + if (e[5] = "de", "5" === Object.getOwnPropertyNames(e)[0]) + return !1; + for (var t = {}, n = 0; n < 10; n++) + t["_" + String.fromCharCode(n)] = n; + if ("0123456789" !== Object.getOwnPropertyNames(t).map(function (e) { return t[e]; }).join("")) + return !1; + var r = {}; + return "abcdefghijklmnopqrst".split("").forEach(function (e) { r[e] = e; }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, r)).join(""); + } + catch (e) { + return !1; + } }() ? Object.assign : function (e, t) { for (var n, s, u = r(e), l = 1; l < arguments.length; l++) { + n = Object(arguments[l]); + for (var c in n) + o.call(n, c) && (u[c] = n[c]); + if (i) { + s = i(n); + for (var p = 0; p < s.length; p++) + a.call(n, s[p]) && (u[s[p]] = n[s[p]]); + } + } return u; }; + }, function (e, t, n) { + "use strict"; + function r(e, t) { return 1 === e.nodeType && e.getAttribute(d) === String(t) || 8 === e.nodeType && e.nodeValue === " react-text: " + t + " " || 8 === e.nodeType && e.nodeValue === " react-empty: " + t + " "; } + function i(e) { for (var t; t = e._renderedComponent;) + e = t; return e; } + function o(e, t) { var n = i(e); n._hostNode = t, t[v] = n; } + function a(e) { var t = e._hostNode; t && (delete t[v], e._hostNode = null); } + function s(e, t) { if (!(e._flags & m.hasCachedChildNodes)) { + var n = e._renderedChildren, a = t.firstChild; + e: for (var s in n) + if (n.hasOwnProperty(s)) { + var u = n[s], l = i(u)._domID; + if (0 !== l) { + for (; null !== a; a = a.nextSibling) + if (r(a, l)) { + o(u, a); + continue e; + } + p("32", l); + } + } + e._flags |= m.hasCachedChildNodes; + } } + function u(e) { if (e[v]) + return e[v]; for (var t = []; !e[v];) { + if (t.push(e), !e.parentNode) + return null; + e = e.parentNode; + } for (var n, r; e && (r = e[v]); e = t.pop()) + n = r, t.length && s(r, e); return n; } + function l(e) { var t = u(e); return null != t && t._hostNode === e ? t : null; } + function c(e) { if (void 0 === e._hostNode && p("33"), e._hostNode) + return e._hostNode; for (var t = []; !e._hostNode;) + t.push(e), e._hostParent || p("34"), e = e._hostParent; for (; t.length; e = t.pop()) + s(e, e._hostNode); return e._hostNode; } + var p = n(11), f = n(89), h = n(469), d = (n(8), f.ID_ATTRIBUTE_NAME), m = h, v = "__reactInternalInstance$" + Math.random().toString(36).slice(2), g = { getClosestInstanceFromNode: u, getInstanceFromNode: l, getNodeFromInstance: c, precacheChildNodes: s, precacheNode: o, uncacheNode: a }; + e.exports = g; + }, function (e, t) { var n = e.exports = { version: "2.5.5" }; "number" == typeof __e && (__e = n); }, function (e, t) { var n; n = function () { return this; }(); try { + n = n || Function("return this")() || (0, eval)("this"); + } + catch (e) { + "object" == typeof window && (n = window); + } e.exports = n; }, function (e, t, n) { + "use strict"; + function r(e) { var t = {}; return null !== e && Object.keys(e).forEach(function (n) { e[n].forEach(function (e) { t[String(e)] = n; }); }), t; } + function i(e, t) { if (t = t || {}, Object.keys(t).forEach(function (t) { if (-1 === a.indexOf(t)) + throw new o('Unknown option "' + t + '" is met in definition of "' + e + '" YAML type.'); }), this.tag = e, this.kind = t.kind || null, this.resolve = t.resolve || function () { return !0; }, this.construct = t.construct || function (e) { return e; }, this.instanceOf = t.instanceOf || null, this.predicate = t.predicate || null, this.represent = t.represent || null, this.defaultStyle = t.defaultStyle || null, this.styleAliases = r(t.styleAliases || null), -1 === s.indexOf(this.kind)) + throw new o('Unknown kind "' + this.kind + '" is specified for "' + e + '" YAML type.'); } + var o = n(116), a = ["kind", "resolve", "construct", "instanceOf", "predicate", "represent", "defaultStyle", "styleAliases"], s = ["scalar", "sequence", "mapping"]; + e.exports = i; + }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + t.__esModule = !0; + var i = n(583), o = r(i), a = n(96), s = r(a); + t.default = function () { function e(e, t) { var n = [], r = !0, i = !1, o = void 0; try { + for (var a, u = (0, s.default)(e); !(r = (a = u.next()).done) && (n.push(a.value), !t || n.length !== t); r = !0) + ; + } + catch (e) { + i = !0, o = e; + } + finally { + try { + !r && u.return && u.return(); + } + finally { + if (i) + throw o; + } + } return n; } return function (t, n) { if (Array.isArray(t)) + return t; if ((0, o.default)(Object(t))) + return e(t, n); throw new TypeError("Invalid attempt to destructure non-iterable instance"); }; }(); + }, function (e, t, n) { var r = n(371)("wks"), i = n(207), o = n(32).Symbol, a = "function" == typeof o; (e.exports = function (e) { return r[e] || (r[e] = a && o[e] || (a ? o : i)("Symbol." + e)); }).store = r; }, function (e, t, n) { + "use strict"; + t.__esModule = !0; + var r = n(23), i = function (e) { return e && e.__esModule ? e : { default: e }; }(r); + t.default = i.default || function (e) { for (var t = 1; t < arguments.length; t++) { + var n = arguments[t]; + for (var r in n) + Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]); + } return e; }; + }, function (e, t, n) { var r = n(193)("wks"), i = n(133), o = n(25).Symbol, a = "function" == typeof o; (e.exports = function (e) { return r[e] || (r[e] = a && o[e] || (a ? o : i)("Symbol." + e)); }).store = r; }, function (e, t) { var n = Array.isArray; e.exports = n; }, function (e, t, n) { e.exports = { default: n(606), __esModule: !0 }; }, function (e, t, n) { var r = n(25), i = n(15), o = n(54), a = n(57), s = n(56), u = function (e, t, n) { var l, c, p, f = e & u.F, h = e & u.G, d = e & u.S, m = e & u.P, v = e & u.B, g = e & u.W, y = h ? i : i[t] || (i[t] = {}), _ = y.prototype, b = h ? r : d ? r[t] : (r[t] || {}).prototype; h && (n = t); for (l in n) + (c = !f && b && void 0 !== b[l]) && s(y, l) || (p = c ? b[l] : n[l], y[l] = h && "function" != typeof b[l] ? n[l] : v && c ? o(p, r) : g && b[l] == p ? function (e) { var t = function (t, n, r) { if (this instanceof e) { + switch (arguments.length) { + case 0: return new e; + case 1: return new e(t); + case 2: return new e(t, n); + } + return new e(t, n, r); + } return e.apply(this, arguments); }; return t.prototype = e.prototype, t; }(p) : m && "function" == typeof p ? o(Function.call, p) : p, m && ((y.virtual || (y.virtual = {}))[l] = p, e & u.R && _ && !_[l] && a(_, l, p))); }; u.F = 1, u.G = 2, u.S = 4, u.P = 8, u.B = 16, u.W = 32, u.U = 64, u.R = 128, e.exports = u; }, function (e, t) { var n = e.exports = "undefined" != typeof window && window.Math == Math ? window : "undefined" != typeof self && self.Math == Math ? self : Function("return this")(); "number" == typeof __g && (__g = n); }, function (e, t, n) { + "use strict"; + var r = !("undefined" == typeof window || !window.document || !window.document.createElement), i = { canUseDOM: r, canUseWorkers: "undefined" != typeof Worker, canUseEventListeners: r && !(!window.addEventListener && !window.attachEvent), canUseViewport: r && !!window.screen, isInWorker: !r }; + e.exports = i; + }, function (e, t, n) { + "use strict"; + function r(e) { return Object.prototype.toString.call(e); } + function i(e) { return "[object String]" === r(e); } + function o(e, t) { return !!e && d.call(e, t); } + function a(e) { return [].slice.call(arguments, 1).forEach(function (t) { if (t) { + if ("object" != typeof t) + throw new TypeError(t + "must be object"); + Object.keys(t).forEach(function (n) { e[n] = t[n]; }); + } }), e; } + function s(e) { return e.indexOf("\\") < 0 ? e : e.replace(m, "$1"); } + function u(e) { return !(e >= 55296 && e <= 57343) && (!(e >= 64976 && e <= 65007) && (65535 != (65535 & e) && 65534 != (65535 & e) && (!(e >= 0 && e <= 8) && (11 !== e && (!(e >= 14 && e <= 31) && (!(e >= 127 && e <= 159) && !(e > 1114111))))))); } + function l(e) { if (e > 65535) { + e -= 65536; + var t = 55296 + (e >> 10), n = 56320 + (1023 & e); + return String.fromCharCode(t, n); + } return String.fromCharCode(e); } + function c(e, t) { var n = 0; return o(y, t) ? y[t] : 35 === t.charCodeAt(0) && g.test(t) && (n = "x" === t[1].toLowerCase() ? parseInt(t.slice(2), 16) : parseInt(t.slice(1), 10), u(n)) ? l(n) : e; } + function p(e) { return e.indexOf("&") < 0 ? e : e.replace(v, c); } + function f(e) { return x[e]; } + function h(e) { return _.test(e) ? e.replace(b, f) : e; } + var d = Object.prototype.hasOwnProperty, m = /\\([\\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g, v = /&([a-z#][a-z0-9]{1,31});/gi, g = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i, y = n(504), _ = /[&<>"]/, b = /[&<>"]/g, x = { "&": "&", "<": "<", ">": ">", '"': """ }; + t.assign = a, t.isString = i, t.has = o, t.unescapeMd = s, t.isValidEntityCode = u, t.fromCodePoint = l, t.replaceEntities = p, t.escapeHtml = h; + }, function (e, t, n) { + "use strict"; + t.__esModule = !0; + var r = n(340), i = function (e) { return e && e.__esModule ? e : { default: e }; }(r); + t.default = function (e, t, n) { return t in e ? (0, i.default)(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e; }; + }, function (e, t) { e.exports = function (e) { return "object" == typeof e ? null !== e : "function" == typeof e; }; }, function (e, t, n) { var r = n(32), i = n(63), o = n(64), a = n(78), s = n(135), u = function (e, t, n) { var l, c, p, f, h = e & u.F, d = e & u.G, m = e & u.S, v = e & u.P, g = e & u.B, y = d ? r : m ? r[t] || (r[t] = {}) : (r[t] || {}).prototype, _ = d ? i : i[t] || (i[t] = {}), b = _.prototype || (_.prototype = {}); d && (n = t); for (l in n) + c = !h && y && void 0 !== y[l], p = (c ? y : n)[l], f = g && c ? s(p, r) : v && "function" == typeof p ? s(Function.call, p) : p, y && a(y, l, p, e & u.U), _[l] != p && o(_, l, f), v && b[l] != p && (b[l] = p); }; r.core = i, u.F = 1, u.G = 2, u.S = 4, u.P = 8, u.B = 16, u.W = 32, u.U = 64, u.R = 128, e.exports = u; }, function (e, t, n) { var r = n(30), i = n(107), o = n(58), a = /"/g, s = function (e, t, n, r) { var i = String(o(e)), s = "<" + t; return "" !== n && (s += " " + n + '="' + String(r).replace(a, """) + '"'), s + ">" + i + ""; }; e.exports = function (e, t) { var n = {}; n[e] = t(s), r(r.P + r.F * i(function () { var t = ""[e]('"'); return t !== t.toLowerCase() || t.split('"').length > 3; }), "String", n); }; }, function (e, t) { var n = e.exports = "undefined" != typeof window && window.Math == Math ? window : "undefined" != typeof self && self.Math == Math ? self : Function("return this")(); "number" == typeof __g && (__g = n); }, function (e, t, n) { + "use strict"; + function r(e) { return function () { return e; }; } + var i = function () { }; + i.thatReturns = r, i.thatReturnsFalse = r(!1), i.thatReturnsTrue = r(!0), i.thatReturnsNull = r(null), i.thatReturnsThis = function () { return this; }, i.thatReturnsArgument = function (e) { return e; }, e.exports = i; + }, function (e, t) { function n() { throw new Error("setTimeout has not been defined"); } function r() { throw new Error("clearTimeout has not been defined"); } function i(e) { if (c === setTimeout) + return setTimeout(e, 0); if ((c === n || !c) && setTimeout) + return c = setTimeout, setTimeout(e, 0); try { + return c(e, 0); + } + catch (t) { + try { + return c.call(null, e, 0); + } + catch (t) { + return c.call(this, e, 0); + } + } } function o(e) { if (p === clearTimeout) + return clearTimeout(e); if ((p === r || !p) && clearTimeout) + return p = clearTimeout, clearTimeout(e); try { + return p(e); + } + catch (t) { + try { + return p.call(null, e); + } + catch (t) { + return p.call(this, e); + } + } } function a() { m && h && (m = !1, h.length ? d = h.concat(d) : v = -1, d.length && s()); } function s() { if (!m) { + var e = i(a); + m = !0; + for (var t = d.length; t;) { + for (h = d, d = []; ++v < t;) + h && h[v].run(); + v = -1, t = d.length; + } + h = null, m = !1, o(e); + } } function u(e, t) { this.fun = e, this.array = t; } function l() { } var c, p, f = e.exports = {}; !function () { try { + c = "function" == typeof setTimeout ? setTimeout : n; + } + catch (e) { + c = n; + } try { + p = "function" == typeof clearTimeout ? clearTimeout : r; + } + catch (e) { + p = r; + } }(); var h, d = [], m = !1, v = -1; f.nextTick = function (e) { var t = new Array(arguments.length - 1); if (arguments.length > 1) + for (var n = 1; n < arguments.length; n++) + t[n - 1] = arguments[n]; d.push(new u(e, t)), 1 !== d.length || m || i(s); }, u.prototype.run = function () { this.fun.apply(null, this.array); }, f.title = "browser", f.browser = !0, f.env = {}, f.argv = [], f.version = "", f.versions = {}, f.on = l, f.addListener = l, f.once = l, f.off = l, f.removeListener = l, f.removeAllListeners = l, f.emit = l, f.prependListener = l, f.prependOnceListener = l, f.listeners = function (e) { return []; }, f.binding = function (e) { throw new Error("process.binding is not supported"); }, f.cwd = function () { return "/"; }, f.chdir = function (e) { throw new Error("process.chdir is not supported"); }, f.umask = function () { return 0; }; }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + function i(e) { var t = e.get("openapi"); return !!t && t.startsWith("3"); } + function o(e) { var t = e.get("swagger"); return !!t && t.startsWith("2"); } + function a(e) { return function (t, n) { return function (r) { if (n && n.specSelectors && n.specSelectors.specJson) { + return i(n.specSelectors.specJson()) ? c.default.createElement(e, (0, u.default)({}, r, n, { Ori: t })) : c.default.createElement(t, r); + } return console.warn("OAS3 wrapper: couldn't get spec"), null; }; }; } + Object.defineProperty(t, "__esModule", { value: !0 }); + var s = n(20), u = r(s); + t.isOAS3 = i, t.isSwagger2 = o, t.OAS3ComponentWrapFactory = a; + var l = n(0), c = r(l); + }, function (e, t, n) { + "use strict"; + var r = n(96), i = function (e) { return e && e.__esModule ? e : { default: e }; }(r); + e.exports = function () { var e = { location: {}, history: {}, open: function () { }, close: function () { }, File: function () { } }; if ("undefined" == typeof window) + return e; try { + e = window; + var t = ["File", "Blob", "FormData"], n = !0, r = !1, o = void 0; + try { + for (var a, s = (0, i.default)(t); !(n = (a = s.next()).done); n = !0) { + var u = a.value; + u in window && (e[u] = window[u]); + } + } + catch (e) { + r = !0, o = e; + } + finally { + try { + !n && s.return && s.return(); + } + finally { + if (r) + throw o; + } + } + } + catch (e) { + console.error(e); + } return e; }(); + }, function (e, t, n) { e.exports = { default: n(605), __esModule: !0 }; }, function (e, t, n) { var r = n(29); e.exports = function (e) { if (!r(e)) + throw TypeError(e + " is not an object!"); return e; }; }, function (e, t, n) { var r = n(422), i = "object" == typeof self && self && self.Object === Object && self, o = r || i || Function("return this")(); e.exports = o; }, function (e, t) { function n(e) { var t = typeof e; return null != e && ("object" == t || "function" == t); } e.exports = n; }, function (e, t, n) { + "use strict"; + var r = null; + e.exports = { debugTool: r }; + }, function (e, t, n) { e.exports = { default: n(610), __esModule: !0 }; }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + t.__esModule = !0; + var i = n(586), o = r(i), a = n(585), s = r(a), u = "function" == typeof s.default && "symbol" == typeof o.default ? function (e) { return typeof e; } : function (e) { return e && "function" == typeof s.default && e.constructor === s.default && e !== s.default.prototype ? "symbol" : typeof e; }; + t.default = "function" == typeof s.default && "symbol" === u(o.default) ? function (e) { return void 0 === e ? "undefined" : u(e); } : function (e) { return e && "function" == typeof s.default && e.constructor === s.default && e !== s.default.prototype ? "symbol" : void 0 === e ? "undefined" : u(e); }; + }, function (e, t, n) { + "use strict"; + (function (e) { + function r() { return o.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823; } + function i(e, t) { if (r() < t) + throw new RangeError("Invalid typed array length"); return o.TYPED_ARRAY_SUPPORT ? (e = new Uint8Array(t), e.__proto__ = o.prototype) : (null === e && (e = new o(t)), e.length = t), e; } + function o(e, t, n) { if (!(o.TYPED_ARRAY_SUPPORT || this instanceof o)) + return new o(e, t, n); if ("number" == typeof e) { + if ("string" == typeof t) + throw new Error("If encoding is specified then the first argument must be a string"); + return l(this, e); + } return a(this, e, t, n); } + function a(e, t, n, r) { if ("number" == typeof t) + throw new TypeError('"value" argument must not be a number'); return "undefined" != typeof ArrayBuffer && t instanceof ArrayBuffer ? f(e, t, n, r) : "string" == typeof t ? c(e, t, n) : h(e, t); } + function s(e) { if ("number" != typeof e) + throw new TypeError('"size" argument must be a number'); if (e < 0) + throw new RangeError('"size" argument must not be negative'); } + function u(e, t, n, r) { return s(t), t <= 0 ? i(e, t) : void 0 !== n ? "string" == typeof r ? i(e, t).fill(n, r) : i(e, t).fill(n) : i(e, t); } + function l(e, t) { if (s(t), e = i(e, t < 0 ? 0 : 0 | d(t)), !o.TYPED_ARRAY_SUPPORT) + for (var n = 0; n < t; ++n) + e[n] = 0; return e; } + function c(e, t, n) { if ("string" == typeof n && "" !== n || (n = "utf8"), !o.isEncoding(n)) + throw new TypeError('"encoding" must be a valid string encoding'); var r = 0 | v(t, n); e = i(e, r); var a = e.write(t, n); return a !== r && (e = e.slice(0, a)), e; } + function p(e, t) { var n = t.length < 0 ? 0 : 0 | d(t.length); e = i(e, n); for (var r = 0; r < n; r += 1) + e[r] = 255 & t[r]; return e; } + function f(e, t, n, r) { if (t.byteLength, n < 0 || t.byteLength < n) + throw new RangeError("'offset' is out of bounds"); if (t.byteLength < n + (r || 0)) + throw new RangeError("'length' is out of bounds"); return t = void 0 === n && void 0 === r ? new Uint8Array(t) : void 0 === r ? new Uint8Array(t, n) : new Uint8Array(t, n, r), o.TYPED_ARRAY_SUPPORT ? (e = t, e.__proto__ = o.prototype) : e = p(e, t), e; } + function h(e, t) { if (o.isBuffer(t)) { + var n = 0 | d(t.length); + return e = i(e, n), 0 === e.length ? e : (t.copy(e, 0, 0, n), e); + } if (t) { + if ("undefined" != typeof ArrayBuffer && t.buffer instanceof ArrayBuffer || "length" in t) + return "number" != typeof t.length || K(t.length) ? i(e, 0) : p(e, t); + if ("Buffer" === t.type && Z(t.data)) + return p(e, t.data); + } throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object."); } + function d(e) { if (e >= r()) + throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + r().toString(16) + " bytes"); return 0 | e; } + function m(e) { return +e != e && (e = 0), o.alloc(+e); } + function v(e, t) { if (o.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 n = e.length; if (0 === n) + return 0; for (var r = !1;;) + switch (t) { + case "ascii": + case "latin1": + case "binary": return n; + case "utf8": + case "utf-8": + case void 0: return V(e).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": return 2 * n; + case "hex": return n >>> 1; + case "base64": return G(e).length; + default: + if (r) + return V(e).length; + t = ("" + t).toLowerCase(), r = !0; + } } + function g(e, t, n) { var r = !1; if ((void 0 === t || t < 0) && (t = 0), t > this.length) + return ""; if ((void 0 === n || n > this.length) && (n = this.length), n <= 0) + return ""; if (n >>>= 0, t >>>= 0, n <= t) + return ""; for (e || (e = "utf8");;) + switch (e) { + case "hex": return P(this, t, n); + case "utf8": + case "utf-8": return D(this, t, n); + case "ascii": return M(this, t, n); + case "latin1": + case "binary": return T(this, t, n); + case "base64": return A(this, t, n); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": return I(this, t, n); + default: + if (r) + throw new TypeError("Unknown encoding: " + e); + e = (e + "").toLowerCase(), r = !0; + } } + function y(e, t, n) { var r = e[t]; e[t] = e[n], e[n] = r; } + function _(e, t, n, r, i) { if (0 === e.length) + return -1; if ("string" == typeof n ? (r = n, n = 0) : n > 2147483647 ? n = 2147483647 : n < -2147483648 && (n = -2147483648), n = +n, isNaN(n) && (n = i ? 0 : e.length - 1), n < 0 && (n = e.length + n), n >= e.length) { + if (i) + return -1; + n = e.length - 1; + } + else if (n < 0) { + if (!i) + return -1; + n = 0; + } if ("string" == typeof t && (t = o.from(t, r)), o.isBuffer(t)) + return 0 === t.length ? -1 : b(e, t, n, r, i); if ("number" == typeof t) + return t &= 255, o.TYPED_ARRAY_SUPPORT && "function" == typeof Uint8Array.prototype.indexOf ? i ? Uint8Array.prototype.indexOf.call(e, t, n) : Uint8Array.prototype.lastIndexOf.call(e, t, n) : b(e, [t], n, r, i); throw new TypeError("val must be string, number or Buffer"); } + function b(e, t, n, r, i) { function o(e, t) { return 1 === a ? e[t] : e.readUInt16BE(t * a); } var a = 1, s = e.length, u = t.length; if (void 0 !== r && ("ucs2" === (r = String(r).toLowerCase()) || "ucs-2" === r || "utf16le" === r || "utf-16le" === r)) { + if (e.length < 2 || t.length < 2) + return -1; + a = 2, s /= 2, u /= 2, n /= 2; + } var l; if (i) { + var c = -1; + for (l = n; l < s; l++) + if (o(e, l) === o(t, -1 === c ? 0 : l - c)) { + if (-1 === c && (c = l), l - c + 1 === u) + return c * a; + } + else + -1 !== c && (l -= l - c), c = -1; + } + else + for (n + u > s && (n = s - u), l = n; l >= 0; l--) { + for (var p = !0, f = 0; f < u; f++) + if (o(e, l + f) !== o(t, f)) { + p = !1; + break; + } + if (p) + return l; + } return -1; } + function x(e, t, n, r) { n = Number(n) || 0; var i = e.length - n; r ? (r = Number(r)) > i && (r = i) : r = i; var o = t.length; if (o % 2 != 0) + throw new TypeError("Invalid hex string"); r > o / 2 && (r = o / 2); for (var a = 0; a < r; ++a) { + var s = parseInt(t.substr(2 * a, 2), 16); + if (isNaN(s)) + return a; + e[n + a] = s; + } return a; } + function w(e, t, n, r) { return Y(V(t, e.length - n), e, n, r); } + function k(e, t, n, r) { return Y(H(t), e, n, r); } + function E(e, t, n, r) { return k(e, t, n, r); } + function S(e, t, n, r) { return Y(G(t), e, n, r); } + function C(e, t, n, r) { return Y(J(t, e.length - n), e, n, r); } + function A(e, t, n) { return 0 === t && n === e.length ? X.fromByteArray(e) : X.fromByteArray(e.slice(t, n)); } + function D(e, t, n) { n = Math.min(e.length, n); for (var r = [], i = t; i < n;) { + var o = e[i], a = null, s = o > 239 ? 4 : o > 223 ? 3 : o > 191 ? 2 : 1; + if (i + s <= n) { + var u, l, c, p; + switch (s) { + case 1: + o < 128 && (a = o); + break; + case 2: + u = e[i + 1], 128 == (192 & u) && (p = (31 & o) << 6 | 63 & u) > 127 && (a = p); + break; + case 3: + u = e[i + 1], l = e[i + 2], 128 == (192 & u) && 128 == (192 & l) && (p = (15 & o) << 12 | (63 & u) << 6 | 63 & l) > 2047 && (p < 55296 || p > 57343) && (a = p); + break; + case 4: u = e[i + 1], l = e[i + 2], c = e[i + 3], 128 == (192 & u) && 128 == (192 & l) && 128 == (192 & c) && (p = (15 & o) << 18 | (63 & u) << 12 | (63 & l) << 6 | 63 & c) > 65535 && p < 1114112 && (a = p); + } + } + null === a ? (a = 65533, s = 1) : a > 65535 && (a -= 65536, r.push(a >>> 10 & 1023 | 55296), a = 56320 | 1023 & a), r.push(a), i += s; + } return O(r); } + function O(e) { var t = e.length; if (t <= Q) + return String.fromCharCode.apply(String, e); for (var n = "", r = 0; r < t;) + n += String.fromCharCode.apply(String, e.slice(r, r += Q)); return n; } + function M(e, t, n) { var r = ""; n = Math.min(e.length, n); for (var i = t; i < n; ++i) + r += String.fromCharCode(127 & e[i]); return r; } + function T(e, t, n) { var r = ""; n = Math.min(e.length, n); for (var i = t; i < n; ++i) + r += String.fromCharCode(e[i]); return r; } + function P(e, t, n) { var r = e.length; (!t || t < 0) && (t = 0), (!n || n < 0 || n > r) && (n = r); for (var i = "", o = t; o < n; ++o) + i += W(e[o]); return i; } + function I(e, t, n) { for (var r = e.slice(t, n), i = "", o = 0; o < r.length; o += 2) + i += String.fromCharCode(r[o] + 256 * r[o + 1]); return i; } + function R(e, t, n) { if (e % 1 != 0 || e < 0) + throw new RangeError("offset is not uint"); if (e + t > n) + throw new RangeError("Trying to access beyond buffer length"); } + function j(e, t, n, r, i, a) { if (!o.isBuffer(e)) + throw new TypeError('"buffer" argument must be a Buffer instance'); if (t > i || t < a) + throw new RangeError('"value" argument is out of bounds'); if (n + r > e.length) + throw new RangeError("Index out of range"); } + function N(e, t, n, r) { t < 0 && (t = 65535 + t + 1); for (var i = 0, o = Math.min(e.length - n, 2); i < o; ++i) + e[n + i] = (t & 255 << 8 * (r ? i : 1 - i)) >>> 8 * (r ? i : 1 - i); } + function F(e, t, n, r) { t < 0 && (t = 4294967295 + t + 1); for (var i = 0, o = Math.min(e.length - n, 4); i < o; ++i) + e[n + i] = t >>> 8 * (r ? i : 3 - i) & 255; } + function B(e, t, n, r, i, o) { if (n + r > e.length) + throw new RangeError("Index out of range"); if (n < 0) + throw new RangeError("Index out of range"); } + function L(e, t, n, r, i) { return i || B(e, t, n, 4, 3.4028234663852886e38, -3.4028234663852886e38), $.write(e, t, n, r, 23, 4), n + 4; } + function q(e, t, n, r, i) { return i || B(e, t, n, 8, 1.7976931348623157e308, -1.7976931348623157e308), $.write(e, t, n, r, 52, 8), n + 8; } + function z(e) { if (e = U(e).replace(ee, ""), e.length < 2) + return ""; for (; e.length % 4 != 0;) + e += "="; return e; } + function U(e) { return e.trim ? e.trim() : e.replace(/^\s+|\s+$/g, ""); } + function W(e) { return e < 16 ? "0" + e.toString(16) : e.toString(16); } + function V(e, t) { t = t || 1 / 0; for (var n, r = e.length, i = null, o = [], a = 0; a < r; ++a) { + if ((n = e.charCodeAt(a)) > 55295 && n < 57344) { + if (!i) { + if (n > 56319) { + (t -= 3) > -1 && o.push(239, 191, 189); + continue; + } + if (a + 1 === r) { + (t -= 3) > -1 && o.push(239, 191, 189); + continue; + } + i = n; + continue; + } + if (n < 56320) { + (t -= 3) > -1 && o.push(239, 191, 189), i = n; + continue; + } + n = 65536 + (i - 55296 << 10 | n - 56320); + } + else + i && (t -= 3) > -1 && o.push(239, 191, 189); + if (i = null, n < 128) { + if ((t -= 1) < 0) + break; + o.push(n); + } + else if (n < 2048) { + if ((t -= 2) < 0) + break; + o.push(n >> 6 | 192, 63 & n | 128); + } + else if (n < 65536) { + if ((t -= 3) < 0) + break; + o.push(n >> 12 | 224, n >> 6 & 63 | 128, 63 & n | 128); + } + else { + if (!(n < 1114112)) + throw new Error("Invalid code point"); + if ((t -= 4) < 0) + break; + o.push(n >> 18 | 240, n >> 12 & 63 | 128, n >> 6 & 63 | 128, 63 & n | 128); + } + } return o; } + function H(e) { for (var t = [], n = 0; n < e.length; ++n) + t.push(255 & e.charCodeAt(n)); return t; } + function J(e, t) { for (var n, r, i, o = [], a = 0; a < e.length && !((t -= 2) < 0); ++a) + n = e.charCodeAt(a), r = n >> 8, i = n % 256, o.push(i), o.push(r); return o; } + function G(e) { return X.toByteArray(z(e)); } + function Y(e, t, n, r) { for (var i = 0; i < r && !(i + n >= t.length || i >= e.length); ++i) + t[i + n] = e[i]; return i; } + function K(e) { return e !== e; } /*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + var X = n(588), $ = n(783), Z = n(399); + t.Buffer = o, t.SlowBuffer = m, t.INSPECT_MAX_BYTES = 50, o.TYPED_ARRAY_SUPPORT = void 0 !== e.TYPED_ARRAY_SUPPORT ? e.TYPED_ARRAY_SUPPORT : function () { try { + var e = new Uint8Array(1); + return e.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42; } }, 42 === e.foo() && "function" == typeof e.subarray && 0 === e.subarray(1, 1).byteLength; + } + catch (e) { + return !1; + } }(), t.kMaxLength = r(), o.poolSize = 8192, o._augment = function (e) { return e.__proto__ = o.prototype, e; }, o.from = function (e, t, n) { return a(null, e, t, n); }, o.TYPED_ARRAY_SUPPORT && (o.prototype.__proto__ = Uint8Array.prototype, o.__proto__ = Uint8Array, "undefined" != typeof Symbol && Symbol.species && o[Symbol.species] === o && Object.defineProperty(o, Symbol.species, { value: null, configurable: !0 })), o.alloc = function (e, t, n) { return u(null, e, t, n); }, o.allocUnsafe = function (e) { return l(null, e); }, o.allocUnsafeSlow = function (e) { return l(null, e); }, o.isBuffer = function (e) { return !(null == e || !e._isBuffer); }, o.compare = function (e, t) { if (!o.isBuffer(e) || !o.isBuffer(t)) + throw new TypeError("Arguments must be Buffers"); if (e === t) + return 0; for (var n = e.length, r = t.length, i = 0, a = Math.min(n, r); i < a; ++i) + if (e[i] !== t[i]) { + n = e[i], r = t[i]; + break; + } return n < r ? -1 : r < n ? 1 : 0; }, o.isEncoding = function (e) { switch (String(e).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 !0; + default: return !1; + } }, o.concat = function (e, t) { if (!Z(e)) + throw new TypeError('"list" argument must be an Array of Buffers'); if (0 === e.length) + return o.alloc(0); var n; if (void 0 === t) + for (t = 0, n = 0; n < e.length; ++n) + t += e[n].length; var r = o.allocUnsafe(t), i = 0; for (n = 0; n < e.length; ++n) { + var a = e[n]; + if (!o.isBuffer(a)) + throw new TypeError('"list" argument must be an Array of Buffers'); + a.copy(r, i), i += a.length; + } return r; }, o.byteLength = v, o.prototype._isBuffer = !0, o.prototype.swap16 = function () { var e = this.length; if (e % 2 != 0) + throw new RangeError("Buffer size must be a multiple of 16-bits"); for (var t = 0; t < e; t += 2) + y(this, t, t + 1); return this; }, o.prototype.swap32 = function () { var e = this.length; if (e % 4 != 0) + throw new RangeError("Buffer size must be a multiple of 32-bits"); for (var t = 0; t < e; t += 4) + y(this, t, t + 3), y(this, t + 1, t + 2); return this; }, o.prototype.swap64 = function () { var e = this.length; if (e % 8 != 0) + throw new RangeError("Buffer size must be a multiple of 64-bits"); for (var t = 0; t < e; t += 8) + y(this, t, t + 7), y(this, t + 1, t + 6), y(this, t + 2, t + 5), y(this, t + 3, t + 4); return this; }, o.prototype.toString = function () { var e = 0 | this.length; return 0 === e ? "" : 0 === arguments.length ? D(this, 0, e) : g.apply(this, arguments); }, o.prototype.equals = function (e) { if (!o.isBuffer(e)) + throw new TypeError("Argument must be a Buffer"); return this === e || 0 === o.compare(this, e); }, o.prototype.inspect = function () { var e = "", n = t.INSPECT_MAX_BYTES; return this.length > 0 && (e = this.toString("hex", 0, n).match(/.{2}/g).join(" "), this.length > n && (e += " ... ")), ""; }, o.prototype.compare = function (e, t, n, r, i) { if (!o.isBuffer(e)) + throw new TypeError("Argument must be a Buffer"); if (void 0 === t && (t = 0), void 0 === n && (n = e ? e.length : 0), void 0 === r && (r = 0), void 0 === i && (i = this.length), t < 0 || n > e.length || r < 0 || i > this.length) + throw new RangeError("out of range index"); if (r >= i && t >= n) + return 0; if (r >= i) + return -1; if (t >= n) + return 1; if (t >>>= 0, n >>>= 0, r >>>= 0, i >>>= 0, this === e) + return 0; for (var a = i - r, s = n - t, u = Math.min(a, s), l = this.slice(r, i), c = e.slice(t, n), p = 0; p < u; ++p) + if (l[p] !== c[p]) { + a = l[p], s = c[p]; + break; + } return a < s ? -1 : s < a ? 1 : 0; }, o.prototype.includes = function (e, t, n) { return -1 !== this.indexOf(e, t, n); }, o.prototype.indexOf = function (e, t, n) { return _(this, e, t, n, !0); }, o.prototype.lastIndexOf = function (e, t, n) { return _(this, e, t, n, !1); }, o.prototype.write = function (e, t, n, r) { if (void 0 === t) + r = "utf8", n = this.length, t = 0; + else if (void 0 === n && "string" == typeof t) + r = t, n = this.length, t = 0; + else { + if (!isFinite(t)) + throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported"); + t |= 0, isFinite(n) ? (n |= 0, void 0 === r && (r = "utf8")) : (r = n, n = void 0); + } var i = this.length - t; if ((void 0 === n || n > i) && (n = i), e.length > 0 && (n < 0 || t < 0) || t > this.length) + throw new RangeError("Attempt to write outside buffer bounds"); r || (r = "utf8"); for (var o = !1;;) + switch (r) { + case "hex": return x(this, e, t, n); + case "utf8": + case "utf-8": return w(this, e, t, n); + case "ascii": return k(this, e, t, n); + case "latin1": + case "binary": return E(this, e, t, n); + case "base64": return S(this, e, t, n); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": return C(this, e, t, n); + default: + if (o) + throw new TypeError("Unknown encoding: " + r); + r = ("" + r).toLowerCase(), o = !0; + } }, o.prototype.toJSON = function () { return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) }; }; + var Q = 4096; + o.prototype.slice = function (e, t) { var n = this.length; e = ~~e, t = void 0 === t ? n : ~~t, e < 0 ? (e += n) < 0 && (e = 0) : e > n && (e = n), t < 0 ? (t += n) < 0 && (t = 0) : t > n && (t = n), t < e && (t = e); var r; if (o.TYPED_ARRAY_SUPPORT) + r = this.subarray(e, t), r.__proto__ = o.prototype; + else { + var i = t - e; + r = new o(i, void 0); + for (var a = 0; a < i; ++a) + r[a] = this[a + e]; + } return r; }, o.prototype.readUIntLE = function (e, t, n) { e |= 0, t |= 0, n || R(e, t, this.length); for (var r = this[e], i = 1, o = 0; ++o < t && (i *= 256);) + r += this[e + o] * i; return r; }, o.prototype.readUIntBE = function (e, t, n) { e |= 0, t |= 0, n || R(e, t, this.length); for (var r = this[e + --t], i = 1; t > 0 && (i *= 256);) + r += this[e + --t] * i; return r; }, o.prototype.readUInt8 = function (e, t) { return t || R(e, 1, this.length), this[e]; }, o.prototype.readUInt16LE = function (e, t) { return t || R(e, 2, this.length), this[e] | this[e + 1] << 8; }, o.prototype.readUInt16BE = function (e, t) { return t || R(e, 2, this.length), this[e] << 8 | this[e + 1]; }, o.prototype.readUInt32LE = function (e, t) { return t || R(e, 4, this.length), (this[e] | this[e + 1] << 8 | this[e + 2] << 16) + 16777216 * this[e + 3]; }, o.prototype.readUInt32BE = function (e, t) { return t || R(e, 4, this.length), 16777216 * this[e] + (this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]); }, o.prototype.readIntLE = function (e, t, n) { e |= 0, t |= 0, n || R(e, t, this.length); for (var r = this[e], i = 1, o = 0; ++o < t && (i *= 256);) + r += this[e + o] * i; return i *= 128, r >= i && (r -= Math.pow(2, 8 * t)), r; }, o.prototype.readIntBE = function (e, t, n) { e |= 0, t |= 0, n || R(e, t, this.length); for (var r = t, i = 1, o = this[e + --r]; r > 0 && (i *= 256);) + o += this[e + --r] * i; return i *= 128, o >= i && (o -= Math.pow(2, 8 * t)), o; }, o.prototype.readInt8 = function (e, t) { return t || R(e, 1, this.length), 128 & this[e] ? -1 * (255 - this[e] + 1) : this[e]; }, o.prototype.readInt16LE = function (e, t) { t || R(e, 2, this.length); var n = this[e] | this[e + 1] << 8; return 32768 & n ? 4294901760 | n : n; }, o.prototype.readInt16BE = function (e, t) { t || R(e, 2, this.length); var n = this[e + 1] | this[e] << 8; return 32768 & n ? 4294901760 | n : n; }, o.prototype.readInt32LE = function (e, t) { return t || R(e, 4, this.length), this[e] | this[e + 1] << 8 | this[e + 2] << 16 | this[e + 3] << 24; }, o.prototype.readInt32BE = function (e, t) { return t || R(e, 4, this.length), this[e] << 24 | this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]; }, o.prototype.readFloatLE = function (e, t) { return t || R(e, 4, this.length), $.read(this, e, !0, 23, 4); }, o.prototype.readFloatBE = function (e, t) { return t || R(e, 4, this.length), $.read(this, e, !1, 23, 4); }, o.prototype.readDoubleLE = function (e, t) { return t || R(e, 8, this.length), $.read(this, e, !0, 52, 8); }, o.prototype.readDoubleBE = function (e, t) { return t || R(e, 8, this.length), $.read(this, e, !1, 52, 8); }, o.prototype.writeUIntLE = function (e, t, n, r) { if (e = +e, t |= 0, n |= 0, !r) { + j(this, e, t, n, Math.pow(2, 8 * n) - 1, 0); + } var i = 1, o = 0; for (this[t] = 255 & e; ++o < n && (i *= 256);) + this[t + o] = e / i & 255; return t + n; }, o.prototype.writeUIntBE = function (e, t, n, r) { if (e = +e, t |= 0, n |= 0, !r) { + j(this, e, t, n, Math.pow(2, 8 * n) - 1, 0); + } var i = n - 1, o = 1; for (this[t + i] = 255 & e; --i >= 0 && (o *= 256);) + this[t + i] = e / o & 255; return t + n; }, o.prototype.writeUInt8 = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 1, 255, 0), o.TYPED_ARRAY_SUPPORT || (e = Math.floor(e)), this[t] = 255 & e, t + 1; }, o.prototype.writeUInt16LE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 2, 65535, 0), o.TYPED_ARRAY_SUPPORT ? (this[t] = 255 & e, this[t + 1] = e >>> 8) : N(this, e, t, !0), t + 2; }, o.prototype.writeUInt16BE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 2, 65535, 0), o.TYPED_ARRAY_SUPPORT ? (this[t] = e >>> 8, this[t + 1] = 255 & e) : N(this, e, t, !1), t + 2; }, o.prototype.writeUInt32LE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 4, 4294967295, 0), o.TYPED_ARRAY_SUPPORT ? (this[t + 3] = e >>> 24, this[t + 2] = e >>> 16, this[t + 1] = e >>> 8, this[t] = 255 & e) : F(this, e, t, !0), t + 4; }, o.prototype.writeUInt32BE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 4, 4294967295, 0), o.TYPED_ARRAY_SUPPORT ? (this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = 255 & e) : F(this, e, t, !1), t + 4; }, o.prototype.writeIntLE = function (e, t, n, r) { if (e = +e, t |= 0, !r) { + var i = Math.pow(2, 8 * n - 1); + j(this, e, t, n, i - 1, -i); + } var o = 0, a = 1, s = 0; for (this[t] = 255 & e; ++o < n && (a *= 256);) + e < 0 && 0 === s && 0 !== this[t + o - 1] && (s = 1), this[t + o] = (e / a >> 0) - s & 255; return t + n; }, o.prototype.writeIntBE = function (e, t, n, r) { if (e = +e, t |= 0, !r) { + var i = Math.pow(2, 8 * n - 1); + j(this, e, t, n, i - 1, -i); + } var o = n - 1, a = 1, s = 0; for (this[t + o] = 255 & e; --o >= 0 && (a *= 256);) + e < 0 && 0 === s && 0 !== this[t + o + 1] && (s = 1), this[t + o] = (e / a >> 0) - s & 255; return t + n; }, o.prototype.writeInt8 = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 1, 127, -128), o.TYPED_ARRAY_SUPPORT || (e = Math.floor(e)), e < 0 && (e = 255 + e + 1), this[t] = 255 & e, t + 1; }, o.prototype.writeInt16LE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 2, 32767, -32768), o.TYPED_ARRAY_SUPPORT ? (this[t] = 255 & e, this[t + 1] = e >>> 8) : N(this, e, t, !0), t + 2; }, o.prototype.writeInt16BE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 2, 32767, -32768), o.TYPED_ARRAY_SUPPORT ? (this[t] = e >>> 8, this[t + 1] = 255 & e) : N(this, e, t, !1), t + 2; }, o.prototype.writeInt32LE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 4, 2147483647, -2147483648), o.TYPED_ARRAY_SUPPORT ? (this[t] = 255 & e, this[t + 1] = e >>> 8, this[t + 2] = e >>> 16, this[t + 3] = e >>> 24) : F(this, e, t, !0), t + 4; }, o.prototype.writeInt32BE = function (e, t, n) { return e = +e, t |= 0, n || j(this, e, t, 4, 2147483647, -2147483648), e < 0 && (e = 4294967295 + e + 1), o.TYPED_ARRAY_SUPPORT ? (this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = 255 & e) : F(this, e, t, !1), t + 4; }, o.prototype.writeFloatLE = function (e, t, n) { return L(this, e, t, !0, n); }, o.prototype.writeFloatBE = function (e, t, n) { return L(this, e, t, !1, n); }, o.prototype.writeDoubleLE = function (e, t, n) { return q(this, e, t, !0, n); }, o.prototype.writeDoubleBE = function (e, t, n) { return q(this, e, t, !1, n); }, o.prototype.copy = function (e, t, n, r) { if (n || (n = 0), r || 0 === r || (r = this.length), t >= e.length && (t = e.length), t || (t = 0), r > 0 && r < n && (r = n), r === n) + return 0; if (0 === e.length || 0 === this.length) + return 0; if (t < 0) + throw new RangeError("targetStart out of bounds"); if (n < 0 || n >= this.length) + throw new RangeError("sourceStart out of bounds"); if (r < 0) + throw new RangeError("sourceEnd out of bounds"); r > this.length && (r = this.length), e.length - t < r - n && (r = e.length - t + n); var i, a = r - n; if (this === e && n < t && t < r) + for (i = a - 1; i >= 0; --i) + e[i + t] = this[i + n]; + else if (a < 1e3 || !o.TYPED_ARRAY_SUPPORT) + for (i = 0; i < a; ++i) + e[i + t] = this[i + n]; + else + Uint8Array.prototype.set.call(e, this.subarray(n, n + a), t); return a; }, o.prototype.fill = function (e, t, n, r) { if ("string" == typeof e) { + if ("string" == typeof t ? (r = t, t = 0, n = this.length) : "string" == typeof n && (r = n, n = this.length), 1 === e.length) { + var i = e.charCodeAt(0); + i < 256 && (e = i); + } + if (void 0 !== r && "string" != typeof r) + throw new TypeError("encoding must be a string"); + if ("string" == typeof r && !o.isEncoding(r)) + throw new TypeError("Unknown encoding: " + r); + } + else + "number" == typeof e && (e &= 255); if (t < 0 || this.length < t || this.length < n) + throw new RangeError("Out of range index"); if (n <= t) + return this; t >>>= 0, n = void 0 === n ? this.length : n >>> 0, e || (e = 0); var a; if ("number" == typeof e) + for (a = t; a < n; ++a) + this[a] = e; + else { + var s = o.isBuffer(e) ? e : V(new o(e, r).toString()), u = s.length; + for (a = 0; a < n - t; ++a) + this[a + t] = s[a % u]; + } return this; }; + var ee = /[^+\/0-9A-Za-z-_]/g; + }).call(t, n(16)); + }, function (e, t, n) { var r = n(38), i = n(345), o = n(195), a = Object.defineProperty; t.f = n(49) ? Object.defineProperty : function (e, t, n) { if (r(e), t = o(t, !0), r(n), i) + try { + return a(e, t, n); + } + catch (e) { } if ("get" in n || "set" in n) + throw TypeError("Accessors not supported!"); return "value" in n && (e[t] = n.value), e; }; }, function (e, t) { "function" == typeof Object.create ? e.exports = function (e, t) { e.super_ = t, e.prototype = Object.create(t.prototype, { constructor: { value: e, enumerable: !1, writable: !0, configurable: !0 } }); } : e.exports = function (e, t) { e.super_ = t; var n = function () { }; n.prototype = t.prototype, e.prototype = new n, e.prototype.constructor = e; }; }, function (e, t, n) { + "use strict"; + function r() { D.ReactReconcileTransaction && w || c("123"); } + function i() { this.reinitializeTransaction(), this.dirtyComponentsLength = null, this.callbackQueue = f.getPooled(), this.reconcileTransaction = D.ReactReconcileTransaction.getPooled(!0); } + function o(e, t, n, i, o, a) { return r(), w.batchedUpdates(e, t, n, i, o, a); } + function a(e, t) { return e._mountOrder - t._mountOrder; } + function s(e) { var t = e.dirtyComponentsLength; t !== y.length && c("124", t, y.length), y.sort(a), _++; for (var n = 0; n < t; n++) { + var r = y[n], i = r._pendingCallbacks; + r._pendingCallbacks = null; + var o; + if (d.logTopLevelRenders) { + var s = r; + r._currentElement.type.isReactTopLevelWrapper && (s = r._renderedComponent), o = "React update: " + s.getName(), console.time(o); + } + if (m.performUpdateIfNecessary(r, e.reconcileTransaction, _), o && console.timeEnd(o), i) + for (var u = 0; u < i.length; u++) + e.callbackQueue.enqueue(i[u], r.getPublicInstance()); + } } + function u(e) { if (r(), !w.isBatchingUpdates) + return void w.batchedUpdates(u, e); y.push(e), null == e._updateBatchNumber && (e._updateBatchNumber = _ + 1); } + function l(e, t) { g(w.isBatchingUpdates, "ReactUpdates.asap: Can't enqueue an asap callback in a context whereupdates are not being batched."), b.enqueue(e, t), x = !0; } + var c = n(11), p = n(13), f = n(467), h = n(70), d = n(472), m = n(90), v = n(163), g = n(8), y = [], _ = 0, b = f.getPooled(), x = !1, w = null, k = { initialize: function () { this.dirtyComponentsLength = y.length; }, close: function () { this.dirtyComponentsLength !== y.length ? (y.splice(0, this.dirtyComponentsLength), C()) : y.length = 0; } }, E = { initialize: function () { this.callbackQueue.reset(); }, close: function () { this.callbackQueue.notifyAll(); } }, S = [k, E]; + p(i.prototype, v, { getTransactionWrappers: function () { return S; }, destructor: function () { this.dirtyComponentsLength = null, f.release(this.callbackQueue), this.callbackQueue = null, D.ReactReconcileTransaction.release(this.reconcileTransaction), this.reconcileTransaction = null; }, perform: function (e, t, n) { return v.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, e, t, n); } }), h.addPoolingTo(i); + var C = function () { for (; y.length || x;) { + if (y.length) { + var e = i.getPooled(); + e.perform(s, null, e), i.release(e); + } + if (x) { + x = !1; + var t = b; + b = f.getPooled(), t.notifyAll(), f.release(t); + } + } }, A = { injectReconcileTransaction: function (e) { e || c("126"), D.ReactReconcileTransaction = e; }, injectBatchingStrategy: function (e) { e || c("127"), "function" != typeof e.batchedUpdates && c("128"), "boolean" != typeof e.isBatchingUpdates && c("129"), w = e; } }, D = { ReactReconcileTransaction: null, batchedUpdates: o, enqueueUpdate: u, flushBatchedUpdates: C, injection: A, asap: l }; + e.exports = D; + }, function (e, t) { (function () { var e = [].indexOf || function (e) { for (var t = 0, n = this.length; t < n; t++) + if (t in this && this[t] === e) + return t; return -1; }, t = function (e, t) { function r() { this.constructor = e; } for (var i in t) + n.call(t, i) && (e[i] = t[i]); return r.prototype = t.prototype, e.prototype = new r, e.__super__ = t.prototype, e; }, n = {}.hasOwnProperty; this.Mark = function () { function t(e, t, n, r) { this.line = e, this.column = t, this.buffer = n, this.pointer = r; } return t.prototype.get_snippet = function (t, n) { var r, i, o, a, s, u, l; if (null == t && (t = 4), null == n && (n = 75), null == this.buffer) + return null; for (r = "\0\r\n…\u2028\u2029", o = "", u = this.pointer; u > 0 && (a = this.buffer[u - 1], e.call(r, a) < 0);) + if (u--, this.pointer - u > n / 2 - 1) { + o = " ... ", u += 5; + break; + } for (l = "", i = this.pointer; i < this.buffer.length && (s = this.buffer[i], e.call(r, s) < 0);) + if (++i - this.pointer > n / 2 - 1) { + l = " ... ", i -= 5; + break; + } return "" + new Array(t).join(" ") + o + this.buffer.slice(u, i) + l + "\n" + new Array(t + this.pointer - u + o.length).join(" ") + "^"; }, t.prototype.toString = function () { var e, t; return e = this.get_snippet(), t = " on line " + (this.line + 1) + ", column " + (this.column + 1), e ? t : t + ":\n" + e; }, t; }(), this.YAMLError = function (e) { function n(e) { this.message = e, n.__super__.constructor.call(this), this.stack = this.toString() + "\n" + (new Error).stack.split("\n").slice(1).join("\n"); } return t(n, e), n.prototype.toString = function () { return this.message; }, n; }(Error), this.MarkedYAMLError = function (e) { function n(e, t, r, i, o) { this.context = e, this.context_mark = t, this.problem = r, this.problem_mark = i, this.note = o, n.__super__.constructor.call(this); } return t(n, e), n.prototype.toString = function () { var e; return e = [], null != this.context && e.push(this.context), null == this.context_mark || null != this.problem && null != this.problem_mark && this.context_mark.line === this.problem_mark.line && this.context_mark.column === this.problem_mark.column || e.push(this.context_mark.toString()), null != this.problem && e.push(this.problem), null != this.problem_mark && e.push(this.problem_mark.toString()), null != this.note && e.push(this.note), e.join("\n"); }, n; }(this.YAMLError); }).call(this); }, function (e, t, n) { e.exports = !n(55)(function () { return 7 != Object.defineProperty({}, "a", { get: function () { return 7; } }).a; }); }, function (e, t, n) { + "use strict"; + function r(e, t, n) { return n ? [e, t] : e; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.default = r, e.exports = t.default; + }, function (e, t) { function n(e) { return null != e && "object" == typeof e; } e.exports = n; }, function (e, t, n) { + "use strict"; + function r(e, t, n, r) { this.dispatchConfig = e, this._targetInst = t, this.nativeEvent = n; var i = this.constructor.Interface; for (var o in i) + if (i.hasOwnProperty(o)) { + var s = i[o]; + s ? this[o] = s(n) : "target" === o ? this.target = r : this[o] = n[o]; + } var u = null != n.defaultPrevented ? n.defaultPrevented : !1 === n.returnValue; return this.isDefaultPrevented = u ? a.thatReturnsTrue : a.thatReturnsFalse, this.isPropagationStopped = a.thatReturnsFalse, this; } + var i = n(13), o = n(70), a = n(33), s = (n(10), ["dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances"]), u = { type: null, target: null, currentTarget: a.thatReturnsNull, eventPhase: null, bubbles: null, cancelable: null, timeStamp: function (e) { return e.timeStamp || Date.now(); }, defaultPrevented: null, isTrusted: null }; + i(r.prototype, { preventDefault: function () { this.defaultPrevented = !0; var e = this.nativeEvent; e && (e.preventDefault ? e.preventDefault() : "unknown" != typeof e.returnValue && (e.returnValue = !1), this.isDefaultPrevented = a.thatReturnsTrue); }, stopPropagation: function () { var e = this.nativeEvent; e && (e.stopPropagation ? e.stopPropagation() : "unknown" != typeof e.cancelBubble && (e.cancelBubble = !0), this.isPropagationStopped = a.thatReturnsTrue); }, persist: function () { this.isPersistent = a.thatReturnsTrue; }, isPersistent: a.thatReturnsFalse, destructor: function () { var e = this.constructor.Interface; for (var t in e) + this[t] = null; for (var n = 0; n < s.length; n++) + this[s[n]] = null; } }), r.Interface = u, r.augmentClass = function (e, t) { var n = this, r = function () { }; r.prototype = n.prototype; var a = new r; i(a, e.prototype), e.prototype = a, e.prototype.constructor = e, e.Interface = i({}, n.Interface, t), e.augmentClass = n.augmentClass, o.addPoolingTo(e, o.fourArgumentPooler); }, o.addPoolingTo(r, o.fourArgumentPooler), e.exports = r; + }, function (e, t, n) { + "use strict"; + var r = { current: null }; + e.exports = r; + }, function (e, t, n) { var r = n(98); e.exports = function (e, t, n) { if (r(e), void 0 === t) + return e; switch (n) { + case 1: return function (n) { return e.call(t, n); }; + case 2: return function (n, r) { return e.call(t, n, r); }; + case 3: return function (n, r, i) { return e.call(t, n, r, i); }; + } return function () { return e.apply(t, arguments); }; }; }, function (e, t) { e.exports = function (e) { try { + return !!e(); + } + catch (e) { + return !0; + } }; }, function (e, t) { var n = {}.hasOwnProperty; e.exports = function (e, t) { return n.call(e, t); }; }, function (e, t, n) { var r = n(45), i = n(101); e.exports = n(49) ? function (e, t, n) { return r.f(e, t, i(1, n)); } : function (e, t, n) { return e[t] = n, e; }; }, function (e, t) { e.exports = function (e) { if (void 0 == e) + throw TypeError("Can't call method on " + e); return e; }; }, function (e, t, n) { + "use strict"; + e.exports = function (e) { if ("function" != typeof e) + throw new TypeError(e + " is not a function"); return e; }; + }, function (e, t, n) { + "use strict"; + function r(e) { if (Array.isArray(e)) { + for (var t = 0, n = Array(e.length); t < e.length; t++) + n[t] = e[t]; + return n; + } return Array.from(e); } + function i(e, t) { return e === t; } + function o(e) { var t = arguments.length <= 1 || void 0 === arguments[1] ? i : arguments[1], n = null, r = null; return function () { for (var i = arguments.length, o = Array(i), a = 0; a < i; a++) + o[a] = arguments[a]; return null !== n && n.length === o.length && o.every(function (e, r) { return t(e, n[r]); }) ? r : (r = e.apply(void 0, o), n = o, r); }; } + function a(e) { var t = Array.isArray(e[0]) ? e[0] : e; if (!t.every(function (e) { return "function" == typeof e; })) { + var n = t.map(function (e) { return typeof e; }).join(", "); + throw new Error("Selector creators expect all input-selectors to be functions, instead received the following types: [" + n + "]"); + } return t; } + function s(e) { for (var t = arguments.length, n = Array(t > 1 ? t - 1 : 0), i = 1; i < t; i++) + n[i - 1] = arguments[i]; return function () { for (var t = arguments.length, i = Array(t), o = 0; o < t; o++) + i[o] = arguments[o]; var s = 0, u = i.pop(), l = a(i), c = e.apply(void 0, [function () { return s++, u.apply(void 0, arguments); }].concat(n)), p = function (e, t) { for (var n = arguments.length, i = Array(n > 2 ? n - 2 : 0), o = 2; o < n; o++) + i[o - 2] = arguments[o]; var a = l.map(function (n) { return n.apply(void 0, [e, t].concat(i)); }); return c.apply(void 0, r(a)); }; return p.resultFunc = u, p.recomputations = function () { return s; }, p.resetRecomputations = function () { return s = 0; }, p; }; } + function u() { return s(o).apply(void 0, arguments); } + function l(e) { var t = arguments.length <= 1 || void 0 === arguments[1] ? u : arguments[1]; if ("object" != typeof e) + throw new Error("createStructuredSelector expects first argument to be an object where each property is a selector, instead received a " + typeof e); var n = Object.keys(e); return t(n.map(function (t) { return e[t]; }), function () { for (var e = arguments.length, t = Array(e), r = 0; r < e; r++) + t[r] = arguments[r]; return t.reduce(function (e, t, r) { return e[n[r]] = t, e; }, {}); }); } + t.__esModule = !0, t.defaultMemoize = o, t.createSelectorCreator = s, t.createSelector = u, t.createStructuredSelector = l; + }, function (e, t, n) { (function (e) { (function () { var t, r, i, o = [].slice, a = {}.hasOwnProperty; this.StringStream = function () { function e() { this.string = ""; } return e.prototype.write = function (e) { return this.string += e; }, e; }(), this.clone = function (e) { return function (t) { return e.extend({}, t); }; }(this), this.extend = function () { var e, t, n, r, i, a, s; for (e = arguments[0], a = 2 <= arguments.length ? o.call(arguments, 1) : [], t = 0, r = a.length; t < r; t++) { + i = a[t]; + for (n in i) + s = i[n], e[n] = s; + } return e; }, this.is_empty = function (e) { var t; if (Array.isArray(e) || "string" == typeof e) + return 0 === e.length; for (t in e) + if (a.call(e, t)) + return !1; return !0; }, this.inspect = null != (t = null != (r = null != (i = n(1212)) ? i.inspect : void 0) ? r : e.inspect) ? t : function (e) { return "" + e; }, this.pad_left = function (e, t, n) { return e = String(e), e.length >= n ? e : e.length + 1 === n ? "" + t + e : "" + new Array(n - e.length + 1).join(t) + e; }, this.to_hex = function (e) { return "string" == typeof e && (e = e.charCodeAt(0)), e.toString(16); }; }).call(this); }).call(t, n(16)); }, function (e, t, n) { var r = n(77); e.exports = function (e) { if (!r(e)) + throw TypeError(e + " is not an object!"); return e; }; }, function (e, t) { var n = e.exports = { version: "2.5.5" }; "number" == typeof __e && (__e = n); }, function (e, t, n) { var r = n(138), i = n(370); e.exports = n(106) ? function (e, t, n) { return r.f(e, t, i(1, n)); } : function (e, t, n) { return e[t] = n, e; }; }, function (e, t, n) { + "use strict"; + var r = n(744), i = Math.max; + e.exports = function (e) { return i(0, r(e)); }; + }, function (e, t, n) { function r(e) { return null == e ? void 0 === e ? u : s : l && l in Object(e) ? o(e) : a(e); } var i = n(82), o = n(912), a = n(941), s = "[object Null]", u = "[object Undefined]", l = i ? i.toStringTag : void 0; e.exports = r; }, function (e, t, n) { function r(e, t) { var n = o(e, t); return i(n) ? n : void 0; } var i = n(873), o = n(913); e.exports = r; }, function (e, t, n) { function r(e) { return a(e) ? i(e) : o(e); } var i = n(406), o = n(876), a = n(86); e.exports = r; }, function (e, t, n) { + "use strict"; + }, function (e, t, n) { + "use strict"; + var r = n(11), i = (n(8), function (e) { var t = this; if (t.instancePool.length) { + var n = t.instancePool.pop(); + return t.call(n, e), n; + } return new t(e); }), o = function (e, t) { var n = this; if (n.instancePool.length) { + var r = n.instancePool.pop(); + return n.call(r, e, t), r; + } return new n(e, t); }, a = function (e, t, n) { var r = this; if (r.instancePool.length) { + var i = r.instancePool.pop(); + return r.call(i, e, t, n), i; + } return new r(e, t, n); }, s = function (e, t, n, r) { var i = this; if (i.instancePool.length) { + var o = i.instancePool.pop(); + return i.call(o, e, t, n, r), o; + } return new i(e, t, n, r); }, u = function (e) { var t = this; e instanceof t || r("25"), e.destructor(), t.instancePool.length < t.poolSize && t.instancePool.push(e); }, l = i, c = function (e, t) { var n = e; return n.instancePool = [], n.getPooled = t || l, n.poolSize || (n.poolSize = 10), n.release = u, n; }, p = { addPoolingTo: c, oneArgumentPooler: i, twoArgumentPooler: o, threeArgumentPooler: a, fourArgumentPooler: s }; + e.exports = p; + }, function (e, t, n) { + "use strict"; + function r(e) { if (!(this instanceof r)) + return new r(e); l.call(this, e), c.call(this, e), e && !1 === e.readable && (this.readable = !1), e && !1 === e.writable && (this.writable = !1), this.allowHalfOpen = !0, e && !1 === e.allowHalfOpen && (this.allowHalfOpen = !1), this.once("end", i); } + function i() { this.allowHalfOpen || this._writableState.ended || a.nextTick(o, this); } + function o(e) { e.end(); } + var a = n(160), s = Object.keys || function (e) { var t = []; for (var n in e) + t.push(n); return t; }; + e.exports = r; + var u = n(110); + u.inherits = n(46); + var l = n(495), c = n(267); + u.inherits(r, l); + for (var p = s(c.prototype), f = 0; f < p.length; f++) { + var h = p[f]; + r.prototype[h] || (r.prototype[h] = c.prototype[h]); + } + Object.defineProperty(r.prototype, "writableHighWaterMark", { enumerable: !1, get: function () { return this._writableState.highWaterMark; } }), Object.defineProperty(r.prototype, "destroyed", { get: function () { return void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed && this._writableState.destroyed); }, set: function (e) { void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed = e, this._writableState.destroyed = e); } }), r.prototype._destroy = function (e, t) { this.push(null), this.end(), a.nextTick(t, e); }; + }, function (e, t, n) { + "use strict"; + t.__esModule = !0; + var r = n(582), i = function (e) { return e && e.__esModule ? e : { default: e }; }(r); + t.default = function (e) { if (Array.isArray(e)) { + for (var t = 0, n = Array(e.length); t < e.length; t++) + n[t] = e[t]; + return n; + } return (0, i.default)(e); }; + }, function (e, t, n) { + "use strict"; + var r = n(445), i = n(444), o = n(113).decodeHTML, a = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});", s = "<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>", u = "]", l = new RegExp("^(?:<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>|]|\x3c!----\x3e|\x3c!--(?:-?[^>-])(?:-?[^-])*--\x3e|[<][?].*?[?][>]|]*>|)", "i"), c = /[\\&]/, p = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]", f = new RegExp("\\\\" + p + "|" + a, "gi"), h = new RegExp('[&<>"]', "g"), d = new RegExp(a + '|[&<>"]', "gi"), m = function (e) { return 92 === e.charCodeAt(0) ? e.charAt(1) : o(e); }, v = function (e) { return c.test(e) ? e.replace(f, m) : e; }, g = function (e) { try { + return r(i(e)); + } + catch (t) { + return e; + } }, y = function (e) { switch (e) { + case "&": return "&"; + case "<": return "<"; + case ">": return ">"; + case '"': return """; + default: return e; + } }, _ = function (e, t) { return h.test(e) ? t ? e.replace(d, y) : e.replace(h, y) : e; }; + e.exports = { unescapeString: v, normalizeURI: g, escapeXml: _, reHtmlTag: l, OPENTAG: s, CLOSETAG: u, ENTITY: a, ESCAPABLE: p }; + }, function (e, t) { e.exports = {}; }, function (e, t, n) { var r = n(186), i = n(183); e.exports = function (e) { return r(i(e)); }; }, function (e, t, n) { var r = n(183); e.exports = function (e) { return Object(r(e)); }; }, function (e, t) { e.exports = function (e) { return "object" == typeof e ? null !== e : "function" == typeof e; }; }, function (e, t, n) { var r = n(32), i = n(64), o = n(137), a = n(207)("src"), s = Function.toString, u = ("" + s).split("toString"); n(63).inspectSource = function (e) { return s.call(e); }, (e.exports = function (e, t, n, s) { var l = "function" == typeof n; l && (o(n, "name") || i(n, "name", t)), e[t] !== n && (l && (o(n, a) || i(n, a, e[t] ? "" + e[t] : u.join(String(t)))), e === r ? e[t] = n : s ? e[t] ? e[t] = n : i(e, t, n) : (delete e[t], i(e, t, n))); })(Function.prototype, "toString", function () { return "function" == typeof this && this[a] || s.call(this); }); }, function (e, t, n) { + "use strict"; + var r = n(383)(); + e.exports = function (e) { return e !== r && null !== e; }; + }, function (e, t, n) { + "use strict"; + function r(e) { return void 0 === e || null === e; } + function i(e) { return "object" == typeof e && null !== e; } + function o(e) { return Array.isArray(e) ? e : r(e) ? [] : [e]; } + function a(e, t) { var n, r, i, o; if (t) + for (o = Object.keys(t), n = 0, r = o.length; n < r; n += 1) + i = o[n], e[i] = t[i]; return e; } + function s(e, t) { var n, r = ""; for (n = 0; n < t; n += 1) + r += e; return r; } + function u(e) { return 0 === e && Number.NEGATIVE_INFINITY === 1 / e; } + e.exports.isNothing = r, e.exports.isObject = i, e.exports.toArray = o, e.exports.repeat = s, e.exports.isNegativeZero = u, e.exports.extend = a; + }, function (e, t, n) { + "use strict"; + function r(e, t, n) { var i = []; return e.include.forEach(function (e) { n = r(e, t, n); }), e[t].forEach(function (e) { n.forEach(function (t, n) { t.tag === e.tag && t.kind === e.kind && i.push(n); }), n.push(e); }), n.filter(function (e, t) { return -1 === i.indexOf(t); }); } + function i() { function e(e) { r[e.kind][e.tag] = r.fallback[e.tag] = e; } var t, n, r = { scalar: {}, sequence: {}, mapping: {}, fallback: {} }; for (t = 0, n = arguments.length; t < n; t += 1) + arguments[t].forEach(e); return r; } + function o(e) { this.include = e.include || [], this.implicit = e.implicit || [], this.explicit = e.explicit || [], this.implicit.forEach(function (e) { if (e.loadKind && "scalar" !== e.loadKind) + throw new s("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported."); }), this.compiledImplicit = r(this, "implicit", []), this.compiledExplicit = r(this, "explicit", []), this.compiledTypeMap = i(this.compiledImplicit, this.compiledExplicit); } + var a = n(80), s = n(116), u = n(17); + o.DEFAULT = null, o.create = function () { var e, t; switch (arguments.length) { + case 1: + e = o.DEFAULT, t = arguments[0]; + break; + case 2: + e = arguments[0], t = arguments[1]; + break; + default: throw new s("Wrong number of arguments for Schema.create function"); + } if (e = a.toArray(e), t = a.toArray(t), !e.every(function (e) { return e instanceof o; })) + throw new s("Specified list of super schemas (or a single Schema object) contains a non-Schema object."); if (!t.every(function (e) { return e instanceof u; })) + throw new s("Specified list of YAML types (or a single Type object) contains a non-Type object."); return new o({ include: e, explicit: t }); }, e.exports = o; + }, function (e, t, n) { var r = n(39), i = r.Symbol; e.exports = i; }, function (e, t, n) { function r(e, t) { return i(e) ? e : o(e, t) ? [e] : a(s(e)); } var i = n(22), o = n(227), a = n(953), s = n(87); e.exports = r; }, function (e, t, n) { function r(e, t, n, r) { var a = !n; n || (n = {}); for (var s = -1, u = t.length; ++s < u;) { + var l = t[s], c = r ? r(n[l], e[l], l, n, e) : void 0; + void 0 === c && (c = e[l]), a ? o(n, l, c) : i(n, l, c); + } return n; } var i = n(147), o = n(410); e.exports = r; }, function (e, t, n) { function r(e) { if ("string" == typeof e || i(e)) + return e; var t = e + ""; return "0" == t && 1 / e == -o ? "-0" : t; } var i = n(157), o = 1 / 0; e.exports = r; }, function (e, t, n) { function r(e) { return null != e && o(e.length) && !i(e); } var i = n(435), o = n(233); e.exports = r; }, function (e, t, n) { function r(e) { return null == e ? "" : i(e); } var i = n(417); e.exports = r; }, function (e, t, n) { + "use strict"; + function r(e) { if (d) { + var t = e.node, n = e.children; + if (n.length) + for (var r = 0; r < n.length; r++) + m(t, n[r], null); + else + null != e.html ? p(t, e.html) : null != e.text && h(t, e.text); + } } + function i(e, t) { e.parentNode.replaceChild(t.node, e), r(t); } + function o(e, t) { d ? e.children.push(t) : e.node.appendChild(t.node); } + function a(e, t) { d ? e.html = t : p(e.node, t); } + function s(e, t) { d ? e.text = t : h(e.node, t); } + function u() { return this.node.nodeName; } + function l(e) { return { node: e, children: [], html: null, text: null, toString: u }; } + var c = n(247), p = n(165), f = n(255), h = n(485), d = "undefined" != typeof document && "number" == typeof document.documentMode || "undefined" != typeof navigator && "string" == typeof navigator.userAgent && /\bEdge\/\d/.test(navigator.userAgent), m = f(function (e, t, n) { 11 === t.node.nodeType || 1 === t.node.nodeType && "object" === t.node.nodeName.toLowerCase() && (null == t.node.namespaceURI || t.node.namespaceURI === c.html) ? (r(t), e.insertBefore(t.node, n)) : (e.insertBefore(t.node, n), r(t)); }); + l.insertTreeBefore = m, l.replaceChildWithTree = i, l.queueChild = o, l.queueHTML = a, l.queueText = s, e.exports = l; + }, function (e, t, n) { + "use strict"; + function r(e, t) { return (e & t) === t; } + var i = n(11), o = (n(8), { MUST_USE_PROPERTY: 1, HAS_BOOLEAN_VALUE: 4, HAS_NUMERIC_VALUE: 8, HAS_POSITIVE_NUMERIC_VALUE: 24, HAS_OVERLOADED_BOOLEAN_VALUE: 32, injectDOMPropertyConfig: function (e) { var t = o, n = e.Properties || {}, a = e.DOMAttributeNamespaces || {}, u = e.DOMAttributeNames || {}, l = e.DOMPropertyNames || {}, c = e.DOMMutationMethods || {}; e.isCustomAttribute && s._isCustomAttributeFunctions.push(e.isCustomAttribute); for (var p in n) { + s.properties.hasOwnProperty(p) && i("48", p); + var f = p.toLowerCase(), h = n[p], d = { attributeName: f, attributeNamespace: null, propertyName: p, mutationMethod: null, mustUseProperty: r(h, t.MUST_USE_PROPERTY), hasBooleanValue: r(h, t.HAS_BOOLEAN_VALUE), hasNumericValue: r(h, t.HAS_NUMERIC_VALUE), hasPositiveNumericValue: r(h, t.HAS_POSITIVE_NUMERIC_VALUE), hasOverloadedBooleanValue: r(h, t.HAS_OVERLOADED_BOOLEAN_VALUE) }; + if (d.hasBooleanValue + d.hasNumericValue + d.hasOverloadedBooleanValue <= 1 || i("50", p), u.hasOwnProperty(p)) { + var m = u[p]; + d.attributeName = m; + } + a.hasOwnProperty(p) && (d.attributeNamespace = a[p]), l.hasOwnProperty(p) && (d.propertyName = l[p]), c.hasOwnProperty(p) && (d.mutationMethod = c[p]), s.properties[p] = d; + } } }), a = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD", s = { ID_ATTRIBUTE_NAME: "data-reactid", ROOT_ATTRIBUTE_NAME: "data-reactroot", ATTRIBUTE_NAME_START_CHAR: a, ATTRIBUTE_NAME_CHAR: a + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040", properties: {}, getPossibleStandardName: null, _isCustomAttributeFunctions: [], isCustomAttribute: function (e) { for (var t = 0; t < s._isCustomAttributeFunctions.length; t++) { + if ((0, s._isCustomAttributeFunctions[t])(e)) + return !0; + } return !1; }, injection: o }; + e.exports = s; + }, function (e, t, n) { + "use strict"; + function r() { i.attachRefs(this, this._currentElement); } + var i = n(1065), o = (n(41), n(10), { mountComponent: function (e, t, n, i, o, a) { var s = e.mountComponent(t, n, i, o, a); return e._currentElement && null != e._currentElement.ref && t.getReactMountReady().enqueue(r, e), s; }, getHostNode: function (e) { return e.getHostNode(); }, unmountComponent: function (e, t) { i.detachRefs(e, e._currentElement), e.unmountComponent(t); }, receiveComponent: function (e, t, n, o) { var a = e._currentElement; if (t !== a || o !== e._context) { + var s = i.shouldUpdateRefs(a, t); + s && i.detachRefs(e, a), e.receiveComponent(t, n, o), s && e._currentElement && null != e._currentElement.ref && n.getReactMountReady().enqueue(r, e); + } }, performUpdateIfNecessary: function (e, t, n) { e._updateBatchNumber === n && e.performUpdateIfNecessary(t); } }); + e.exports = o; + }, function (e, t, n) { + "use strict"; + var r = n(445), i = n(444), o = n(113).decodeHTML, a = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});", s = "<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>", u = "]", l = new RegExp("^(?:<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>|]|\x3c!----\x3e|\x3c!--(?:-?[^>-])(?:-?[^-])*--\x3e|[<][?].*?[?][>]|]*>|)", "i"), c = /[\\&]/, p = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]", f = new RegExp("\\\\" + p + "|" + a, "gi"), h = new RegExp('[&<>"]', "g"), d = new RegExp(a + '|[&<>"]', "gi"), m = function (e) { return 92 === e.charCodeAt(0) ? e.charAt(1) : o(e); }, v = function (e) { return c.test(e) ? e.replace(f, m) : e; }, g = function (e) { try { + return r(i(e)); + } + catch (t) { + return e; + } }, y = function (e) { switch (e) { + case "&": return "&"; + case "<": return "<"; + case ">": return ">"; + case '"': return """; + default: return e; + } }, _ = function (e, t) { return h.test(e) ? t ? e.replace(d, y) : e.replace(h, y) : e; }; + e.exports = { unescapeString: v, normalizeURI: g, escapeXml: _, reHtmlTag: l, OPENTAG: s, CLOSETAG: u, ENTITY: a, ESCAPABLE: p }; + }, function (e, t, n) { + "use strict"; + var r = n(13), i = n(490), o = n(1120), a = n(1121), s = n(93), u = n(1122), l = n(1123), c = n(1124), p = n(1128), f = s.createElement, h = s.createFactory, d = s.cloneElement, m = r, v = function (e) { return e; }, g = { Children: { map: o.map, forEach: o.forEach, count: o.count, toArray: o.toArray, only: p }, Component: i.Component, PureComponent: i.PureComponent, createElement: f, cloneElement: d, isValidElement: s.isValidElement, PropTypes: u, createClass: c, createFactory: h, createMixin: v, DOM: a, version: l, __spread: m }; + e.exports = g; + }, function (e, t, n) { + "use strict"; + function r(e) { return void 0 !== e.ref; } + function i(e) { return void 0 !== e.key; } + var o = n(13), a = n(53), s = (n(10), n(494), Object.prototype.hasOwnProperty), u = n(492), l = { key: !0, ref: !0, __self: !0, __source: !0 }, c = function (e, t, n, r, i, o, a) { var s = { $$typeof: u, type: e, key: t, ref: n, props: a, _owner: o }; return s; }; + c.createElement = function (e, t, n) { var o, u = {}, p = null, f = null; if (null != t) { + r(t) && (f = t.ref), i(t) && (p = "" + t.key), void 0 === t.__self ? null : t.__self, void 0 === t.__source ? null : t.__source; + for (o in t) + s.call(t, o) && !l.hasOwnProperty(o) && (u[o] = t[o]); + } var h = arguments.length - 2; if (1 === h) + u.children = n; + else if (h > 1) { + for (var d = Array(h), m = 0; m < h; m++) + d[m] = arguments[m + 2]; + u.children = d; + } if (e && e.defaultProps) { + var v = e.defaultProps; + for (o in v) + void 0 === u[o] && (u[o] = v[o]); + } return c(e, p, f, 0, 0, a.current, u); }, c.createFactory = function (e) { var t = c.createElement.bind(null, e); return t.type = e, t; }, c.cloneAndReplaceKey = function (e, t) { return c(e.type, t, e.ref, e._self, e._source, e._owner, e.props); }, c.cloneElement = function (e, t, n) { var u, p = o({}, e.props), f = e.key, h = e.ref, d = (e._self, e._source, e._owner); if (null != t) { + r(t) && (h = t.ref, d = a.current), i(t) && (f = "" + t.key); + var m; + e.type && e.type.defaultProps && (m = e.type.defaultProps); + for (u in t) + s.call(t, u) && !l.hasOwnProperty(u) && (void 0 === t[u] && void 0 !== m ? p[u] = m[u] : p[u] = t[u]); + } var v = arguments.length - 2; if (1 === v) + p.children = n; + else if (v > 1) { + for (var g = Array(v), y = 0; y < v; y++) + g[y] = arguments[y + 2]; + p.children = g; + } return c(e.type, f, h, 0, 0, d, p); }, c.isValidElement = function (e) { return "object" == typeof e && null !== e && e.$$typeof === u; }, e.exports = c; + }, function (e, t) { e.exports = function (e) { return e.webpackPolyfill || (e.deprecate = function () { }, e.paths = [], e.children || (e.children = []), Object.defineProperty(e, "loaded", { enumerable: !0, get: function () { return e.l; } }), Object.defineProperty(e, "id", { enumerable: !0, get: function () { return e.i; } }), e.webpackPolyfill = 1), e; }; }, function (e, t) { (function () { var e, t = function (e, t) { function r() { this.constructor = e; } for (var i in t) + n.call(t, i) && (e[i] = t[i]); return r.prototype = t.prototype, e.prototype = new r, e.__super__ = t.prototype, e; }, n = {}.hasOwnProperty; e = 0, this.Node = function () { function t(t, n, r, i) { this.tag = t, this.value = n, this.start_mark = r, this.end_mark = i, this.unique_id = "node_" + e++; } return t; }(), this.ScalarNode = function (e) { function n(e, t, r, i, o) { this.tag = e, this.value = t, this.start_mark = r, this.end_mark = i, this.style = o, n.__super__.constructor.apply(this, arguments); } return t(n, e), n.prototype.id = "scalar", n; }(this.Node), this.CollectionNode = function (e) { function n(e, t, r, i, o) { this.tag = e, this.value = t, this.start_mark = r, this.end_mark = i, this.flow_style = o, n.__super__.constructor.apply(this, arguments); } return t(n, e), n; }(this.Node), this.SequenceNode = function (e) { function n() { return n.__super__.constructor.apply(this, arguments); } return t(n, e), n.prototype.id = "sequence", n; }(this.CollectionNode), this.MappingNode = function (e) { function n() { return n.__super__.constructor.apply(this, arguments); } return t(n, e), n.prototype.id = "mapping", n; }(this.CollectionNode); }).call(this); }, function (e, t, n) { e.exports = { default: n(603), __esModule: !0 }; }, function (e, t, n) { + "use strict"; + t.__esModule = !0, t.default = function (e, t) { var n = {}; for (var r in e) + t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]); return n; }; + }, function (e, t) { e.exports = function (e) { if ("function" != typeof e) + throw TypeError(e + " is not a function!"); return e; }; }, function (e, t) { var n = {}.toString; e.exports = function (e) { return n.call(e).slice(8, -1); }; }, function (e, t, n) { var r = n(355), i = n(185); e.exports = Object.keys || function (e) { return r(e, i); }; }, function (e, t) { e.exports = function (e, t) { return { enumerable: !(1 & e), configurable: !(2 & e), writable: !(4 & e), value: t }; }; }, function (e, t, n) { var r = n(45).f, i = n(56), o = n(21)("toStringTag"); e.exports = function (e, t, n) { e && !i(e = n ? e : e.prototype, o) && r(e, o, { configurable: !0, value: t }); }; }, function (e, t, n) { + "use strict"; + var r = n(634)(!0); + n(349)(String, "String", function (e) { this._t = String(e), this._i = 0; }, function () { var e, t = this._t, n = this._i; return n >= t.length ? { value: void 0, done: !0 } : (e = r(t, n), this._i += e.length, { value: e, done: !1 }); }); + }, function (e, t, n) { n(639); for (var r = n(25), i = n(57), o = n(74), a = n(21)("toStringTag"), s = "CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,TextTrackList,TouchList".split(","), u = 0; u < s.length; u++) { + var l = s[u], c = r[l], p = c && c.prototype; + p && !p[a] && i(p, a, l), o[l] = o.Array; + } }, function (e, t) { var n = {}.toString; e.exports = function (e) { return n.call(e).slice(8, -1); }; }, function (e, t, n) { e.exports = !n(107)(function () { return 7 != Object.defineProperty({}, "a", { get: function () { return 7; } }).a; }); }, function (e, t) { e.exports = function (e) { try { + return !!e(); + } + catch (e) { + return !0; + } }; }, function (e, t) { e.exports = {}; }, function (e, t, n) { var r = n(139), i = Math.min; e.exports = function (e) { return e > 0 ? i(r(e), 9007199254740991) : 0; }; }, function (e, t, n) { (function (e) { function n(e) { return Array.isArray ? Array.isArray(e) : "[object Array]" === v(e); } function r(e) { return "boolean" == typeof e; } function i(e) { return null === e; } function o(e) { return null == e; } function a(e) { return "number" == typeof e; } function s(e) { return "string" == typeof e; } function u(e) { return "symbol" == typeof e; } function l(e) { return void 0 === e; } function c(e) { return "[object RegExp]" === v(e); } function p(e) { return "object" == typeof e && null !== e; } function f(e) { return "[object Date]" === v(e); } function h(e) { return "[object Error]" === v(e) || e instanceof Error; } function d(e) { return "function" == typeof e; } function m(e) { return null === e || "boolean" == typeof e || "number" == typeof e || "string" == typeof e || "symbol" == typeof e || void 0 === e; } function v(e) { return Object.prototype.toString.call(e); } t.isArray = n, t.isBoolean = r, t.isNull = i, t.isNullOrUndefined = o, t.isNumber = a, t.isString = s, t.isSymbol = u, t.isUndefined = l, t.isRegExp = c, t.isObject = p, t.isDate = f, t.isError = h, t.isFunction = d, t.isPrimitive = m, t.isBuffer = e.isBuffer; }).call(t, n(44).Buffer); }, function (e, t, n) { + "use strict"; + function r(e) { return "string" == typeof e && i.test(e); } + Object.defineProperty(t, "__esModule", { value: !0 }), t.default = r; + var i = /-webkit-|-moz-|-ms-/; + e.exports = t.default; + }, function (e, t) { e.exports = { Text: "text", Directive: "directive", Comment: "comment", Script: "script", Style: "style", Tag: "tag", CDATA: "cdata", Doctype: "doctype", isTag: function (e) { return "tag" === e.type || "script" === e.type || "style" === e.type; } }; }, function (e, t, n) { var r = n(730), i = n(729); t.decode = function (e, t) { return (!t || t <= 0 ? i.XML : i.HTML)(e); }, t.decodeStrict = function (e, t) { return (!t || t <= 0 ? i.XML : i.HTMLStrict)(e); }, t.encode = function (e, t) { return (!t || t <= 0 ? r.XML : r.HTML)(e); }, t.encodeXML = r.XML, t.encodeHTML4 = t.encodeHTML5 = t.encodeHTML = r.HTML, t.decodeXML = t.decodeXMLStrict = i.XML, t.decodeHTML4 = t.decodeHTML5 = t.decodeHTML = i.HTML, t.decodeHTML4Strict = t.decodeHTML5Strict = t.decodeHTMLStrict = i.HTMLStrict, t.escape = r.escape; }, function (e, t, n) { + "use strict"; + var r = n(79); + e.exports = function (e) { if (!r(e)) + throw new TypeError("Cannot use null or undefined"); return e; }; + }, function (e, t, n) { function r(t, n) { return delete e.exports[t], e.exports[t] = n, n; } var i = n(392), o = n(719); e.exports = { Parser: i, Tokenizer: n(393), ElementType: n(112), DomHandler: o, get FeedHandler() { return r("FeedHandler", n(779)); }, get Stream() { return r("Stream", n(781)); }, get WritableStream() { return r("WritableStream", n(394)); }, get ProxyHandler() { return r("ProxyHandler", n(780)); }, get DomUtils() { return r("DomUtils", n(721)); }, get CollectingHandler() { return r("CollectingHandler", n(778)); }, DefaultHandler: o, get RssHandler() { return r("RssHandler", this.FeedHandler); }, parseDOM: function (e, t) { var n = new o(t); return new i(n, t).end(e), n.dom; }, parseFeed: function (t, n) { var r = new e.exports.FeedHandler(n); return new i(r, n).end(t), r.dom; }, createDomStream: function (e, t, n) { var r = new o(e, t, n); return new i(r, t); }, EVENTS: { attribute: 2, cdatastart: 0, cdataend: 0, text: 1, processinginstruction: 2, comment: 1, commentend: 0, closetag: 1, opentag: 2, opentagname: 1, error: 1, end: 0 } }; }, function (e, t, n) { + "use strict"; + function r(e, t) { Error.call(this), this.name = "YAMLException", this.reason = e, this.mark = t, this.message = (this.reason || "(unknown reason)") + (this.mark ? " " + this.mark.toString() : ""), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = (new Error).stack || ""; } + r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r.prototype.toString = function (e) { var t = this.name + ": "; return t += this.reason || "(unknown reason)", !e && this.mark && (t += " " + this.mark.toString()), t; }, e.exports = r; + }, function (e, t, n) { + "use strict"; + var r = n(81); + e.exports = new r({ include: [n(400)], implicit: [n(834), n(827)], explicit: [n(819), n(829), n(830), n(832)] }); + }, function (e, t) { function n(e, t) { return e === t || e !== e && t !== t; } e.exports = n; }, function (e, t) { function n(e, t, n) { if (t in e) + return e[t]; if (3 === arguments.length) + return n; throw new Error('"' + t + '" is a required argument.'); } function r(e) { var t = e.match(y); return t ? { scheme: t[1], auth: t[2], host: t[3], port: t[4], path: t[5] } : null; } function i(e) { var t = ""; return e.scheme && (t += e.scheme + ":"), t += "//", e.auth && (t += e.auth + "@"), e.host && (t += e.host), e.port && (t += ":" + e.port), e.path && (t += e.path), t; } function o(e) { var n = e, o = r(e); if (o) { + if (!o.path) + return e; + n = o.path; + } for (var a, s = t.isAbsolute(n), u = n.split(/\/+/), l = 0, c = u.length - 1; c >= 0; c--) + a = u[c], "." === a ? u.splice(c, 1) : ".." === a ? l++ : l > 0 && ("" === a ? (u.splice(c + 1, l), l = 0) : (u.splice(c, 2), l--)); return n = u.join("/"), "" === n && (n = s ? "/" : "."), o ? (o.path = n, i(o)) : n; } function a(e, t) { "" === e && (e = "."), "" === t && (t = "."); var n = r(t), a = r(e); if (a && (e = a.path || "/"), n && !n.scheme) + return a && (n.scheme = a.scheme), i(n); if (n || t.match(_)) + return t; if (a && !a.host && !a.path) + return a.host = t, i(a); var s = "/" === t.charAt(0) ? t : o(e.replace(/\/+$/, "") + "/" + t); return a ? (a.path = s, i(a)) : s; } function s(e, t) { "" === e && (e = "."), e = e.replace(/\/$/, ""); for (var n = 0; 0 !== t.indexOf(e + "/");) { + var r = e.lastIndexOf("/"); + if (r < 0) + return t; + if (e = e.slice(0, r), e.match(/^([^\/]+:\/)?\/*$/)) + return t; + ++n; + } return Array(n + 1).join("../") + t.substr(e.length + 1); } function u(e) { return e; } function l(e) { return p(e) ? "$" + e : e; } function c(e) { return p(e) ? e.slice(1) : e; } function p(e) { if (!e) + return !1; var t = e.length; if (t < 9) + return !1; if (95 !== e.charCodeAt(t - 1) || 95 !== e.charCodeAt(t - 2) || 111 !== e.charCodeAt(t - 3) || 116 !== e.charCodeAt(t - 4) || 111 !== e.charCodeAt(t - 5) || 114 !== e.charCodeAt(t - 6) || 112 !== e.charCodeAt(t - 7) || 95 !== e.charCodeAt(t - 8) || 95 !== e.charCodeAt(t - 9)) + return !1; for (var n = t - 10; n >= 0; n--) + if (36 !== e.charCodeAt(n)) + return !1; return !0; } function f(e, t, n) { var r = d(e.source, t.source); return 0 !== r ? r : 0 !== (r = e.originalLine - t.originalLine) ? r : 0 !== (r = e.originalColumn - t.originalColumn) || n ? r : 0 !== (r = e.generatedColumn - t.generatedColumn) ? r : (r = e.generatedLine - t.generatedLine, 0 !== r ? r : d(e.name, t.name)); } function h(e, t, n) { var r = e.generatedLine - t.generatedLine; return 0 !== r ? r : 0 !== (r = e.generatedColumn - t.generatedColumn) || n ? r : 0 !== (r = d(e.source, t.source)) ? r : 0 !== (r = e.originalLine - t.originalLine) ? r : (r = e.originalColumn - t.originalColumn, 0 !== r ? r : d(e.name, t.name)); } function d(e, t) { return e === t ? 0 : null === e ? 1 : null === t ? -1 : e > t ? 1 : -1; } function m(e, t) { var n = e.generatedLine - t.generatedLine; return 0 !== n ? n : 0 !== (n = e.generatedColumn - t.generatedColumn) ? n : 0 !== (n = d(e.source, t.source)) ? n : 0 !== (n = e.originalLine - t.originalLine) ? n : (n = e.originalColumn - t.originalColumn, 0 !== n ? n : d(e.name, t.name)); } function v(e) { return JSON.parse(e.replace(/^\)]}'[^\n]*\n/, "")); } function g(e, t, n) { if (t = t || "", e && ("/" !== e[e.length - 1] && "/" !== t[0] && (e += "/"), t = e + t), n) { + var s = r(n); + if (!s) + throw new Error("sourceMapURL could not be parsed"); + if (s.path) { + var u = s.path.lastIndexOf("/"); + u >= 0 && (s.path = s.path.substring(0, u + 1)); + } + t = a(i(s), t); + } return o(t); } t.getArg = n; var y = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/, _ = /^data:.+\,.+$/; t.urlParse = r, t.urlGenerate = i, t.normalize = o, t.join = a, t.isAbsolute = function (e) { return "/" === e.charAt(0) || y.test(e); }, t.relative = s; var b = function () { return !("__proto__" in Object.create(null)); }(); t.toSetString = b ? u : l, t.fromSetString = b ? u : c, t.compareByOriginalPositions = f, t.compareByGeneratedPositionsDeflated = h, t.compareByGeneratedPositionsInflated = m, t.parseSourceMapInput = v, t.computeSourceURL = g; }, function (e, t, n) { + "use strict"; + function r(e) { return "button" === e || "input" === e || "select" === e || "textarea" === e; } + function i(e, t, n) { switch (e) { + case "onClick": + case "onClickCapture": + case "onDoubleClick": + case "onDoubleClickCapture": + case "onMouseDown": + case "onMouseDownCapture": + case "onMouseMove": + case "onMouseMoveCapture": + case "onMouseUp": + case "onMouseUpCapture": return !(!n.disabled || !r(t)); + default: return !1; + } } + var o = n(11), a = n(248), s = n(249), u = n(253), l = n(478), c = n(479), p = (n(8), {}), f = null, h = function (e, t) { e && (s.executeDispatchesInOrder(e, t), e.isPersistent() || e.constructor.release(e)); }, d = function (e) { return h(e, !0); }, m = function (e) { return h(e, !1); }, v = function (e) { return "." + e._rootNodeID; }, g = { injection: { injectEventPluginOrder: a.injectEventPluginOrder, injectEventPluginsByName: a.injectEventPluginsByName }, putListener: function (e, t, n) { "function" != typeof n && o("94", t, typeof n); var r = v(e); (p[t] || (p[t] = {}))[r] = n; var i = a.registrationNameModules[t]; i && i.didPutListener && i.didPutListener(e, t, n); }, getListener: function (e, t) { var n = p[t]; if (i(t, e._currentElement.type, e._currentElement.props)) + return null; var r = v(e); return n && n[r]; }, deleteListener: function (e, t) { var n = a.registrationNameModules[t]; n && n.willDeleteListener && n.willDeleteListener(e, t); var r = p[t]; if (r) { + delete r[v(e)]; + } }, deleteAllListeners: function (e) { var t = v(e); for (var n in p) + if (p.hasOwnProperty(n) && p[n][t]) { + var r = a.registrationNameModules[n]; + r && r.willDeleteListener && r.willDeleteListener(e, n), delete p[n][t]; + } }, extractEvents: function (e, t, n, r) { for (var i, o = a.plugins, s = 0; s < o.length; s++) { + var u = o[s]; + if (u) { + var c = u.extractEvents(e, t, n, r); + c && (i = l(i, c)); + } + } return i; }, enqueueEvents: function (e) { e && (f = l(f, e)); }, processEventQueue: function (e) { var t = f; f = null, e ? c(t, d) : c(t, m), f && o("95"), u.rethrowCaughtError(); }, __purge: function () { p = {}; }, __getListenerBank: function () { return p; } }; + e.exports = g; + }, function (e, t, n) { + "use strict"; + function r(e, t, n) { var r = t.dispatchConfig.phasedRegistrationNames[n]; return g(e, r); } + function i(e, t, n) { var i = r(e, n, t); i && (n._dispatchListeners = m(n._dispatchListeners, i), n._dispatchInstances = m(n._dispatchInstances, e)); } + function o(e) { e && e.dispatchConfig.phasedRegistrationNames && d.traverseTwoPhase(e._targetInst, i, e); } + function a(e) { if (e && e.dispatchConfig.phasedRegistrationNames) { + var t = e._targetInst, n = t ? d.getParentInstance(t) : null; + d.traverseTwoPhase(n, i, e); + } } + function s(e, t, n) { if (n && n.dispatchConfig.registrationName) { + var r = n.dispatchConfig.registrationName, i = g(e, r); + i && (n._dispatchListeners = m(n._dispatchListeners, i), n._dispatchInstances = m(n._dispatchInstances, e)); + } } + function u(e) { e && e.dispatchConfig.registrationName && s(e._targetInst, null, e); } + function l(e) { v(e, o); } + function c(e) { v(e, a); } + function p(e, t, n, r) { d.traverseEnterLeave(n, r, s, e, t); } + function f(e) { v(e, u); } + var h = n(120), d = n(249), m = n(478), v = n(479), g = (n(10), h.getListener), y = { accumulateTwoPhaseDispatches: l, accumulateTwoPhaseDispatchesSkipTarget: c, accumulateDirectDispatches: f, accumulateEnterLeaveDispatches: p }; + e.exports = y; + }, function (e, t, n) { + "use strict"; + var r = { remove: function (e) { e._reactInternalInstance = void 0; }, get: function (e) { return e._reactInternalInstance; }, has: function (e) { return void 0 !== e._reactInternalInstance; }, set: function (e, t) { e._reactInternalInstance = t; } }; + e.exports = r; + }, function (e, t, n) { + "use strict"; + function r(e, t, n, r) { return i.call(this, e, t, n, r); } + var i = n(52), o = n(258), a = { view: function (e) { if (e.view) + return e.view; var t = o(e); if (t.window === t) + return t; var n = t.ownerDocument; return n ? n.defaultView || n.parentWindow : window; }, detail: function (e) { return e.detail || 0; } }; + i.augmentClass(r, a), e.exports = r; + }, function (e, t, n) { + "use strict"; + function r(e) { for (var t = arguments.length - 1, n = "Minified React error #" + e + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant=" + e, r = 0; r < t; r++) + n += "&args[]=" + encodeURIComponent(arguments[r + 1]); n += " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; var i = new Error(n); throw i.name = "Invariant Violation", i.framesToPop = 1, i; } + e.exports = r; + }, function (e, t) { (function () { var e = function (e, n) { function r() { this.constructor = e; } for (var i in n) + t.call(n, i) && (e[i] = n[i]); return r.prototype = n.prototype, e.prototype = new r, e.__super__ = n.prototype, e; }, t = {}.hasOwnProperty; this.Event = function () { function e(e, t) { this.start_mark = e, this.end_mark = t; } return e; }(), this.NodeEvent = function (t) { function n(e, t, n) { this.anchor = e, this.start_mark = t, this.end_mark = n; } return e(n, t), n; }(this.Event), this.CollectionStartEvent = function (t) { function n(e, t, n, r, i, o) { this.anchor = e, this.tag = t, this.implicit = n, this.start_mark = r, this.end_mark = i, this.flow_style = o; } return e(n, t), n; }(this.NodeEvent), this.CollectionEndEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.Event), this.StreamStartEvent = function (t) { function n(e, t, n) { this.start_mark = e, this.end_mark = t, this.encoding = n; } return e(n, t), n; }(this.Event), this.StreamEndEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.Event), this.DocumentStartEvent = function (t) { function n(e, t, n, r, i) { this.start_mark = e, this.end_mark = t, this.explicit = n, this.version = r, this.tags = i; } return e(n, t), n; }(this.Event), this.DocumentEndEvent = function (t) { function n(e, t, n) { this.start_mark = e, this.end_mark = t, this.explicit = n; } return e(n, t), n; }(this.Event), this.AliasEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.NodeEvent), this.ScalarEvent = function (t) { function n(e, t, n, r, i, o, a) { this.anchor = e, this.tag = t, this.implicit = n, this.value = r, this.start_mark = i, this.end_mark = o, this.style = a; } return e(n, t), n; }(this.NodeEvent), this.SequenceStartEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.CollectionStartEvent), this.SequenceEndEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.CollectionEndEvent), this.MappingStartEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.CollectionStartEvent), this.MappingEndEvent = function (t) { function n() { return n.__super__.constructor.apply(this, arguments); } return e(n, t), n; }(this.CollectionEndEvent); }).call(this); }, function (e, t, n) { + "use strict"; + function r(e) { return { type: f, payload: (0, p.default)(e) }; } + function i(e) { return { type: h, payload: e }; } + function o(e) { return { type: d, payload: e }; } + function a(e) { return { type: m, payload: e }; } + function s(e) { return { type: v, payload: e }; } + function u() { var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}; return { type: g, payload: e }; } + function l() { var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : function () { return !0; }; return { type: y, payload: e }; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.CLEAR_BY = t.CLEAR = t.NEW_AUTH_ERR = t.NEW_SPEC_ERR_BATCH = t.NEW_SPEC_ERR = t.NEW_THROWN_ERR_BATCH = t.NEW_THROWN_ERR = void 0, t.newThrownErr = r, t.newThrownErrBatch = i, t.newSpecErr = o, t.newSpecErrBatch = a, t.newAuthErr = s, t.clear = u, t.clearBy = l; + var c = n(270), p = function (e) { return e && e.__esModule ? e : { default: e }; }(c), f = t.NEW_THROWN_ERR = "err_new_thrown_err", h = t.NEW_THROWN_ERR_BATCH = "err_new_thrown_err_batch", d = t.NEW_SPEC_ERR = "err_new_spec_err", m = t.NEW_SPEC_ERR_BATCH = "err_new_spec_err_batch", v = t.NEW_AUTH_ERR = "err_new_auth_err", g = t.CLEAR = "err_clear", y = t.CLEAR_BY = "err_clear_by"; + }, function (e, t, n) { e.exports = { default: n(612), __esModule: !0 }; }, function (e, t, n) { var r = n(54), i = n(348), o = n(346), a = n(38), s = n(132), u = n(198), l = {}, c = {}, t = e.exports = function (e, t, n, p, f) { var h, d, m, v, g = f ? function () { return e; } : u(e), y = r(n, p, t ? 2 : 1), _ = 0; if ("function" != typeof g) + throw TypeError(e + " is not iterable!"); if (o(g)) { + for (h = s(e.length); h > _; _++) + if ((v = t ? y(a(d = e[_])[0], d[1]) : y(e[_])) === l || v === c) + return v; + } + else + for (m = g.call(e); !(d = m.next()).done;) + if ((v = i(m, y, d.value, t)) === l || v === c) + return v; }; t.BREAK = l, t.RETURN = c; }, function (e, t) { e.exports = !0; }, function (e, t, n) { var r = n(133)("meta"), i = n(29), o = n(56), a = n(45).f, s = 0, u = Object.isExtensible || function () { return !0; }, l = !n(55)(function () { return u(Object.preventExtensions({})); }), c = function (e) { a(e, r, { value: { i: "O" + ++s, w: {} } }); }, p = function (e, t) { if (!i(e)) + return "symbol" == typeof e ? e : ("string" == typeof e ? "S" : "P") + e; if (!o(e, r)) { + if (!u(e)) + return "F"; + if (!t) + return "E"; + c(e); + } return e[r].i; }, f = function (e, t) { if (!o(e, r)) { + if (!u(e)) + return !0; + if (!t) + return !1; + c(e); + } return e[r].w; }, h = function (e) { return l && d.NEED && u(e) && !o(e, r) && c(e), e; }, d = e.exports = { KEY: r, NEED: !1, fastKey: p, getWeak: f, onFreeze: h }; }, function (e, t) { t.f = {}.propertyIsEnumerable; }, function (e, t, n) { var r = n(194), i = Math.min; e.exports = function (e) { return e > 0 ? i(r(e), 9007199254740991) : 0; }; }, function (e, t) { var n = 0, r = Math.random(); e.exports = function (e) { return "Symbol(".concat(void 0 === e ? "" : e, ")_", (++n + r).toString(36)); }; }, function (e, t) { e.exports = function (e) { if ("function" != typeof e) + throw TypeError(e + " is not a function!"); return e; }; }, function (e, t, n) { var r = n(134); e.exports = function (e, t, n) { if (r(e), void 0 === t) + return e; switch (n) { + case 1: return function (n) { return e.call(t, n); }; + case 2: return function (n, r) { return e.call(t, n, r); }; + case 3: return function (n, r, i) { return e.call(t, n, r, i); }; + } return function () { return e.apply(t, arguments); }; }; }, function (e, t, n) { + "use strict"; + var r = n(64), i = n(78), o = n(107), a = n(58), s = n(19); + e.exports = function (e, t, n) { var u = s(e), l = n(a, u, ""[e]), c = l[0], p = l[1]; o(function () { var t = {}; return t[u] = function () { return 7; }, 7 != ""[e](t); }) && (i(String.prototype, e, c), r(RegExp.prototype, u, 2 == t ? function (e, t) { return p.call(e, this, t); } : function (e) { return p.call(e, this); })); }; + }, function (e, t) { var n = {}.hasOwnProperty; e.exports = function (e, t) { return n.call(e, t); }; }, function (e, t, n) { var r = n(62), i = n(659), o = n(678), a = Object.defineProperty; t.f = n(106) ? Object.defineProperty : function (e, t, n) { if (r(e), t = o(t, !0), r(n), i) + try { + return a(e, t, n); + } + catch (e) { } if ("get" in n || "set" in n) + throw TypeError("Accessors not supported!"); return "value" in n && (e[t] = n.value), e; }; }, function (e, t) { var n = Math.ceil, r = Math.floor; e.exports = function (e) { return isNaN(e = +e) ? 0 : (e > 0 ? r : n)(e); }; }, function (e, t, n) { var r = n(661), i = n(58); e.exports = function (e) { return r(i(e)); }; }, function (e, t, n) { + "use strict"; + var r, i = n(384), o = n(387), a = n(748), s = n(753); + r = e.exports = function (e, t) { var n, r, a, u, l; return arguments.length < 2 || "string" != typeof e ? (u = t, t = e, e = null) : u = arguments[2], null == e ? (n = a = !0, r = !1) : (n = s.call(e, "c"), r = s.call(e, "e"), a = s.call(e, "w")), l = { value: t, configurable: n, enumerable: r, writable: a }, u ? i(o(u), l) : l; }, r.gs = function (e, t, n) { var r, u, l, c; return "string" != typeof e ? (l = n, n = t, t = e, e = null) : l = arguments[3], null == t ? t = void 0 : a(t) ? null == n ? n = void 0 : a(n) || (l = n, n = void 0) : (l = t, t = n = void 0), null == e ? (r = !0, u = !1) : (r = s.call(e, "c"), u = s.call(e, "e")), c = { get: t, set: n, configurable: r, enumerable: u }, l ? i(o(l), c) : c; }; + }, function (e, t, n) { + "use strict"; + e.exports = n(745)("forEach"); + }, function (e, t) { function n() { this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0; } function r(e) { return "function" == typeof e; } function i(e) { return "number" == typeof e; } function o(e) { return "object" == typeof e && null !== e; } function a(e) { return void 0 === e; } e.exports = n, n.EventEmitter = n, n.prototype._events = void 0, n.prototype._maxListeners = void 0, n.defaultMaxListeners = 10, n.prototype.setMaxListeners = function (e) { if (!i(e) || e < 0 || isNaN(e)) + throw TypeError("n must be a positive number"); return this._maxListeners = e, this; }, n.prototype.emit = function (e) { var t, n, i, s, u, l; if (this._events || (this._events = {}), "error" === e && (!this._events.error || o(this._events.error) && !this._events.error.length)) { + if ((t = arguments[1]) instanceof Error) + throw t; + var c = new Error('Uncaught, unspecified "error" event. (' + t + ")"); + throw c.context = t, c; + } if (n = this._events[e], a(n)) + return !1; if (r(n)) + switch (arguments.length) { + case 1: + n.call(this); + break; + case 2: + n.call(this, arguments[1]); + break; + case 3: + n.call(this, arguments[1], arguments[2]); + break; + default: s = Array.prototype.slice.call(arguments, 1), n.apply(this, s); + } + else if (o(n)) + for (s = Array.prototype.slice.call(arguments, 1), l = n.slice(), i = l.length, u = 0; u < i; u++) + l[u].apply(this, s); return !0; }, n.prototype.addListener = function (e, t) { var i; if (!r(t)) + throw TypeError("listener must be a function"); return this._events || (this._events = {}), this._events.newListener && this.emit("newListener", e, r(t.listener) ? t.listener : t), this._events[e] ? o(this._events[e]) ? this._events[e].push(t) : this._events[e] = [this._events[e], t] : this._events[e] = t, o(this._events[e]) && !this._events[e].warned && (i = a(this._maxListeners) ? n.defaultMaxListeners : this._maxListeners) && i > 0 && this._events[e].length > i && (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.on = n.prototype.addListener, n.prototype.once = function (e, t) { function n() { this.removeListener(e, n), i || (i = !0, t.apply(this, arguments)); } if (!r(t)) + throw TypeError("listener must be a function"); var i = !1; return n.listener = t, this.on(e, n), this; }, n.prototype.removeListener = function (e, t) { var n, i, a, s; if (!r(t)) + throw TypeError("listener must be a function"); if (!this._events || !this._events[e]) + return this; if (n = this._events[e], a = n.length, i = -1, n === t || r(n.listener) && n.listener === t) + delete this._events[e], this._events.removeListener && this.emit("removeListener", e, t); + else if (o(n)) { + for (s = a; s-- > 0;) + if (n[s] === t || n[s].listener && n[s].listener === t) { + i = s; + break; + } + if (i < 0) + return this; + 1 === n.length ? (n.length = 0, delete this._events[e]) : n.splice(i, 1), this._events.removeListener && this.emit("removeListener", e, t); + } return this; }, n.prototype.removeAllListeners = function (e) { var t, n; if (!this._events) + return this; if (!this._events.removeListener) + return 0 === arguments.length ? this._events = {} : this._events[e] && delete this._events[e], this; if (0 === arguments.length) { + for (t in this._events) + "removeListener" !== t && this.removeAllListeners(t); + return this.removeAllListeners("removeListener"), this._events = {}, this; + } if (n = this._events[e], r(n)) + this.removeListener(e, n); + else if (n) + for (; n.length;) + this.removeListener(e, n[n.length - 1]); return delete this._events[e], this; }, n.prototype.listeners = function (e) { return this._events && this._events[e] ? r(this._events[e]) ? [this._events[e]] : this._events[e].slice() : []; }, n.prototype.listenerCount = function (e) { if (this._events) { + var t = this._events[e]; + if (r(t)) + return 1; + if (t) + return t.length; + } return 0; }, n.listenerCount = function (e, t) { return e.listenerCount(t); }; }, function (e, t, n) { + "use strict"; + var r = {}; + e.exports = r; + }, function (e, t, n) { + "use strict"; + var r = n(81); + e.exports = r.DEFAULT = new r({ include: [n(117)], explicit: [n(825), n(824), n(823)] }); + }, function (e, t, n) { function r(e) { var t = -1, n = null == e ? 0 : e.length; for (this.clear(); ++t < n;) { + var r = e[t]; + this.set(r[0], r[1]); + } } var i = n(927), o = n(928), a = n(929), s = n(930), u = n(931); r.prototype.clear = i, r.prototype.delete = o, r.prototype.get = a, r.prototype.has = s, r.prototype.set = u, e.exports = r; }, function (e, t, n) { function r(e, t, n) { var r = e[t]; s.call(e, t) && o(r, n) && (void 0 !== n || t in e) || i(e, t, n); } var i = n(410), o = n(118), a = Object.prototype, s = a.hasOwnProperty; e.exports = r; }, function (e, t, n) { function r(e, t) { for (var n = e.length; n--;) + if (i(e[n][0], t)) + return n; return -1; } var i = n(118); e.exports = r; }, function (e, t, n) { function r(e, t) { t = i(t, e); for (var n = 0, r = t.length; null != e && n < r;) + e = e[o(t[n++])]; return n && n == r ? e : void 0; } var i = n(83), o = n(85); e.exports = r; }, function (e, t, n) { function r(e) { return "function" == typeof e ? e : null == e ? a : "object" == typeof e ? s(e) ? o(e[0], e[1]) : i(e) : u(e); } var i = n(878), o = n(879), a = n(230), s = n(22), u = n(972); e.exports = r; }, function (e, t, n) { function r(e, t) { var n = e.__data__; return i(t) ? n["string" == typeof t ? "string" : "hash"] : n.map; } var i = n(925); e.exports = r; }, function (e, t, n) { var r = n(849), i = n(219), o = n(851), a = n(852), s = n(854), u = n(66), l = n(433), c = l(r), p = l(i), f = l(o), h = l(a), d = l(s), m = u; (r && "[object DataView]" != m(new r(new ArrayBuffer(1))) || i && "[object Map]" != m(new i) || o && "[object Promise]" != m(o.resolve()) || a && "[object Set]" != m(new a) || s && "[object WeakMap]" != m(new s)) && (m = function (e) { var t = u(e), n = "[object Object]" == t ? e.constructor : void 0, r = n ? l(n) : ""; if (r) + switch (r) { + case c: return "[object DataView]"; + case p: return "[object Map]"; + case f: return "[object Promise]"; + case h: return "[object Set]"; + case d: return "[object WeakMap]"; + } return t; }), e.exports = m; }, function (e, t) { function n(e, t) { var n = typeof e; return !!(t = null == t ? r : t) && ("number" == n || "symbol" != n && i.test(e)) && e > -1 && e % 1 == 0 && e < t; } var r = 9007199254740991, i = /^(?:0|[1-9]\d*)$/; e.exports = n; }, function (e, t) { function n(e) { var t = e && e.constructor; return e === ("function" == typeof t && t.prototype || r); } var r = Object.prototype; e.exports = n; }, function (e, t, n) { var r = n(67), i = r(Object, "create"); e.exports = i; }, function (e, t, n) { function r(e, t, n) { var r = null == e ? void 0 : i(e, t); return void 0 === r ? n : r; } var i = n(149); e.exports = r; }, function (e, t, n) { function r(e) { return "symbol" == typeof e || o(e) && i(e) == a; } var i = n(66), o = n(51), a = "[object Symbol]"; e.exports = r; }, function (e, t, n) { + "use strict"; + function r(e, t) { if (!(e instanceof t)) + throw new TypeError("Cannot call a class as a function"); } + function i(e, t) { if (!e) + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return !t || "object" != typeof t && "function" != typeof t ? e : t; } + function o(e, t) { if ("function" != typeof t && null !== t) + throw new TypeError("Super expression must either be null or a function, not " + typeof t); e.prototype = Object.create(t && t.prototype, { constructor: { value: e, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(e, t) : e.__proto__ = t); } + t.__esModule = !0; + var a = n(239), s = function (e) { return e && e.__esModule ? e : { default: e }; }(a), u = function (e) { function t(n) { r(this, t); var o = i(this, e.call(this, n)); return o.type = "atrule", o; } return o(t, e), t.prototype.append = function () { var t; this.nodes || (this.nodes = []); for (var n = arguments.length, r = Array(n), i = 0; i < n; i++) + r[i] = arguments[i]; return (t = e.prototype.append).call.apply(t, [this].concat(r)); }, t.prototype.prepend = function () { var t; this.nodes || (this.nodes = []); for (var n = arguments.length, r = Array(n), i = 0; i < n; i++) + r[i] = arguments[i]; return (t = e.prototype.prepend).call.apply(t, [this].concat(r)); }, t; }(s.default); + t.default = u, e.exports = t.default; + }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + function i(e, t) { if (!(e instanceof t)) + throw new TypeError("Cannot call a class as a function"); } + function o(e, t) { if (!e) + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return !t || "object" != typeof t && "function" != typeof t ? e : t; } + function a(e, t) { if ("function" != typeof t && null !== t) + throw new TypeError("Super expression must either be null or a function, not " + typeof t); e.prototype = Object.create(t && t.prototype, { constructor: { value: e, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(e, t) : e.__proto__ = t); } + t.__esModule = !0; + var s = function () { function e(e, t) { for (var n = 0; n < t.length; n++) { + var r = t[n]; + r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r); + } } return function (t, n, r) { return n && e(t.prototype, n), r && e(t, r), t; }; }(), u = n(239), l = r(u), c = n(450), p = r(c), f = function (e) { function t(n) { i(this, t); var r = o(this, e.call(this, n)); return r.type = "rule", r.nodes || (r.nodes = []), r; } return a(t, e), s(t, [{ key: "selectors", get: function () { return p.default.comma(this.selector); }, set: function (e) { var t = this.selector ? this.selector.match(/,\s*/) : null, n = t ? t[0] : "," + this.raw("between", "beforeOpen"); this.selector = e.join(n); } }]), t; }(l.default); + t.default = f, e.exports = t.default; + }, function (e, t, n) { + "use strict"; + (function (t) { function n(e, n, r, i) { if ("function" != typeof e) + throw new TypeError('"callback" argument must be a function'); var o, a, s = arguments.length; switch (s) { + case 0: + case 1: return t.nextTick(e); + case 2: return t.nextTick(function () { e.call(null, n); }); + case 3: return t.nextTick(function () { e.call(null, n, r); }); + case 4: return t.nextTick(function () { e.call(null, n, r, i); }); + default: + for (o = new Array(s - 1), a = 0; a < o.length;) + o[a++] = arguments[a]; + return t.nextTick(function () { e.apply(null, o); }); + } } !t.version || 0 === t.version.indexOf("v0.") || 0 === t.version.indexOf("v1.") && 0 !== t.version.indexOf("v1.8.") ? e.exports = { nextTick: n } : e.exports = t; }).call(t, n(34)); + }, function (e, t, n) { + "use strict"; + function r(e) { return Object.prototype.hasOwnProperty.call(e, m) || (e[m] = h++, p[e[m]] = {}), p[e[m]]; } + var i, o = n(13), a = n(248), s = n(1057), u = n(477), l = n(1089), c = n(259), p = {}, f = !1, h = 0, d = { topAbort: "abort", topAnimationEnd: l("animationend") || "animationend", topAnimationIteration: l("animationiteration") || "animationiteration", topAnimationStart: l("animationstart") || "animationstart", topBlur: "blur", topCanPlay: "canplay", topCanPlayThrough: "canplaythrough", topChange: "change", topClick: "click", topCompositionEnd: "compositionend", topCompositionStart: "compositionstart", topCompositionUpdate: "compositionupdate", topContextMenu: "contextmenu", topCopy: "copy", topCut: "cut", topDoubleClick: "dblclick", topDrag: "drag", topDragEnd: "dragend", topDragEnter: "dragenter", topDragExit: "dragexit", topDragLeave: "dragleave", topDragOver: "dragover", topDragStart: "dragstart", topDrop: "drop", topDurationChange: "durationchange", topEmptied: "emptied", topEncrypted: "encrypted", topEnded: "ended", topError: "error", topFocus: "focus", topInput: "input", topKeyDown: "keydown", topKeyPress: "keypress", topKeyUp: "keyup", topLoadedData: "loadeddata", topLoadedMetadata: "loadedmetadata", topLoadStart: "loadstart", topMouseDown: "mousedown", topMouseMove: "mousemove", topMouseOut: "mouseout", topMouseOver: "mouseover", topMouseUp: "mouseup", topPaste: "paste", topPause: "pause", topPlay: "play", topPlaying: "playing", topProgress: "progress", topRateChange: "ratechange", topScroll: "scroll", topSeeked: "seeked", topSeeking: "seeking", topSelectionChange: "selectionchange", topStalled: "stalled", topSuspend: "suspend", topTextInput: "textInput", topTimeUpdate: "timeupdate", topTouchCancel: "touchcancel", topTouchEnd: "touchend", topTouchMove: "touchmove", topTouchStart: "touchstart", topTransitionEnd: l("transitionend") || "transitionend", topVolumeChange: "volumechange", topWaiting: "waiting", topWheel: "wheel" }, m = "_reactListenersID" + String(Math.random()).slice(2), v = o({}, s, { ReactEventListener: null, injection: { injectReactEventListener: function (e) { e.setHandleTopLevel(v.handleTopLevel), v.ReactEventListener = e; } }, setEnabled: function (e) { v.ReactEventListener && v.ReactEventListener.setEnabled(e); }, isEnabled: function () { return !(!v.ReactEventListener || !v.ReactEventListener.isEnabled()); }, listenTo: function (e, t) { for (var n = t, i = r(n), o = a.registrationNameDependencies[e], s = 0; s < o.length; s++) { + var u = o[s]; + i.hasOwnProperty(u) && i[u] || ("topWheel" === u ? c("wheel") ? v.ReactEventListener.trapBubbledEvent("topWheel", "wheel", n) : c("mousewheel") ? v.ReactEventListener.trapBubbledEvent("topWheel", "mousewheel", n) : v.ReactEventListener.trapBubbledEvent("topWheel", "DOMMouseScroll", n) : "topScroll" === u ? c("scroll", !0) ? v.ReactEventListener.trapCapturedEvent("topScroll", "scroll", n) : v.ReactEventListener.trapBubbledEvent("topScroll", "scroll", v.ReactEventListener.WINDOW_HANDLE) : "topFocus" === u || "topBlur" === u ? (c("focus", !0) ? (v.ReactEventListener.trapCapturedEvent("topFocus", "focus", n), v.ReactEventListener.trapCapturedEvent("topBlur", "blur", n)) : c("focusin") && (v.ReactEventListener.trapBubbledEvent("topFocus", "focusin", n), v.ReactEventListener.trapBubbledEvent("topBlur", "focusout", n)), i.topBlur = !0, i.topFocus = !0) : d.hasOwnProperty(u) && v.ReactEventListener.trapBubbledEvent(u, d[u], n), i[u] = !0); + } }, trapBubbledEvent: function (e, t, n) { return v.ReactEventListener.trapBubbledEvent(e, t, n); }, trapCapturedEvent: function (e, t, n) { return v.ReactEventListener.trapCapturedEvent(e, t, n); }, supportsEventPageXY: function () { if (!document.createEvent) + return !1; var e = document.createEvent("MouseEvent"); return null != e && "pageX" in e; }, ensureScrollValueMonitoring: function () { if (void 0 === i && (i = v.supportsEventPageXY()), !i && !f) { + var e = u.refreshScrollValues; + v.ReactEventListener.monitorScrollValue(e), f = !0; + } } }); + e.exports = v; + }, function (e, t, n) { + "use strict"; + function r(e, t, n, r) { return i.call(this, e, t, n, r); } + var i = n(123), o = n(477), a = n(257), s = { screenX: null, screenY: null, clientX: null, clientY: null, ctrlKey: null, shiftKey: null, altKey: null, metaKey: null, getModifierState: a, button: function (e) { var t = e.button; return "which" in e ? t : 2 === t ? 2 : 4 === t ? 1 : 0; }, buttons: null, relatedTarget: function (e) { return e.relatedTarget || (e.fromElement === e.srcElement ? e.toElement : e.fromElement); }, pageX: function (e) { return "pageX" in e ? e.pageX : e.clientX + o.currentScrollLeft; }, pageY: function (e) { return "pageY" in e ? e.pageY : e.clientY + o.currentScrollTop; } }; + i.augmentClass(r, s), e.exports = r; + }, function (e, t, n) { + "use strict"; + var r = n(11), i = (n(8), {}), o = { reinitializeTransaction: function () { this.transactionWrappers = this.getTransactionWrappers(), this.wrapperInitData ? this.wrapperInitData.length = 0 : this.wrapperInitData = [], this._isInTransaction = !1; }, _isInTransaction: !1, getTransactionWrappers: null, isInTransaction: function () { return !!this._isInTransaction; }, perform: function (e, t, n, i, o, a, s, u) { this.isInTransaction() && r("27"); var l, c; try { + this._isInTransaction = !0, l = !0, this.initializeAll(0), c = e.call(t, n, i, o, a, s, u), l = !1; + } + finally { + try { + if (l) + try { + this.closeAll(0); + } + catch (e) { } + else + this.closeAll(0); + } + finally { + this._isInTransaction = !1; + } + } return c; }, initializeAll: function (e) { for (var t = this.transactionWrappers, n = e; n < t.length; n++) { + var r = t[n]; + try { + this.wrapperInitData[n] = i, this.wrapperInitData[n] = r.initialize ? r.initialize.call(this) : null; + } + finally { + if (this.wrapperInitData[n] === i) + try { + this.initializeAll(n + 1); + } + catch (e) { } + } + } }, closeAll: function (e) { this.isInTransaction() || r("28"); for (var t = this.transactionWrappers, n = e; n < t.length; n++) { + var o, a = t[n], s = this.wrapperInitData[n]; + try { + o = !0, s !== i && a.close && a.close.call(this, s), o = !1; + } + finally { + if (o) + try { + this.closeAll(n + 1); + } + catch (e) { } + } + } this.wrapperInitData.length = 0; } }; + e.exports = o; + }, function (e, t, n) { + "use strict"; + function r(e) { var t = "" + e, n = o.exec(t); if (!n) + return t; var r, i = "", a = 0, s = 0; for (a = n.index; a < t.length; a++) { + switch (t.charCodeAt(a)) { + case 34: + r = """; + break; + case 38: + r = "&"; + break; + case 39: + r = "'"; + break; + case 60: + r = "<"; + break; + case 62: + r = ">"; + break; + default: continue; + } + s !== a && (i += t.substring(s, a)), s = a + 1, i += r; + } return s !== a ? i + t.substring(s, a) : i; } + function i(e) { return "boolean" == typeof e || "number" == typeof e ? "" + e : r(e); } + var o = /["'&<>]/; + e.exports = i; + }, function (e, t, n) { + "use strict"; + var r, i = n(26), o = n(247), a = /^[ \r\n\t\f]/, s = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/, u = n(255), l = u(function (e, t) { if (e.namespaceURI !== o.svg || "innerHTML" in e) + e.innerHTML = t; + else { + r = r || document.createElement("div"), r.innerHTML = "" + t + ""; + for (var n = r.firstChild; n.firstChild;) + e.appendChild(n.firstChild); + } }); + if (i.canUseDOM) { + var c = document.createElement("div"); + c.innerHTML = " ", "" === c.innerHTML && (l = function (e, t) { if (e.parentNode && e.parentNode.replaceChild(e, e), a.test(t) || "<" === t[0] && s.test(t)) { + e.innerHTML = String.fromCharCode(65279) + t; + var n = e.firstChild; + 1 === n.data.length ? e.removeChild(n) : n.deleteData(0, 1); + } + else + e.innerHTML = t; }), c = null; + } + e.exports = l; + }, function (e, t, n) { + "use strict"; + function r(e) { var t = {}; for (var n in e) + Object.prototype.hasOwnProperty.call(e, n) && (t[n] = "number" == typeof e[n] ? e[n] : e[n].val); return t; } + t.__esModule = !0, t.default = r, e.exports = t.default; + }, function (e, t, n) { + "use strict"; + e.exports = function (e, t) { var n, r, i, o = -1, a = e.posMax, s = e.pos, u = e.isInLabel; if (e.isInLabel) + return -1; if (e.labelUnmatchedScopes) + return e.labelUnmatchedScopes--, -1; for (e.pos = t + 1, e.isInLabel = !0, n = 1; e.pos < a;) { + if (91 === (i = e.src.charCodeAt(e.pos))) + n++; + else if (93 === i && 0 === --n) { + r = !0; + break; + } + e.parser.skipToken(e); + } return r ? (o = e.pos, e.labelUnmatchedScopes = 0) : e.labelUnmatchedScopes = n - 1, e.pos = s, e.isInLabel = u, o; }; + }, function (e, t, n) { + "use strict"; + function r() { this.__rules__ = [], this.__cache__ = null; } + r.prototype.__find__ = function (e) { for (var t = this.__rules__.length, n = -1; t--;) + if (this.__rules__[++n].name === e) + return n; return -1; }, r.prototype.__compile__ = function () { var e = this, t = [""]; e.__rules__.forEach(function (e) { e.enabled && e.alt.forEach(function (e) { t.indexOf(e) < 0 && t.push(e); }); }), e.__cache__ = {}, t.forEach(function (t) { e.__cache__[t] = [], e.__rules__.forEach(function (n) { n.enabled && (t && n.alt.indexOf(t) < 0 || e.__cache__[t].push(n.fn)); }); }); }, r.prototype.at = function (e, t, n) { var r = this.__find__(e), i = n || {}; if (-1 === r) + throw new Error("Parser rule not found: " + e); this.__rules__[r].fn = t, this.__rules__[r].alt = i.alt || [], this.__cache__ = null; }, r.prototype.before = function (e, t, n, r) { var i = this.__find__(e), o = r || {}; if (-1 === i) + throw new Error("Parser rule not found: " + e); this.__rules__.splice(i, 0, { name: t, enabled: !0, fn: n, alt: o.alt || [] }), this.__cache__ = null; }, r.prototype.after = function (e, t, n, r) { var i = this.__find__(e), o = r || {}; if (-1 === i) + throw new Error("Parser rule not found: " + e); this.__rules__.splice(i + 1, 0, { name: t, enabled: !0, fn: n, alt: o.alt || [] }), this.__cache__ = null; }, r.prototype.push = function (e, t, n) { var r = n || {}; this.__rules__.push({ name: e, enabled: !0, fn: t, alt: r.alt || [] }), this.__cache__ = null; }, r.prototype.enable = function (e, t) { e = Array.isArray(e) ? e : [e], t && this.__rules__.forEach(function (e) { e.enabled = !1; }), e.forEach(function (e) { var t = this.__find__(e); if (t < 0) + throw new Error("Rules manager: invalid rule name " + e); this.__rules__[t].enabled = !0; }, this), this.__cache__ = null; }, r.prototype.disable = function (e) { e = Array.isArray(e) ? e : [e], e.forEach(function (e) { var t = this.__find__(e); if (t < 0) + throw new Error("Rules manager: invalid rule name " + e); this.__rules__[t].enabled = !1; }, this), this.__cache__ = null; }, r.prototype.getRules = function (e) { return null === this.__cache__ && this.__compile__(), this.__cache__[e] || []; }, e.exports = r; + }, function (e, t, n) { function r(e, t) { for (var n in e) + t[n] = e[n]; } function i(e, t, n) { return a(e, t, n); } var o = n(44), a = o.Buffer; a.from && a.alloc && a.allocUnsafe && a.allocUnsafeSlow ? e.exports = o : (r(o, t), t.Buffer = i), r(a, i), i.from = function (e, t, n) { if ("number" == typeof e) + throw new TypeError("Argument must not be a number"); return a(e, t, n); }, i.alloc = function (e, t, n) { if ("number" != typeof e) + throw new TypeError("Argument must be a number"); var r = a(e); return void 0 !== t ? "string" == typeof n ? r.fill(t, n) : r.fill(t) : r.fill(0), r; }, i.allocUnsafe = function (e) { if ("number" != typeof e) + throw new TypeError("Argument must be a number"); return a(e); }, i.allocUnsafeSlow = function (e) { if ("number" != typeof e) + throw new TypeError("Argument must be a number"); return o.SlowBuffer(e); }; }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + function i(e) { return { type: b, payload: e }; } + function o(e) { return { type: x, payload: e }; } + function a(e) { return { type: w, payload: e }; } + function s(e) { return { type: k, payload: e }; } + function u(e) { return { type: E, payload: e }; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.authorizeRequest = t.authorizeAccessCodeWithBasicAuthentication = t.authorizeAccessCodeWithFormParams = t.authorizeApplication = t.authorizePassword = t.preAuthorizeImplicit = t.CONFIGURE_AUTH = t.VALIDATE = t.AUTHORIZE_OAUTH2 = t.PRE_AUTHORIZE_OAUTH2 = t.LOGOUT = t.AUTHORIZE = t.SHOW_AUTH_POPUP = void 0; + var l = n(43), c = r(l), p = n(23), f = r(p), h = n(37), d = r(h); + t.showDefinitions = i, t.authorize = o, t.logout = a, t.authorizeOauth2 = s, t.configureAuth = u; + var m = n(514), v = r(m), g = n(36), y = r(g), _ = n(9), b = t.SHOW_AUTH_POPUP = "show_popup", x = t.AUTHORIZE = "authorize", w = t.LOGOUT = "logout", k = (t.PRE_AUTHORIZE_OAUTH2 = "pre_authorize_oauth2", t.AUTHORIZE_OAUTH2 = "authorize_oauth2"), E = (t.VALIDATE = "validate", t.CONFIGURE_AUTH = "configure_auth"); + t.preAuthorizeImplicit = function (e) { return function (t) { var n = t.authActions, r = t.errActions, i = e.auth, o = e.token, a = e.isValid, s = i.schema, u = i.name, l = s.get("flow"); if (delete y.default.swaggerUIRedirectOauth2, "accessCode" === l || a || r.newAuthErr({ authId: u, source: "auth", level: "warning", message: "Authorization may be unsafe, passed state was changed in server Passed state wasn't returned from auth server" }), o.error) + return void r.newAuthErr({ authId: u, source: "auth", level: "error", message: (0, d.default)(o) }); n.authorizeOauth2({ auth: i, token: o }); }; }, t.authorizePassword = function (e) { return function (t) { var n = t.authActions, r = e.schema, i = e.name, o = e.username, a = e.password, s = e.passwordType, u = e.clientId, l = e.clientSecret, c = { grant_type: "password", scope: e.scopes.join(" ") }, p = {}, h = {}; return "basic" === s ? h.Authorization = "Basic " + (0, _.btoa)(o + ":" + a) : ((0, f.default)(c, { username: o }, { password: a }), "query" === s ? (u && (p.client_id = u), l && (p.client_secret = l)) : h.Authorization = "Basic " + (0, _.btoa)(u + ":" + l)), n.authorizeRequest({ body: (0, _.buildFormData)(c), url: r.get("tokenUrl"), name: i, headers: h, query: p, auth: e }); }; }, t.authorizeApplication = function (e) { return function (t) { var n = t.authActions, r = e.schema, i = e.scopes, o = e.name, a = e.clientId, s = e.clientSecret, u = { Authorization: "Basic " + (0, _.btoa)(a + ":" + s) }, l = { grant_type: "client_credentials", scope: i.join(" ") }; return n.authorizeRequest({ body: (0, _.buildFormData)(l), name: o, url: r.get("tokenUrl"), auth: e, headers: u }); }; }, t.authorizeAccessCodeWithFormParams = function (e) { var t = e.auth, n = e.redirectUrl; return function (e) { var r = e.authActions, i = t.schema, o = t.name, a = t.clientId, s = t.clientSecret, u = { grant_type: "authorization_code", code: t.code, client_id: a, client_secret: s, redirect_uri: n }; return r.authorizeRequest({ body: (0, _.buildFormData)(u), name: o, url: i.get("tokenUrl"), auth: t }); }; }, t.authorizeAccessCodeWithBasicAuthentication = function (e) { var t = e.auth, n = e.redirectUrl; return function (e) { var r = e.authActions, i = t.schema, o = t.name, a = t.clientId, s = t.clientSecret, u = { Authorization: "Basic " + (0, _.btoa)(a + ":" + s) }, l = { grant_type: "authorization_code", code: t.code, client_id: a, redirect_uri: n }; return r.authorizeRequest({ body: (0, _.buildFormData)(l), name: o, url: i.get("tokenUrl"), auth: t, headers: u }); }; }, t.authorizeRequest = function (e) { return function (t) { var n = t.fn, r = t.getConfigs, i = t.authActions, o = t.errActions, a = t.oas3Selectors, s = t.specSelectors, u = t.authSelectors, l = e.body, p = e.query, h = void 0 === p ? {} : p, m = e.headers, g = void 0 === m ? {} : m, y = e.name, _ = e.url, b = e.auth, x = u.getConfigs() || {}, w = x.additionalQueryStringParams, k = void 0; k = s.isOAS3() ? (0, v.default)(_, a.selectedServer(), !0) : (0, v.default)(_, s.url(), !0), "object" === (void 0 === w ? "undefined" : (0, c.default)(w)) && (k.query = (0, f.default)({}, k.query, w)); var E = k.toString(), S = (0, f.default)({ Accept: "application/json, text/plain, */*", "Content-Type": "application/x-www-form-urlencoded" }, g); n.fetch({ url: E, method: "post", headers: S, query: h, body: l, requestInterceptor: r().requestInterceptor, responseInterceptor: r().responseInterceptor }).then(function (e) { var t = JSON.parse(e.data), n = t && (t.error || ""), r = t && (t.parseError || ""); return e.ok ? n || r ? void o.newAuthErr({ authId: y, level: "error", source: "auth", message: (0, d.default)(t) }) : void i.authorizeOauth2({ auth: b, token: t }) : void o.newAuthErr({ authId: y, level: "error", source: "auth", message: e.statusText }); }).catch(function (e) { var t = new Error(e); o.newAuthErr({ authId: y, level: "error", source: "auth", message: t.message }); }); }; }; + }, function (e, t, n) { + "use strict"; + function r(e, t) { return { type: s, payload: (0, a.default)({}, e, t) }; } + function i(e) { return { type: u, payload: e }; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.TOGGLE_CONFIGS = t.UPDATE_CONFIGS = void 0; + var o = n(28), a = function (e) { return e && e.__esModule ? e : { default: e }; }(o); + t.update = r, t.toggle = i; + var s = t.UPDATE_CONFIGS = "configs_update", u = t.TOGGLE_CONFIGS = "configs_toggle"; + }, function (e, t, n) { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), t.parseYamlConfig = void 0; + var r = n(217), i = function (e) { return e && e.__esModule ? e : { default: e }; }(r); + t.parseYamlConfig = function (e, t) { try { + return i.default.safeLoad(e); + } + catch (e) { + return t && t.errActions.newThrownErr(new Error(e)), {}; + } }; + }, function (e, t, n) { + "use strict"; + function r(e) { return { type: u, payload: e }; } + function i(e) { return { type: l, payload: e }; } + function o(e) { var t = !(arguments.length > 1 && void 0 !== arguments[1]) || arguments[1]; return e = (0, s.normalizeArray)(e), { type: p, payload: { thing: e, shown: t } }; } + function a(e) { var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : ""; return e = (0, s.normalizeArray)(e), { type: c, payload: { thing: e, mode: t } }; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.SHOW = t.UPDATE_MODE = t.UPDATE_FILTER = t.UPDATE_LAYOUT = void 0, t.updateLayout = r, t.updateFilter = i, t.show = o, t.changeMode = a; + var s = n(9), u = t.UPDATE_LAYOUT = "layout_update_layout", l = t.UPDATE_FILTER = "layout_update_filter", c = t.UPDATE_MODE = "layout_update_mode", p = t.SHOW = "layout_show"; + }, function (e, t, n) { + "use strict"; + function r(e, t) { return { type: u, payload: { selectedServerUrl: e, namespace: t } }; } + function i(e) { var t = e.value, n = e.pathMethod; return { type: l, payload: { value: t, pathMethod: n } }; } + function o(e) { var t = e.value, n = e.pathMethod; return { type: c, payload: { value: t, pathMethod: n } }; } + function a(e) { var t = e.value, n = e.path, r = e.method; return { type: p, payload: { value: t, path: n, method: r } }; } + function s(e) { var t = e.server, n = e.namespace, r = e.key, i = e.val; return { type: f, payload: { server: t, namespace: n, key: r, val: i } }; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.setSelectedServer = r, t.setRequestBodyValue = i, t.setRequestContentType = o, t.setResponseContentType = a, t.setServerVariableValue = s; + var u = t.UPDATE_SELECTED_SERVER = "oas3_set_servers", l = t.UPDATE_REQUEST_BODY_VALUE = "oas3_set_request_body_value", c = t.UPDATE_REQUEST_CONTENT_TYPE = "oas3_set_request_content_type", p = t.UPDATE_RESPONSE_CONTENT_TYPE = "oas3_set_response_content_type", f = t.UPDATE_SERVER_VARIABLE_VALUE = "oas3_set_server_variable_value"; + }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + function i(e, t) { var n = h(e, t); if (n) + return (0, s.default)(n, { declaration: !0, indent: "\t" }); } + Object.defineProperty(t, "__esModule", { value: !0 }), t.memoizedSampleFromSchema = t.memoizedCreateXMLExample = t.sampleXmlFromSchema = t.inferSchema = t.sampleFromSchema = void 0, t.createXMLExample = i; + var o = n(9), a = n(1217), s = r(a), u = n(987), l = r(u), c = { string: function () { return "string"; }, string_email: function () { return "user@example.com"; }, "string_date-time": function () { return (new Date).toISOString(); }, number: function () { return 0; }, number_float: function () { return 0; }, integer: function () { return 0; }, boolean: function (e) { return "boolean" != typeof e.default || e.default; } }, p = function (e) { e = (0, o.objectify)(e); var t = e, n = t.type, r = t.format, i = c[n + "_" + r] || c[n]; return (0, o.isFunc)(i) ? i(e) : "Unknown Type: " + e.type; }, f = t.sampleFromSchema = function e(t) { var n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {}, r = (0, o.objectify)(t), i = r.type, a = r.example, s = r.properties, u = r.additionalProperties, l = r.items, c = n.includeReadOnly, f = n.includeWriteOnly; if (void 0 !== a) + return (0, o.deeplyStripKey)(a, "$$ref", function (e) { return "string" == typeof e && e.indexOf("#") > -1; }); if (!i) + if (s) + i = "object"; + else { + if (!l) + return; + i = "array"; + } if ("object" === i) { + var h = (0, o.objectify)(s), d = {}; + for (var m in h) + h[m].readOnly && !c || h[m].writeOnly && !f || (d[m] = e(h[m], n)); + if (!0 === u) + d.additionalProp1 = {}; + else if (u) + for (var v = (0, o.objectify)(u), g = e(v, n), y = 1; y < 4; y++) + d["additionalProp" + y] = g; + return d; + } return "array" === i ? Array.isArray(l.anyOf) ? l.anyOf.map(function (t) { return e(t, n); }) : Array.isArray(l.oneOf) ? l.oneOf.map(function (t) { return e(t, n); }) : [e(l, n)] : t.enum ? t.default ? t.default : (0, o.normalizeArray)(t.enum)[0] : "file" !== i ? p(t) : void 0; }, h = (t.inferSchema = function (e) { return e.schema && (e = e.schema), e.properties && (e.type = "object"), e; }, t.sampleXmlFromSchema = function e(t) { var n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {}, r = (0, o.objectify)(t), i = r.type, a = r.properties, s = r.additionalProperties, u = r.items, l = r.example, c = n.includeReadOnly, f = n.includeWriteOnly, h = r.default, d = {}, m = {}, v = t.xml, g = v.name, y = v.prefix, _ = v.namespace, b = r.enum, x = void 0, w = void 0; if (!i) + if (a || s) + i = "object"; + else { + if (!u) + return; + i = "array"; + } if (g = g || "notagname", x = (y ? y + ":" : "") + g, _) { + m[y ? "xmlns:" + y : "xmlns"] = _; + } if ("array" === i && u) { + if (u.xml = u.xml || v || {}, u.xml.name = u.xml.name || v.name, v.wrapped) + return d[x] = [], Array.isArray(l) ? l.forEach(function (t) { u.example = t, d[x].push(e(u, n)); }) : Array.isArray(h) ? h.forEach(function (t) { u.default = t, d[x].push(e(u, n)); }) : d[x] = [e(u, n)], m && d[x].push({ _attr: m }), d; + var k = []; + return Array.isArray(l) ? (l.forEach(function (t) { u.example = t, k.push(e(u, n)); }), k) : Array.isArray(h) ? (h.forEach(function (t) { u.default = t, k.push(e(u, n)); }), k) : e(u, n); + } if ("object" === i) { + var E = (0, o.objectify)(a); + d[x] = [], l = l || {}; + for (var S in E) + if (E.hasOwnProperty(S) && (!E[S].readOnly || c) && (!E[S].writeOnly || f)) + if (E[S].xml = E[S].xml || {}, E[S].xml.attribute) { + var C = Array.isArray(E[S].enum) && E[S].enum[0], A = E[S].example, D = E[S].default; + m[E[S].xml.name || S] = void 0 !== A && A || void 0 !== l[S] && l[S] || void 0 !== D && D || C || p(E[S]); + } + else { + E[S].xml.name = E[S].xml.name || S, void 0 === E[S].example && void 0 !== l[S] && (E[S].example = l[S]); + var O = e(E[S]); + Array.isArray(O) ? d[x] = d[x].concat(O) : d[x].push(O); + } + return !0 === s ? d[x].push({ additionalProp: "Anything can be here" }) : s && d[x].push({ additionalProp: p(s) }), m && d[x].push({ _attr: m }), d; + } return w = void 0 !== l ? l : void 0 !== h ? h : Array.isArray(b) ? b[0] : p(t), d[x] = m ? [{ _attr: m }, w] : w, d; }); + t.memoizedCreateXMLExample = (0, l.default)(i), t.memoizedSampleFromSchema = (0, l.default)(f); + }, function (e, t, n) { + "use strict"; + function r(e) { return e && e.__esModule ? e : { default: e }; } + function i(e) { var t = se(e).replace(/\t/g, " "); if ("string" == typeof e) + return { type: H, payload: t }; } + function o(e) { return { type: ie, payload: e }; } + function a(e) { return { type: J, payload: e }; } + function s(e) { return { type: G, payload: e }; } + function u(e, t, n, r, i) { return { type: Y, payload: { path: e, value: r, paramName: t, paramIn: n, isXml: i } }; } + function l(e) { return { type: ne, payload: { pathMethod: e } }; } + function c(e, t) { return { type: re, payload: { path: e, value: t, key: "consumes_value" } }; } + function p(e, t) { return { type: re, payload: { path: e, value: t, key: "produces_value" } }; } + function f(e, t) { return { type: ee, payload: { path: e, method: t } }; } + function h(e, t) { return { type: te, payload: { path: e, method: t } }; } + function d(e, t, n) { return { type: ae, payload: { scheme: e, path: t, method: n } }; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.execute = t.executeRequest = t.logRequest = t.setMutatedRequest = t.setRequest = t.setResponse = t.validateParams = t.invalidateResolvedSubtreeCache = t.updateResolvedSubtree = t.requestResolvedSubtree = t.resolveSpec = t.parseToJson = t.SET_SCHEME = t.UPDATE_RESOLVED_SUBTREE = t.UPDATE_RESOLVED = t.UPDATE_OPERATION_META_VALUE = t.CLEAR_VALIDATE_PARAMS = t.CLEAR_REQUEST = t.CLEAR_RESPONSE = t.LOG_REQUEST = t.SET_MUTATED_REQUEST = t.SET_REQUEST = t.SET_RESPONSE = t.VALIDATE_PARAMS = t.UPDATE_PARAM = t.UPDATE_JSON = t.UPDATE_URL = t.UPDATE_SPEC = void 0; + var m = n(20), v = r(m), g = n(97), y = r(g), _ = n(23), b = r(_), x = n(42), w = r(x), k = n(127), E = r(k), S = n(342), C = r(S), A = n(341), D = r(A), O = n(43), M = r(O); + t.updateSpec = i, t.updateResolved = o, t.updateUrl = a, t.updateJsonSpec = s, t.changeParam = u, t.clearValidateParams = l, t.changeConsumesValue = c, t.changeProducesValue = p, t.clearResponse = f, t.clearRequest = h, t.setScheme = d; + var T = n(217), P = r(T), I = n(7), R = n(514), j = r(R), N = n(270), F = r(N), B = n(436), L = r(B), q = n(961), z = r(q), U = n(974), W = r(U), V = n(9), H = t.UPDATE_SPEC = "spec_update_spec", J = t.UPDATE_URL = "spec_update_url", G = t.UPDATE_JSON = "spec_update_json", Y = t.UPDATE_PARAM = "spec_update_param", K = t.VALIDATE_PARAMS = "spec_validate_param", X = t.SET_RESPONSE = "spec_set_response", $ = t.SET_REQUEST = "spec_set_request", Z = t.SET_MUTATED_REQUEST = "spec_set_mutated_request", Q = t.LOG_REQUEST = "spec_log_request", ee = t.CLEAR_RESPONSE = "spec_clear_response", te = t.CLEAR_REQUEST = "spec_clear_request", ne = t.CLEAR_VALIDATE_PARAMS = "spec_clear_validate_param", re = t.UPDATE_OPERATION_META_VALUE = "spec_update_operation_meta_value", ie = t.UPDATE_RESOLVED = "spec_update_resolved", oe = t.UPDATE_RESOLVED_SUBTREE = "spec_update_resolved_subtree", ae = t.SET_SCHEME = "set_scheme", se = function (e) { return (0, L.default)(e) ? e : ""; }, ue = (t.parseToJson = function (e) { return function (t) { var n = t.specActions, r = t.specSelectors, i = t.errActions, o = r.specStr, a = null; try { + e = e || o(), i.clear({ source: "parser" }), a = P.default.safeLoad(e); + } + catch (e) { + return console.error(e), i.newSpecErr({ source: "parser", level: "error", message: e.reason, line: e.mark && e.mark.line ? e.mark.line + 1 : void 0 }); + } return a && "object" === (void 0 === a ? "undefined" : (0, M.default)(a)) ? n.updateJsonSpec(a) : {}; }; }, !1), le = (t.resolveSpec = function (e, t) { return function (n) { var r = n.specActions, i = n.specSelectors, o = n.errActions, a = n.fn, s = a.fetch, u = a.resolve, l = a.AST, c = n.getConfigs; ue || (console.warn("specActions.resolveSpec is deprecated since v3.10.0 and will be removed in v4.0.0; use requestResolvedSubtree instead!"), ue = !0); var p = c(), f = p.modelPropertyMacro, h = p.parameterMacro, d = p.requestInterceptor, m = p.responseInterceptor; void 0 === e && (e = i.specJson()), void 0 === t && (t = i.url()); var v = l.getLineNumberForPath, g = i.specStr(); return u({ fetch: s, spec: e, baseDoc: t, modelPropertyMacro: f, parameterMacro: h, requestInterceptor: d, responseInterceptor: m }).then(function (e) { var t = e.spec, n = e.errors; if (o.clear({ type: "thrown" }), Array.isArray(n) && n.length > 0) { + var i = n.map(function (e) { return console.error(e), e.line = e.fullPath ? v(g, e.fullPath) : null, e.path = e.fullPath ? e.fullPath.join(".") : null, e.level = "error", e.type = "thrown", e.source = "resolver", Object.defineProperty(e, "message", { enumerable: !0, value: e.message }), e; }); + o.newThrownErrBatch(i); + } return r.updateResolved(t); }); }; }, []), ce = (0, z.default)((0, D.default)(C.default.mark(function e() { var t, n, r, i, o, a, s, u, l, c, p, f, h, d, m; return C.default.wrap(function (e) { for (;;) + switch (e.prev = e.next) { + case 0: + if (t = le.system) { + e.next = 4; + break; + } + return console.error("debResolveSubtrees: don't have a system to operate on, aborting."), e.abrupt("return"); + case 4: + if (n = t.errActions, r = t.errSelectors, i = t.fn, o = i.resolveSubtree, a = i.AST.getLineNumberForPath, s = t.specSelectors, u = t.specActions, o) { + e.next = 8; + break; + } + return console.error("Error: Swagger-Client did not provide a `resolveSubtree` method, doing nothing."), e.abrupt("return"); + case 8: return l = s.specStr(), c = t.getConfigs(), p = c.modelPropertyMacro, f = c.parameterMacro, h = c.requestInterceptor, d = c.responseInterceptor, e.prev = 10, e.next = 13, le.reduce(function () { var e = (0, D.default)(C.default.mark(function e(t, i) { var u, c, m, v, g, y, _; return C.default.wrap(function (e) { for (;;) + switch (e.prev = e.next) { + case 0: return e.next = 2, t; + case 2: return u = e.sent, c = u.resultMap, m = u.specWithCurrentSubtrees, e.next = 7, o(m, i, { baseDoc: s.url(), modelPropertyMacro: p, parameterMacro: f, requestInterceptor: h, responseInterceptor: d }); + case 7: return v = e.sent, g = v.errors, y = v.spec, r.allErrors().size && n.clear({ type: "thrown" }), Array.isArray(g) && g.length > 0 && (_ = g.map(function (e) { return e.line = e.fullPath ? a(l, e.fullPath) : null, e.path = e.fullPath ? e.fullPath.join(".") : null, e.level = "error", e.type = "thrown", e.source = "resolver", Object.defineProperty(e, "message", { enumerable: !0, value: e.message }), e; }), n.newThrownErrBatch(_)), (0, W.default)(c, i, y), (0, W.default)(m, i, y), e.abrupt("return", { resultMap: c, specWithCurrentSubtrees: m }); + case 15: + case "end": return e.stop(); + } }, e, void 0); })); return function (t, n) { return e.apply(this, arguments); }; }(), E.default.resolve({ resultMap: (s.specResolvedSubtree([]) || (0, I.Map)()).toJS(), specWithCurrentSubtrees: s.specJson().toJS() })); + case 13: + m = e.sent, delete le.system, le = [], e.next = 21; + break; + case 18: e.prev = 18, e.t0 = e.catch(10), console.error(e.t0); + case 21: u.updateResolvedSubtree([], m.resultMap); + case 22: + case "end": return e.stop(); + } }, e, void 0, [[10, 18]]); })), 35), pe = (t.requestResolvedSubtree = function (e) { return function (t) { le.push(e), le.system = t, ce(); }; }, t.updateResolvedSubtree = function (e, t) { return { type: oe, payload: { path: e, value: t } }; }, t.invalidateResolvedSubtreeCache = function () { return { type: oe, payload: { path: [], value: (0, I.Map)() } }; }, t.validateParams = function (e, t) { return { type: K, payload: { pathMethod: e, isOAS3: t } }; }, t.setResponse = function (e, t, n) { return { payload: { path: e, method: t, res: n }, type: X }; }, t.setRequest = function (e, t, n) { return { payload: { path: e, method: t, req: n }, type: $ }; }, t.setMutatedRequest = function (e, t, n) { return { payload: { path: e, method: t, req: n }, type: Z }; }, t.logRequest = function (e) { return { payload: e, type: Q }; }, t.executeRequest = function (e) { return function (t) { var n = t.fn, r = t.specActions, i = t.specSelectors, o = t.getConfigs, a = t.oas3Selectors, s = e.pathName, u = e.method, l = e.operation, c = o(), p = c.requestInterceptor, f = c.responseInterceptor, h = l.toJS(); if (e.contextUrl = (0, j.default)(i.url()).toString(), h && h.operationId ? e.operationId = h.operationId : h && s && u && (e.operationId = n.opId(h, s, u)), i.isOAS3()) { + var d = s + ":" + u; + e.server = a.selectedServer(d) || a.selectedServer(); + var m = a.serverVariables({ server: e.server, namespace: d }).toJS(), v = a.serverVariables({ server: e.server }).toJS(); + e.serverVariables = (0, w.default)(m).length ? m : v, e.requestContentType = a.requestContentType(s, u), e.responseContentType = a.responseContentType(s, u) || "*/*"; + var g = a.requestBodyValue(s, u); + (0, V.isJSONObject)(g) ? e.requestBody = JSON.parse(g) : e.requestBody = g; + } var y = (0, b.default)({}, e); y = n.buildRequest(y), r.setRequest(e.pathName, e.method, y); var _ = function (t) { var n = p.apply(this, [t]), i = (0, b.default)({}, n); return r.setMutatedRequest(e.pathName, e.method, i), n; }; e.requestInterceptor = _, e.responseInterceptor = f; var x = Date.now(); return n.execute(e).then(function (t) { t.duration = Date.now() - x, r.setResponse(e.pathName, e.method, t); }).catch(function (t) { return r.setResponse(e.pathName, e.method, { error: !0, err: (0, F.default)(t) }); }); }; }, function () { var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, t = e.path, n = e.method, r = (0, y.default)(e, ["path", "method"]); return function (e) { var i = e.fn.fetch, o = e.specSelectors, a = e.specActions, s = o.specJsonWithResolvedSubtrees().toJS(), u = o.operationScheme(t, n), l = o.contentTypeValues([t, n]).toJS(), c = l.requestContentType, p = l.responseContentType, f = /xml/i.test(c), h = o.parameterValues([t, n], f).toJS(); return a.executeRequest((0, v.default)({}, r, { fetch: i, spec: s, pathName: t, method: n, parameters: h, requestContentType: c, scheme: u, responseContentType: p })); }; }); + t.execute = pe; + }, function (e, t, n) { + "use strict"; + function r(e, t, n, r) { return t = t || [], e.getIn(["meta", "paths"].concat((0, f.default)(t), ["parameters"]), (0, m.fromJS)([])).find(function (e) { return m.Map.isMap(e) && e.get("name") === n && e.get("in") === r; }) || (0, m.Map)(); } + function i(e, t, n) { return t = t || [], j.apply(void 0, [e].concat((0, f.default)(t))).get("parameters", (0, m.List)()).reduce(function (e, t) { var r = n && "body" === t.get("in") ? t.get("value_xml") : t.get("value"); return e.set(t.get("in") + "." + t.get("name"), r); }, (0, m.fromJS)({})); } + function o(e) { var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : ""; if (m.List.isList(e)) + return e.some(function (e) { return m.Map.isMap(e) && e.get("in") === t; }); } + function a(e) { var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : ""; if (m.List.isList(e)) + return e.some(function (e) { return m.Map.isMap(e) && e.get("type") === t; }); } + function s(e, t) { t = t || []; var n = b(e).getIn(["paths"].concat((0, f.default)(t)), (0, m.fromJS)({})), r = e.getIn(["meta", "paths"].concat((0, f.default)(t)), (0, m.fromJS)({})), i = l(e, t), o = n.get("parameters") || new m.List, s = r.get("consumes_value") ? r.get("consumes_value") : a(o, "file") ? "multipart/form-data" : a(o, "formData") ? "application/x-www-form-urlencoded" : void 0; return (0, m.fromJS)({ requestContentType: s, responseContentType: i }); } + function u(e, t) { return t = t || [], b(e).getIn(["paths"].concat((0, f.default)(t), ["consumes"]), (0, m.fromJS)({})); } + function l(e, t) { t = t || []; var n = b(e).getIn(["paths"].concat((0, f.default)(t)), null); if (null !== n) { + var r = e.getIn(["meta", "paths"].concat((0, f.default)(t), ["produces_value"]), null), i = n.getIn(["produces", 0], null); + return r || i || "application/json"; + } } + function c(e) { return m.Map.isMap(e) ? e : new m.Map; } + Object.defineProperty(t, "__esModule", { value: !0 }), t.validateBeforeExecute = t.canExecuteScheme = t.operationScheme = t.hasHost = t.parameterWithMeta = t.operationWithMeta = t.allowTryItOutFor = t.mutatedRequestFor = t.requestFor = t.responseFor = t.mutatedRequests = t.requests = t.responses = t.taggedOperations = t.operationsWithTags = t.tagDetails = t.tags = t.operationsWithRootInherited = t.schemes = t.host = t.basePath = t.definitions = t.findDefinition = t.securityDefinitions = t.security = t.produces = t.consumes = t.operations = t.paths = t.semver = t.version = t.externalDocs = t.info = t.isOAS3 = t.spec = t.specJsonWithResolvedSubtrees = t.specResolvedSubtree = t.specResolved = t.specJson = t.specSource = t.specStr = t.url = t.lastError = void 0; + var p = n(72), f = function (e) { return e && e.__esModule ? e : { default: e }; }(p); + t.getParameter = r, t.parameterValues = i, t.parametersIncludeIn = o, t.parametersIncludeType = a, t.contentTypeValues = s, t.operationConsumes = u, t.currentProducesFor = l; + var h = n(60), d = n(9), m = n(7), v = ["get", "put", "post", "delete", "options", "head", "patch", "trace"], g = function (e) { return e || (0, m.Map)(); }, y = (t.lastError = (0, h.createSelector)(g, function (e) { return e.get("lastError"); }), t.url = (0, h.createSelector)(g, function (e) { return e.get("url"); }), t.specStr = (0, h.createSelector)(g, function (e) { return e.get("spec") || ""; }), t.specSource = (0, h.createSelector)(g, function (e) { return e.get("specSource") || "not-editor"; }), t.specJson = (0, h.createSelector)(g, function (e) { return e.get("json", (0, m.Map)()); })), _ = (t.specResolved = (0, h.createSelector)(g, function (e) { return e.get("resolved", (0, m.Map)()); }), t.specResolvedSubtree = function (e, t) { return e.getIn(["resolvedSubtrees"].concat((0, f.default)(t)), void 0); }, function e(t, n) { return m.Map.isMap(t) && m.Map.isMap(n) ? n.get("$$ref") ? n : (0, m.OrderedMap)().mergeWith(e, t, n) : n; }), b = t.specJsonWithResolvedSubtrees = (0, h.createSelector)(g, function (e) { return (0, m.OrderedMap)().mergeWith(_, e.get("json"), e.get("resolvedSubtrees")); }), x = t.spec = function (e) { return y(e); }, w = (t.isOAS3 = (0, h.createSelector)(x, function () { return !1; }), t.info = (0, h.createSelector)(x, function (e) { return c(e && e.get("info")); })), k = (t.externalDocs = (0, h.createSelector)(x, function (e) { return c(e && e.get("externalDocs")); }), t.version = (0, h.createSelector)(w, function (e) { return e && e.get("version"); })), E = (t.semver = (0, h.createSelector)(k, function (e) { return /v?([0-9]*)\.([0-9]*)\.([0-9]*)/i.exec(e).slice(1); }), t.paths = (0, h.createSelector)(b, function (e) { return e.get("paths"); })), S = t.operations = (0, h.createSelector)(E, function (e) { if (!e || e.size < 1) + return (0, m.List)(); var t = (0, m.List)(); return e && e.forEach ? (e.forEach(function (e, n) { if (!e || !e.forEach) + return {}; e.forEach(function (e, r) { v.indexOf(r) < 0 || (t = t.push((0, m.fromJS)({ path: n, method: r, operation: e, id: r + "-" + n }))); }); }), t) : (0, m.List)(); }), C = t.consumes = (0, h.createSelector)(x, function (e) { return (0, m.Set)(e.get("consumes")); }), A = t.produces = (0, h.createSelector)(x, function (e) { return (0, m.Set)(e.get("produces")); }), D = (t.security = (0, h.createSelector)(x, function (e) { return e.get("security", (0, m.List)()); }), t.securityDefinitions = (0, h.createSelector)(x, function (e) { return e.get("securityDefinitions"); }), t.findDefinition = function (e, t) { var n = e.getIn(["resolvedSubtrees", "definitions", t], null), r = e.getIn(["json", "definitions", t], null); return n || r || null; }, t.definitions = (0, h.createSelector)(x, function (e) { return e.get("definitions") || (0, m.Map)(); }), t.basePath = (0, h.createSelector)(x, function (e) { return e.get("basePath"); }), t.host = (0, h.createSelector)(x, function (e) { return e.get("host"); }), t.schemes = (0, h.createSelector)(x, function (e) { return e.get("schemes", (0, m.Map)()); }), t.operationsWithRootInherited = (0, h.createSelector)(S, C, A, function (e, t, n) { return e.map(function (e) { return e.update("operation", function (e) { if (e) { + if (!m.Map.isMap(e)) + return; + return e.withMutations(function (e) { return e.get("consumes") || e.update("consumes", function (e) { return (0, m.Set)(e).merge(t); }), e.get("produces") || e.update("produces", function (e) { return (0, m.Set)(e).merge(n); }), e; }); + } return (0, m.Map)(); }); }); })), O = t.tags = (0, h.createSelector)(x, function (e) { return e.get("tags", (0, m.List)()); }), M = t.tagDetails = function (e, t) { return (O(e) || (0, m.List)()).filter(m.Map.isMap).find(function (e) { return e.get("name") === t; }, (0, m.Map)()); }, T = t.operationsWithTags = (0, h.createSelector)(D, O, function (e, t) { return e.reduce(function (e, t) { var n = (0, m.Set)(t.getIn(["operation", "tags"])); return n.count() < 1 ? e.update("default", (0, m.List)(), function (e) { return e.push(t); }) : n.reduce(function (e, n) { return e.update(n, (0, m.List)(), function (e) { return e.push(t); }); }, e); }, t.reduce(function (e, t) { return e.set(t.get("name"), (0, m.List)()); }, (0, m.OrderedMap)())); }), P = (t.taggedOperations = function (e) { return function (t) { var n = t.getConfigs, r = n(), i = r.tagsSorter, o = r.operationsSorter; return T(e).sortBy(function (e, t) { return t; }, function (e, t) { var n = "function" == typeof i ? i : d.sorters.tagsSorter[i]; return n ? n(e, t) : null; }).map(function (t, n) { var r = "function" == typeof o ? o : d.sorters.operationsSorter[o], i = r ? t.sort(r) : t; return (0, m.Map)({ tagDetails: M(e, n), operations: i }); }); }; }, t.responses = (0, h.createSelector)(g, function (e) { return e.get("responses", (0, m.Map)()); })), I = t.requests = (0, h.createSelector)(g, function (e) { return e.get("requests", (0, m.Map)()); }), R = t.mutatedRequests = (0, h.createSelector)(g, function (e) { return e.get("mutatedRequests", (0, m.Map)()); }), j = (t.responseFor = function (e, t, n) { return P(e).getIn([t, n], null); }, t.requestFor = function (e, t, n) { return I(e).getIn([t, n], null); }, t.mutatedRequestFor = function (e, t, n) { return R(e).getIn([t, n], null); }, t.allowTryItOutFor = function () { return !0; }, t.operationWithMeta = function (e, t, n) { var r = b(e).getIn(["paths", t, n], (0, m.Map)()), i = e.getIn(["meta", "paths", t, n], (0, m.Map)()), o = r.get("parameters", (0, m.List)()).map(function (e) { return (0, m.Map)().merge(e, i.getIn(["parameters", e.get("name") + "." + e.get("in")])); }); return (0, m.Map)().merge(r, i).set("parameters", o); }), N = (t.parameterWithMeta = function (e, t, n, r) { var i = b(e).getIn(["paths"].concat((0, f.default)(t), ["parameters"]), (0, m.Map)()), o = e.getIn(["meta", "paths"].concat((0, f.default)(t), ["parameters"]), (0, m.Map)()); return i.map(function (e) { return (0, m.Map)().merge(e, o.get(e.get("name") + "." + e.get("in"))); }).find(function (e) { return e.get("in") === r && e.get("name") === n; }, (0, m.Map)()); }, t.hasHost = (0, h.createSelector)(x, function (e) { var t = e.get("host"); return "string" == typeof t && t.length > 0 && "/" !== t[0]; }), t.operationScheme = function (e, t, n) { var r = e.get("url"), i = r.match(/^([a-z][a-z0-9+\-.]*):/), o = Array.isArray(i) ? i[1] : null; return e.getIn(["scheme", t, n]) || e.getIn(["scheme", "_defaultScheme"]) || o || ""; }); + t.canExecuteScheme = function (e, t, n) { return ["http", "https"].indexOf(N(e, t, n)) > -1; }, t.validateBeforeExecute = function (e, t) { t = t || []; var n = e.getIn(["meta", "paths"].concat((0, f.default)(t), ["parameters"]), (0, m.fromJS)([])), r = !0; return n.forEach(function (e) { var t = e.get("errors"); t && t.count() && (r = !1); }), r; }; + }, function (e, t, n) { + var r, i; /*! + Copyright (c) 2016 Jed Watson. + Licensed under the MIT License (MIT), see + http://jedwatson.github.io/classnames + */ + !function () { + "use strict"; + function n() { for (var e = [], t = 0; t < arguments.length; t++) { + var r = arguments[t]; + if (r) { + var i = typeof r; + if ("string" === i || "number" === i) + e.push(r); + else if (Array.isArray(r)) + e.push(n.apply(null, r)); + else if ("object" === i) + for (var a in r) + o.call(r, a) && r[a] && e.push(a); + } + } return e.join(" "); } + var o = {}.hasOwnProperty; + void 0 !== e && e.exports ? e.exports = n : (r = [], void 0 !== (i = function () { return n; }.apply(t, r)) && (e.exports = i)); + }(); + }, function (e, t, n) { + "use strict"; + function r(e) { switch (e._type) { + case "document": + case "block_quote": + case "list": + case "item": + case "paragraph": + case "heading": + case "emph": + case "strong": + case "link": + case "image": + case "custom_inline": + case "custom_block": return !0; + default: return !1; + } } + var i = function (e, t) { this.current = e, this.entering = !0 === t; }, o = function () { var e = this.current, t = this.entering; if (null === e) + return null; var n = r(e); return t && n ? e._firstChild ? (this.current = e._firstChild, this.entering = !0) : this.entering = !1 : e === this.root ? this.current = null : null === e._next ? (this.current = e._parent, this.entering = !1) : (this.current = e._next, this.entering = !0), { entering: t, node: e }; }, a = function (e) { return { current: e, root: e, entering: !0, next: o, resumeAt: i }; }, s = function (e, t) { this._type = e, this._parent = null, this._firstChild = null, this._lastChild = null, this._prev = null, this._next = null, this._sourcepos = t, this._lastLineBlank = !1, this._open = !0, this._string_content = null, this._literal = null, this._listData = {}, this._info = null, this._destination = null, this._title = null, this._isFenced = !1, this._fenceChar = null, this._fenceLength = 0, this._fenceOffset = null, this._level = null, this._onEnter = null, this._onExit = null; }, u = s.prototype; + Object.defineProperty(u, "isContainer", { get: function () { return r(this); } }), Object.defineProperty(u, "type", { get: function () { return this._type; } }), Object.defineProperty(u, "firstChild", { get: function () { return this._firstChild; } }), Object.defineProperty(u, "lastChild", { get: function () { return this._lastChild; } }), Object.defineProperty(u, "next", { get: function () { return this._next; } }), Object.defineProperty(u, "prev", { get: function () { return this._prev; } }), Object.defineProperty(u, "parent", { get: function () { return this._parent; } }), Object.defineProperty(u, "sourcepos", { get: function () { return this._sourcepos; } }), Object.defineProperty(u, "literal", { get: function () { return this._literal; }, set: function (e) { this._literal = e; } }), Object.defineProperty(u, "destination", { get: function () { return this._destination; }, set: function (e) { this._destination = e; } }), Object.defineProperty(u, "title", { get: function () { return this._title; }, set: function (e) { this._title = e; } }), Object.defineProperty(u, "info", { get: function () { return this._info; }, set: function (e) { this._info = e; } }), Object.defineProperty(u, "level", { get: function () { return this._level; }, set: function (e) { this._level = e; } }), Object.defineProperty(u, "listType", { get: function () { return this._listData.type; }, set: function (e) { this._listData.type = e; } }), Object.defineProperty(u, "listTight", { get: function () { return this._listData.tight; }, set: function (e) { this._listData.tight = e; } }), Object.defineProperty(u, "listStart", { get: function () { return this._listData.start; }, set: function (e) { this._listData.start = e; } }), Object.defineProperty(u, "listDelimiter", { get: function () { return this._listData.delimiter; }, set: function (e) { this._listData.delimiter = e; } }), Object.defineProperty(u, "onEnter", { get: function () { return this._onEnter; }, set: function (e) { this._onEnter = e; } }), Object.defineProperty(u, "onExit", { get: function () { return this._onExit; }, set: function (e) { this._onExit = e; } }), s.prototype.appendChild = function (e) { e.unlink(), e._parent = this, this._lastChild ? (this._lastChild._next = e, e._prev = this._lastChild, this._lastChild = e) : (this._firstChild = e, this._lastChild = e); }, s.prototype.prependChild = function (e) { e.unlink(), e._parent = this, this._firstChild ? (this._firstChild._prev = e, e._next = this._firstChild, this._firstChild = e) : (this._firstChild = e, this._lastChild = e); }, s.prototype.unlink = function () { this._prev ? this._prev._next = this._next : this._parent && (this._parent._firstChild = this._next), this._next ? this._next._prev = this._prev : this._parent && (this._parent._lastChild = this._prev), this._parent = null, this._next = null, this._prev = null; }, s.prototype.insertAfter = function (e) { e.unlink(), e._next = this._next, e._next && (e._next._prev = e), e._prev = this, this._next = e, e._parent = this._parent, e._next || (e._parent._lastChild = e); }, s.prototype.insertBefore = function (e) { e.unlink(), e._prev = this._prev, e._prev && (e._prev._next = e), e._next = this, this._prev = e, e._parent = this._parent, e._prev || (e._parent._firstChild = e); }, s.prototype.walker = function () { return new a(this); }, e.exports = s; + }, function (e, t) { e.exports = function (e, t, n, r) { if (!(e instanceof t) || void 0 !== r && r in e) + throw TypeError(n + ": incorrect invocation!"); return e; }; }, function (e, t, n) { var r = n(54), i = n(186), o = n(76), a = n(132), s = n(619); e.exports = function (e, t) { var n = 1 == e, u = 2 == e, l = 3 == e, c = 4 == e, p = 6 == e, f = 5 == e || p, h = t || s; return function (t, s, d) { for (var m, v, g = o(t), y = i(g), _ = r(s, d, 3), b = a(y.length), x = 0, w = n ? h(t, b) : u ? h(t, 0) : void 0; b > x; x++) + if ((f || x in y) && (m = y[x], v = _(m, x, g), e)) + if (n) + w[x] = v; + else if (v) + switch (e) { + case 3: return !0; + case 5: return m; + case 6: return x; + case 2: w.push(m); + } + else if (c) + return !1; return p ? -1 : l || c ? c : w; }; }; }, function (e, t, n) { var r = n(99), i = n(21)("toStringTag"), o = "Arguments" == r(function () { return arguments; }()), a = function (e, t) { try { + return e[t]; + } + catch (e) { } }; e.exports = function (e) { var t, n, s; return void 0 === e ? "Undefined" : null === e ? "Null" : "string" == typeof (n = a(t = Object(e), i)) ? n : o ? r(t) : "Object" == (s = r(t)) && "function" == typeof t.callee ? "Arguments" : s; }; }, function (e, t) { e.exports = function (e) { if (void 0 == e) + throw TypeError("Can't call method on " + e); return e; }; }, function (e, t, n) { var r = n(29), i = n(25).document, o = r(i) && r(i.createElement); e.exports = function (e) { return o ? i.createElement(e) : {}; }; }, function (e, t) { e.exports = "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(","); }, function (e, t, n) { var r = n(99); e.exports = Object("z").propertyIsEnumerable(0) ? Object : function (e) { return "String" == r(e) ? e.split("") : Object(e); }; }, function (e, t, n) { + "use strict"; + function r(e) { var t, n; this.promise = new e(function (e, r) { if (void 0 !== t || void 0 !== n) + throw TypeError("Bad Promise constructor"); t = e, n = r; }), this.resolve = i(t), this.reject = i(n); } + var i = n(98); + e.exports.f = function (e) { return new r(e); }; + }, function (e, t, n) { var r = n(38), i = n(628), o = n(185), a = n(192)("IE_PROTO"), s = function () { }, u = function () { var e, t = n(184)("iframe"), r = o.length; for (t.style.display = "none", n(344).appendChild(t), t.src = "javascript:", e = t.contentWindow.document, e.open(), e.write("