diff --git a/perf/constants-refactor/raw-numeric-hits.txt b/perf/constants-refactor/raw-numeric-hits.txt deleted file mode 100644 index 36f11c36..00000000 --- a/perf/constants-refactor/raw-numeric-hits.txt +++ /dev/null @@ -1,349 +0,0 @@ -js/docsView.js:112: -js/dmDecryptor.js:234: return 5; -js/index.js:591:// 3) Load the disclaimer (now separate) -js/testHarness.js:183:function waitForFeedItems(minCount = 1, timeoutMs = 15000) { -js/testHarness.js:211:function waitForSelector(selector, timeoutMs = 10000) { -js/magnetShared.js:76: buffer = (buffer << 5) | index; -js/magnetShared.js:77: bits += 5; -js/app.js:783: // 3) For each author, fetchAndRenderProfile with forceRefresh = true -js/nostr/commentEvents.js:29:const commentCache = new LRUCache({ maxSize: 100 }); -js/nostr/videoEventBuffer.js:74: * 3. Updates the client's `activeMap` (Latest Wins). -js/nostr/videoEventBuffer.js:76: * 5. Triggers background hydration of NIP-71 metadata. -js/nostr/videoEventBuffer.js:108: // If this is a deletion event (Kind 5 or deletion marker), record a tombstone -js/nostr/adapters/nip07Adapter.js:30: const delay = isChannelClosed ? 250 : 100; -js/nostr/watchHistory.js:45:const WATCH_HISTORY_REPUBLISH_MAX_DELAY_MS = 5 * 60 * 1000; -js/nostr/watchHistory.js:1151: { concurrency: 5 }, -js/nostr/watchHistory.js:1885: if (segments.length < 3) { -js/nostr/watchHistory.js:1940: { concurrency: 5 }, -js/nostr/relayConstants.js:17:export const RELAY_RECONNECT_MAX_ATTEMPTS = 5; -js/nostr/relayConstants.js:20:export const RELAY_CIRCUIT_BREAKER_THRESHOLD = 3; -js/nostr/relayConstants.js:23:export const RELAY_FAILURE_WINDOW_THRESHOLD = 3; -js/nostr/relayConstants.js:25:export const RELAY_BACKGROUND_CONCURRENCY = 3; -js/nostr/managers/SignerManager.js:507: const maxAttempts = 3; -js/nostr/managers/PersistenceManager.js:35: * 3. Rehydrates `allEvents`, `activeMap`, and `tombstones`. -js/nostr/managers/EventsCacheStore.js:264: * 3. Updates IDB only if fingerprint differs from `fingerprintsMap`. -js/nostr/managers/EventsCacheStore.js:266: * 5. Checks if deletions are needed (if `items.size < fingerprintsMap.size`). -js/nostr/videoPayloadBuilder.js:129: version: 3, -js/nostr/publishHelpers.js:611: if (!candidate || typeof candidate !== "object" || depth > 3) { -js/nostr/publishHelpers.js:643: if (candidate.pointerInfo && depth <= 3) { -js/nostr/publishHelpers.js:653: if (candidate.video && depth <= 3) { -js/nostr/publishHelpers.js:721: if (parts.length >= 3) { -js/nostr/nip07Permissions.js:4:export const NIP07_EXTENSION_WAIT_TIMEOUT_MS = 5000; -js/nostr/nip07Permissions.js:38: NORMAL: 5, -js/nostr/nip07Permissions.js:101:// PERF: Increased from 3 to 5 to allow more parallel decrypt operations -js/nostr/nip07Permissions.js:104:const requestQueue = new Nip07RequestQueue(5); -js/nostr/relayBatchFetcher.js:19: timeoutMs = 10000, -js/nostr/relayBatchFetcher.js:135: const listTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 10000; -js/nostr/nip46LoggingUtils.js:23: const visible = trimmed.length <= 4 ? "*".repeat(trimmed.length) : `${"*".repeat(3)}…`; -js/nostr/commentTargetNormalizer.js:568: const authorHint = getTagField(rootEventTag, 3); -js/nostr/commentTargetNormalizer.js:606: const authorHint = getTagField(candidate.tag, 3); -js/nostr/commentTargetNormalizer.js:630: const authorHint = getTagField(parentTag, 3); -js/nostr/nip71.js:513: const language = stringFromInput(tag[3]); -js/nostr/nip71.js:723: if (parts.length === 3 && parts[0] === "30078") { -js/nostr/nip46Queue.js:7: NORMAL: 5, -js/nostr/client.js:796: * @param {number} params.kind - The event kind to fetch (e.g. 10000 for mute list). -js/nostr/client.js:812: timeoutMs = 10000, -js/nostr/client.js:1019: * 3. **Network Connect**: Initializes `SimplePool` and establishes WebSocket connections to relays. -js/nostr/client.js:1325: priority: -5, -js/nostr/client.js:1378: * 3. **Decryption**: Attempts to decrypt each event using available strategies: -js/nostr/client.js:1425: const timeoutMs = options.timeoutMs || 10000; -js/nostr/client.js:2167: * 3. **Wrap**: Generate an ephemeral keypair, encrypt the seal to the recipient, and wrap in a Kind 1059 (Gift Wrap). -js/nostr/client.js:2444: * 3. **NIP-71 Metadata**: If the user added categories/tags, we publish a Kind 22 event -js/nostr/client.js:2470: // 3. Publish NIP-71 Metadata (Kind 22) if categories/tags were added. -js/nostr/client.js:2489: * 3. **Content Update**: The new payload (title, magnet, etc.) replaces the old content. -js/nostr/client.js:2901: version: Number.isFinite(vid.version) ? vid.version : 3, -js/nostr/client.js:2969: * Helper to perform a hard delete (Kind 5) on a set of video events. -js/nostr/client.js:3057: const chunkSize = 100; -js/nostr/client.js:3141: * 3. **Hard Delete (NIP-09)**: We construct a Kind 5 event referencing: -js/nostr/client.js:3145: * Relays that respect Kind 5 will physically delete these rows. -js/nostr/client.js:3270: * 3. **Batch Process (Flush)**: -js/nostr/client.js:3802: // 3. Fetch histories -js/nostr/client.js:3846: * 3. **Legacy Fallback**: Older versions might only be linked by the `d` tag or lack a root pointer entirely. -js/nostr/client.js:3852: * 3. **Sparse History Check**: If we found <= 1 version locally, we assume our cache is incomplete. -js/nostr/client.js:3854: * 5. **Merge & Sort**: Combine local and network findings, deduplicate by ID, filter out unrelated events, and sort by `created_at` (Newest -> Oldest). -js/nostr/nip46Client.js:49:const NIP46_PING_TIMEOUT_MS = 5000; -js/nostr/nip46Client.js:54:export const NIP46_AUTH_CHALLENGE_MAX_ATTEMPTS = 5; -js/nostr/reactionEvents.js:15:const reactionCache = new LRUCache({ maxSize: 100 }); -js/nostr/reactionEvents.js:96: pointerInput.length >= 3 && -js/relayManager.js:19:const FAST_RELAY_FETCH_LIMIT = 3; -js/payments/zapReceiptValidator.js:152: const length = (dataWords[index] << 5) + dataWords[index + 1]; -js/payments/zapSharedState.js:119: const platformShare = Math.floor((numericAmount * feePercent) / 100); -js/payments/lnurl.js:19: const left = chars.map((char) => char.charCodeAt(0) >> 5); -js/payments/lnurl.js:28: chk = ((chk & 0x1ffffff) << 5) ^ value; -js/payments/lnurl.js:120: checksum.push((mod >> ((5 - i) * 5)) & 31); -js/payments/lnurl.js:141: const words = convertWords(bytes, 8, 5, { pad: true }); -js/payments/lnurl.js:151: const bytes = convertWords(words, 5, 8, { pad: false }); -js/payments/nwcClient.js:1092: if (type === "EVENT" && payload.length >= 3) { -js/payments/zapSplit.js:543: const platformShare = Math.floor((amount * platformFee) / 100); -js/payments/platformFee.js:28: return (second / total) * 100; -js/payments/platformFee.js:57: return Math.min(100, Math.max(0, numeric)); -js/webtorrent.min.js.map:1:{"version":3,"file":"webtorrent.min.js","mappings":"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","sources":["webpack://webtorrent/webpack/runtime/create fake namespace object","webpack://webtorrent/./node_modules/block-iterator/index.js","webpack://webtorrent/./node_modules/cache-chunk-store/index.js","webpack://webtorrent/./node_modules/cpus/browser.js","webpack://webtorrent/./node_modules/debug/src/browser.js","webpack://webtorrent/./node_modules/debug/src/common.js","webpack://webtorrent/./node_modules/end-of-stream/index.js","webpack://webtorrent/./node_modules/err-code/index.js","webpack://webtorrent/./node_modules/escape-html/index.js","webpack://webtorrent/./node_modules/events/events.js","webpack://webtorrent/./node_modules/fast-fifo/fixed-size.js","webpack://webtorrent/./node_modules/fast-fifo/index.js","webpack://webtorrent/./node_modules/fast-readable-async-iterator/index.js","webpack://webtorrent/./node_modules/immediate-chunk-store/index.js","webpack://webtorrent/./node_modules/inherits/inherits_browser.js","webpack://webtorrent/./node_modules/join-async-iterator/index.js","webpack://webtorrent/./node_modules/limiter/index.js","webpack://webtorrent/./node_modules/limiter/lib/clock.js","webpack://webtorrent/./node_modules/limiter/lib/rateLimiter.js","webpack://webtorrent/./node_modules/limiter/lib/tokenBucket.js","webpack://webtorrent/./node_modules/lru/index.js","webpack://webtorrent/./node_modules/memory-chunk-store/index.js","webpack://webtorrent/./node_modules/mime/Mime.js","webpack://webtorrent/./node_modules/mime/lite.js","webpack://webtorrent/./node_modules/mime/types/standard.js","webpack://webtorrent/./node_modules/ms/index.js","webpack://webtorrent/./node_modules/once/once.js","webpack://webtorrent/./node_modules/piece-length/index.js","webpack://webtorrent/./node_modules/pump/index.js","webpack://webtorrent/./node_modules/queue-microtask/index.js","webpack://webtorrent/./node_modules/queue-tick/queue-microtask.js","webpack://webtorrent/./node_modules/random-iterate/index.js","webpack://webtorrent/./node_modules/range-parser/index.js","webpack://webtorrent/./node_modules/rc4/rc4.js","webpack://webtorrent/./node_modules/run-parallel-limit/index.js","webpack://webtorrent/./node_modules/run-parallel/index.js","webpack://webtorrent/./node_modules/speed-limiter/index.js","webpack://webtorrent/./node_modules/speed-limiter/lib/throttle-group.js","webpack://webtorrent/./node_modules/speed-limiter/lib/throttle.js","webpack://webtorrent/./node_modules/speed-limiter/lib/utils.js","webpack://webtorrent/./node_modules/streamx/index.js","webpack://webtorrent/./node_modules/text-decoder/index.js","webpack://webtorrent/./node_modules/text-decoder/lib/browser-decoder.js","webpack://webtorrent/./node_modules/throughput/index.js","webpack://webtorrent/./node_modules/unordered-array-remove/index.js","webpack://webtorrent/./node_modules/wrappy/wrappy.js","webpack://webtorrent/./version.cjs","webpack://webtorrent/./lib/peer.js","webpack://webtorrent/./node_modules/bencode/lib/util.js","webpack://webtorrent/./node_modules/bencode/lib/encode.js","webpack://webtorrent/./node_modules/bencode/lib/decode.js","webpack://webtorrent/./node_modules/bencode/lib/encoding-length.js","webpack://webtorrent/./node_modules/bencode/index.js","webpack://webtorrent/./node_modules/bitfield/lib/esm/index.js","webpack://webtorrent/./node_modules/bittorrent-protocol/index.js","webpack://webtorrent/./node_modules/uint8-util/util.js","webpack://webtorrent/./node_modules/base64-arraybuffer/dist/base64-arraybuffer.es5.js","webpack://webtorrent/./node_modules/uint8-util/browser.js","webpack://webtorrent/./polyfills/process-fast.js","webpack://webtorrent/webpack/bootstrap","webpack://webtorrent/webpack/runtime/define property getters","webpack://webtorrent/webpack/runtime/hasOwnProperty shorthand","webpack://webtorrent/webpack/runtime/make namespace object","webpack://webtorrent/./node_modules/path-esm/lib/util.js","webpack://webtorrent/./node_modules/path-esm/lib/join.js","webpack://webtorrent/./node_modules/path-esm/lib/normalize.js","webpack://webtorrent/./node_modules/path-esm/index.js","webpack://webtorrent/./node_modules/junk/index.js","webpack://webtorrent/./node_modules/create-torrent/index.js","webpack://webtorrent/./node_modules/path-esm/lib/basename.js","webpack://webtorrent/./node_modules/cross-fetch-ponyfill/browser.js","webpack://webtorrent/./node_modules/@thaunknown/thirty-two/lib/thirty-two/index.js","webpack://webtorrent/./node_modules/bep53-range/index.js","webpack://webtorrent/./node_modules/magnet-uri/index.js","webpack://webtorrent/./node_modules/parse-torrent/index.js","webpack://webtorrent/./node_modules/webrtc-polyfill/browser.js","webpack://webtorrent/./node_modules/@thaunknown/simple-peer/lite.js","webpack://webtorrent/./node_modules/addr-to-ip-port/index.js","webpack://webtorrent/./node_modules/chunk-store-iterator/index.js","webpack://webtorrent/./node_modules/bittorrent-tracker/lib/common.js","webpack://webtorrent/./node_modules/@thaunknown/simple-websocket/index.js","webpack://webtorrent/./node_modules/bittorrent-tracker/lib/client/tracker.js","webpack://webtorrent/./node_modules/bittorrent-tracker/lib/client/websocket-tracker.js","webpack://webtorrent/./node_modules/bittorrent-tracker/client.js","webpack://webtorrent/./node_modules/torrent-discovery/index.js","webpack://webtorrent/./node_modules/fsa-chunk-store/createWritable.js","webpack://webtorrent/./node_modules/fsa-chunk-store/index.js","webpack://webtorrent/./node_modules/filename-reserved-regex/index.js","webpack://webtorrent/./node_modules/lt_donthave/index.js","webpack://webtorrent/./node_modules/torrent-piece/index.js","webpack://webtorrent/./node_modules/ut_metadata/index.js","webpack://webtorrent/./lib/file-iterator.js","webpack://webtorrent/./lib/file.js","webpack://webtorrent/./lib/rarity-map.js","webpack://webtorrent/./lib/webconn.js","webpack://webtorrent/./lib/selections.js","webpack://webtorrent/./lib/torrent.js","webpack://webtorrent/./lib/server.js","webpack://webtorrent/./index.js","webpack://webtorrent/./node_modules/path-esm/lib/dirname.js"],"sourcesContent":["var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","function concat (chunks, size) {\r\n if (typeof chunks[0] === 'string') return chunks.join('')\r\n if (typeof chunks[0] === 'number') return new Uint8Array(chunks)\r\n const b = new Uint8Array(size)\r\n let offset = 0\r\n for (let i = 0, l = chunks.length; i < l; i++) {\r\n const chunk = chunks[i]\r\n b.set(chunk, offset)\r\n offset += chunk.byteLength || chunk.length\r\n }\r\n\r\n return b\r\n}\r\n\r\nmodule.exports = async function * (iterator, size = 512, opts = {}) {\r\n if (typeof size === 'object') {\r\n opts = size\r\n size = opts.size\r\n }\r\n let { nopad, zeroPadding = true } = opts\r\n\r\n if (nopad) zeroPadding = false\r\n\r\n let buffered = []\r\n let bufferedBytes = 0\r\n\r\n for await (const value of iterator) {\r\n bufferedBytes += value.byteLength || value.length || 1\r\n buffered.push(value)\r\n\r\n if (bufferedBytes >= size) {\r\n const b = concat(buffered, bufferedBytes)\r\n let offset = 0\r\n\r\n while (bufferedBytes >= size) {\r\n yield b.slice(offset, offset + size)\r\n bufferedBytes -= size\r\n offset += size\r\n }\r\n\r\n buffered = [b.slice(offset, b.length)]\r\n }\r\n }\r\n if (bufferedBytes) yield concat(buffered, zeroPadding ? size : bufferedBytes)\r\n}\r\n","/*! cache-chunk-store. MIT License. Feross Aboukhadijeh */\nconst LRU = require('lru')\nconst queueMicrotask = require('queue-microtask')\n\nclass CacheStore {\n constructor (store, opts) {\n this.store = store\n this.chunkLength = store.chunkLength\n this.inProgressGets = new Map() // Map from chunk index to info on callbacks waiting for that chunk\n\n if (!this.store || !this.store.get || !this.store.put) {\n throw new Error('First argument must be abstract-chunk-store compliant')\n }\n\n this.cache = new LRU(opts)\n }\n\n put (index, buf, cb = () => {}) {\n if (!this.cache) {\n return queueMicrotask(() => cb(new Error('CacheStore closed')))\n }\n\n this.cache.remove(index)\n this.store.put(index, buf, cb)\n }\n\n get (index, opts, cb = () => {}) {\n if (typeof opts === 'function') return this.get(index, null, opts)\n\n if (!this.cache) {\n return queueMicrotask(() => cb(new Error('CacheStore closed')))\n }\n\n if (!opts) opts = {}\n\n let buf = this.cache.get(index)\n if (buf) {\n const offset = opts.offset || 0\n const len = opts.length || (buf.length - offset)\n if (offset !== 0 || len !== buf.length) {\n buf = buf.slice(offset, len + offset)\n }\n return queueMicrotask(() => cb(null, buf))\n }\n\n // See if a get for this index has already started\n let waiters = this.inProgressGets.get(index)\n const getAlreadyStarted = !!waiters\n if (!waiters) {\n waiters = []\n this.inProgressGets.set(index, waiters)\n }\n\n waiters.push({\n opts,\n cb\n })\n\n if (!getAlreadyStarted) {\n this.store.get(index, (err, buf) => {\n if (!err && this.cache != null) this.cache.set(index, buf)\n\n const inProgressEntry = this.inProgressGets.get(index)\n this.inProgressGets.delete(index)\n\n for (const { opts, cb } of inProgressEntry) {\n if (err) {\n cb(err)\n } else {\n const offset = opts.offset || 0\n const len = opts.length || (buf.length - offset)\n let slicedBuf = buf\n if (offset !== 0 || len !== buf.length) {\n slicedBuf = buf.slice(offset, len + offset)\n }\n cb(null, slicedBuf)\n }\n }\n })\n }\n }\n\n close (cb = () => {}) {\n if (!this.cache) {\n return queueMicrotask(() => cb(new Error('CacheStore closed')))\n }\n\n this.cache = null\n this.store.close(cb)\n }\n\n destroy (cb = () => {}) {\n if (!this.cache) {\n return queueMicrotask(() => cb(new Error('CacheStore closed')))\n }\n\n this.cache = null\n this.store.destroy(cb)\n }\n}\n\nmodule.exports = CacheStore\n","module.exports = function cpus () {\n var num = navigator.hardwareConcurrency || 1\n var cpus = []\n for (var i = 0; i < num; i++) {\n cpus.push({\n model: '',\n speed: 0,\n times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 }\n })\n }\n return cpus\n}\n","/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\tlet m;\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\t// eslint-disable-next-line no-return-assign\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/)) && parseInt(m[1], 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\t\tlet namespacesCache;\n\t\tlet enabledCache;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => {\n\t\t\t\tif (enableOverride !== null) {\n\t\t\t\t\treturn enableOverride;\n\t\t\t\t}\n\t\t\t\tif (namespacesCache !== createDebug.namespaces) {\n\t\t\t\t\tnamespacesCache = createDebug.namespaces;\n\t\t\t\t\tenabledCache = createDebug.enabled(namespace);\n\t\t\t\t}\n\n\t\t\t\treturn enabledCache;\n\t\t\t},\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\t\tcreateDebug.namespaces = namespaces;\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '')\n\t\t\t.trim()\n\t\t\t.replace(' ', ',')\n\t\t\t.split(',')\n\t\t\t.filter(Boolean);\n\n\t\tfor (const ns of split) {\n\t\t\tif (ns[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(ns.slice(1));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(ns);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Checks if the given string matches a namespace template, honoring\n\t * asterisks as wildcards.\n\t *\n\t * @param {String} search\n\t * @param {String} template\n\t * @return {Boolean}\n\t */\n\tfunction matchesTemplate(search, template) {\n\t\tlet searchIndex = 0;\n\t\tlet templateIndex = 0;\n\t\tlet starIndex = -1;\n\t\tlet matchIndex = 0;\n\n\t\twhile (searchIndex < search.length) {\n\t\t\tif (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {\n\t\t\t\t// Match character or proceed with wildcard\n\t\t\t\tif (template[templateIndex] === '*') {\n\t\t\t\t\tstarIndex = templateIndex;\n\t\t\t\t\tmatchIndex = searchIndex;\n\t\t\t\t\ttemplateIndex++; // Skip the '*'\n\t\t\t\t} else {\n\t\t\t\t\tsearchIndex++;\n\t\t\t\t\ttemplateIndex++;\n\t\t\t\t}\n\t\t\t} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition\n\t\t\t\t// Backtrack to the last '*' and try to match more characters\n\t\t\t\ttemplateIndex = starIndex + 1;\n\t\t\t\tmatchIndex++;\n\t\t\t\tsearchIndex = matchIndex;\n\t\t\t} else {\n\t\t\t\treturn false; // No match\n\t\t\t}\n\t\t}\n\n\t\t// Handle trailing '*' in template\n\t\twhile (templateIndex < template.length && template[templateIndex] === '*') {\n\t\t\ttemplateIndex++;\n\t\t}\n\n\t\treturn templateIndex === template.length;\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names,\n\t\t\t...createDebug.skips.map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tfor (const skip of createDebug.skips) {\n\t\t\tif (matchesTemplate(name, skip)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (const ns of createDebug.names) {\n\t\t\tif (matchesTemplate(name, ns)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n","var once = require('once');\n\nvar noop = function() {};\n\nvar isRequest = function(stream) {\n\treturn stream.setHeader && typeof stream.abort === 'function';\n};\n\nvar isChildProcess = function(stream) {\n\treturn stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3\n};\n\nvar eos = function(stream, opts, callback) {\n\tif (typeof opts === 'function') return eos(stream, null, opts);\n\tif (!opts) opts = {};\n\n\tcallback = once(callback || noop);\n\n\tvar ws = stream._writableState;\n\tvar rs = stream._readableState;\n\tvar readable = opts.readable || (opts.readable !== false && stream.readable);\n\tvar writable = opts.writable || (opts.writable !== false && stream.writable);\n\tvar cancelled = false;\n\n\tvar onlegacyfinish = function() {\n\t\tif (!stream.writable) onfinish();\n\t};\n\n\tvar onfinish = function() {\n\t\twritable = false;\n\t\tif (!readable) callback.call(stream);\n\t};\n\n\tvar onend = function() {\n\t\treadable = false;\n\t\tif (!writable) callback.call(stream);\n\t};\n\n\tvar onexit = function(exitCode) {\n\t\tcallback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);\n\t};\n\n\tvar onerror = function(err) {\n\t\tcallback.call(stream, err);\n\t};\n\n\tvar onclose = function() {\n\t\tprocess.nextTick(onclosenexttick);\n\t};\n\n\tvar onclosenexttick = function() {\n\t\tif (cancelled) return;\n\t\tif (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));\n\t\tif (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));\n\t};\n\n\tvar onrequest = function() {\n\t\tstream.req.on('finish', onfinish);\n\t};\n\n\tif (isRequest(stream)) {\n\t\tstream.on('complete', onfinish);\n\t\tstream.on('abort', onclose);\n\t\tif (stream.req) onrequest();\n\t\telse stream.on('request', onrequest);\n\t} else if (writable && !ws) { // legacy streams\n\t\tstream.on('end', onlegacyfinish);\n\t\tstream.on('close', onlegacyfinish);\n\t}\n\n\tif (isChildProcess(stream)) stream.on('exit', onexit);\n\n\tstream.on('end', onend);\n\tstream.on('finish', onfinish);\n\tif (opts.error !== false) stream.on('error', onerror);\n\tstream.on('close', onclose);\n\n\treturn function() {\n\t\tcancelled = true;\n\t\tstream.removeListener('complete', onfinish);\n\t\tstream.removeListener('abort', onclose);\n\t\tstream.removeListener('request', onrequest);\n\t\tif (stream.req) stream.req.removeListener('finish', onfinish);\n\t\tstream.removeListener('end', onlegacyfinish);\n\t\tstream.removeListener('close', onlegacyfinish);\n\t\tstream.removeListener('finish', onfinish);\n\t\tstream.removeListener('exit', onexit);\n\t\tstream.removeListener('end', onend);\n\t\tstream.removeListener('error', onerror);\n\t\tstream.removeListener('close', onclose);\n\t};\n};\n\nmodule.exports = eos;\n","'use strict';\n\n/**\n * @typedef {{ [key: string]: any }} Extensions\n * @typedef {Error} Err\n * @property {string} message\n */\n\n/**\n *\n * @param {Error} obj\n * @param {Extensions} props\n * @returns {Error & Extensions}\n */\nfunction assign(obj, props) {\n for (const key in props) {\n Object.defineProperty(obj, key, {\n value: props[key],\n enumerable: true,\n configurable: true,\n });\n }\n\n return obj;\n}\n\n/**\n *\n * @param {any} err - An Error\n * @param {string|Extensions} code - A string code or props to set on the error\n * @param {Extensions} [props] - Props to set on the error\n * @returns {Error & Extensions}\n */\nfunction createError(err, code, props) {\n if (!err || typeof err === 'string') {\n throw new TypeError('Please pass an Error to err-code');\n }\n\n if (!props) {\n props = {};\n }\n\n if (typeof code === 'object') {\n props = code;\n code = '';\n }\n\n if (code) {\n props.code = code;\n }\n\n try {\n return assign(err, props);\n } catch (_) {\n props.message = err.message;\n props.stack = err.stack;\n\n const ErrClass = function () {};\n\n ErrClass.prototype = Object.create(Object.getPrototypeOf(err));\n\n // @ts-ignore\n const output = assign(new ErrClass(), props);\n\n return output;\n }\n}\n\nmodule.exports = createError;\n","/*!\n * escape-html\n * Copyright(c) 2012-2013 TJ Holowaychuk\n * Copyright(c) 2015 Andreas Lubbe\n * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module variables.\n * @private\n */\n\nvar matchHtmlRegExp = /[\"'&<>]/;\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = escapeHtml;\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param {string} string The string to escape for inserting into HTML\n * @return {string}\n * @public\n */\n\nfunction escapeHtml(string) {\n var str = '' + string;\n var match = matchHtmlRegExp.exec(str);\n\n if (!match) {\n return str;\n }\n\n var escape;\n var html = '';\n var index = 0;\n var lastIndex = 0;\n\n for (index = match.index; index < str.length; index++) {\n switch (str.charCodeAt(index)) {\n case 34: // \"\n escape = '"';\n break;\n case 38: // &\n escape = '&';\n break;\n case 39: // '\n escape = ''';\n break;\n case 60: // <\n escape = '<';\n break;\n case 62: // >\n escape = '>';\n break;\n default:\n continue;\n }\n\n if (lastIndex !== index) {\n html += str.substring(lastIndex, index);\n }\n\n lastIndex = index + 1;\n html += escape;\n }\n\n return lastIndex !== index\n ? html + str.substring(lastIndex, index)\n : html;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar objectCreate = Object.create || objectCreatePolyfill\nvar objectKeys = Object.keys || objectKeysPolyfill\nvar bind = Function.prototype.bind || functionBindPolyfill\n\nfunction EventEmitter() {\n if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {\n this._events = objectCreate(null);\n this._eventsCount = 0;\n }\n\n this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nvar hasDefineProperty;\ntry {\n var o = {};\n if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });\n hasDefineProperty = o.x === 0;\n} catch (err) { hasDefineProperty = false }\nif (hasDefineProperty) {\n Object.defineProperty(EventEmitter, 'defaultMaxListeners', {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n // check whether the input is a positive number (whose value is zero or\n // greater and not a NaN).\n if (typeof arg !== 'number' || arg < 0 || arg !== arg)\n throw new TypeError('\"defaultMaxListeners\" must be a positive number');\n defaultMaxListeners = arg;\n }\n });\n} else {\n EventEmitter.defaultMaxListeners = defaultMaxListeners;\n}\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== 'number' || n < 0 || isNaN(n))\n throw new TypeError('\"n\" argument must be a positive number');\n this._maxListeners = n;\n return this;\n};\n\nfunction $getMaxListeners(that) {\n if (that._maxListeners === undefined)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return $getMaxListeners(this);\n};\n\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n if (isFn)\n handler.call(self);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self);\n }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n if (isFn)\n handler.call(self, arg1);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1);\n }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n if (isFn)\n handler.call(self, arg1, arg2);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1, arg2);\n }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n if (isFn)\n handler.call(self, arg1, arg2, arg3);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1, arg2, arg3);\n }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n if (isFn)\n handler.apply(self, args);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].apply(self, args);\n }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n var er, handler, len, args, i, events;\n var doError = (type === 'error');\n\n events = this._events;\n if (events)\n doError = (doError && events.error == null);\n else if (!doError)\n return false;\n\n // If there is no 'error' event listener then throw.\n if (doError) {\n if (arguments.length > 1)\n er = arguments[1];\n if (er instanceof Error) {\n throw er; // Unhandled 'error' event\n } else {\n // At least give some kind of context to the user\n var err = new Error('Unhandled \"error\" event. (' + er + ')');\n err.context = er;\n throw err;\n }\n return false;\n }\n\n handler = events[type];\n\n if (!handler)\n return false;\n\n var isFn = typeof handler === 'function';\n len = arguments.length;\n switch (len) {\n // fast cases\n case 1:\n emitNone(handler, isFn, this);\n break;\n case 2:\n emitOne(handler, isFn, this, arguments[1]);\n break;\n case 3:\n emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n break;\n case 4:\n emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n break;\n // slower\n default:\n args = new Array(len - 1);\n for (i = 1; i < len; i++)\n args[i - 1] = arguments[i];\n emitMany(handler, isFn, this, args);\n }\n\n return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n\n events = target._events;\n if (!events) {\n events = target._events = objectCreate(null);\n target._eventsCount = 0;\n } else {\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (events.newListener) {\n target.emit('newListener', type,\n listener.listener ? listener.listener : listener);\n\n // Re-assign `events` because a newListener handler could have caused the\n // this._events to be assigned to a new object\n events = target._events;\n }\n existing = events[type];\n }\n\n if (!existing) {\n // Optimize the case of one listener. Don't need the extra array object.\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === 'function') {\n // Adding the second element, need to change to array.\n existing = events[type] =\n prepend ? [listener, existing] : [existing, listener];\n } else {\n // If we've already got an array, just append.\n if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n }\n\n // Check for listener leak\n if (!existing.warned) {\n m = $getMaxListeners(target);\n if (m && m > 0 && existing.length > m) {\n existing.warned = true;\n var w = new Error('Possible EventEmitter memory leak detected. ' +\n existing.length + ' \"' + String(type) + '\" listeners ' +\n 'added. Use emitter.setMaxListeners() to ' +\n 'increase limit.');\n w.name = 'MaxListenersExceededWarning';\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n if (typeof console === 'object' && console.warn) {\n console.warn('%s: %s', w.name, w.message);\n }\n }\n }\n }\n\n return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n\nfunction onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n switch (arguments.length) {\n case 0:\n return this.listener.call(this.target);\n case 1:\n return this.listener.call(this.target, arguments[0]);\n case 2:\n return this.listener.call(this.target, arguments[0], arguments[1]);\n case 3:\n return this.listener.call(this.target, arguments[0], arguments[1],\n arguments[2]);\n default:\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; ++i)\n args[i] = arguments[i];\n this.listener.apply(this.target, args);\n }\n }\n}\n\nfunction _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n var wrapped = bind.call(onceWrapper, state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n this.on(type, _onceWrap(this, type, listener));\n return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n function prependOnceListener(type, listener) {\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n\n events = this._events;\n if (!events)\n return this;\n\n list = events[type];\n if (!list)\n return this;\n\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = objectCreate(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit('removeListener', type, list.listener || listener);\n }\n } else if (typeof list !== 'function') {\n position = -1;\n\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (position === 0)\n list.shift();\n else\n spliceOne(list, position);\n\n if (list.length === 1)\n events[type] = list[0];\n\n if (events.removeListener)\n this.emit('removeListener', type, originalListener || listener);\n }\n\n return this;\n };\n\nEventEmitter.prototype.removeAllListeners =\n function removeAllListeners(type) {\n var listeners, events, i;\n\n events = this._events;\n if (!events)\n return this;\n\n // not listening for removeListener, no need to emit\n if (!events.removeListener) {\n if (arguments.length === 0) {\n this._events = objectCreate(null);\n this._eventsCount = 0;\n } else if (events[type]) {\n if (--this._eventsCount === 0)\n this._events = objectCreate(null);\n else\n delete events[type];\n }\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n var keys = objectKeys(events);\n var key;\n for (i = 0; i < keys.length; ++i) {\n key = keys[i];\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = objectCreate(null);\n this._eventsCount = 0;\n return this;\n }\n\n listeners = events[type];\n\n if (typeof listeners === 'function') {\n this.removeListener(type, listeners);\n } else if (listeners) {\n // LIFO order\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n\n return this;\n };\n\nfunction _listeners(target, type, unwrap) {\n var events = target._events;\n\n if (!events)\n return [];\n\n var evlistener = events[type];\n if (!evlistener)\n return [];\n\n if (typeof evlistener === 'function')\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === 'function') {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n var events = this._events;\n\n if (events) {\n var evlistener = events[type];\n\n if (typeof evlistener === 'function') {\n return 1;\n } else if (evlistener) {\n return evlistener.length;\n }\n }\n\n return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n list[i] = list[k];\n list.pop();\n}\n\nfunction arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n}\n\nfunction unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n}\n\nfunction objectCreatePolyfill(proto) {\n var F = function() {};\n F.prototype = proto;\n return new F;\n}\nfunction objectKeysPolyfill(obj) {\n var keys = [];\n for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {\n keys.push(k);\n }\n return k;\n}\nfunction functionBindPolyfill(context) {\n var fn = this;\n return function () {\n return fn.apply(context, arguments);\n };\n}\n","module.exports = class FixedFIFO {\n constructor (hwm) {\n if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two')\n this.buffer = new Array(hwm)\n this.mask = hwm - 1\n this.top = 0\n this.btm = 0\n this.next = null\n }\n\n clear () {\n this.top = this.btm = 0\n this.next = null\n this.buffer.fill(undefined)\n }\n\n push (data) {\n if (this.buffer[this.top] !== undefined) return false\n this.buffer[this.top] = data\n this.top = (this.top + 1) & this.mask\n return true\n }\n\n shift () {\n const last = this.buffer[this.btm]\n if (last === undefined) return undefined\n this.buffer[this.btm] = undefined\n this.btm = (this.btm + 1) & this.mask\n return last\n }\n\n peek () {\n return this.buffer[this.btm]\n }\n\n isEmpty () {\n return this.buffer[this.btm] === undefined\n }\n}\n","const FixedFIFO = require('./fixed-size')\n\nmodule.exports = class FastFIFO {\n constructor (hwm) {\n this.hwm = hwm || 16\n this.head = new FixedFIFO(this.hwm)\n this.tail = this.head\n this.length = 0\n }\n\n clear () {\n this.head = this.tail\n this.head.clear()\n this.length = 0\n }\n\n push (val) {\n this.length++\n if (!this.head.push(val)) {\n const prev = this.head\n this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length)\n this.head.push(val)\n }\n }\n\n shift () {\n if (this.length !== 0) this.length--\n const val = this.tail.shift()\n if (val === undefined && this.tail.next) {\n const next = this.tail.next\n this.tail.next = null\n this.tail = next\n return this.tail.shift()\n }\n\n return val\n }\n\n peek () {\n const val = this.tail.peek()\n if (val === undefined && this.tail.next) return this.tail.next.peek()\n return val\n }\n\n isEmpty () {\n return this.length === 0\n }\n}\n","if (typeof ReadableStream !== 'undefined') {\r\n if (!ReadableStream.prototype[Symbol.asyncIterator]) {\r\n ReadableStream.prototype[Symbol.asyncIterator] = function ({ preventCancel } = {}) {\r\n const reader = this.getReader()\r\n const stream = this\r\n let last = reader.read()\r\n return {\r\n next () {\r\n const temp = last\r\n last = reader.read()\r\n return temp\r\n },\r\n async return (value) {\r\n await last\r\n reader.releaseLock()\r\n if (!preventCancel) stream.cancel()\r\n return { done: true, value }\r\n },\r\n async throw (err) {\r\n await this.return()\r\n throw err\r\n },\r\n [Symbol.asyncIterator] () {\r\n return this\r\n }\r\n }\r\n }\r\n }\r\n if (!ReadableStream.prototype.getIterator) {\r\n ReadableStream.prototype.getIterator = function ({ preventCancel } = {}) {\r\n return this[Symbol.asyncIterator]({ preventCancel })\r\n }\r\n }\r\n}\r\n","/*! immediate-chunk-store. MIT License. Feross Aboukhadijeh */\n// TODO: remove when window.queueMicrotask() is well supported\nconst queueMicrotask = require('queue-microtask')\n\nclass ImmediateStore {\n constructor (store) {\n this.store = store\n this.chunkLength = store.chunkLength\n\n if (!this.store || !this.store.get || !this.store.put) {\n throw new Error('First argument must be abstract-chunk-store compliant')\n }\n\n this.mem = []\n }\n\n put (index, buf, cb = () => {}) {\n this.mem[index] = buf\n this.store.put(index, buf, err => {\n this.mem[index] = null\n cb(err)\n })\n }\n\n get (index, opts, cb = () => {}) {\n if (typeof opts === 'function') return this.get(index, null, opts)\n\n let buf = this.mem[index]\n\n // if the chunk isn't in the immediate memory cache\n if (!buf) {\n return this.store.get(index, opts, cb)\n }\n\n if (!opts) opts = {}\n\n const offset = opts.offset || 0\n const len = opts.length || (buf.length - offset)\n\n if (offset !== 0 || len !== buf.length) {\n buf = buf.slice(offset, len + offset)\n }\n queueMicrotask(() => cb(null, buf))\n }\n\n close (cb = () => {}) {\n this.store.close(cb)\n }\n\n destroy (cb = () => {}) {\n this.store.destroy(cb)\n }\n}\n\nmodule.exports = ImmediateStore\n","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n })\n }\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n }\n}\n","module.exports = async function * (iterators) {\r\n for (let iterator of iterators) {\r\n // can be lazy functions returning streams\r\n if (typeof iterator === 'function') iterator = iterator()\r\n yield * iterator\r\n }\r\n}\r\n","\r\nexports.RateLimiter = require('./lib/rateLimiter');\r\nexports.TokenBucket = require('./lib/tokenBucket');\r\n","var getMilliseconds = function() {\r\n if (typeof process !== 'undefined' && process.hrtime) {\r\n var hrtime = process.hrtime();\r\n var seconds = hrtime[0];\r\n var nanoseconds = hrtime[1];\r\n\r\n return seconds * 1e3 + Math.floor(nanoseconds / 1e6);\r\n }\r\n\r\n return new Date().getTime();\r\n}\r\n\r\nmodule.exports = getMilliseconds;\r\n","var TokenBucket = require('./tokenBucket');\r\nvar getMilliseconds = require('./clock');\r\n\r\n/**\r\n * A generic rate limiter. Underneath the hood, this uses a token bucket plus\r\n * an additional check to limit how many tokens we can remove each interval.\r\n * @author John Hurliman \r\n *\r\n * @param {Number} tokensPerInterval Maximum number of tokens that can be\r\n * removed at any given moment and over the course of one interval.\r\n * @param {String|Number} interval The interval length in milliseconds, or as\r\n * one of the following strings: 'second', 'minute', 'hour', day'.\r\n * @param {Boolean} fireImmediately Optional. Whether or not the callback\r\n * will fire immediately when rate limiting is in effect (default is false).\r\n */\r\nvar RateLimiter = function(tokensPerInterval, interval, fireImmediately) {\r\n this.tokenBucket = new TokenBucket(tokensPerInterval, tokensPerInterval,\r\n interval, null);\r\n\r\n // Fill the token bucket to start\r\n this.tokenBucket.content = tokensPerInterval;\r\n\r\n this.curIntervalStart = getMilliseconds();\r\n this.tokensThisInterval = 0;\r\n this.fireImmediately = fireImmediately;\r\n};\r\n\r\nRateLimiter.prototype = {\r\n tokenBucket: null,\r\n curIntervalStart: 0,\r\n tokensThisInterval: 0,\r\n fireImmediately: false,\r\n\r\n /**\r\n * Remove the requested number of tokens and fire the given callback. If the\r\n * rate limiter contains enough tokens and we haven't spent too many tokens\r\n * in this interval already, this will happen immediately. Otherwise, the\r\n * removal and callback will happen when enough tokens become available.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Function} callback(err, remainingTokens)\r\n * @returns {Boolean} True if the callback was fired immediately, otherwise\r\n * false.\r\n */\r\n removeTokens: function(count, callback) {\r\n // Make sure the request isn't for more than we can handle\r\n if (count > this.tokenBucket.bucketSize) {\r\n process.nextTick(callback.bind(null, 'Requested tokens ' + count +\r\n ' exceeds maximum tokens per interval ' + this.tokenBucket.bucketSize,\r\n null));\r\n return false;\r\n }\r\n\r\n var self = this;\r\n var now = getMilliseconds();\r\n\r\n // Advance the current interval and reset the current interval token count\r\n // if needed\r\n if (now < this.curIntervalStart\r\n || now - this.curIntervalStart >= this.tokenBucket.interval) {\r\n this.curIntervalStart = now;\r\n this.tokensThisInterval = 0;\r\n }\r\n\r\n // If we don't have enough tokens left in this interval, wait until the\r\n // next interval\r\n if (count > this.tokenBucket.tokensPerInterval - this.tokensThisInterval) {\r\n if (this.fireImmediately) {\r\n process.nextTick(callback.bind(null, null, -1));\r\n } else {\r\n var waitInterval = Math.ceil(\r\n this.curIntervalStart + this.tokenBucket.interval - now);\r\n\r\n setTimeout(function() {\r\n self.tokenBucket.removeTokens(count, afterTokensRemoved);\r\n }, waitInterval);\r\n }\r\n return false;\r\n }\r\n\r\n // Remove the requested number of tokens from the token bucket\r\n return this.tokenBucket.removeTokens(count, afterTokensRemoved);\r\n\r\n function afterTokensRemoved(err, tokensRemaining) {\r\n if (err) return callback(err, null);\r\n\r\n self.tokensThisInterval += count;\r\n callback(null, tokensRemaining);\r\n }\r\n },\r\n\r\n /**\r\n * Attempt to remove the requested number of tokens and return immediately.\r\n * If the bucket (and any parent buckets) contains enough tokens and we\r\n * haven't spent too many tokens in this interval already, this will return\r\n * true. Otherwise, false is returned.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Boolean} True if the tokens were successfully removed, otherwise\r\n * false.\r\n */\r\n tryRemoveTokens: function(count) {\r\n // Make sure the request isn't for more than we can handle\r\n if (count > this.tokenBucket.bucketSize)\r\n return false;\r\n\r\n var now = getMilliseconds();\r\n\r\n // Advance the current interval and reset the current interval token count\r\n // if needed\r\n if (now < this.curIntervalStart\r\n || now - this.curIntervalStart >= this.tokenBucket.interval) {\r\n this.curIntervalStart = now;\r\n this.tokensThisInterval = 0;\r\n }\r\n\r\n // If we don't have enough tokens left in this interval, return false\r\n if (count > this.tokenBucket.tokensPerInterval - this.tokensThisInterval)\r\n return false;\r\n\r\n // Try to remove the requested number of tokens from the token bucket\r\n var removed = this.tokenBucket.tryRemoveTokens(count);\r\n if (removed) {\r\n this.tokensThisInterval += count;\r\n }\r\n return removed;\r\n },\r\n\r\n /**\r\n * Returns the number of tokens remaining in the TokenBucket.\r\n * @returns {Number} The number of tokens remaining.\r\n */\r\n getTokensRemaining: function () {\r\n this.tokenBucket.drip();\r\n return this.tokenBucket.content;\r\n }\r\n};\r\n\r\nmodule.exports = RateLimiter;\r\n","\r\n/**\r\n * A hierarchical token bucket for rate limiting. See\r\n * http://en.wikipedia.org/wiki/Token_bucket for more information.\r\n * @author John Hurliman \r\n *\r\n * @param {Number} bucketSize Maximum number of tokens to hold in the bucket.\r\n * Also known as the burst rate.\r\n * @param {Number} tokensPerInterval Number of tokens to drip into the bucket\r\n * over the course of one interval.\r\n * @param {String|Number} interval The interval length in milliseconds, or as\r\n * one of the following strings: 'second', 'minute', 'hour', day'.\r\n * @param {TokenBucket} parentBucket Optional. A token bucket that will act as\r\n * the parent of this bucket.\r\n */\r\nvar TokenBucket = function(bucketSize, tokensPerInterval, interval, parentBucket) {\r\n this.bucketSize = bucketSize;\r\n this.tokensPerInterval = tokensPerInterval;\r\n\r\n if (typeof interval === 'string') {\r\n switch (interval) {\r\n case 'sec': case 'second':\r\n this.interval = 1000; break;\r\n case 'min': case 'minute':\r\n this.interval = 1000 * 60; break;\r\n case 'hr': case 'hour':\r\n this.interval = 1000 * 60 * 60; break;\r\n case 'day':\r\n this.interval = 1000 * 60 * 60 * 24; break;\r\n default:\r\n throw new Error('Invaid interval ' + interval);\r\n }\r\n } else {\r\n this.interval = interval;\r\n }\r\n\r\n this.parentBucket = parentBucket;\r\n this.content = 0;\r\n this.lastDrip = +new Date();\r\n};\r\n\r\nTokenBucket.prototype = {\r\n bucketSize: 1,\r\n tokensPerInterval: 1,\r\n interval: 1000,\r\n parentBucket: null,\r\n content: 0,\r\n lastDrip: 0,\r\n\r\n /**\r\n * Remove the requested number of tokens and fire the given callback. If the\r\n * bucket (and any parent buckets) contains enough tokens this will happen\r\n * immediately. Otherwise, the removal and callback will happen when enough\r\n * tokens become available.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Function} callback(err, remainingTokens)\r\n * @returns {Boolean} True if the callback was fired immediately, otherwise\r\n * false.\r\n */\r\n removeTokens: function(count, callback) {\r\n var self = this;\r\n\r\n // Is this an infinite size bucket?\r\n if (!this.bucketSize) {\r\n process.nextTick(callback.bind(null, null, count, Number.POSITIVE_INFINITY));\r\n return true;\r\n }\r\n\r\n // Make sure the bucket can hold the requested number of tokens\r\n if (count > this.bucketSize) {\r\n process.nextTick(callback.bind(null, 'Requested tokens ' + count + ' exceeds bucket size ' +\r\n this.bucketSize, null));\r\n return false;\r\n }\r\n\r\n // Drip new tokens into this bucket\r\n this.drip();\r\n\r\n // If we don't have enough tokens in this bucket, come back later\r\n if (count > this.content)\r\n return comeBackLater();\r\n\r\n if (this.parentBucket) {\r\n // Remove the requested from the parent bucket first\r\n return this.parentBucket.removeTokens(count, function(err, remainingTokens) {\r\n if (err) return callback(err, null);\r\n\r\n // Check that we still have enough tokens in this bucket\r\n if (count > self.content)\r\n return comeBackLater();\r\n\r\n // Tokens were removed from the parent bucket, now remove them from\r\n // this bucket and fire the callback. Note that we look at the current\r\n // bucket and parent bucket's remaining tokens and return the smaller\r\n // of the two values\r\n self.content -= count;\r\n callback(null, Math.min(remainingTokens, self.content));\r\n });\r\n } else {\r\n // Remove the requested tokens from this bucket and fire the callback\r\n this.content -= count;\r\n process.nextTick(callback.bind(null, null, this.content));\r\n return true;\r\n }\r\n\r\n function comeBackLater() {\r\n // How long do we need to wait to make up the difference in tokens?\r\n var waitInterval = Math.ceil(\r\n (count - self.content) * (self.interval / self.tokensPerInterval));\r\n setTimeout(function() { self.removeTokens(count, callback); }, waitInterval);\r\n return false;\r\n }\r\n },\r\n\r\n /**\r\n * Attempt to remove the requested number of tokens and return immediately.\r\n * If the bucket (and any parent buckets) contains enough tokens this will\r\n * return true, otherwise false is returned.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Boolean} True if the tokens were successfully removed, otherwise\r\n * false.\r\n */\r\n tryRemoveTokens: function(count) {\r\n // Is this an infinite size bucket?\r\n if (!this.bucketSize)\r\n return true;\r\n\r\n // Make sure the bucket can hold the requested number of tokens\r\n if (count > this.bucketSize)\r\n return false;\r\n\r\n // Drip new tokens into this bucket\r\n this.drip();\r\n\r\n // If we don't have enough tokens in this bucket, return false\r\n if (count > this.content)\r\n return false;\r\n\r\n // Try to remove the requested tokens from the parent bucket\r\n if (this.parentBucket && !this.parentBucket.tryRemoveTokens(count))\r\n return false;\r\n\r\n // Remove the requested tokens from this bucket and return\r\n this.content -= count;\r\n return true;\r\n },\r\n\r\n /**\r\n * Add any new tokens to the bucket since the last drip.\r\n * @returns {Boolean} True if new tokens were added, otherwise false.\r\n */\r\n drip: function() {\r\n if (!this.tokensPerInterval) {\r\n this.content = this.bucketSize;\r\n return;\r\n }\r\n\r\n var now = +new Date();\r\n var deltaMS = Math.max(now - this.lastDrip, 0);\r\n this.lastDrip = now;\r\n\r\n var dripAmount = deltaMS * (this.tokensPerInterval / this.interval);\r\n this.content = Math.min(this.content + dripAmount, this.bucketSize);\r\n }\r\n};\r\n\r\nmodule.exports = TokenBucket;\r\n","var events = require('events')\nvar inherits = require('inherits')\n\nmodule.exports = LRU\n\nfunction LRU (opts) {\n if (!(this instanceof LRU)) return new LRU(opts)\n if (typeof opts === 'number') opts = {max: opts}\n if (!opts) opts = {}\n events.EventEmitter.call(this)\n this.cache = {}\n this.head = this.tail = null\n this.length = 0\n this.max = opts.max || 1000\n this.maxAge = opts.maxAge || 0\n}\n\ninherits(LRU, events.EventEmitter)\n\nObject.defineProperty(LRU.prototype, 'keys', {\n get: function () { return Object.keys(this.cache) }\n})\n\nLRU.prototype.clear = function () {\n this.cache = {}\n this.head = this.tail = null\n this.length = 0\n}\n\nLRU.prototype.remove = function (key) {\n if (typeof key !== 'string') key = '' + key\n if (!this.cache.hasOwnProperty(key)) return\n\n var element = this.cache[key]\n delete this.cache[key]\n this._unlink(key, element.prev, element.next)\n return element.value\n}\n\nLRU.prototype._unlink = function (key, prev, next) {\n this.length--\n\n if (this.length === 0) {\n this.head = this.tail = null\n } else {\n if (this.head === key) {\n this.head = prev\n this.cache[this.head].next = null\n } else if (this.tail === key) {\n this.tail = next\n this.cache[this.tail].prev = null\n } else {\n this.cache[prev].next = next\n this.cache[next].prev = prev\n }\n }\n}\n\nLRU.prototype.peek = function (key) {\n if (!this.cache.hasOwnProperty(key)) return\n\n var element = this.cache[key]\n\n if (!this._checkAge(key, element)) return\n return element.value\n}\n\nLRU.prototype.set = function (key, value) {\n if (typeof key !== 'string') key = '' + key\n\n var element\n\n if (this.cache.hasOwnProperty(key)) {\n element = this.cache[key]\n element.value = value\n if (this.maxAge) element.modified = Date.now()\n\n // If it's already the head, there's nothing more to do:\n if (key === this.head) return value\n this._unlink(key, element.prev, element.next)\n } else {\n element = {value: value, modified: 0, next: null, prev: null}\n if (this.maxAge) element.modified = Date.now()\n this.cache[key] = element\n\n // Eviction is only possible if the key didn't already exist:\n if (this.length === this.max) this.evict()\n }\n\n this.length++\n element.next = null\n element.prev = this.head\n\n if (this.head) this.cache[this.head].next = key\n this.head = key\n\n if (!this.tail) this.tail = key\n return value\n}\n\nLRU.prototype._checkAge = function (key, element) {\n if (this.maxAge && (Date.now() - element.modified) > this.maxAge) {\n this.remove(key)\n this.emit('evict', {key: key, value: element.value})\n return false\n }\n return true\n}\n\nLRU.prototype.get = function (key) {\n if (typeof key !== 'string') key = '' + key\n if (!this.cache.hasOwnProperty(key)) return\n\n var element = this.cache[key]\n\n if (!this._checkAge(key, element)) return\n\n if (this.head !== key) {\n if (key === this.tail) {\n this.tail = element.next\n this.cache[this.tail].prev = null\n } else {\n // Set prev.next -> element.next:\n this.cache[element.prev].next = element.next\n }\n\n // Set element.next.prev -> element.prev:\n this.cache[element.next].prev = element.prev\n\n // Element is the new head\n this.cache[this.head].next = key\n element.prev = this.head\n element.next = null\n this.head = key\n }\n\n return element.value\n}\n\nLRU.prototype.evict = function () {\n if (!this.tail) return\n var key = this.tail\n var value = this.remove(this.tail)\n this.emit('evict', {key: key, value: value})\n}\n","module.exports = Storage\n\nconst queueMicrotask = require('queue-microtask')\n\nfunction Storage (chunkLength, opts) {\n if (!(this instanceof Storage)) return new Storage(chunkLength, opts)\n if (!opts) opts = {}\n\n this.chunkLength = Number(chunkLength)\n if (!this.chunkLength) throw new Error('First argument must be a chunk length')\n\n this.chunks = []\n this.closed = false\n this.length = Number(opts.length) || Infinity\n\n if (this.length !== Infinity) {\n this.lastChunkLength = (this.length % this.chunkLength) || this.chunkLength\n this.lastChunkIndex = Math.ceil(this.length / this.chunkLength) - 1\n }\n}\n\nStorage.prototype.put = function (index, buf, cb = () => {}) {\n if (this.closed) return queueMicrotask(() => cb(new Error('Storage is closed')))\n\n const isLastChunk = (index === this.lastChunkIndex)\n if (isLastChunk && buf.length !== this.lastChunkLength) {\n return queueMicrotask(() => cb(new Error('Last chunk length must be ' + this.lastChunkLength)))\n }\n if (!isLastChunk && buf.length !== this.chunkLength) {\n return queueMicrotask(() => cb(new Error('Chunk length must be ' + this.chunkLength)))\n }\n this.chunks[index] = buf\n queueMicrotask(() => cb(null))\n}\n\nStorage.prototype.get = function (index, opts, cb = () => {}) {\n if (typeof opts === 'function') return this.get(index, null, opts)\n if (this.closed) return queueMicrotask(() => cb(new Error('Storage is closed')))\n\n let buf = this.chunks[index]\n\n if (!buf) {\n const err = new Error('Chunk not found')\n err.notFound = true\n return queueMicrotask(() => cb(err))\n }\n\n if (!opts) opts = {}\n\n const offset = opts.offset || 0\n const len = opts.length || (buf.length - offset)\n\n if (offset !== 0 || len !== buf.length) {\n buf = buf.slice(offset, len + offset)\n }\n\n queueMicrotask(() => cb(null, buf))\n}\n\nStorage.prototype.close = Storage.prototype.destroy = function (cb = () => {}) {\n if (this.closed) return queueMicrotask(() => cb(new Error('Storage is closed')))\n this.closed = true\n this.chunks = null\n queueMicrotask(() => cb(null))\n}\n","'use strict';\n\n/**\n * @param typeMap [Object] Map of MIME type -> Array[extensions]\n * @param ...\n */\nfunction Mime() {\n this._types = Object.create(null);\n this._extensions = Object.create(null);\n\n for (let i = 0; i < arguments.length; i++) {\n this.define(arguments[i]);\n }\n\n this.define = this.define.bind(this);\n this.getType = this.getType.bind(this);\n this.getExtension = this.getExtension.bind(this);\n}\n\n/**\n * Define mimetype -> extension mappings. Each key is a mime-type that maps\n * to an array of extensions associated with the type. The first extension is\n * used as the default extension for the type.\n *\n * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});\n *\n * If a type declares an extension that has already been defined, an error will\n * be thrown. To suppress this error and force the extension to be associated\n * with the new type, pass `force`=true. Alternatively, you may prefix the\n * extension with \"*\" to map the type to extension, without mapping the\n * extension to the type.\n *\n * e.g. mime.define({'audio/wav', ['wav']}, {'audio/x-wav', ['*wav']});\n *\n *\n * @param map (Object) type definitions\n * @param force (Boolean) if true, force overriding of existing definitions\n */\nMime.prototype.define = function(typeMap, force) {\n for (let type in typeMap) {\n let extensions = typeMap[type].map(function(t) {\n return t.toLowerCase();\n });\n type = type.toLowerCase();\n\n for (let i = 0; i < extensions.length; i++) {\n const ext = extensions[i];\n\n // '*' prefix = not the preferred type for this extension. So fixup the\n // extension, and skip it.\n if (ext[0] === '*') {\n continue;\n }\n\n if (!force && (ext in this._types)) {\n throw new Error(\n 'Attempt to change mapping for \"' + ext +\n '\" extension from \"' + this._types[ext] + '\" to \"' + type +\n '\". Pass `force=true` to allow this, otherwise remove \"' + ext +\n '\" from the list of extensions for \"' + type + '\".'\n );\n }\n\n this._types[ext] = type;\n }\n\n // Use first extension as default\n if (force || !this._extensions[type]) {\n const ext = extensions[0];\n this._extensions[type] = (ext[0] !== '*') ? ext : ext.substr(1);\n }\n }\n};\n\n/**\n * Lookup a mime type based on extension\n */\nMime.prototype.getType = function(path) {\n path = String(path);\n let last = path.replace(/^.*[/\\\\]/, '').toLowerCase();\n let ext = last.replace(/^.*\\./, '').toLowerCase();\n\n let hasPath = last.length < path.length;\n let hasDot = ext.length < last.length - 1;\n\n return (hasDot || !hasPath) && this._types[ext] || null;\n};\n\n/**\n * Return file extension associated with a mime type\n */\nMime.prototype.getExtension = function(type) {\n type = /^\\s*([^;\\s]*)/.test(type) && RegExp.$1;\n return type && this._extensions[type.toLowerCase()] || null;\n};\n\nmodule.exports = Mime;\n","'use strict';\n\nlet Mime = require('./Mime');\nmodule.exports = new Mime(require('./types/standard'));\n","module.exports = {\"application/andrew-inset\":[\"ez\"],\"application/applixware\":[\"aw\"],\"application/atom+xml\":[\"atom\"],\"application/atomcat+xml\":[\"atomcat\"],\"application/atomdeleted+xml\":[\"atomdeleted\"],\"application/atomsvc+xml\":[\"atomsvc\"],\"application/atsc-dwd+xml\":[\"dwd\"],\"application/atsc-held+xml\":[\"held\"],\"application/atsc-rsat+xml\":[\"rsat\"],\"application/bdoc\":[\"bdoc\"],\"application/calendar+xml\":[\"xcs\"],\"application/ccxml+xml\":[\"ccxml\"],\"application/cdfx+xml\":[\"cdfx\"],\"application/cdmi-capability\":[\"cdmia\"],\"application/cdmi-container\":[\"cdmic\"],\"application/cdmi-domain\":[\"cdmid\"],\"application/cdmi-object\":[\"cdmio\"],\"application/cdmi-queue\":[\"cdmiq\"],\"application/cu-seeme\":[\"cu\"],\"application/dash+xml\":[\"mpd\"],\"application/davmount+xml\":[\"davmount\"],\"application/docbook+xml\":[\"dbk\"],\"application/dssc+der\":[\"dssc\"],\"application/dssc+xml\":[\"xdssc\"],\"application/ecmascript\":[\"es\",\"ecma\"],\"application/emma+xml\":[\"emma\"],\"application/emotionml+xml\":[\"emotionml\"],\"application/epub+zip\":[\"epub\"],\"application/exi\":[\"exi\"],\"application/express\":[\"exp\"],\"application/fdt+xml\":[\"fdt\"],\"application/font-tdpfr\":[\"pfr\"],\"application/geo+json\":[\"geojson\"],\"application/gml+xml\":[\"gml\"],\"application/gpx+xml\":[\"gpx\"],\"application/gxf\":[\"gxf\"],\"application/gzip\":[\"gz\"],\"application/hjson\":[\"hjson\"],\"application/hyperstudio\":[\"stk\"],\"application/inkml+xml\":[\"ink\",\"inkml\"],\"application/ipfix\":[\"ipfix\"],\"application/its+xml\":[\"its\"],\"application/java-archive\":[\"jar\",\"war\",\"ear\"],\"application/java-serialized-object\":[\"ser\"],\"application/java-vm\":[\"class\"],\"application/javascript\":[\"js\",\"mjs\"],\"application/json\":[\"json\",\"map\"],\"application/json5\":[\"json5\"],\"application/jsonml+json\":[\"jsonml\"],\"application/ld+json\":[\"jsonld\"],\"application/lgr+xml\":[\"lgr\"],\"application/lost+xml\":[\"lostxml\"],\"application/mac-binhex40\":[\"hqx\"],\"application/mac-compactpro\":[\"cpt\"],\"application/mads+xml\":[\"mads\"],\"application/manifest+json\":[\"webmanifest\"],\"application/marc\":[\"mrc\"],\"application/marcxml+xml\":[\"mrcx\"],\"application/mathematica\":[\"ma\",\"nb\",\"mb\"],\"application/mathml+xml\":[\"mathml\"],\"application/mbox\":[\"mbox\"],\"application/mediaservercontrol+xml\":[\"mscml\"],\"application/metalink+xml\":[\"metalink\"],\"application/metalink4+xml\":[\"meta4\"],\"application/mets+xml\":[\"mets\"],\"application/mmt-aei+xml\":[\"maei\"],\"application/mmt-usd+xml\":[\"musd\"],\"application/mods+xml\":[\"mods\"],\"application/mp21\":[\"m21\",\"mp21\"],\"application/mp4\":[\"mp4s\",\"m4p\"],\"application/msword\":[\"doc\",\"dot\"],\"application/mxf\":[\"mxf\"],\"application/n-quads\":[\"nq\"],\"application/n-triples\":[\"nt\"],\"application/node\":[\"cjs\"],\"application/octet-stream\":[\"bin\",\"dms\",\"lrf\",\"mar\",\"so\",\"dist\",\"distz\",\"pkg\",\"bpk\",\"dump\",\"elc\",\"deploy\",\"exe\",\"dll\",\"deb\",\"dmg\",\"iso\",\"img\",\"msi\",\"msp\",\"msm\",\"buffer\"],\"application/oda\":[\"oda\"],\"application/oebps-package+xml\":[\"opf\"],\"application/ogg\":[\"ogx\"],\"application/omdoc+xml\":[\"omdoc\"],\"application/onenote\":[\"onetoc\",\"onetoc2\",\"onetmp\",\"onepkg\"],\"application/oxps\":[\"oxps\"],\"application/p2p-overlay+xml\":[\"relo\"],\"application/patch-ops-error+xml\":[\"xer\"],\"application/pdf\":[\"pdf\"],\"application/pgp-encrypted\":[\"pgp\"],\"application/pgp-signature\":[\"asc\",\"sig\"],\"application/pics-rules\":[\"prf\"],\"application/pkcs10\":[\"p10\"],\"application/pkcs7-mime\":[\"p7m\",\"p7c\"],\"application/pkcs7-signature\":[\"p7s\"],\"application/pkcs8\":[\"p8\"],\"application/pkix-attr-cert\":[\"ac\"],\"application/pkix-cert\":[\"cer\"],\"application/pkix-crl\":[\"crl\"],\"application/pkix-pkipath\":[\"pkipath\"],\"application/pkixcmp\":[\"pki\"],\"application/pls+xml\":[\"pls\"],\"application/postscript\":[\"ai\",\"eps\",\"ps\"],\"application/provenance+xml\":[\"provx\"],\"application/pskc+xml\":[\"pskcxml\"],\"application/raml+yaml\":[\"raml\"],\"application/rdf+xml\":[\"rdf\",\"owl\"],\"application/reginfo+xml\":[\"rif\"],\"application/relax-ng-compact-syntax\":[\"rnc\"],\"application/resource-lists+xml\":[\"rl\"],\"application/resource-lists-diff+xml\":[\"rld\"],\"application/rls-services+xml\":[\"rs\"],\"application/route-apd+xml\":[\"rapd\"],\"application/route-s-tsid+xml\":[\"sls\"],\"application/route-usd+xml\":[\"rusd\"],\"application/rpki-ghostbusters\":[\"gbr\"],\"application/rpki-manifest\":[\"mft\"],\"application/rpki-roa\":[\"roa\"],\"application/rsd+xml\":[\"rsd\"],\"application/rss+xml\":[\"rss\"],\"application/rtf\":[\"rtf\"],\"application/sbml+xml\":[\"sbml\"],\"application/scvp-cv-request\":[\"scq\"],\"application/scvp-cv-response\":[\"scs\"],\"application/scvp-vp-request\":[\"spq\"],\"application/scvp-vp-response\":[\"spp\"],\"application/sdp\":[\"sdp\"],\"application/senml+xml\":[\"senmlx\"],\"application/sensml+xml\":[\"sensmlx\"],\"application/set-payment-initiation\":[\"setpay\"],\"application/set-registration-initiation\":[\"setreg\"],\"application/shf+xml\":[\"shf\"],\"application/sieve\":[\"siv\",\"sieve\"],\"application/smil+xml\":[\"smi\",\"smil\"],\"application/sparql-query\":[\"rq\"],\"application/sparql-results+xml\":[\"srx\"],\"application/srgs\":[\"gram\"],\"application/srgs+xml\":[\"grxml\"],\"application/sru+xml\":[\"sru\"],\"application/ssdl+xml\":[\"ssdl\"],\"application/ssml+xml\":[\"ssml\"],\"application/swid+xml\":[\"swidtag\"],\"application/tei+xml\":[\"tei\",\"teicorpus\"],\"application/thraud+xml\":[\"tfi\"],\"application/timestamped-data\":[\"tsd\"],\"application/toml\":[\"toml\"],\"application/trig\":[\"trig\"],\"application/ttml+xml\":[\"ttml\"],\"application/ubjson\":[\"ubj\"],\"application/urc-ressheet+xml\":[\"rsheet\"],\"application/urc-targetdesc+xml\":[\"td\"],\"application/voicexml+xml\":[\"vxml\"],\"application/wasm\":[\"wasm\"],\"application/widget\":[\"wgt\"],\"application/winhlp\":[\"hlp\"],\"application/wsdl+xml\":[\"wsdl\"],\"application/wspolicy+xml\":[\"wspolicy\"],\"application/xaml+xml\":[\"xaml\"],\"application/xcap-att+xml\":[\"xav\"],\"application/xcap-caps+xml\":[\"xca\"],\"application/xcap-diff+xml\":[\"xdf\"],\"application/xcap-el+xml\":[\"xel\"],\"application/xcap-ns+xml\":[\"xns\"],\"application/xenc+xml\":[\"xenc\"],\"application/xhtml+xml\":[\"xhtml\",\"xht\"],\"application/xliff+xml\":[\"xlf\"],\"application/xml\":[\"xml\",\"xsl\",\"xsd\",\"rng\"],\"application/xml-dtd\":[\"dtd\"],\"application/xop+xml\":[\"xop\"],\"application/xproc+xml\":[\"xpl\"],\"application/xslt+xml\":[\"*xsl\",\"xslt\"],\"application/xspf+xml\":[\"xspf\"],\"application/xv+xml\":[\"mxml\",\"xhvml\",\"xvml\",\"xvm\"],\"application/yang\":[\"yang\"],\"application/yin+xml\":[\"yin\"],\"application/zip\":[\"zip\"],\"audio/3gpp\":[\"*3gpp\"],\"audio/adpcm\":[\"adp\"],\"audio/amr\":[\"amr\"],\"audio/basic\":[\"au\",\"snd\"],\"audio/midi\":[\"mid\",\"midi\",\"kar\",\"rmi\"],\"audio/mobile-xmf\":[\"mxmf\"],\"audio/mp3\":[\"*mp3\"],\"audio/mp4\":[\"m4a\",\"mp4a\"],\"audio/mpeg\":[\"mpga\",\"mp2\",\"mp2a\",\"mp3\",\"m2a\",\"m3a\"],\"audio/ogg\":[\"oga\",\"ogg\",\"spx\",\"opus\"],\"audio/s3m\":[\"s3m\"],\"audio/silk\":[\"sil\"],\"audio/wav\":[\"wav\"],\"audio/wave\":[\"*wav\"],\"audio/webm\":[\"weba\"],\"audio/xm\":[\"xm\"],\"font/collection\":[\"ttc\"],\"font/otf\":[\"otf\"],\"font/ttf\":[\"ttf\"],\"font/woff\":[\"woff\"],\"font/woff2\":[\"woff2\"],\"image/aces\":[\"exr\"],\"image/apng\":[\"apng\"],\"image/avif\":[\"avif\"],\"image/bmp\":[\"bmp\"],\"image/cgm\":[\"cgm\"],\"image/dicom-rle\":[\"drle\"],\"image/emf\":[\"emf\"],\"image/fits\":[\"fits\"],\"image/g3fax\":[\"g3\"],\"image/gif\":[\"gif\"],\"image/heic\":[\"heic\"],\"image/heic-sequence\":[\"heics\"],\"image/heif\":[\"heif\"],\"image/heif-sequence\":[\"heifs\"],\"image/hej2k\":[\"hej2\"],\"image/hsj2\":[\"hsj2\"],\"image/ief\":[\"ief\"],\"image/jls\":[\"jls\"],\"image/jp2\":[\"jp2\",\"jpg2\"],\"image/jpeg\":[\"jpeg\",\"jpg\",\"jpe\"],\"image/jph\":[\"jph\"],\"image/jphc\":[\"jhc\"],\"image/jpm\":[\"jpm\"],\"image/jpx\":[\"jpx\",\"jpf\"],\"image/jxr\":[\"jxr\"],\"image/jxra\":[\"jxra\"],\"image/jxrs\":[\"jxrs\"],\"image/jxs\":[\"jxs\"],\"image/jxsc\":[\"jxsc\"],\"image/jxsi\":[\"jxsi\"],\"image/jxss\":[\"jxss\"],\"image/ktx\":[\"ktx\"],\"image/ktx2\":[\"ktx2\"],\"image/png\":[\"png\"],\"image/sgi\":[\"sgi\"],\"image/svg+xml\":[\"svg\",\"svgz\"],\"image/t38\":[\"t38\"],\"image/tiff\":[\"tif\",\"tiff\"],\"image/tiff-fx\":[\"tfx\"],\"image/webp\":[\"webp\"],\"image/wmf\":[\"wmf\"],\"message/disposition-notification\":[\"disposition-notification\"],\"message/global\":[\"u8msg\"],\"message/global-delivery-status\":[\"u8dsn\"],\"message/global-disposition-notification\":[\"u8mdn\"],\"message/global-headers\":[\"u8hdr\"],\"message/rfc822\":[\"eml\",\"mime\"],\"model/3mf\":[\"3mf\"],\"model/gltf+json\":[\"gltf\"],\"model/gltf-binary\":[\"glb\"],\"model/iges\":[\"igs\",\"iges\"],\"model/mesh\":[\"msh\",\"mesh\",\"silo\"],\"model/mtl\":[\"mtl\"],\"model/obj\":[\"obj\"],\"model/step+xml\":[\"stpx\"],\"model/step+zip\":[\"stpz\"],\"model/step-xml+zip\":[\"stpxz\"],\"model/stl\":[\"stl\"],\"model/vrml\":[\"wrl\",\"vrml\"],\"model/x3d+binary\":[\"*x3db\",\"x3dbz\"],\"model/x3d+fastinfoset\":[\"x3db\"],\"model/x3d+vrml\":[\"*x3dv\",\"x3dvz\"],\"model/x3d+xml\":[\"x3d\",\"x3dz\"],\"model/x3d-vrml\":[\"x3dv\"],\"text/cache-manifest\":[\"appcache\",\"manifest\"],\"text/calendar\":[\"ics\",\"ifb\"],\"text/coffeescript\":[\"coffee\",\"litcoffee\"],\"text/css\":[\"css\"],\"text/csv\":[\"csv\"],\"text/html\":[\"html\",\"htm\",\"shtml\"],\"text/jade\":[\"jade\"],\"text/jsx\":[\"jsx\"],\"text/less\":[\"less\"],\"text/markdown\":[\"markdown\",\"md\"],\"text/mathml\":[\"mml\"],\"text/mdx\":[\"mdx\"],\"text/n3\":[\"n3\"],\"text/plain\":[\"txt\",\"text\",\"conf\",\"def\",\"list\",\"log\",\"in\",\"ini\"],\"text/richtext\":[\"rtx\"],\"text/rtf\":[\"*rtf\"],\"text/sgml\":[\"sgml\",\"sgm\"],\"text/shex\":[\"shex\"],\"text/slim\":[\"slim\",\"slm\"],\"text/spdx\":[\"spdx\"],\"text/stylus\":[\"stylus\",\"styl\"],\"text/tab-separated-values\":[\"tsv\"],\"text/troff\":[\"t\",\"tr\",\"roff\",\"man\",\"me\",\"ms\"],\"text/turtle\":[\"ttl\"],\"text/uri-list\":[\"uri\",\"uris\",\"urls\"],\"text/vcard\":[\"vcard\"],\"text/vtt\":[\"vtt\"],\"text/xml\":[\"*xml\"],\"text/yaml\":[\"yaml\",\"yml\"],\"video/3gpp\":[\"3gp\",\"3gpp\"],\"video/3gpp2\":[\"3g2\"],\"video/h261\":[\"h261\"],\"video/h263\":[\"h263\"],\"video/h264\":[\"h264\"],\"video/iso.segment\":[\"m4s\"],\"video/jpeg\":[\"jpgv\"],\"video/jpm\":[\"*jpm\",\"jpgm\"],\"video/mj2\":[\"mj2\",\"mjp2\"],\"video/mp2t\":[\"ts\"],\"video/mp4\":[\"mp4\",\"mp4v\",\"mpg4\"],\"video/mpeg\":[\"mpeg\",\"mpg\",\"mpe\",\"m1v\",\"m2v\"],\"video/ogg\":[\"ogv\"],\"video/quicktime\":[\"qt\",\"mov\"],\"video/webm\":[\"webm\"]};","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {};\n var type = typeof val;\n if (type === 'string' && val.length > 0) {\n return parse(val);\n } else if (type === 'number' && isFinite(val)) {\n return options.long ? fmtLong(val) : fmtShort(val);\n }\n throw new Error(\n 'val is not a non-empty string or a valid number. val=' +\n JSON.stringify(val)\n );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str);\n if (str.length > 100) {\n return;\n }\n var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n str\n );\n if (!match) {\n return;\n }\n var n = parseFloat(match[1]);\n var type = (match[2] || 'ms').toLowerCase();\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y;\n case 'weeks':\n case 'week':\n case 'w':\n return n * w;\n case 'days':\n case 'day':\n case 'd':\n return n * d;\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h;\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m;\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s;\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n;\n default:\n return undefined;\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n var msAbs = Math.abs(ms);\n if (msAbs >= d) {\n return Math.round(ms / d) + 'd';\n }\n if (msAbs >= h) {\n return Math.round(ms / h) + 'h';\n }\n if (msAbs >= m) {\n return Math.round(ms / m) + 'm';\n }\n if (msAbs >= s) {\n return Math.round(ms / s) + 's';\n }\n return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n var msAbs = Math.abs(ms);\n if (msAbs >= d) {\n return plural(ms, msAbs, d, 'day');\n }\n if (msAbs >= h) {\n return plural(ms, msAbs, h, 'hour');\n }\n if (msAbs >= m) {\n return plural(ms, msAbs, m, 'minute');\n }\n if (msAbs >= s) {\n return plural(ms, msAbs, s, 'second');\n }\n return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n var isPlural = msAbs >= n * 1.5;\n return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n","var wrappy = require('wrappy')\nmodule.exports = wrappy(once)\nmodule.exports.strict = wrappy(onceStrict)\n\nonce.proto = once(function () {\n Object.defineProperty(Function.prototype, 'once', {\n value: function () {\n return once(this)\n },\n configurable: true\n })\n\n Object.defineProperty(Function.prototype, 'onceStrict', {\n value: function () {\n return onceStrict(this)\n },\n configurable: true\n })\n})\n\nfunction once (fn) {\n var f = function () {\n if (f.called) return f.value\n f.called = true\n return f.value = fn.apply(this, arguments)\n }\n f.called = false\n return f\n}\n\nfunction onceStrict (fn) {\n var f = function () {\n if (f.called)\n throw new Error(f.onceError)\n f.called = true\n return f.value = fn.apply(this, arguments)\n }\n var name = fn.name || 'Function wrapped with `once`'\n f.onceError = name + \" shouldn't be called more than once\"\n f.called = false\n return f\n}\n","module.exports = length\n\nfunction length (bytes) {\n return Math.max(16384, 1 << Math.log2(bytes < 1024 ? 1 : bytes / 1024) + 0.5 | 0)\n}\n","var once = require('once')\nvar eos = require('end-of-stream')\nvar fs\n\ntry {\n fs = require('fs') // we only need fs to get the ReadStream and WriteStream prototypes\n} catch (e) {}\n\nvar noop = function () {}\nvar ancient = /^v?\\.0/.test(process.version)\n\nvar isFn = function (fn) {\n return typeof fn === 'function'\n}\n\nvar isFS = function (stream) {\n if (!ancient) return false // newer node version do not need to care about fs is a special way\n if (!fs) return false // browser\n return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)\n}\n\nvar isRequest = function (stream) {\n return stream.setHeader && isFn(stream.abort)\n}\n\nvar destroyer = function (stream, reading, writing, callback) {\n callback = once(callback)\n\n var closed = false\n stream.on('close', function () {\n closed = true\n })\n\n eos(stream, {readable: reading, writable: writing}, function (err) {\n if (err) return callback(err)\n closed = true\n callback()\n })\n\n var destroyed = false\n return function (err) {\n if (closed) return\n if (destroyed) return\n destroyed = true\n\n if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks\n if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want\n\n if (isFn(stream.destroy)) return stream.destroy()\n\n callback(err || new Error('stream was destroyed'))\n }\n}\n\nvar call = function (fn) {\n fn()\n}\n\nvar pipe = function (from, to) {\n return from.pipe(to)\n}\n\nvar pump = function () {\n var streams = Array.prototype.slice.call(arguments)\n var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop\n\n if (Array.isArray(streams[0])) streams = streams[0]\n if (streams.length < 2) throw new Error('pump requires two streams per minimum')\n\n var error\n var destroys = streams.map(function (stream, i) {\n var reading = i < streams.length - 1\n var writing = i > 0\n return destroyer(stream, reading, writing, function (err) {\n if (!error) error = err\n if (err) destroys.forEach(call)\n if (reading) return\n destroys.forEach(call)\n callback(error)\n })\n })\n\n return streams.reduce(pipe)\n}\n\nmodule.exports = pump\n","/*! queue-microtask. MIT License. Feross Aboukhadijeh */\nlet promise\n\nmodule.exports = typeof queueMicrotask === 'function'\n ? queueMicrotask.bind(typeof window !== 'undefined' ? window : global)\n // reuse resolved promise, and allocate it lazily\n : cb => (promise || (promise = Promise.resolve()))\n .then(cb)\n .catch(err => setTimeout(() => { throw err }, 0))\n","module.exports = typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn)\n","var iterate = function (list) {\n var offset = 0\n return function () {\n if (offset === list.length) return null\n\n var len = list.length - offset\n var i = (Math.random() * len) | 0\n var el = list[offset + i]\n\n var tmp = list[offset]\n list[offset] = el\n list[offset + i] = tmp\n offset++\n\n return el\n }\n}\n\nmodule.exports = iterate\n","/*!\n * range-parser\n * Copyright(c) 2012-2014 TJ Holowaychuk\n * Copyright(c) 2015-2016 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict'\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = rangeParser\n\n/**\n * Parse \"Range\" header `str` relative to the given file `size`.\n *\n * @param {Number} size\n * @param {String} str\n * @param {Object} [options]\n * @return {Array}\n * @public\n */\n\nfunction rangeParser (size, str, options) {\n if (typeof str !== 'string') {\n throw new TypeError('argument str must be a string')\n }\n\n var index = str.indexOf('=')\n\n if (index === -1) {\n return -2\n }\n\n // split the range string\n var arr = str.slice(index + 1).split(',')\n var ranges = []\n\n // add ranges type\n ranges.type = str.slice(0, index)\n\n // parse all ranges\n for (var i = 0; i < arr.length; i++) {\n var range = arr[i].split('-')\n var start = parseInt(range[0], 10)\n var end = parseInt(range[1], 10)\n\n // -nnn\n if (isNaN(start)) {\n start = size - end\n end = size - 1\n // nnn-\n } else if (isNaN(end)) {\n end = size - 1\n }\n\n // limit last-byte-pos to current length\n if (end > size - 1) {\n end = size - 1\n }\n\n // invalid or unsatisifiable\n if (isNaN(start) || isNaN(end) || start > end || start < 0) {\n continue\n }\n\n // add range\n ranges.push({\n start: start,\n end: end\n })\n }\n\n if (ranges.length < 1) {\n // unsatisifiable\n return -1\n }\n\n return options && options.combine\n ? combineRanges(ranges)\n : ranges\n}\n\n/**\n * Combine overlapping & adjacent ranges.\n * @private\n */\n\nfunction combineRanges (ranges) {\n var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart)\n\n for (var j = 0, i = 1; i < ordered.length; i++) {\n var range = ordered[i]\n var current = ordered[j]\n\n if (range.start > current.end + 1) {\n // next range\n ordered[++j] = range\n } else if (range.end > current.end) {\n // extend range\n current.end = range.end\n current.index = Math.min(current.index, range.index)\n }\n }\n\n // trim ordered array\n ordered.length = j + 1\n\n // generate combined range\n var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex)\n\n // copy ranges type\n combined.type = ranges.type\n\n return combined\n}\n\n/**\n * Map function to add index value to ranges.\n * @private\n */\n\nfunction mapWithIndex (range, index) {\n return {\n start: range.start,\n end: range.end,\n index: index\n }\n}\n\n/**\n * Map function to remove index value from ranges.\n * @private\n */\n\nfunction mapWithoutIndex (range) {\n return {\n start: range.start,\n end: range.end\n }\n}\n\n/**\n * Sort function to sort ranges by index.\n * @private\n */\n\nfunction sortByRangeIndex (a, b) {\n return a.index - b.index\n}\n\n/**\n * Sort function to sort ranges by start position.\n * @private\n */\n\nfunction sortByRangeStart (a, b) {\n return a.start - b.start\n}\n","\"use strict\";\n\n// Based on RC4 algorithm, as described in\n// http://en.wikipedia.org/wiki/RC4\n\nfunction isInteger(n) {\n return parseInt(n, 10) === n;\n}\n\nfunction createRC4(N) {\n function identityPermutation() {\n var s = new Array(N);\n for (var i = 0; i < N; i++) {\n s[i] = i;\n }\n return s;\n }\n\n // :: string | array integer -> array integer\n function seed(key) {\n if (key === undefined) {\n key = new Array(N);\n for (var k = 0; k < N; k++) {\n key[k] = Math.floor(Math.random() * N);\n }\n } else if (typeof key === \"string\") {\n // to string\n key = \"\" + key;\n key = key.split(\"\").map(function (c) { return c.charCodeAt(0) % N; });\n } else if (Array.isArray(key)) {\n if (!key.every(function (v) {\n return typeof v === \"number\" && v === (v | 0);\n })) {\n throw new TypeError(\"invalid seed key specified: not array of integers\");\n }\n } else {\n throw new TypeError(\"invalid seed key specified\");\n }\n\n var keylen = key.length;\n\n // resed state\n var s = identityPermutation();\n\n var j = 0;\n for (var i = 0; i < N; i++) {\n j = (j + s[i] + key[i % keylen]) % N;\n var tmp = s[i];\n s[i] = s[j];\n s[j] = tmp;\n }\n\n return s;\n }\n\n /* eslint-disable no-shadow */\n function RC4(key) {\n this.s = seed(key);\n this.i = 0;\n this.j = 0;\n }\n /* eslint-enable no-shadow */\n\n RC4.prototype.randomNative = function () {\n this.i = (this.i + 1) % N;\n this.j = (this.j + this.s[this.i]) % N;\n\n var tmp = this.s[this.i];\n this.s[this.i] = this.s[this.j];\n this.s[this.j] = tmp;\n\n var k = this.s[(this.s[this.i] + this.s[this.j]) % N];\n\n return k;\n };\n\n RC4.prototype.randomUInt32 = function () {\n var a = this.randomByte();\n var b = this.randomByte();\n var c = this.randomByte();\n var d = this.randomByte();\n\n return ((a * 256 + b) * 256 + c) * 256 + d;\n };\n\n RC4.prototype.randomFloat = function () {\n return this.randomUInt32() / 0x100000000;\n };\n\n RC4.prototype.random = function () {\n var a;\n var b;\n\n if (arguments.length === 1) {\n a = 0;\n b = arguments[0];\n } else if (arguments.length === 2) {\n a = arguments[0];\n b = arguments[1];\n } else {\n throw new TypeError(\"random takes one or two integer arguments\");\n }\n\n if (!isInteger(a) || !isInteger(b)) {\n throw new TypeError(\"random takes one or two integer arguments\");\n }\n\n return a + this.randomUInt32() % (b - a + 1);\n };\n\n RC4.prototype.currentState = function () {\n return {\n i: this.i,\n j: this.j,\n s: this.s.slice(), // copy\n };\n };\n\n RC4.prototype.setState = function (state) {\n var s = state.s;\n var i = state.i;\n var j = state.j;\n\n /* eslint-disable yoda */\n if (!(i === (i | 0) && 0 <= i && i < N)) {\n throw new Error(\"state.i should be integer [0, \" + (N - 1) + \"]\");\n }\n\n if (!(j === (j | 0) && 0 <= j && j < N)) {\n throw new Error(\"state.j should be integer [0, \" + (N - 1) + \"]\");\n }\n /* eslint-enable yoda */\n\n // check length\n if (!Array.isArray(s) || s.length !== N) {\n throw new Error(\"state should be array of length \" + N);\n }\n\n // check that all params are there\n for (var k = 0; k < N; k++) {\n if (s.indexOf(k) === -1) {\n throw new Error(\"state should be permutation of 0..\" + (N - 1) + \": \" + k + \" is missing\");\n }\n }\n\n this.i = i;\n this.j = j;\n this.s = s.slice(); // assign copy\n };\n\n return RC4;\n}\n\nvar RC4 = createRC4(256);\nRC4.prototype.randomByte = RC4.prototype.randomNative;\n\nvar RC4small = createRC4(16);\nRC4small.prototype.randomByte = function () {\n var a = this.randomNative();\n var b = this.randomNative();\n\n return a * 16 + b;\n};\n\nvar ordA = \"a\".charCodeAt(0);\nvar ord0 = \"0\".charCodeAt(0);\n\nfunction toHex(n) {\n return n < 10 ? String.fromCharCode(ord0 + n) : String.fromCharCode(ordA + n - 10);\n}\n\nfunction fromHex(c) {\n return parseInt(c, 16);\n}\n\nRC4small.prototype.currentStateString = function () {\n var state = this.currentState();\n\n var i = toHex(state.i);\n var j = toHex(state.j);\n\n var res = i + j + state.s.map(toHex).join(\"\");\n return res;\n};\n\nRC4small.prototype.setStateString = function (stateString) {\n if (!stateString.match(/^[0-9a-f]{18}$/)) {\n throw new TypeError(\"RC4small stateString should be 18 hex character string\");\n }\n\n var i = fromHex(stateString[0]);\n var j = fromHex(stateString[1]);\n var s = stateString.split(\"\").slice(2).map(fromHex);\n\n this.setState({\n i: i,\n j: j,\n s: s,\n });\n};\n\nRC4.RC4small = RC4small;\n\nmodule.exports = RC4;\n","/*! run-parallel-limit. MIT License. Feross Aboukhadijeh */\nmodule.exports = runParallelLimit\n\nconst queueMicrotask = require('queue-microtask')\n\nfunction runParallelLimit (tasks, limit, cb) {\n if (typeof limit !== 'number') throw new Error('second argument must be a Number')\n let results, len, pending, keys, isErrored\n let isSync = true\n let next\n\n if (Array.isArray(tasks)) {\n results = []\n pending = len = tasks.length\n } else {\n keys = Object.keys(tasks)\n results = {}\n pending = len = keys.length\n }\n\n function done (err) {\n function end () {\n if (cb) cb(err, results)\n cb = null\n }\n if (isSync) queueMicrotask(end)\n else end()\n }\n\n function each (i, err, result) {\n results[i] = result\n if (err) isErrored = true\n if (--pending === 0 || err) {\n done(err)\n } else if (!isErrored && next < len) {\n let key\n if (keys) {\n key = keys[next]\n next += 1\n tasks[key](function (err, result) { each(key, err, result) })\n } else {\n key = next\n next += 1\n tasks[key](function (err, result) { each(key, err, result) })\n }\n }\n }\n\n next = limit\n if (!pending) {\n // empty\n done(null)\n } else if (keys) {\n // object\n keys.some(function (key, i) {\n tasks[key](function (err, result) { each(key, err, result) })\n if (i === limit - 1) return true // early return\n return false\n })\n } else {\n // array\n tasks.some(function (task, i) {\n task(function (err, result) { each(i, err, result) })\n if (i === limit - 1) return true // early return\n return false\n })\n }\n\n isSync = false\n}\n","/*! run-parallel. MIT License. Feross Aboukhadijeh */\nmodule.exports = runParallel\n\nconst queueMicrotask = require('queue-microtask')\n\nfunction runParallel (tasks, cb) {\n let results, pending, keys\n let isSync = true\n\n if (Array.isArray(tasks)) {\n results = []\n pending = tasks.length\n } else {\n keys = Object.keys(tasks)\n results = {}\n pending = keys.length\n }\n\n function done (err) {\n function end () {\n if (cb) cb(err, results)\n cb = null\n }\n if (isSync) queueMicrotask(end)\n else end()\n }\n\n function each (i, err, result) {\n results[i] = result\n if (--pending === 0 || err) {\n done(err)\n }\n }\n\n if (!pending) {\n // empty\n done(null)\n } else if (keys) {\n // object\n keys.forEach(function (key) {\n tasks[key](function (err, result) { each(key, err, result) })\n })\n } else {\n // array\n tasks.forEach(function (task, i) {\n task(function (err, result) { each(i, err, result) })\n })\n }\n\n isSync = false\n}\n","const Throttle = require('./lib/throttle')\nconst ThrottleGroup = require('./lib/throttle-group')\n\nmodule.exports = {\n Throttle,\n ThrottleGroup\n}\n","const { TokenBucket } = require('limiter')\nconst Throttle = require('./throttle')\n\nclass ThrottleGroup {\n constructor (opts = {}) {\n if (typeof opts !== 'object') throw new Error('Options must be an object')\n\n this.throttles = []\n this.setEnabled(opts.enabled)\n this.setRate(opts.rate, opts.chunksize)\n }\n\n getEnabled () {\n return this._enabled\n }\n\n getRate () {\n // Note: bucketSize === tokensPerInterval\n return this.bucket.tokensPerInterval\n }\n\n getChunksize () {\n return this.chunksize\n }\n\n setEnabled (val = true) {\n if (typeof val !== 'boolean') throw new Error('Enabled must be a boolean')\n\n this._enabled = val\n for (const throttle of this.throttles) {\n throttle.setEnabled(val)\n }\n }\n\n setRate (rate, chunksize = null) {\n // Note: rate = 0, means we should stop processing chunks\n if (!Number.isInteger(rate) || rate < 0) throw new Error('Rate must be an integer bigger than zero')\n rate = parseInt(rate)\n\n if (chunksize && (typeof chunksize !== 'number' || chunksize <= 0)) throw new Error('Chunksize must be bigger than zero')\n chunksize = chunksize || Math.max(parseInt(rate / 10), 1)\n chunksize = parseInt(chunksize)\n if (rate > 0 && chunksize > rate) throw new Error('Chunk size must be smaller than rate')\n\n if (!this.bucket) this.bucket = new TokenBucket(rate, rate, 'second', null)\n\n this.bucket.bucketSize = rate\n this.bucket.tokensPerInterval = rate\n this.chunksize = chunksize\n }\n\n setChunksize (chunksize) {\n if (!Number.isInteger(chunksize) || chunksize <= 0) throw new Error('Chunk size must be an integer bigger than zero')\n const rate = this.getRate()\n chunksize = parseInt(chunksize)\n if (rate > 0 && chunksize > rate) throw new Error('Chunk size must be smaller than rate')\n this.chunksize = chunksize\n }\n\n throttle (opts = {}) {\n if (typeof opts !== 'object') throw new Error('Options must be an object')\n\n const newThrottle = new Throttle({\n ...opts,\n group: this\n })\n\n return newThrottle\n }\n\n destroy () {\n for (const throttle of this.throttles) {\n throttle.destroy()\n }\n\n this.throttles = []\n }\n\n _addThrottle (throttle) {\n if (!(throttle instanceof Throttle)) throw new Error('Throttle must be an instance of Throttle')\n\n this.throttles.push(throttle)\n }\n\n _removeThrottle (throttle) {\n const index = this.throttles.indexOf(throttle)\n if (index > -1) this.throttles.splice(index, 1)\n }\n}\n\nmodule.exports = ThrottleGroup\n","const { EventEmitter } = require('events')\nconst { Transform } = require('streamx')\nconst { wait } = require('./utils')\n\nclass Throttle extends Transform {\n constructor (opts = {}) {\n super()\n\n if (typeof opts !== 'object') throw new Error('Options must be an object')\n\n const params = Object.assign({}, opts)\n\n if (params.group && !(params.group instanceof ThrottleGroup)) throw new Error('Group must be an instanece of ThrottleGroup')\n else if (!params.group) params.group = new ThrottleGroup(params)\n\n this._setEnabled(params.enabled || params.group.enabled)\n this._group = params.group\n this._emitter = new EventEmitter()\n this._destroyed = false\n\n this._group._addThrottle(this)\n }\n\n getEnabled () {\n return this._enabled\n }\n\n getGroup () {\n return this._group\n }\n\n _setEnabled (val = true) {\n if (typeof val !== 'boolean') throw new Error('Enabled must be a boolean')\n this._enabled = val\n }\n\n setEnabled (val) {\n this._setEnabled(val)\n if (this._enabled) this._emitter.emit('enabled')\n else this._emitter.emit('disabled')\n }\n\n _transform (chunk, done) {\n this._processChunk(chunk, done)\n }\n\n /* async _waitForPositiveRate () {\n // Stop pushing chunks if rate is zero\n while (this._group.getRate() === 0 && !this._destroyed && this._areBothEnabled()) {\n await wait(1 * 1000) // wait 1 second\n }\n } */\n\n async _waitForTokens (amount) {\n // Wait for enabled, destroyed or tokens\n return new Promise((resolve, reject) => {\n let done = false\n const self = this\n function isDone (err) {\n self._emitter.removeListener('disabled', isDone)\n self._emitter.removeListener('destroyed', isDone)\n\n if (done) return\n done = true\n if (err) return reject(err)\n resolve()\n }\n this._emitter.once('disabled', isDone)\n this._emitter.once('destroyed', isDone)\n // TODO: next version remove lisener in \"isDone\"\n this._group.bucket.removeTokens(amount, isDone)\n })\n }\n\n _areBothEnabled () {\n return this._enabled && this._group.getEnabled()\n }\n\n /* async _throttleChunk (size) {\n // Stop pushing chunks if rate is zero\n await this._waitForPositiveRate()\n if (this._destroyed) return\n if (!this._areBothEnabled()) return\n\n // Get tokens from bucket\n await this._waitForTokens(size)\n } */\n\n async _processChunk (chunk, done) {\n if (!this._areBothEnabled()) return done(null, chunk)\n\n let pos = 0\n let chunksize = this._group.getChunksize()\n let slice = chunk.slice(pos, pos + chunksize)\n while (slice.length > 0) {\n // Check here again because we might be in the middle of a big chunk\n // with a lot of small slices\n if (this._areBothEnabled()) {\n try {\n // WAIT FOR POSITIVE RATE\n // Stop pushing chunks if rate is zero\n while (this._group.getRate() === 0 && !this._destroyed && this._areBothEnabled()) {\n await wait(1000) // wait 1 second\n if (this._destroyed) return\n }\n\n // WAIT FOR TOKENS\n if (this._areBothEnabled() && !this._group.bucket.tryRemoveTokens(slice.length)) {\n await this._waitForTokens(slice.length)\n if (this._destroyed) return\n }\n } catch (err) {\n return done(err)\n }\n }\n\n this.push(slice)\n pos += chunksize\n\n // Calculate params for next slice\n chunksize = (this._areBothEnabled())\n ? this._group.getChunksize() // Chunksize might have changed\n : chunk.length - pos // Get the rest of the chunk\n slice = chunk.slice(pos, pos + chunksize)\n }\n\n return done()\n }\n\n destroy (...args) {\n this._group._removeThrottle(this)\n\n this._destroyed = true\n this._emitter.emit('destroyed')\n\n super.destroy(...args)\n }\n}\n\nmodule.exports = Throttle\n\n// Fix circular dependency\nconst ThrottleGroup = require('./throttle-group')\n","function wait (time) {\n return new Promise((resolve) => setTimeout(resolve, time))\n}\n\nmodule.exports = {\n wait\n}\n","const { EventEmitter } = require('events')\nconst STREAM_DESTROYED = new Error('Stream was destroyed')\nconst PREMATURE_CLOSE = new Error('Premature close')\n\nconst queueTick = require('queue-tick')\nconst FIFO = require('fast-fifo')\nconst TextDecoder = require('text-decoder')\n\n/* eslint-disable no-multi-spaces */\n\n// 29 bits used total (4 from shared, 14 from read, and 11 from write)\nconst MAX = ((1 << 29) - 1)\n\n// Shared state\nconst OPENING = 0b0001\nconst PREDESTROYING = 0b0010\nconst DESTROYING = 0b0100\nconst DESTROYED = 0b1000\n\nconst NOT_OPENING = MAX ^ OPENING\nconst NOT_PREDESTROYING = MAX ^ PREDESTROYING\n\n// Read state (4 bit offset from shared state)\nconst READ_ACTIVE = 0b00000000000001 << 4\nconst READ_UPDATING = 0b00000000000010 << 4\nconst READ_PRIMARY = 0b00000000000100 << 4\nconst READ_QUEUED = 0b00000000001000 << 4\nconst READ_RESUMED = 0b00000000010000 << 4\nconst READ_PIPE_DRAINED = 0b00000000100000 << 4\nconst READ_ENDING = 0b00000001000000 << 4\nconst READ_EMIT_DATA = 0b00000010000000 << 4\nconst READ_EMIT_READABLE = 0b00000100000000 << 4\nconst READ_EMITTED_READABLE = 0b00001000000000 << 4\nconst READ_DONE = 0b00010000000000 << 4\nconst READ_NEXT_TICK = 0b00100000000000 << 4\nconst READ_NEEDS_PUSH = 0b01000000000000 << 4\nconst READ_READ_AHEAD = 0b10000000000000 << 4\n\n// Combined read state\nconst READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED\nconst READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH\nconst READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE\nconst READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED\nconst READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD\n\nconst READ_NOT_ACTIVE = MAX ^ READ_ACTIVE\nconst READ_NON_PRIMARY = MAX ^ READ_PRIMARY\nconst READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH)\nconst READ_PUSHED = MAX ^ READ_NEEDS_PUSH\nconst READ_PAUSED = MAX ^ READ_RESUMED\nconst READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE)\nconst READ_NOT_ENDING = MAX ^ READ_ENDING\nconst READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING\nconst READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK\nconst READ_NOT_UPDATING = MAX ^ READ_UPDATING\nconst READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD\nconst READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD\n\n// Write state (18 bit offset, 4 bit offset from shared state and 14 from read state)\nconst WRITE_ACTIVE = 0b00000000001 << 18\nconst WRITE_UPDATING = 0b00000000010 << 18\nconst WRITE_PRIMARY = 0b00000000100 << 18\nconst WRITE_QUEUED = 0b00000001000 << 18\nconst WRITE_UNDRAINED = 0b00000010000 << 18\nconst WRITE_DONE = 0b00000100000 << 18\nconst WRITE_EMIT_DRAIN = 0b00001000000 << 18\nconst WRITE_NEXT_TICK = 0b00010000000 << 18\nconst WRITE_WRITING = 0b00100000000 << 18\nconst WRITE_FINISHING = 0b01000000000 << 18\nconst WRITE_CORKED = 0b10000000000 << 18\n\nconst WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING)\nconst WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY\nconst WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING)\nconst WRITE_DRAINED = MAX ^ WRITE_UNDRAINED\nconst WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED\nconst WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK\nconst WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING\nconst WRITE_NOT_CORKED = MAX ^ WRITE_CORKED\n\n// Combined shared state\nconst ACTIVE = READ_ACTIVE | WRITE_ACTIVE\nconst NOT_ACTIVE = MAX ^ ACTIVE\nconst DONE = READ_DONE | WRITE_DONE\nconst DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING\nconst OPEN_STATUS = DESTROY_STATUS | OPENING\nconst AUTO_DESTROY = DESTROY_STATUS | DONE\nconst NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY\nconst ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK\nconst TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE\nconst IS_OPENING = OPEN_STATUS | TICKING\n\n// Combined shared state and read state\nconst READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE\nconst READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED\nconst READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED\nconst READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE\nconst SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD\nconst READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE\nconst READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY\n\n// Combined write state\nconst WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE\nconst WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED\nconst WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE\nconst WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE\nconst WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED\nconst WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE\nconst WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING\nconst WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE\nconst WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE\nconst WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY\nconst WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS\n\nconst asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator')\n\nclass WritableState {\n constructor (stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {\n this.stream = stream\n this.queue = new FIFO()\n this.highWaterMark = highWaterMark\n this.buffered = 0\n this.error = null\n this.pipeline = null\n this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr\n this.byteLength = byteLengthWritable || byteLength || defaultByteLength\n this.map = mapWritable || map\n this.afterWrite = afterWrite.bind(this)\n this.afterUpdateNextTick = updateWriteNT.bind(this)\n }\n\n get ended () {\n return (this.stream._duplexState & WRITE_DONE) !== 0\n }\n\n push (data) {\n if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false\n if (this.map !== null) data = this.map(data)\n\n this.buffered += this.byteLength(data)\n this.queue.push(data)\n\n if (this.buffered < this.highWaterMark) {\n this.stream._duplexState |= WRITE_QUEUED\n return true\n }\n\n this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED\n return false\n }\n\n shift () {\n const data = this.queue.shift()\n\n this.buffered -= this.byteLength(data)\n if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED\n\n return data\n }\n\n end (data) {\n if (typeof data === 'function') this.stream.once('finish', data)\n else if (data !== undefined && data !== null) this.push(data)\n this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY\n }\n\n autoBatch (data, cb) {\n const buffer = []\n const stream = this.stream\n\n buffer.push(data)\n while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {\n buffer.push(stream._writableState.shift())\n }\n\n if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null)\n stream._writev(buffer, cb)\n }\n\n update () {\n const stream = this.stream\n\n stream._duplexState |= WRITE_UPDATING\n\n do {\n while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {\n const data = this.shift()\n stream._duplexState |= WRITE_ACTIVE_AND_WRITING\n stream._write(data, this.afterWrite)\n }\n\n if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()\n } while (this.continueUpdate() === true)\n\n stream._duplexState &= WRITE_NOT_UPDATING\n }\n\n updateNonPrimary () {\n const stream = this.stream\n\n if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {\n stream._duplexState = stream._duplexState | WRITE_ACTIVE\n stream._final(afterFinal.bind(this))\n return\n }\n\n if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {\n if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {\n stream._duplexState |= ACTIVE\n stream._destroy(afterDestroy.bind(this))\n }\n return\n }\n\n if ((stream._duplexState & IS_OPENING) === OPENING) {\n stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING\n stream._open(afterOpen.bind(this))\n }\n }\n\n continueUpdate () {\n if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false\n this.stream._duplexState &= WRITE_NOT_NEXT_TICK\n return true\n }\n\n updateCallback () {\n if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update()\n else this.updateNextTick()\n }\n\n updateNextTick () {\n if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return\n this.stream._duplexState |= WRITE_NEXT_TICK\n if ((this.stream._duplexState & WRITE_UPDATING) === 0) queueTick(this.afterUpdateNextTick)\n }\n}\n\nclass ReadableState {\n constructor (stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {\n this.stream = stream\n this.queue = new FIFO()\n this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark\n this.buffered = 0\n this.readAhead = highWaterMark > 0\n this.error = null\n this.pipeline = null\n this.byteLength = byteLengthReadable || byteLength || defaultByteLength\n this.map = mapReadable || map\n this.pipeTo = null\n this.afterRead = afterRead.bind(this)\n this.afterUpdateNextTick = updateReadNT.bind(this)\n }\n\n get ended () {\n return (this.stream._duplexState & READ_DONE) !== 0\n }\n\n pipe (pipeTo, cb) {\n if (this.pipeTo !== null) throw new Error('Can only pipe to one destination')\n if (typeof cb !== 'function') cb = null\n\n this.stream._duplexState |= READ_PIPE_DRAINED\n this.pipeTo = pipeTo\n this.pipeline = new Pipeline(this.stream, pipeTo, cb)\n\n if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes\n\n if (isStreamx(pipeTo)) {\n pipeTo._writableState.pipeline = this.pipeline\n if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes\n pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself\n } else {\n const onerror = this.pipeline.done.bind(this.pipeline, pipeTo)\n const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg\n pipeTo.on('error', onerror)\n pipeTo.on('close', onclose)\n pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline))\n }\n\n pipeTo.on('drain', afterDrain.bind(this))\n this.stream.emit('piping', pipeTo)\n pipeTo.emit('pipe', this.stream)\n }\n\n push (data) {\n const stream = this.stream\n\n if (data === null) {\n this.highWaterMark = 0\n stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED\n return false\n }\n\n if (this.map !== null) {\n data = this.map(data)\n if (data === null) {\n stream._duplexState &= READ_PUSHED\n return this.buffered < this.highWaterMark\n }\n }\n\n this.buffered += this.byteLength(data)\n this.queue.push(data)\n\n stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED\n\n return this.buffered < this.highWaterMark\n }\n\n shift () {\n const data = this.queue.shift()\n\n this.buffered -= this.byteLength(data)\n if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED\n return data\n }\n\n unshift (data) {\n const pending = [this.map !== null ? this.map(data) : data]\n while (this.buffered > 0) pending.push(this.shift())\n\n for (let i = 0; i < pending.length - 1; i++) {\n const data = pending[i]\n this.buffered += this.byteLength(data)\n this.queue.push(data)\n }\n\n this.push(pending[pending.length - 1])\n }\n\n read () {\n const stream = this.stream\n\n if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {\n const data = this.shift()\n if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED\n if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)\n return data\n }\n\n if (this.readAhead === false) {\n stream._duplexState |= READ_READ_AHEAD\n this.updateNextTick()\n }\n\n return null\n }\n\n drain () {\n const stream = this.stream\n\n while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {\n const data = this.shift()\n if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED\n if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)\n }\n }\n\n update () {\n const stream = this.stream\n\n stream._duplexState |= READ_UPDATING\n\n do {\n this.drain()\n\n while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) {\n stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH\n stream._read(this.afterRead)\n this.drain()\n }\n\n if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {\n stream._duplexState |= READ_EMITTED_READABLE\n stream.emit('readable')\n }\n\n if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()\n } while (this.continueUpdate() === true)\n\n stream._duplexState &= READ_NOT_UPDATING\n }\n\n updateNonPrimary () {\n const stream = this.stream\n\n if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {\n stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING\n stream.emit('end')\n if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING\n if (this.pipeTo !== null) this.pipeTo.end()\n }\n\n if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {\n if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {\n stream._duplexState |= ACTIVE\n stream._destroy(afterDestroy.bind(this))\n }\n return\n }\n\n if ((stream._duplexState & IS_OPENING) === OPENING) {\n stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING\n stream._open(afterOpen.bind(this))\n }\n }\n\n continueUpdate () {\n if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false\n this.stream._duplexState &= READ_NOT_NEXT_TICK\n return true\n }\n\n updateCallback () {\n if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update()\n else this.updateNextTick()\n }\n\n updateNextTick () {\n if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return\n this.stream._duplexState |= READ_NEXT_TICK\n if ((this.stream._duplexState & READ_UPDATING) === 0) queueTick(this.afterUpdateNextTick)\n }\n}\n\nclass TransformState {\n constructor (stream) {\n this.data = null\n this.afterTransform = afterTransform.bind(stream)\n this.afterFinal = null\n }\n}\n\nclass Pipeline {\n constructor (src, dst, cb) {\n this.from = src\n this.to = dst\n this.afterPipe = cb\n this.error = null\n this.pipeToFinished = false\n }\n\n finished () {\n this.pipeToFinished = true\n }\n\n done (stream, err) {\n if (err) this.error = err\n\n if (stream === this.to) {\n this.to = null\n\n if (this.from !== null) {\n if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {\n this.from.destroy(this.error || new Error('Writable stream closed prematurely'))\n }\n return\n }\n }\n\n if (stream === this.from) {\n this.from = null\n\n if (this.to !== null) {\n if ((stream._duplexState & READ_DONE) === 0) {\n this.to.destroy(this.error || new Error('Readable stream closed before ending'))\n }\n return\n }\n }\n\n if (this.afterPipe !== null) this.afterPipe(this.error)\n this.to = this.from = this.afterPipe = null\n }\n}\n\nfunction afterDrain () {\n this.stream._duplexState |= READ_PIPE_DRAINED\n this.updateCallback()\n}\n\nfunction afterFinal (err) {\n const stream = this.stream\n if (err) stream.destroy(err)\n if ((stream._duplexState & DESTROY_STATUS) === 0) {\n stream._duplexState |= WRITE_DONE\n stream.emit('finish')\n }\n if ((stream._duplexState & AUTO_DESTROY) === DONE) {\n stream._duplexState |= DESTROYING\n }\n\n stream._duplexState &= WRITE_NOT_FINISHING\n\n // no need to wait the extra tick here, so we short circuit that\n if ((stream._duplexState & WRITE_UPDATING) === 0) this.update()\n else this.updateNextTick()\n}\n\nfunction afterDestroy (err) {\n const stream = this.stream\n\n if (!err && this.error !== STREAM_DESTROYED) err = this.error\n if (err) stream.emit('error', err)\n stream._duplexState |= DESTROYED\n stream.emit('close')\n\n const rs = stream._readableState\n const ws = stream._writableState\n\n if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err)\n\n if (ws !== null) {\n while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false)\n if (ws.pipeline !== null) ws.pipeline.done(stream, err)\n }\n}\n\nfunction afterWrite (err) {\n const stream = this.stream\n\n if (err) stream.destroy(err)\n stream._duplexState &= WRITE_NOT_ACTIVE\n\n if (this.drains !== null) tickDrains(this.drains)\n\n if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {\n stream._duplexState &= WRITE_DRAINED\n if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {\n stream.emit('drain')\n }\n }\n\n this.updateCallback()\n}\n\nfunction afterRead (err) {\n if (err) this.stream.destroy(err)\n this.stream._duplexState &= READ_NOT_ACTIVE\n if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) this.stream._duplexState &= READ_NO_READ_AHEAD\n this.updateCallback()\n}\n\nfunction updateReadNT () {\n if ((this.stream._duplexState & READ_UPDATING) === 0) {\n this.stream._duplexState &= READ_NOT_NEXT_TICK\n this.update()\n }\n}\n\nfunction updateWriteNT () {\n if ((this.stream._duplexState & WRITE_UPDATING) === 0) {\n this.stream._duplexState &= WRITE_NOT_NEXT_TICK\n this.update()\n }\n}\n\nfunction tickDrains (drains) {\n for (let i = 0; i < drains.length; i++) {\n // drains.writes are monotonic, so if one is 0 its always the first one\n if (--drains[i].writes === 0) {\n drains.shift().resolve(true)\n i--\n }\n }\n}\n\nfunction afterOpen (err) {\n const stream = this.stream\n\n if (err) stream.destroy(err)\n\n if ((stream._duplexState & DESTROYING) === 0) {\n if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY\n if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY\n stream.emit('open')\n }\n\n stream._duplexState &= NOT_ACTIVE\n\n if (stream._writableState !== null) {\n stream._writableState.updateCallback()\n }\n\n if (stream._readableState !== null) {\n stream._readableState.updateCallback()\n }\n}\n\nfunction afterTransform (err, data) {\n if (data !== undefined && data !== null) this.push(data)\n this._writableState.afterWrite(err)\n}\n\nfunction newListener (name) {\n if (this._readableState !== null) {\n if (name === 'data') {\n this._duplexState |= (READ_EMIT_DATA | READ_RESUMED_READ_AHEAD)\n this._readableState.updateNextTick()\n }\n if (name === 'readable') {\n this._duplexState |= READ_EMIT_READABLE\n this._readableState.updateNextTick()\n }\n }\n\n if (this._writableState !== null) {\n if (name === 'drain') {\n this._duplexState |= WRITE_EMIT_DRAIN\n this._writableState.updateNextTick()\n }\n }\n}\n\nclass Stream extends EventEmitter {\n constructor (opts) {\n super()\n\n this._duplexState = 0\n this._readableState = null\n this._writableState = null\n\n if (opts) {\n if (opts.open) this._open = opts.open\n if (opts.destroy) this._destroy = opts.destroy\n if (opts.predestroy) this._predestroy = opts.predestroy\n if (opts.signal) {\n opts.signal.addEventListener('abort', abort.bind(this))\n }\n }\n\n this.on('newListener', newListener)\n }\n\n _open (cb) {\n cb(null)\n }\n\n _destroy (cb) {\n cb(null)\n }\n\n _predestroy () {\n // does nothing\n }\n\n get readable () {\n return this._readableState !== null ? true : undefined\n }\n\n get writable () {\n return this._writableState !== null ? true : undefined\n }\n\n get destroyed () {\n return (this._duplexState & DESTROYED) !== 0\n }\n\n get destroying () {\n return (this._duplexState & DESTROY_STATUS) !== 0\n }\n\n destroy (err) {\n if ((this._duplexState & DESTROY_STATUS) === 0) {\n if (!err) err = STREAM_DESTROYED\n this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY\n\n if (this._readableState !== null) {\n this._readableState.highWaterMark = 0\n this._readableState.error = err\n }\n if (this._writableState !== null) {\n this._writableState.highWaterMark = 0\n this._writableState.error = err\n }\n\n this._duplexState |= PREDESTROYING\n this._predestroy()\n this._duplexState &= NOT_PREDESTROYING\n\n if (this._readableState !== null) this._readableState.updateNextTick()\n if (this._writableState !== null) this._writableState.updateNextTick()\n }\n }\n}\n\nclass Readable extends Stream {\n constructor (opts) {\n super(opts)\n\n this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD\n this._readableState = new ReadableState(this, opts)\n\n if (opts) {\n if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD\n if (opts.read) this._read = opts.read\n if (opts.eagerOpen) this._readableState.updateNextTick()\n if (opts.encoding) this.setEncoding(opts.encoding)\n }\n }\n\n setEncoding (encoding) {\n const dec = new TextDecoder(encoding)\n const map = this._readableState.map || echo\n this._readableState.map = mapOrSkip\n return this\n\n function mapOrSkip (data) {\n const next = dec.push(data)\n return next === '' && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next)\n }\n }\n\n _read (cb) {\n cb(null)\n }\n\n pipe (dest, cb) {\n this._readableState.updateNextTick()\n this._readableState.pipe(dest, cb)\n return dest\n }\n\n read () {\n this._readableState.updateNextTick()\n return this._readableState.read()\n }\n\n push (data) {\n this._readableState.updateNextTick()\n return this._readableState.push(data)\n }\n\n unshift (data) {\n this._readableState.updateNextTick()\n return this._readableState.unshift(data)\n }\n\n resume () {\n this._duplexState |= READ_RESUMED_READ_AHEAD\n this._readableState.updateNextTick()\n return this\n }\n\n pause () {\n this._duplexState &= (this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED)\n return this\n }\n\n static _fromAsyncIterator (ite, opts) {\n let destroy\n\n const rs = new Readable({\n ...opts,\n read (cb) {\n ite.next().then(push).then(cb.bind(null, null)).catch(cb)\n },\n predestroy () {\n destroy = ite.return()\n },\n destroy (cb) {\n if (!destroy) return cb(null)\n destroy.then(cb.bind(null, null)).catch(cb)\n }\n })\n\n return rs\n\n function push (data) {\n if (data.done) rs.push(null)\n else rs.push(data.value)\n }\n }\n\n static from (data, opts) {\n if (isReadStreamx(data)) return data\n if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts)\n if (!Array.isArray(data)) data = data === undefined ? [] : [data]\n\n let i = 0\n return new Readable({\n ...opts,\n read (cb) {\n this.push(i === data.length ? null : data[i++])\n cb(null)\n }\n })\n }\n\n static isBackpressured (rs) {\n return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark\n }\n\n static isPaused (rs) {\n return (rs._duplexState & READ_RESUMED) === 0\n }\n\n [asyncIterator] () {\n const stream = this\n\n let error = null\n let promiseResolve = null\n let promiseReject = null\n\n this.on('error', (err) => { error = err })\n this.on('readable', onreadable)\n this.on('close', onclose)\n\n return {\n [asyncIterator] () {\n return this\n },\n next () {\n return new Promise(function (resolve, reject) {\n promiseResolve = resolve\n promiseReject = reject\n const data = stream.read()\n if (data !== null) ondata(data)\n else if ((stream._duplexState & DESTROYED) !== 0) ondata(null)\n })\n },\n return () {\n return destroy(null)\n },\n throw (err) {\n return destroy(err)\n }\n }\n\n function onreadable () {\n if (promiseResolve !== null) ondata(stream.read())\n }\n\n function onclose () {\n if (promiseResolve !== null) ondata(null)\n }\n\n function ondata (data) {\n if (promiseReject === null) return\n if (error) promiseReject(error)\n else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED)\n else promiseResolve({ value: data, done: data === null })\n promiseReject = promiseResolve = null\n }\n\n function destroy (err) {\n stream.destroy(err)\n return new Promise((resolve, reject) => {\n if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true })\n stream.once('close', function () {\n if (err) reject(err)\n else resolve({ value: undefined, done: true })\n })\n })\n }\n }\n}\n\nclass Writable extends Stream {\n constructor (opts) {\n super(opts)\n\n this._duplexState |= OPENING | READ_DONE\n this._writableState = new WritableState(this, opts)\n\n if (opts) {\n if (opts.writev) this._writev = opts.writev\n if (opts.write) this._write = opts.write\n if (opts.final) this._final = opts.final\n if (opts.eagerOpen) this._writableState.updateNextTick()\n }\n }\n\n cork () {\n this._duplexState |= WRITE_CORKED\n }\n\n uncork () {\n this._duplexState &= WRITE_NOT_CORKED\n this._writableState.updateNextTick()\n }\n\n _writev (batch, cb) {\n cb(null)\n }\n\n _write (data, cb) {\n this._writableState.autoBatch(data, cb)\n }\n\n _final (cb) {\n cb(null)\n }\n\n static isBackpressured (ws) {\n return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0\n }\n\n static drained (ws) {\n if (ws.destroyed) return Promise.resolve(false)\n const state = ws._writableState\n const pending = (isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length)\n const writes = pending + ((ws._duplexState & WRITE_WRITING) ? 1 : 0)\n if (writes === 0) return Promise.resolve(true)\n if (state.drains === null) state.drains = []\n return new Promise((resolve) => {\n state.drains.push({ writes, resolve })\n })\n }\n\n write (data) {\n this._writableState.updateNextTick()\n return this._writableState.push(data)\n }\n\n end (data) {\n this._writableState.updateNextTick()\n this._writableState.end(data)\n return this\n }\n}\n\nclass Duplex extends Readable { // and Writable\n constructor (opts) {\n super(opts)\n\n this._duplexState = OPENING | (this._duplexState & READ_READ_AHEAD)\n this._writableState = new WritableState(this, opts)\n\n if (opts) {\n if (opts.writev) this._writev = opts.writev\n if (opts.write) this._write = opts.write\n if (opts.final) this._final = opts.final\n }\n }\n\n cork () {\n this._duplexState |= WRITE_CORKED\n }\n\n uncork () {\n this._duplexState &= WRITE_NOT_CORKED\n this._writableState.updateNextTick()\n }\n\n _writev (batch, cb) {\n cb(null)\n }\n\n _write (data, cb) {\n this._writableState.autoBatch(data, cb)\n }\n\n _final (cb) {\n cb(null)\n }\n\n write (data) {\n this._writableState.updateNextTick()\n return this._writableState.push(data)\n }\n\n end (data) {\n this._writableState.updateNextTick()\n this._writableState.end(data)\n return this\n }\n}\n\nclass Transform extends Duplex {\n constructor (opts) {\n super(opts)\n this._transformState = new TransformState(this)\n\n if (opts) {\n if (opts.transform) this._transform = opts.transform\n if (opts.flush) this._flush = opts.flush\n }\n }\n\n _write (data, cb) {\n if (this._readableState.buffered >= this._readableState.highWaterMark) {\n this._transformState.data = data\n } else {\n this._transform(data, this._transformState.afterTransform)\n }\n }\n\n _read (cb) {\n if (this._transformState.data !== null) {\n const data = this._transformState.data\n this._transformState.data = null\n cb(null)\n this._transform(data, this._transformState.afterTransform)\n } else {\n cb(null)\n }\n }\n\n destroy (err) {\n super.destroy(err)\n if (this._transformState.data !== null) {\n this._transformState.data = null\n this._transformState.afterTransform()\n }\n }\n\n _transform (data, cb) {\n cb(null, data)\n }\n\n _flush (cb) {\n cb(null)\n }\n\n _final (cb) {\n this._transformState.afterFinal = cb\n this._flush(transformAfterFlush.bind(this))\n }\n}\n\nclass PassThrough extends Transform {}\n\nfunction transformAfterFlush (err, data) {\n const cb = this._transformState.afterFinal\n if (err) return cb(err)\n if (data !== null && data !== undefined) this.push(data)\n this.push(null)\n cb(null)\n}\n\nfunction pipelinePromise (...streams) {\n return new Promise((resolve, reject) => {\n return pipeline(...streams, (err) => {\n if (err) return reject(err)\n resolve()\n })\n })\n}\n\nfunction pipeline (stream, ...streams) {\n const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams]\n const done = (all.length && typeof all[all.length - 1] === 'function') ? all.pop() : null\n\n if (all.length < 2) throw new Error('Pipeline requires at least 2 streams')\n\n let src = all[0]\n let dest = null\n let error = null\n\n for (let i = 1; i < all.length; i++) {\n dest = all[i]\n\n if (isStreamx(src)) {\n src.pipe(dest, onerror)\n } else {\n errorHandle(src, true, i > 1, onerror)\n src.pipe(dest)\n }\n\n src = dest\n }\n\n if (done) {\n let fin = false\n\n const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy)\n\n dest.on('error', (err) => {\n if (error === null) error = err\n })\n\n dest.on('finish', () => {\n fin = true\n if (!autoDestroy) done(error)\n })\n\n if (autoDestroy) {\n dest.on('close', () => done(error || (fin ? null : PREMATURE_CLOSE)))\n }\n }\n\n return dest\n\n function errorHandle (s, rd, wr, onerror) {\n s.on('error', onerror)\n s.on('close', onclose)\n\n function onclose () {\n if (rd && s._readableState && !s._readableState.ended) return onerror(PREMATURE_CLOSE)\n if (wr && s._writableState && !s._writableState.ended) return onerror(PREMATURE_CLOSE)\n }\n }\n\n function onerror (err) {\n if (!err || error) return\n error = err\n\n for (const s of all) {\n s.destroy(err)\n }\n }\n}\n\nfunction echo (s) {\n return s\n}\n\nfunction isStream (stream) {\n return !!stream._readableState || !!stream._writableState\n}\n\nfunction isStreamx (stream) {\n return typeof stream._duplexState === 'number' && isStream(stream)\n}\n\nfunction isEnded (stream) {\n return !!stream._readableState && stream._readableState.ended\n}\n\nfunction isFinished (stream) {\n return !!stream._writableState && stream._writableState.ended\n}\n\nfunction getStreamError (stream, opts = {}) {\n const err = (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error)\n\n // avoid implicit errors by default\n return (!opts.all && err === STREAM_DESTROYED) ? null : err\n}\n\nfunction isReadStreamx (stream) {\n return isStreamx(stream) && stream.readable\n}\n\nfunction isTypedArray (data) {\n return typeof data === 'object' && data !== null && typeof data.byteLength === 'number'\n}\n\nfunction defaultByteLength (data) {\n return isTypedArray(data) ? data.byteLength : 1024\n}\n\nfunction noop () {}\n\nfunction abort () {\n this.destroy(new Error('Stream aborted.'))\n}\n\nfunction isWritev (s) {\n return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev\n}\n\nmodule.exports = {\n pipeline,\n pipelinePromise,\n isStream,\n isStreamx,\n isEnded,\n isFinished,\n getStreamError,\n Stream,\n Writable,\n Readable,\n Duplex,\n Transform,\n // Export PassThrough for compatibility with Node.js core's stream module\n PassThrough\n}\n","const PassThroughDecoder = require('./lib/pass-through-decoder')\nconst UTF8Decoder = require('./lib/utf8-decoder')\n\nmodule.exports = class TextDecoder {\n constructor (encoding = 'utf8') {\n this.encoding = normalizeEncoding(encoding)\n\n switch (this.encoding) {\n case 'utf8':\n this.decoder = new UTF8Decoder()\n break\n case 'utf16le':\n case 'base64':\n throw new Error('Unsupported encoding: ' + this.encoding)\n default:\n this.decoder = new PassThroughDecoder(this.encoding)\n }\n }\n\n get remaining () {\n return this.decoder.remaining\n }\n\n push (data) {\n if (typeof data === 'string') return data\n return this.decoder.decode(data)\n }\n\n // For Node.js compatibility\n write (data) {\n return this.push(data)\n }\n\n end (data) {\n let result = ''\n if (data) result = this.push(data)\n result += this.decoder.flush()\n return result\n }\n}\n\nfunction normalizeEncoding (encoding) {\n encoding = encoding.toLowerCase()\n\n switch (encoding) {\n case 'utf8':\n case 'utf-8':\n return 'utf8'\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return 'utf16le'\n case 'latin1':\n case 'binary':\n return 'latin1'\n case 'base64':\n case 'ascii':\n case 'hex':\n return encoding\n default:\n throw new Error('Unknown encoding: ' + encoding)\n }\n};\n","module.exports = class BrowserDecoder {\n constructor (encoding) {\n this.decoder = new TextDecoder(encoding === 'utf16le' ? 'utf16-le' : encoding)\n }\n\n get remaining () {\n return -1\n }\n\n decode (data) {\n return this.decoder.decode(data, { stream: true })\n }\n\n flush () {\n return this.decoder.decode(new Uint8Array(0))\n }\n}\n","const maxTick = 65535\r\nconst resolution = 10\r\nconst timeDiff = 1000 / resolution\r\nfunction getTick (start) {\r\n return (+Date.now() - start) / timeDiff & 65535\r\n}\r\n\r\nmodule.exports = function (seconds) {\r\n const start = +Date.now()\r\n\r\n const size = resolution * (seconds || 5)\r\n const buffer = [0]\r\n let pointer = 1\r\n let last = (getTick(start) - 1) & maxTick\r\n\r\n return function (delta) {\r\n const tick = getTick(start)\r\n let dist = (tick - last) & maxTick\r\n if (dist > size) dist = size\r\n last = tick\r\n\r\n while (dist--) {\r\n if (pointer === size) pointer = 0\r\n buffer[pointer] = buffer[pointer === 0 ? size - 1 : pointer - 1]\r\n pointer++\r\n }\r\n\r\n if (delta) buffer[pointer - 1] += delta\r\n\r\n const top = buffer[pointer - 1]\r\n const btm = buffer.length < size ? 0 : buffer[pointer === size ? 0 : pointer]\r\n\r\n return buffer.length < resolution ? top : (top - btm) * resolution / buffer.length\r\n }\r\n}\r\n","module.exports = remove\n\nfunction remove (arr, i) {\n if (i >= arr.length || i < 0) return\n var last = arr.pop()\n if (i < arr.length) {\n var tmp = arr[i]\n arr[i] = last\n return tmp\n }\n return last\n}\n","// Returns a wrapper function that returns a wrapped callback\n// The wrapper function should do some stuff, and return a\n// presumably different callback function.\n// This makes sure that own properties are retained, so that\n// decorations and such are not lost along the way.\nmodule.exports = wrappy\nfunction wrappy (fn, cb) {\n if (fn && cb) return wrappy(fn)(cb)\n\n if (typeof fn !== 'function')\n throw new TypeError('need wrapper function')\n\n Object.keys(fn).forEach(function (k) {\n wrapper[k] = fn[k]\n })\n\n return wrapper\n\n function wrapper() {\n var args = new Array(arguments.length)\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i]\n }\n var ret = fn.apply(this, args)\n var cb = args[args.length-1]\n if (typeof ret === 'function' && ret !== cb) {\n Object.keys(cb).forEach(function (k) {\n ret[k] = cb[k]\n })\n }\n return ret\n }\n}\n","// Exports package.json to work around \"with\" and \"assert\" for backwards compatability.\nmodule.exports = require('./package.json').version\n","import EventEmitter from 'events'\nimport { Transform, pipeline } from 'streamx'\nimport arrayRemove from 'unordered-array-remove'\nimport debugFactory from 'debug'\nimport Wire from 'bittorrent-protocol'\n\nconst CONNECT_TIMEOUT_TCP = 5_000\nconst CONNECT_TIMEOUT_UTP = 5_000\nconst CONNECT_TIMEOUT_WEBRTC = 25_000\nconst HANDSHAKE_TIMEOUT = 25_000\n\n// Types of peers\nconst TYPE_TCP_INCOMING = 'tcpIncoming'\nconst TYPE_TCP_OUTGOING = 'tcpOutgoing'\nconst TYPE_UTP_INCOMING = 'utpIncoming'\nconst TYPE_UTP_OUTGOING = 'utpOutgoing'\nconst TYPE_WEBRTC = 'webrtc'\nconst TYPE_WEBSEED = 'webSeed'\n\n// Source used to obtain the peer\nconst SOURCE_MANUAL = 'manual'\nconst SOURCE_TRACKER = 'tracker'\nconst SOURCE_DHT = 'dht'\nconst SOURCE_LSD = 'lsd'\nconst SOURCE_UT_PEX = 'ut_pex'\n\nconst debug = debugFactory('webtorrent:peer')\n\nlet secure = false\n\nexport const enableSecure = () => {\n secure = true\n}\n\n/**\n * Peer. Represents a peer in the torrent swarm.\n *\n * @param {string} id \"ip:port\" string, peer id (for WebRTC peers), or url (for Web Seeds)\n * @param {string} type the type of the peer\n */\nexport default class Peer extends EventEmitter {\n constructor (id, type) {\n super()\n\n this.id = id\n this.type = type\n\n debug('new %s Peer %s', type, id)\n\n this.addr = null\n this.conn = null\n this.swarm = null\n this.wire = null\n this.source = null\n\n this.connected = false\n this.destroyed = false\n this.timeout = null // handshake timeout\n this.retries = 0 // outgoing TCP connection retry count\n\n this.sentPe1 = false\n this.sentPe2 = false\n this.sentPe3 = false\n this.sentPe4 = false\n this.sentHandshake = false\n }\n\n /**\n * Called once the peer is connected (i.e. fired 'connect' event)\n * @param {Socket} conn\n */\n onConnect () {\n if (this.destroyed) return\n this.connected = true\n\n debug('Peer %s connected', this.id)\n\n clearTimeout(this.connectTimeout)\n\n const conn = this.conn\n conn.once('end', () => {\n this.destroy()\n })\n conn.once('close', () => {\n this.destroy()\n })\n conn.once('finish', () => {\n this.destroy()\n })\n conn.once('error', err => {\n this.destroy(err)\n })\n\n const wire = this.wire = new Wire(this.type, this.retries, secure)\n\n wire.once('end', () => {\n this.destroy()\n })\n wire.once('close', () => {\n this.destroy()\n })\n wire.once('finish', () => {\n this.destroy()\n })\n wire.once('error', err => {\n this.destroy(err)\n })\n\n wire.once('pe1', () => {\n this.onPe1()\n })\n wire.once('pe2', () => {\n this.onPe2()\n })\n wire.once('pe3', () => {\n this.onPe3()\n })\n wire.once('pe4', () => {\n this.onPe4()\n })\n wire.once('handshake', (infoHash, peerId) => {\n this.onHandshake(infoHash, peerId)\n })\n this.startHandshakeTimeout()\n\n this.setThrottlePipes()\n\n if (this.swarm) {\n if (this.type === 'tcpOutgoing') {\n if (secure && this.retries === 0 && !this.sentPe1) this.sendPe1()\n else if (!this.sentHandshake) this.handshake()\n } else if (this.type !== 'tcpIncoming' && !this.sentHandshake) this.handshake()\n }\n }\n\n sendPe1 () {\n this.wire.sendPe1()\n this.sentPe1 = true\n }\n\n onPe1 () {\n this.sendPe2()\n }\n\n sendPe2 () {\n this.wire.sendPe2()\n this.sentPe2 = true\n }\n\n onPe2 () {\n this.sendPe3()\n }\n\n sendPe3 () {\n this.wire.sendPe3(this.swarm.infoHash)\n this.sentPe3 = true\n }\n\n onPe3 (infoHashHash) {\n if (this.swarm) {\n if (this.swarm.infoHashHash !== infoHashHash) {\n this.destroy(new Error('unexpected crypto handshake info hash for this swarm'))\n }\n this.sendPe4()\n }\n }\n\n sendPe4 () {\n this.wire.sendPe4(this.swarm.infoHash)\n this.sentPe4 = true\n }\n\n onPe4 () {\n if (!this.sentHandshake) this.handshake()\n }\n\n clearPipes () {\n this.conn.unpipe()\n this.wire.unpipe()\n }\n\n setThrottlePipes () {\n const self = this\n pipeline(\n this.conn,\n this.throttleGroups.down.throttle(),\n new Transform({\n transform (chunk, callback) {\n self.emit('download', chunk.length)\n if (self.destroyed) return\n callback(null, chunk)\n }\n }),\n this.wire,\n this.throttleGroups.up.throttle(),\n new Transform({\n transform (chunk, callback) {\n self.emit('upload', chunk.length)\n if (self.destroyed) return\n callback(null, chunk)\n }\n }),\n this.conn\n )\n }\n\n /**\n * Called when handshake is received from remote peer.\n * @param {string} infoHash\n * @param {string} peerId\n */\n onHandshake (infoHash, peerId) {\n if (!this.swarm) return // `this.swarm` not set yet, so do nothing\n if (this.destroyed) return\n\n if (this.swarm.destroyed) {\n return this.destroy(new Error('swarm already destroyed'))\n }\n if (infoHash !== this.swarm.infoHash) {\n return this.destroy(new Error('unexpected handshake info hash for this swarm'))\n }\n if (peerId === this.swarm.peerId) {\n return this.destroy(new Error('refusing to connect to ourselves'))\n }\n\n debug('Peer %s got handshake %s', this.id, infoHash)\n\n clearTimeout(this.handshakeTimeout)\n\n this.retries = 0\n\n let addr = this.addr\n if (!addr && this.conn.remoteAddress && this.conn.remotePort) {\n addr = `${this.conn.remoteAddress}:${this.conn.remotePort}`\n }\n this.swarm._onWire(this.wire, addr)\n\n // swarm could be destroyed in user's 'wire' event handler\n if (!this.swarm || this.swarm.destroyed) return\n\n if (!this.sentHandshake) this.handshake()\n }\n\n handshake () {\n const opts = {\n dht: this.swarm.private ? false : !!this.swarm.client.dht,\n fast: true\n }\n this.wire.handshake(this.swarm.infoHash, this.swarm.client.peerId, opts)\n this.sentHandshake = true\n }\n\n startConnectTimeout () {\n clearTimeout(this.connectTimeout)\n\n const connectTimeoutValues = {\n webrtc: CONNECT_TIMEOUT_WEBRTC,\n tcpOutgoing: CONNECT_TIMEOUT_TCP,\n utpOutgoing: CONNECT_TIMEOUT_UTP\n }\n\n this.connectTimeout = setTimeout(() => {\n this.destroy(new Error('connect timeout'))\n }, connectTimeoutValues[this.type])\n if (this.connectTimeout.unref) this.connectTimeout.unref()\n }\n\n startHandshakeTimeout () {\n clearTimeout(this.handshakeTimeout)\n this.handshakeTimeout = setTimeout(() => {\n this.destroy(new Error('handshake timeout'))\n }, HANDSHAKE_TIMEOUT)\n if (this.handshakeTimeout.unref) this.handshakeTimeout.unref()\n }\n\n destroy (err) {\n if (this.destroyed) return\n this.destroyed = true\n this.connected = false\n\n debug('destroy %s %s (error: %s)', this.type, this.id, err && (err.message || err))\n\n clearTimeout(this.connectTimeout)\n clearTimeout(this.handshakeTimeout)\n\n const swarm = this.swarm\n const conn = this.conn\n const wire = this.wire\n\n this.swarm = null\n this.conn = null\n this.wire = null\n\n if (swarm && wire) {\n arrayRemove(swarm.wires, swarm.wires.indexOf(wire))\n }\n if (conn) {\n conn.on('error', () => {})\n conn.destroy()\n }\n if (wire) wire.destroy()\n if (swarm) swarm.removePeer(this.id)\n }\n}\n\nPeer.TYPE_TCP_INCOMING = TYPE_TCP_INCOMING\nPeer.TYPE_TCP_OUTGOING = TYPE_TCP_OUTGOING\nPeer.TYPE_UTP_INCOMING = TYPE_UTP_INCOMING\nPeer.TYPE_UTP_OUTGOING = TYPE_UTP_OUTGOING\nPeer.TYPE_WEBRTC = TYPE_WEBRTC\nPeer.TYPE_WEBSEED = TYPE_WEBSEED\n\nPeer.SOURCE_MANUAL = SOURCE_MANUAL\nPeer.SOURCE_TRACKER = SOURCE_TRACKER\nPeer.SOURCE_DHT = SOURCE_DHT\nPeer.SOURCE_LSD = SOURCE_LSD\nPeer.SOURCE_UT_PEX = SOURCE_UT_PEX\n\n/**\n * WebRTC peer connections start out connected, because WebRTC peers require an\n * \"introduction\" (i.e. WebRTC signaling), and there's no equivalent to an IP address\n * that lets you refer to a WebRTC endpoint.\n */\nPeer.createWebRTCPeer = (conn, swarm, throttleGroups) => {\n const peer = new Peer(conn.id, 'webrtc')\n peer.conn = conn\n peer.swarm = swarm\n peer.throttleGroups = throttleGroups\n\n if (peer.conn.connected) {\n peer.onConnect()\n } else {\n const cleanup = () => {\n peer.conn.removeListener('connect', onConnect)\n peer.conn.removeListener('error', onError)\n }\n const onConnect = () => {\n cleanup()\n peer.onConnect()\n }\n const onError = err => {\n cleanup()\n peer.destroy(err)\n }\n peer.conn.once('connect', onConnect)\n peer.conn.once('error', onError)\n peer.startConnectTimeout()\n }\n\n return peer\n}\n\n/**\n * Incoming TCP peers start out connected, because the remote peer connected to the\n * listening port of the TCP server. Until the remote peer sends a handshake, we don't\n * know what swarm the connection is intended for.\n */\nPeer.createTCPIncomingPeer = (conn, throttleGroups) => {\n return Peer._createIncomingPeer(conn, TYPE_TCP_INCOMING, throttleGroups)\n}\n\n/**\n * Incoming uTP peers start out connected, because the remote peer connected to the\n * listening port of the uTP server. Until the remote peer sends a handshake, we don't\n * know what swarm the connection is intended for.\n */\nPeer.createUTPIncomingPeer = (conn, throttleGroups) => {\n return Peer._createIncomingPeer(conn, TYPE_UTP_INCOMING, throttleGroups)\n}\n\n/**\n * Outgoing TCP peers start out with just an IP address. At some point (when there is an\n * available connection), the client can attempt to connect to the address.\n */\nPeer.createTCPOutgoingPeer = (addr, swarm, throttleGroups) => {\n return Peer._createOutgoingPeer(addr, swarm, TYPE_TCP_OUTGOING, throttleGroups)\n}\n\n/**\n * Outgoing uTP peers start out with just an IP address. At some point (when there is an\n * available connection), the client can attempt to connect to the address.\n */\nPeer.createUTPOutgoingPeer = (addr, swarm, throttleGroups) => {\n return Peer._createOutgoingPeer(addr, swarm, TYPE_UTP_OUTGOING, throttleGroups)\n}\n\nPeer._createIncomingPeer = (conn, type, throttleGroups) => {\n const addr = `${conn.remoteAddress}:${conn.remotePort}`\n const peer = new Peer(addr, type)\n peer.conn = conn\n peer.addr = addr\n peer.throttleGroups = throttleGroups\n\n peer.onConnect()\n\n return peer\n}\n\nPeer._createOutgoingPeer = (addr, swarm, type, throttleGroups) => {\n const peer = new Peer(addr, type)\n peer.addr = addr\n peer.swarm = swarm\n peer.throttleGroups = throttleGroups\n\n return peer\n}\n\n/**\n * Peer that represents a Web Seed (BEP17 / BEP19).\n */\n\nPeer.createWebSeedPeer = (conn, id, swarm, throttleGroups) => {\n const peer = new Peer(id, TYPE_WEBSEED)\n\n peer.swarm = swarm\n peer.conn = conn\n peer.throttleGroups = throttleGroups\n\n peer.onConnect()\n\n return peer\n}\n","export function digitCount (value) {\n // Add a digit for negative numbers, as the sign will be prefixed\n const sign = value < 0 ? 1 : 0\n // Guard against negative numbers & zero going into log10(),\n // as that would return -Infinity\n value = Math.abs(Number(value || 1))\n return Math.floor(Math.log10(value)) + 1 + sign\n}\n\nexport function getType (value) {\n if (ArrayBuffer.isView(value)) return 'arraybufferview'\n if (Array.isArray(value)) return 'array'\n if (value instanceof Number) return 'number'\n if (value instanceof Boolean) return 'boolean'\n if (value instanceof Set) return 'set'\n if (value instanceof Map) return 'map'\n if (value instanceof String) return 'string'\n if (value instanceof ArrayBuffer) return 'arraybuffer'\n return typeof value\n}\n","import { concat, text2arr } from 'uint8-util'\nimport { getType } from './util.js'\n\n/**\n * Encodes data in bencode.\n *\n * @param {Uint8Array|Array|String|Object|Number|Boolean} data\n * @return {Uint8Array}\n */\nfunction encode (data, buffer, offset) {\n const buffers = []\n let result = null\n\n encode._encode(buffers, data)\n result = concat(buffers)\n encode.bytes = result.length\n\n if (ArrayBuffer.isView(buffer)) {\n buffer.set(result, offset)\n return buffer\n }\n\n return result\n}\n\nencode.bytes = -1\nencode._floatConversionDetected = false\n\nencode._encode = function (buffers, data) {\n if (data == null) { return }\n\n switch (getType(data)) {\n case 'object': encode.dict(buffers, data); break\n case 'map': encode.dictMap(buffers, data); break\n case 'array': encode.list(buffers, data); break\n case 'set': encode.listSet(buffers, data); break\n case 'string': encode.string(buffers, data); break\n case 'number': encode.number(buffers, data); break\n case 'boolean': encode.number(buffers, data); break\n case 'arraybufferview': encode.buffer(buffers, new Uint8Array(data.buffer, data.byteOffset, data.byteLength)); break\n case 'arraybuffer': encode.buffer(buffers, new Uint8Array(data)); break\n }\n}\n\nconst buffE = new Uint8Array([0x65])\nconst buffD = new Uint8Array([0x64])\nconst buffL = new Uint8Array([0x6C])\n\nencode.buffer = function (buffers, data) {\n buffers.push(text2arr(data.length + ':'), data)\n}\n\nencode.string = function (buffers, data) {\n buffers.push(text2arr(text2arr(data).byteLength + ':' + data))\n}\n\nencode.number = function (buffers, data) {\n if (Number.isInteger(data)) return buffers.push(text2arr('i' + BigInt(data) + 'e'))\n\n const maxLo = 0x80000000\n const hi = (data / maxLo) << 0\n const lo = (data % maxLo) << 0\n const val = hi * maxLo + lo\n\n buffers.push(text2arr('i' + val + 'e'))\n\n if (val !== data && !encode._floatConversionDetected) {\n encode._floatConversionDetected = true\n console.warn(\n 'WARNING: Possible data corruption detected with value \"' + data + '\":',\n 'Bencoding only defines support for integers, value was converted to \"' + val + '\"'\n )\n console.trace()\n }\n}\n\nencode.dict = function (buffers, data) {\n buffers.push(buffD)\n\n let j = 0\n let k\n // fix for issue #13 - sorted dicts\n const keys = Object.keys(data).sort()\n const kl = keys.length\n\n for (; j < kl; j++) {\n k = keys[j]\n if (data[k] == null) continue\n encode.string(buffers, k)\n encode._encode(buffers, data[k])\n }\n\n buffers.push(buffE)\n}\n\nencode.dictMap = function (buffers, data) {\n buffers.push(buffD)\n\n const keys = Array.from(data.keys()).sort()\n\n for (const key of keys) {\n if (data.get(key) == null) continue\n ArrayBuffer.isView(key)\n ? encode._encode(buffers, key)\n : encode.string(buffers, String(key))\n encode._encode(buffers, data.get(key))\n }\n\n buffers.push(buffE)\n}\n\nencode.list = function (buffers, data) {\n let i = 0\n const c = data.length\n buffers.push(buffL)\n\n for (; i < c; i++) {\n if (data[i] == null) continue\n encode._encode(buffers, data[i])\n }\n\n buffers.push(buffE)\n}\n\nencode.listSet = function (buffers, data) {\n buffers.push(buffL)\n\n for (const item of data) {\n if (item == null) continue\n encode._encode(buffers, item)\n }\n\n buffers.push(buffE)\n}\n\nexport default encode\n","import { arr2text, text2arr, arr2hex } from 'uint8-util'\n\nconst INTEGER_START = 0x69 // 'i'\nconst STRING_DELIM = 0x3A // ':'\nconst DICTIONARY_START = 0x64 // 'd'\nconst LIST_START = 0x6C // 'l'\nconst END_OF_TYPE = 0x65 // 'e'\n\n/**\n * replaces parseInt(buffer.toString('ascii', start, end)).\n * For strings with less then ~30 charachters, this is actually a lot faster.\n *\n * @param {Uint8Array} data\n * @param {Number} start\n * @param {Number} end\n * @return {Number} calculated number\n */\nfunction getIntFromBuffer (buffer, start, end) {\n let sum = 0\n let sign = 1\n\n for (let i = start; i < end; i++) {\n const num = buffer[i]\n\n if (num < 58 && num >= 48) {\n sum = sum * 10 + (num - 48)\n continue\n }\n\n if (i === start && num === 43) { // +\n continue\n }\n\n if (i === start && num === 45) { // -\n sign = -1\n continue\n }\n\n if (num === 46) { // .\n // its a float. break here.\n break\n }\n\n throw new Error('not a number: buffer[' + i + '] = ' + num)\n }\n\n return sum * sign\n}\n\n/**\n * Decodes bencoded data.\n *\n * @param {Uint8Array} data\n * @param {Number} start (optional)\n * @param {Number} end (optional)\n * @param {String} encoding (optional)\n * @return {Object|Array|Uint8Array|String|Number}\n */\nfunction decode (data, start, end, encoding) {\n if (data == null || data.length === 0) {\n return null\n }\n\n if (typeof start !== 'number' && encoding == null) {\n encoding = start\n start = undefined\n }\n\n if (typeof end !== 'number' && encoding == null) {\n encoding = end\n end = undefined\n }\n\n decode.position = 0\n decode.encoding = encoding || null\n\n decode.data = !(ArrayBuffer.isView(data))\n ? text2arr(data)\n : new Uint8Array(data.slice(start, end))\n\n decode.bytes = decode.data.length\n\n return decode.next()\n}\n\ndecode.bytes = 0\ndecode.position = 0\ndecode.data = null\ndecode.encoding = null\n\ndecode.next = function () {\n switch (decode.data[decode.position]) {\n case DICTIONARY_START:\n return decode.dictionary()\n case LIST_START:\n return decode.list()\n case INTEGER_START:\n return decode.integer()\n default:\n return decode.buffer()\n }\n}\n\ndecode.find = function (chr) {\n let i = decode.position\n const c = decode.data.length\n const d = decode.data\n\n while (i < c) {\n if (d[i] === chr) return i\n i++\n }\n\n throw new Error(\n 'Invalid data: Missing delimiter \"' +\n String.fromCharCode(chr) + '\" [0x' +\n chr.toString(16) + ']'\n )\n}\n\ndecode.dictionary = function () {\n decode.position++\n\n const dict = {}\n\n while (decode.data[decode.position] !== END_OF_TYPE) {\n const buffer = decode.buffer()\n let key = arr2text(buffer)\n if (key.includes('\\uFFFD')) key = arr2hex(buffer)\n dict[key] = decode.next()\n }\n\n decode.position++\n\n return dict\n}\n\ndecode.list = function () {\n decode.position++\n\n const lst = []\n\n while (decode.data[decode.position] !== END_OF_TYPE) {\n lst.push(decode.next())\n }\n\n decode.position++\n\n return lst\n}\n\ndecode.integer = function () {\n const end = decode.find(END_OF_TYPE)\n const number = getIntFromBuffer(decode.data, decode.position + 1, end)\n\n decode.position += end + 1 - decode.position\n\n return number\n}\n\ndecode.buffer = function () {\n let sep = decode.find(STRING_DELIM)\n const length = getIntFromBuffer(decode.data, decode.position, sep)\n const end = ++sep + length\n\n decode.position = end\n\n return decode.encoding\n ? arr2text(decode.data.slice(sep, end))\n : decode.data.slice(sep, end)\n}\n\nexport default decode\n","import { text2arr } from 'uint8-util'\nimport { digitCount, getType } from './util.js'\n\nfunction listLength (list) {\n let length = 1 + 1 // type marker + end-of-type marker\n\n for (const value of list) {\n length += encodingLength(value)\n }\n\n return length\n}\n\nfunction mapLength (map) {\n let length = 1 + 1 // type marker + end-of-type marker\n\n for (const [key, value] of map) {\n const keyLength = text2arr(key).byteLength\n length += digitCount(keyLength) + 1 + keyLength\n length += encodingLength(value)\n }\n\n return length\n}\n\nfunction objectLength (value) {\n let length = 1 + 1 // type marker + end-of-type marker\n const keys = Object.keys(value)\n\n for (let i = 0; i < keys.length; i++) {\n const keyLength = text2arr(keys[i]).byteLength\n length += digitCount(keyLength) + 1 + keyLength\n length += encodingLength(value[keys[i]])\n }\n\n return length\n}\n\nfunction stringLength (value) {\n const length = text2arr(value).byteLength\n return digitCount(length) + 1 + length\n}\n\nfunction arrayBufferLength (value) {\n const length = value.byteLength - value.byteOffset\n return digitCount(length) + 1 + length\n}\n\nfunction encodingLength (value) {\n const length = 0\n\n if (value == null) return length\n\n const type = getType(value)\n\n switch (type) {\n case 'arraybufferview': return arrayBufferLength(value)\n case 'string': return stringLength(value)\n case 'array': case 'set': return listLength(value)\n case 'number': return 1 + digitCount(Math.floor(value)) + 1\n case 'bigint': return 1 + value.toString().length + 1\n case 'object': return objectLength(value)\n case 'map': return mapLength(value)\n default:\n throw new TypeError(`Unsupported value of type \"${type}\"`)\n }\n}\n\nexport default encodingLength\n","import encode from './lib/encode.js'\nimport decode from './lib/decode.js'\nimport byteLength from './lib/encoding-length.js'\n/**\n * Determines the amount of bytes\n * needed to encode the given value\n * @param {Object|Array|Uint8Array|String|Number|Boolean} value\n * @return {Number} byteCount\n */\nconst encodingLength = byteLength\nexport default { encode, decode, byteLength, encodingLength }\n","/**\n * Converts a number of bits to a number of bytes.\n *\n * @param numberOfBits The number of bits to convert.\n * @returns The number of bytes that are needed to store the given number of bits.\n */\nfunction bitsToBytes(numberOfBits) {\n return (numberOfBits >> 3) + Number(numberOfBits % 8 !== 0);\n}\nexport default class BitField {\n /** The number of bits in the bitfield. */\n get length() {\n return this.buffer.length << 3;\n }\n /**\n * Constructs a BitField.\n *\n * @param data Either a number representing the maximum number of supported bits, or a Uint8Array.\n * @param opts Options for the bitfield.\n */\n constructor(data = 0, options) {\n const grow = options === null || options === void 0 ? void 0 : options.grow;\n this.grow = grow\n ? Number.isFinite(grow)\n ? bitsToBytes(grow)\n : grow\n : 0;\n this.buffer =\n typeof data === \"number\" ? new Uint8Array(bitsToBytes(data)) : data;\n }\n /**\n * Get a particular bit.\n *\n * @param bitIndex Bit index to retrieve.\n * @returns A boolean indicating whether the `i`th bit is set.\n */\n get(bitIndex) {\n const byteIndex = bitIndex >> 3;\n return (byteIndex < this.buffer.length &&\n !!(this.buffer[byteIndex] & (128 >> bitIndex % 8)));\n }\n /**\n * Set a particular bit.\n *\n * Will grow the underlying array if the bit is out of bounds and the `grow` option is set.\n *\n * @param bitIndex Bit index to set.\n * @param value Value to set the bit to. Defaults to `true`.\n */\n set(bitIndex, value = true) {\n const byteIndex = bitIndex >> 3;\n if (value) {\n if (byteIndex >= this.buffer.length) {\n const newLength = Math.max(byteIndex + 1, Math.min(2 * this.buffer.length, this.grow));\n if (newLength <= this.grow) {\n const newBuffer = new Uint8Array(newLength);\n newBuffer.set(this.buffer);\n this.buffer = newBuffer;\n }\n }\n this.buffer[byteIndex] |= 128 >> bitIndex % 8;\n }\n else if (byteIndex < this.buffer.length) {\n this.buffer[byteIndex] &= ~(128 >> bitIndex % 8);\n }\n }\n /**\n * Sets a value or an array of values.\n *\n * @param array An array of booleans to set.\n * @param offset The bit offset at which the values are to be written.\n */\n setAll(array, offset = 0) {\n const targetLength = Math.min(bitsToBytes(offset + array.length), this.grow);\n if (this.buffer.length < targetLength) {\n const newBuffer = new Uint8Array(targetLength);\n newBuffer.set(this.buffer);\n this.buffer = newBuffer;\n }\n let byteIndex = offset >> 3;\n let bitMask = 128 >> offset % 8;\n for (let index = 0; index < array.length; index++) {\n if (array[index]) {\n this.buffer[byteIndex] |= bitMask;\n }\n else {\n this.buffer[byteIndex] &= ~bitMask;\n }\n if (bitMask === 1) {\n byteIndex += 1;\n if (byteIndex >= this.buffer.length) {\n break;\n }\n bitMask = 128;\n }\n else {\n bitMask >>= 1;\n }\n }\n }\n /**\n * Loop through the bits in the bitfield.\n *\n * @param callbackfn Function to be called with the bit value and index.\n * @param start Index of the first bit to look at.\n * @param end Index of the first bit that should no longer be considered.\n */\n forEach(callbackfn, start = 0, end = this.buffer.length * 8) {\n let byteIndex = start >> 3;\n let bitMask = 128 >> start % 8;\n for (let bitIndex = start; bitIndex < end; bitIndex++) {\n callbackfn(!!(this.buffer[byteIndex] & bitMask), bitIndex);\n if (bitMask === 1) {\n byteIndex += 1;\n bitMask = 128;\n }\n else {\n bitMask >>= 1;\n }\n }\n }\n /**\n * Check if all bits in the Bitfield are unset.\n *\n * @returns A boolean indicating whether all bits are unset.\n */\n isEmpty() {\n for (let i = 0; i < this.buffer.length; i++) {\n if (this.buffer[i] !== 0) {\n return false;\n }\n }\n return true;\n }\n}\n//# sourceMappingURL=index.js.map","/*! bittorrent-protocol. MIT License. WebTorrent LLC */\nimport bencode from 'bencode'\nimport BitField from 'bitfield'\nimport crypto from 'crypto'\nimport Debug from 'debug'\nimport RC4 from 'rc4'\nimport { Duplex } from 'streamx'\nimport { hash, concat, equal, hex2arr, arr2hex, text2arr, arr2text, randomBytes } from 'uint8-util'\nimport throughput from 'throughput'\nimport arrayRemove from 'unordered-array-remove'\n\nconst debug = Debug('bittorrent-protocol')\n\nconst BITFIELD_GROW = 400000\nconst KEEP_ALIVE_TIMEOUT = 55000\nconst ALLOWED_FAST_SET_MAX_LENGTH = 100\n\nconst MESSAGE_PROTOCOL = text2arr('\\u0013BitTorrent protocol')\nconst MESSAGE_KEEP_ALIVE = new Uint8Array([0x00, 0x00, 0x00, 0x00])\nconst MESSAGE_CHOKE = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x00])\nconst MESSAGE_UNCHOKE = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x01])\nconst MESSAGE_INTERESTED = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x02])\nconst MESSAGE_UNINTERESTED = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x03])\n\nconst MESSAGE_RESERVED = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]\nconst MESSAGE_PORT = [0x00, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00]\n\n// BEP6 Fast Extension\nconst MESSAGE_HAVE_ALL = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x0E])\nconst MESSAGE_HAVE_NONE = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x0F])\n\nconst DH_PRIME = 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a36210000000000090563'\nconst DH_GENERATOR = 2\nconst VC = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])\nconst CRYPTO_PROVIDE = new Uint8Array([0x00, 0x00, 0x01, 0x02])\nconst CRYPTO_SELECT = new Uint8Array([0x00, 0x00, 0x00, 0x02]) // always try to choose RC4 encryption instead of plaintext\n\nfunction xor (a, b) {\n for (let len = a.length; len--;) a[len] ^= b[len]\n return a\n}\n\nclass Request {\n constructor (piece, offset, length, callback) {\n this.piece = piece\n this.offset = offset\n this.length = length\n this.callback = callback\n }\n}\n\nclass HaveAllBitField {\n constructor () {\n this.buffer = new Uint8Array() // dummy\n }\n\n get (index) {\n return true\n }\n\n set (index) {}\n}\n\nclass Wire extends Duplex {\n constructor (type = null, retries = 0, peEnabled = false) {\n super()\n\n this._debugId = arr2hex(randomBytes(4))\n this._debug('new wire')\n\n this.peerId = null // remote peer id (hex string)\n this.peerIdBuffer = null // remote peer id (buffer)\n this.type = type // connection type ('webrtc', 'tcpIncoming', 'tcpOutgoing', 'webSeed')\n\n this.amChoking = true // are we choking the peer?\n this.amInterested = false // are we interested in the peer?\n\n this.peerChoking = true // is the peer choking us?\n this.peerInterested = false // is the peer interested in us?\n\n // The largest torrent that I know of (the Geocities archive) is ~641 GB and has\n // ~41,000 pieces. Therefore, cap bitfield to 10x larger (400,000 bits) to support all\n // possible torrents but prevent malicious peers from growing bitfield to fill memory.\n this.peerPieces = new BitField(0, { grow: BITFIELD_GROW })\n\n this.extensions = {}\n this.peerExtensions = {}\n\n this.requests = [] // outgoing\n this.peerRequests = [] // incoming\n\n this.extendedMapping = {} // number -> string, ex: 1 -> 'ut_metadata'\n this.peerExtendedMapping = {} // string -> number, ex: 9 -> 'ut_metadata'\n\n // The extended handshake to send, minus the \"m\" field, which gets automatically\n // filled from `this.extendedMapping`\n this.extendedHandshake = {}\n\n this.peerExtendedHandshake = {} // remote peer's extended handshake\n\n // BEP6 Fast Estension\n this.hasFast = false // is fast extension enabled?\n this.allowedFastSet = [] // allowed fast set\n this.peerAllowedFastSet = [] // peer's allowed fast set\n\n this._ext = {} // string -> function, ex 'ut_metadata' -> ut_metadata()\n this._nextExt = 1\n\n this.uploaded = 0\n this.downloaded = 0\n this.uploadSpeed = throughput()\n this.downloadSpeed = throughput()\n\n this._keepAliveInterval = null\n this._timeout = null\n this._timeoutMs = 0\n this._timeoutExpiresAt = null\n\n this._finished = false\n\n this._parserSize = 0 // number of needed bytes to parse next message from remote peer\n this._parser = null // function to call once `this._parserSize` bytes are available\n\n this._buffer = [] // incomplete message data\n this._bufferSize = 0 // cached total length of buffers in `this._buffer`\n\n this._peEnabled = peEnabled\n if (peEnabled) {\n this._dh = crypto.createDiffieHellman(DH_PRIME, 'hex', DH_GENERATOR) // crypto object used to generate keys/secret\n this._myPubKey = this._dh.generateKeys('hex') // my DH public key\n } else {\n this._myPubKey = null\n }\n this._peerPubKey = null // peer's DH public key\n this._sharedSecret = null // shared DH secret\n this._peerCryptoProvide = [] // encryption methods provided by peer; we expect this to always contain 0x02\n this._cryptoHandshakeDone = false\n\n this._cryptoSyncPattern = null // the pattern to search for when resynchronizing after receiving pe1/pe2\n this._waitMaxBytes = null // the maximum number of bytes resynchronization must occur within\n this._encryptionMethod = null // 1 for plaintext, 2 for RC4\n this._encryptGenerator = null // RC4 keystream generator for encryption\n this._decryptGenerator = null // RC4 keystream generator for decryption\n this._setGenerators = false // a flag for whether setEncrypt() has successfully completed\n\n this.once('finish', () => this._onFinish())\n\n this.on('finish', this._onFinish)\n this._debug('type:', this.type)\n\n if (this.type === 'tcpIncoming' && this._peEnabled) {\n // If we are not the initiator, we should wait to see if the client begins\n // with PE/MSE handshake or the standard bittorrent handshake.\n this._determineHandshakeType()\n } else if (this.type === 'tcpOutgoing' && this._peEnabled && retries === 0) {\n this._parsePe2()\n } else {\n this._parseHandshake(null)\n }\n }\n\n /**\n * Set whether to send a \"keep-alive\" ping (sent every 55s)\n * @param {boolean} enable\n */\n setKeepAlive (enable) {\n this._debug('setKeepAlive %s', enable)\n clearInterval(this._keepAliveInterval)\n if (enable === false) return\n this._keepAliveInterval = setInterval(() => {\n this.keepAlive()\n }, KEEP_ALIVE_TIMEOUT)\n }\n\n /**\n * Set the amount of time to wait before considering a request to be \"timed out\"\n * @param {number} ms\n * @param {boolean=} unref (should the timer be unref'd? default: false)\n */\n setTimeout (ms, unref) {\n this._debug('setTimeout ms=%d unref=%s', ms, unref)\n this._timeoutMs = ms\n this._timeoutUnref = !!unref\n this._resetTimeout(true)\n }\n\n destroy () {\n if (this.destroyed) return\n this._debug('destroy')\n this.end()\n return this\n }\n\n end (data) {\n if (this.destroyed || this.destroying) return\n this._debug('end')\n this._onUninterested()\n this._onChoke()\n return super.end(data)\n }\n\n /**\n * Use the specified protocol extension.\n * @param {function} Extension\n */\n use (Extension) {\n const name = Extension.prototype.name\n if (!name) {\n throw new Error('Extension class requires a \"name\" property on the prototype')\n }\n this._debug('use extension.name=%s', name)\n\n const ext = this._nextExt\n const handler = new Extension(this)\n\n function noop () {}\n\n if (typeof handler.onHandshake !== 'function') {\n handler.onHandshake = noop\n }\n if (typeof handler.onExtendedHandshake !== 'function') {\n handler.onExtendedHandshake = noop\n }\n if (typeof handler.onMessage !== 'function') {\n handler.onMessage = noop\n }\n\n this.extendedMapping[ext] = name\n this._ext[name] = handler\n this[name] = handler\n\n this._nextExt += 1\n }\n\n //\n // OUTGOING MESSAGES\n //\n\n /**\n * Message \"keep-alive\": \n */\n keepAlive () {\n this._debug('keep-alive')\n this._push(MESSAGE_KEEP_ALIVE)\n }\n\n sendPe1 () {\n if (this._peEnabled) {\n const padALen = Math.floor(Math.random() * 513)\n const padA = randomBytes(padALen)\n this._push(concat([hex2arr(this._myPubKey), padA]))\n }\n }\n\n sendPe2 () {\n const padBLen = Math.floor(Math.random() * 513)\n const padB = randomBytes(padBLen)\n this._push(concat([hex2arr(this._myPubKey), padB]))\n }\n\n async sendPe3 (infoHash) {\n await this.setEncrypt(this._sharedSecret, infoHash)\n\n const hash1Buffer = await hash(hex2arr(this._utfToHex('req1') + this._sharedSecret))\n\n const hash2Buffer = await hash(hex2arr(this._utfToHex('req2') + infoHash))\n const hash3Buffer = await hash(hex2arr(this._utfToHex('req3') + this._sharedSecret))\n const hashesXorBuffer = xor(hash2Buffer, hash3Buffer)\n\n const padCLen = new DataView(randomBytes(2).buffer).getUint16(0) % 512\n const padCBuffer = randomBytes(padCLen)\n\n let vcAndProvideBuffer = new Uint8Array(8 + 4 + 2 + padCLen + 2)\n vcAndProvideBuffer.set(VC)\n vcAndProvideBuffer.set(CRYPTO_PROVIDE, 8)\n\n const view = new DataView(vcAndProvideBuffer.buffer)\n\n view.setInt16(12, padCLen) // pad C length\n padCBuffer.copy(vcAndProvideBuffer, 14)\n view.setInt16(14 + padCLen, 0) // IA length\n vcAndProvideBuffer = this._encryptHandshake(vcAndProvideBuffer)\n\n this._push(concat([hash1Buffer, hashesXorBuffer, vcAndProvideBuffer]))\n }\n\n async sendPe4 (infoHash) {\n await this.setEncrypt(this._sharedSecret, infoHash)\n\n const padDLen = new DataView(randomBytes(2).buffer).getUint16(0) % 512\n const padDBuffer = randomBytes(padDLen)\n let vcAndSelectBuffer = new Uint8Array(8 + 4 + 2 + padDLen)\n const view = new DataView(vcAndSelectBuffer.buffer)\n\n vcAndSelectBuffer.set(VC)\n vcAndSelectBuffer.set(CRYPTO_SELECT, 8)\n view.setInt16(12, padDLen) // lenD?\n vcAndSelectBuffer.set(padDBuffer, 14)\n vcAndSelectBuffer = this._encryptHandshake(vcAndSelectBuffer)\n this._push(vcAndSelectBuffer)\n this._cryptoHandshakeDone = true\n this._debug('completed crypto handshake')\n }\n\n /**\n * Message: \"handshake\" \n * @param {Uint8Array|string} infoHash (as Buffer or *hex* string)\n * @param {Uint8Array|string} peerId\n * @param {Object} extensions\n */\n handshake (infoHash, peerId, extensions) {\n let infoHashBuffer\n let peerIdBuffer\n if (typeof infoHash === 'string') {\n infoHash = infoHash.toLowerCase()\n infoHashBuffer = hex2arr(infoHash)\n } else {\n infoHashBuffer = infoHash\n infoHash = arr2hex(infoHashBuffer)\n }\n if (typeof peerId === 'string') {\n peerIdBuffer = hex2arr(peerId)\n } else {\n peerIdBuffer = peerId\n peerId = arr2hex(peerIdBuffer)\n }\n\n this._infoHash = infoHashBuffer\n\n if (infoHashBuffer.length !== 20 || peerIdBuffer.length !== 20) {\n throw new Error('infoHash and peerId MUST have length 20')\n }\n\n this._debug('handshake i=%s p=%s exts=%o', infoHash, peerId, extensions)\n\n const reserved = new Uint8Array(MESSAGE_RESERVED)\n\n this.extensions = {\n extended: true,\n dht: !!(extensions && extensions.dht),\n fast: !!(extensions && extensions.fast)\n }\n\n reserved[5] |= 0x10 // enable extended message\n if (this.extensions.dht) reserved[7] |= 0x01\n if (this.extensions.fast) reserved[7] |= 0x04\n\n // BEP6 Fast Extension: The extension is enabled only if both ends of the connection set this bit.\n if (this.extensions.fast && this.peerExtensions.fast) {\n this._debug('fast extension is enabled')\n this.hasFast = true\n }\n this._push(concat([MESSAGE_PROTOCOL, reserved, infoHashBuffer, peerIdBuffer]))\n this._handshakeSent = true\n\n if (this.peerExtensions.extended && !this._extendedHandshakeSent) {\n // Peer's handshake indicated support already\n // (incoming connection)\n this._sendExtendedHandshake()\n }\n }\n\n /* Peer supports BEP-0010, send extended handshake.\n *\n * This comes after the 'handshake' event to give the user a chance to populate\n * `this.extendedHandshake` and `this.extendedMapping` before the extended handshake\n * is sent to the remote peer.\n */\n _sendExtendedHandshake () {\n // Create extended message object from registered extensions\n const msg = Object.assign({}, this.extendedHandshake)\n msg.m = {}\n for (const ext in this.extendedMapping) {\n const name = this.extendedMapping[ext]\n msg.m[name] = Number(ext)\n }\n\n // Send extended handshake\n this.extended(0, bencode.encode(msg))\n this._extendedHandshakeSent = true\n }\n\n /**\n * Message \"choke\": \n */\n choke () {\n if (this.amChoking) return\n this.amChoking = true\n this._debug('choke')\n this._push(MESSAGE_CHOKE)\n\n if (this.hasFast) {\n // BEP6: If a peer sends a choke, it MUST reject all requests from the peer to whom the choke\n // was sent except it SHOULD NOT reject requests for pieces that are in the allowed fast set.\n let allowedCount = 0\n while (this.peerRequests.length > allowedCount) { // until only allowed requests are left\n const request = this.peerRequests[allowedCount] // first non-allowed request\n if (this.allowedFastSet.includes(request.piece)) {\n ++allowedCount // count request as allowed\n } else {\n this.reject(request.piece, request.offset, request.length) // removes from this.peerRequests\n }\n }\n } else {\n while (this.peerRequests.length) {\n this.peerRequests.pop()\n }\n }\n }\n\n /**\n * Message \"unchoke\": \n */\n unchoke () {\n if (!this.amChoking) return\n this.amChoking = false\n this._debug('unchoke')\n this._push(MESSAGE_UNCHOKE)\n }\n\n /**\n * Message \"interested\": \n */\n interested () {\n if (this.amInterested) return\n this.amInterested = true\n this._debug('interested')\n this._push(MESSAGE_INTERESTED)\n }\n\n /**\n * Message \"uninterested\": \n */\n uninterested () {\n if (!this.amInterested) return\n this.amInterested = false\n this._debug('uninterested')\n this._push(MESSAGE_UNINTERESTED)\n }\n\n /**\n * Message \"have\": \n * @param {number} index\n */\n have (index) {\n this._debug('have %d', index)\n this._message(4, [index], null)\n }\n\n /**\n * Message \"bitfield\": \n * @param {BitField|Buffer} bitfield\n */\n bitfield (bitfield) {\n this._debug('bitfield')\n if (!ArrayBuffer.isView(bitfield)) bitfield = bitfield.buffer\n this._message(5, [], bitfield)\n }\n\n /**\n * Message \"request\": \n * @param {number} index\n * @param {number} offset\n * @param {number} length\n * @param {function} cb\n */\n request (index, offset, length, cb) {\n if (!cb) cb = () => {}\n if (this._finished) return cb(new Error('wire is closed'))\n\n if (this.peerChoking && !(this.hasFast && this.peerAllowedFastSet.includes(index))) {\n return cb(new Error('peer is choking'))\n }\n\n this._debug('request index=%d offset=%d length=%d', index, offset, length)\n\n this.requests.push(new Request(index, offset, length, cb))\n if (!this._timeout) {\n this._resetTimeout(true)\n }\n this._message(6, [index, offset, length], null)\n }\n\n /**\n * Message \"piece\": \n * @param {number} index\n * @param {number} offset\n * @param {Uint8Array} buffer\n */\n piece (index, offset, buffer) {\n this._debug('piece index=%d offset=%d', index, offset)\n this._message(7, [index, offset], buffer)\n this.uploaded += buffer.length\n this.uploadSpeed(buffer.length)\n this.emit('upload', buffer.length)\n }\n\n /**\n * Message \"cancel\": \n * @param {number} index\n * @param {number} offset\n * @param {number} length\n */\n cancel (index, offset, length) {\n this._debug('cancel index=%d offset=%d length=%d', index, offset, length)\n this._callback(\n this._pull(this.requests, index, offset, length),\n new Error('request was cancelled'),\n null\n )\n this._message(8, [index, offset, length], null)\n }\n\n /**\n * Message: \"port\" \n * @param {Number} port\n */\n port (port) {\n this._debug('port %d', port)\n const message = new Uint8Array(MESSAGE_PORT)\n const view = new DataView(message.buffer)\n view.setUint16(5, port)\n this._push(message)\n }\n\n /**\n * Message: \"suggest\" (BEP6)\n * @param {number} index\n */\n suggest (index) {\n if (!this.hasFast) throw Error('fast extension is disabled')\n this._debug('suggest %d', index)\n this._message(0x0D, [index], null)\n }\n\n /**\n * Message: \"have-all\" (BEP6)\n */\n haveAll () {\n if (!this.hasFast) throw Error('fast extension is disabled')\n this._debug('have-all')\n this._push(MESSAGE_HAVE_ALL)\n }\n\n /**\n * Message: \"have-none\" (BEP6)\n */\n haveNone () {\n if (!this.hasFast) throw Error('fast extension is disabled')\n this._debug('have-none')\n this._push(MESSAGE_HAVE_NONE)\n }\n\n /**\n * Message \"reject\": (BEP6)\n * @param {number} index\n * @param {number} offset\n * @param {number} length\n */\n reject (index, offset, length) {\n if (!this.hasFast) throw Error('fast extension is disabled')\n this._debug('reject index=%d offset=%d length=%d', index, offset, length)\n this._pull(this.peerRequests, index, offset, length)\n this._message(0x10, [index, offset, length], null)\n }\n\n /**\n * Message: \"allowed-fast\" (BEP6)\n * @param {number} index\n */\n allowedFast (index) {\n if (!this.hasFast) throw Error('fast extension is disabled')\n this._debug('allowed-fast %d', index)\n if (!this.allowedFastSet.includes(index)) this.allowedFastSet.push(index)\n this._message(0x11, [index], null)\n }\n\n /**\n * Message: \"extended\" \n * @param {number|string} ext\n * @param {Object} obj\n */\n extended (ext, obj) {\n this._debug('extended ext=%s', ext)\n if (typeof ext === 'string' && this.peerExtendedMapping[ext]) {\n ext = this.peerExtendedMapping[ext]\n }\n if (typeof ext === 'number') {\n const extId = new Uint8Array([ext])\n const buf = ArrayBuffer.isView(obj) ? obj : bencode.encode(obj)\n\n this._message(20, [], concat([extId, buf]))\n } else {\n throw new Error(`Unrecognized extension: ${ext}`)\n }\n }\n\n /**\n * Sets the encryption method for this wire, as per PSE/ME specification\n *\n * @param {string} sharedSecret: A hex-encoded string, which is the shared secret agreed\n * upon from DH key exchange\n * @param {string} infoHash: A hex-encoded info hash\n * @returns boolean, true if encryption setting succeeds, false if it fails.\n */\n async setEncrypt (sharedSecret, infoHash) {\n let encryptKeyBuf\n let encryptKeyIntArray\n let decryptKeyBuf\n let decryptKeyIntArray\n switch (this.type) {\n case 'tcpIncoming':\n encryptKeyBuf = await hash(hex2arr(this._utfToHex('keyB') + sharedSecret + infoHash))\n decryptKeyBuf = await hash(hex2arr(this._utfToHex('keyA') + sharedSecret + infoHash))\n encryptKeyIntArray = []\n for (const value of encryptKeyBuf.values()) {\n encryptKeyIntArray.push(value)\n }\n decryptKeyIntArray = []\n for (const value of decryptKeyBuf.values()) {\n decryptKeyIntArray.push(value)\n }\n this._encryptGenerator = new RC4(encryptKeyIntArray)\n this._decryptGenerator = new RC4(decryptKeyIntArray)\n break\n case 'tcpOutgoing':\n encryptKeyBuf = await hash(hex2arr(this._utfToHex('keyA') + sharedSecret + infoHash))\n decryptKeyBuf = await hash(hex2arr(this._utfToHex('keyB') + sharedSecret + infoHash))\n encryptKeyIntArray = []\n for (const value of encryptKeyBuf.values()) {\n encryptKeyIntArray.push(value)\n }\n decryptKeyIntArray = []\n for (const value of decryptKeyBuf.values()) {\n decryptKeyIntArray.push(value)\n }\n this._encryptGenerator = new RC4(encryptKeyIntArray)\n this._decryptGenerator = new RC4(decryptKeyIntArray)\n break\n default:\n return false\n }\n\n // Discard the first 1024 bytes, as per MSE/PE implementation\n for (let i = 0; i < 1024; i++) {\n this._encryptGenerator.randomByte()\n this._decryptGenerator.randomByte()\n }\n\n this._setGenerators = true\n return true\n }\n\n /**\n * Send a message to the remote peer.\n */\n _message (id, numbers, data) {\n const dataLength = data ? data.length : 0\n const buffer = new Uint8Array(5 + (4 * numbers.length))\n const view = new DataView(buffer.buffer)\n\n view.setUint32(0, buffer.length + dataLength - 4)\n buffer[4] = id\n for (let i = 0; i < numbers.length; i++) {\n view.setUint32(5 + (4 * i), numbers[i])\n }\n\n this._push(buffer)\n if (data) this._push(data)\n }\n\n _push (data) {\n if (this._finished) return\n if (this._encryptionMethod === 2 && this._cryptoHandshakeDone) {\n data = this._encrypt(data)\n }\n return this.push(data)\n }\n\n //\n // INCOMING MESSAGES\n //\n\n _onKeepAlive () {\n this._debug('got keep-alive')\n this.emit('keep-alive')\n }\n\n _onPe1 (pubKeyBuffer) {\n this._peerPubKey = arr2hex(pubKeyBuffer)\n this._sharedSecret = this._dh.computeSecret(this._peerPubKey, 'hex', 'hex')\n this.emit('pe1')\n }\n\n _onPe2 (pubKeyBuffer) {\n this._peerPubKey = arr2hex(pubKeyBuffer)\n this._sharedSecret = this._dh.computeSecret(this._peerPubKey, 'hex', 'hex')\n this.emit('pe2')\n }\n\n async _onPe3 (hashesXorBuffer) {\n const hash3 = await (arr2hex(this._utfToHex('req3') + this._sharedSecret))\n const sKeyHash = arr2hex(xor(hash3, hashesXorBuffer))\n this.emit('pe3', sKeyHash)\n }\n\n _onPe3Encrypted (vcBuffer, peerProvideBuffer) {\n if (!equal(vcBuffer, VC)) {\n this._debug('Error: verification constant did not match')\n this.destroy()\n return\n }\n\n for (const provideByte of peerProvideBuffer.values()) {\n if (provideByte !== 0) {\n this._peerCryptoProvide.push(provideByte)\n }\n }\n if (this._peerCryptoProvide.includes(2)) {\n this._encryptionMethod = 2\n } else {\n this._debug('Error: RC4 encryption method not provided by peer')\n this.destroy()\n }\n }\n\n _onPe4 (peerSelectBuffer) {\n this._encryptionMethod = peerSelectBuffer[3]\n if (!CRYPTO_PROVIDE.includes(this._encryptionMethod)) {\n this._debug('Error: peer selected invalid crypto method')\n this.destroy()\n }\n this._cryptoHandshakeDone = true\n this._debug('crypto handshake done')\n this.emit('pe4')\n }\n\n _onHandshake (infoHashBuffer, peerIdBuffer, extensions) {\n const infoHash = arr2hex(infoHashBuffer)\n const peerId = arr2hex(peerIdBuffer)\n\n this._debug('got handshake i=%s p=%s exts=%o', infoHash, peerId, extensions)\n\n this.peerId = peerId\n this.peerIdBuffer = peerIdBuffer\n this.peerExtensions = extensions\n\n // BEP6 Fast Extension: The extension is enabled only if both ends of the connection set this bit.\n if (this.extensions.fast && this.peerExtensions.fast) {\n this._debug('fast extension is enabled')\n this.hasFast = true\n }\n\n this.emit('handshake', infoHash, peerId, extensions)\n\n for (const name in this._ext) {\n this._ext[name].onHandshake(infoHash, peerId, extensions)\n }\n\n if (extensions.extended && this._handshakeSent &&\n !this._extendedHandshakeSent) {\n // outgoing connection\n this._sendExtendedHandshake()\n }\n }\n\n _onChoke () {\n this.peerChoking = true\n this._debug('got choke')\n this.emit('choke')\n if (!this.hasFast) {\n // BEP6 Fast Extension: Choke no longer implicitly rejects all pending requests\n while (this.requests.length) {\n this._callback(this.requests.pop(), new Error('peer is choking'), null)\n }\n }\n }\n\n _onUnchoke () {\n this.peerChoking = false\n this._debug('got unchoke')\n this.emit('unchoke')\n }\n\n _onInterested () {\n this.peerInterested = true\n this._debug('got interested')\n this.emit('interested')\n }\n\n _onUninterested () {\n this.peerInterested = false\n this._debug('got uninterested')\n this.emit('uninterested')\n }\n\n _onHave (index) {\n if (this.peerPieces.get(index)) return\n this._debug('got have %d', index)\n\n this.peerPieces.set(index, true)\n this.emit('have', index)\n }\n\n _onBitField (buffer) {\n this.peerPieces = new BitField(buffer)\n this._debug('got bitfield')\n this.emit('bitfield', this.peerPieces)\n }\n\n _onRequest (index, offset, length) {\n if (this.amChoking && !(this.hasFast && this.allowedFastSet.includes(index))) {\n // BEP6: If a peer receives a request from a peer its choking, the peer receiving\n // the request SHOULD send a reject unless the piece is in the allowed fast set.\n if (this.hasFast) this.reject(index, offset, length)\n return\n }\n this._debug('got request index=%d offset=%d length=%d', index, offset, length)\n\n const respond = (err, buffer) => {\n if (request !== this._pull(this.peerRequests, index, offset, length)) return\n if (err) {\n this._debug('error satisfying request index=%d offset=%d length=%d (%s)', index, offset, length, err.message)\n if (this.hasFast) this.reject(index, offset, length)\n return\n }\n this.piece(index, offset, buffer)\n }\n\n const request = new Request(index, offset, length, respond)\n this.peerRequests.push(request)\n this.emit('request', index, offset, length, respond)\n }\n\n _onPiece (index, offset, buffer) {\n this._debug('got piece index=%d offset=%d', index, offset)\n this._callback(this._pull(this.requests, index, offset, buffer.length), null, buffer)\n this.downloaded += buffer.length\n this.downloadSpeed(buffer.length)\n this.emit('download', buffer.length)\n this.emit('piece', index, offset, buffer)\n }\n\n _onCancel (index, offset, length) {\n this._debug('got cancel index=%d offset=%d length=%d', index, offset, length)\n this._pull(this.peerRequests, index, offset, length)\n this.emit('cancel', index, offset, length)\n }\n\n _onPort (port) {\n this._debug('got port %d', port)\n this.emit('port', port)\n }\n\n _onSuggest (index) {\n if (!this.hasFast) {\n // BEP6: the peer MUST close the connection\n this._debug('Error: got suggest whereas fast extension is disabled')\n this.destroy()\n return\n }\n this._debug('got suggest %d', index)\n this.emit('suggest', index)\n }\n\n _onHaveAll () {\n if (!this.hasFast) {\n // BEP6: the peer MUST close the connection\n this._debug('Error: got have-all whereas fast extension is disabled')\n this.destroy()\n return\n }\n this._debug('got have-all')\n this.peerPieces = new HaveAllBitField()\n this.emit('have-all')\n }\n\n _onHaveNone () {\n if (!this.hasFast) {\n // BEP6: the peer MUST close the connection\n this._debug('Error: got have-none whereas fast extension is disabled')\n this.destroy()\n return\n }\n this._debug('got have-none')\n this.emit('have-none')\n }\n\n _onReject (index, offset, length) {\n if (!this.hasFast) {\n // BEP6: the peer MUST close the connection\n this._debug('Error: got reject whereas fast extension is disabled')\n this.destroy()\n return\n }\n this._debug('got reject index=%d offset=%d length=%d', index, offset, length)\n this._callback(\n this._pull(this.requests, index, offset, length),\n new Error('request was rejected'),\n null\n )\n this.emit('reject', index, offset, length)\n }\n\n _onAllowedFast (index) {\n if (!this.hasFast) {\n // BEP6: the peer MUST close the connection\n this._debug('Error: got allowed-fast whereas fast extension is disabled')\n this.destroy()\n return\n }\n this._debug('got allowed-fast %d', index)\n if (!this.peerAllowedFastSet.includes(index)) this.peerAllowedFastSet.push(index)\n if (this.peerAllowedFastSet.length > ALLOWED_FAST_SET_MAX_LENGTH) this.peerAllowedFastSet.shift()\n this.emit('allowed-fast', index)\n }\n\n _onExtended (ext, buf) {\n if (ext === 0) {\n let info\n try {\n info = bencode.decode(buf)\n } catch (err) {\n this._debug('ignoring invalid extended handshake: %s', err.message || err)\n }\n\n if (!info) return\n this.peerExtendedHandshake = info\n\n if (typeof info.m === 'object') {\n for (const name in info.m) {\n this.peerExtendedMapping[name] = Number(info.m[name].toString())\n }\n }\n for (const name in this._ext) {\n if (this.peerExtendedMapping[name]) {\n this._ext[name].onExtendedHandshake(this.peerExtendedHandshake)\n }\n }\n this._debug('got extended handshake')\n this.emit('extended', 'handshake', this.peerExtendedHandshake)\n } else {\n if (this.extendedMapping[ext]) {\n ext = this.extendedMapping[ext] // friendly name for extension\n if (this._ext[ext]) {\n // there is an registered extension handler, so call it\n this._ext[ext].onMessage(buf)\n }\n }\n this._debug('got extended message ext=%s', ext)\n this.emit('extended', ext, buf)\n }\n }\n\n _onTimeout () {\n this._debug('request timed out')\n this._callback(this.requests.shift(), new Error('request has timed out'), null)\n this.emit('timeout')\n }\n\n /**\n * Duplex stream method. Called whenever the remote peer has data for us. Data that the\n * remote peer sends gets buffered (i.e. not actually processed) until the right number\n * of bytes have arrived, determined by the last call to `this._parse(number, callback)`.\n * Once enough bytes have arrived to process the message, the callback function\n * (i.e. `this._parser`) gets called with the full buffer of data.\n * @param {Uint8Array} data\n * @param {function} cb\n */\n _write (data, cb) {\n if (this._encryptionMethod === 2 && this._cryptoHandshakeDone) {\n data = this._decrypt(data)\n }\n this._bufferSize += data.length\n this._buffer.push(data)\n if (this._buffer.length > 1) {\n this._buffer = [concat(this._buffer, this._bufferSize)]\n }\n // now this._buffer is an array containing a single Buffer\n if (this._cryptoSyncPattern) {\n const index = this._buffer[0].indexOf(this._cryptoSyncPattern)\n if (index !== -1) {\n this._buffer[0] = this._buffer[0].slice(index + this._cryptoSyncPattern.length)\n this._bufferSize -= (index + this._cryptoSyncPattern.length)\n this._cryptoSyncPattern = null\n } else if (this._bufferSize + data.length > this._waitMaxBytes + this._cryptoSyncPattern.length) {\n this._debug('Error: could not resynchronize')\n this.destroy()\n return\n }\n }\n\n while (this._bufferSize >= this._parserSize && !this._cryptoSyncPattern) {\n if (this._parserSize === 0) {\n this._parser(new Uint8Array())\n } else {\n const buffer = this._buffer[0]\n // console.log('buffer:', this._buffer)\n this._bufferSize -= this._parserSize\n this._buffer = this._bufferSize\n ? [buffer.slice(this._parserSize)]\n : []\n this._parser(buffer.slice(0, this._parserSize))\n }\n }\n\n cb(null) // Signal that we're ready for more data\n }\n\n _callback (request, err, buffer) {\n if (!request) return\n\n this._resetTimeout(!this.peerChoking && !this._finished)\n\n request.callback(err, buffer)\n }\n\n _resetTimeout (setAgain) {\n if (!setAgain || !this._timeoutMs || !this.requests.length) {\n clearTimeout(this._timeout)\n this._timeout = null\n this._timeoutExpiresAt = null\n return\n }\n\n const timeoutExpiresAt = Date.now() + this._timeoutMs\n\n if (this._timeout) {\n // If existing expiration is already within 5% of correct, it's close enough\n if (timeoutExpiresAt - this._timeoutExpiresAt < this._timeoutMs * 0.05) {\n return\n }\n clearTimeout(this._timeout)\n }\n\n this._timeoutExpiresAt = timeoutExpiresAt\n this._timeout = setTimeout(() => this._onTimeout(), this._timeoutMs)\n if (this._timeoutUnref && this._timeout.unref) this._timeout.unref()\n }\n\n /**\n * Takes a number of bytes that the local peer is waiting to receive from the remote peer\n * in order to parse a complete message, and a callback function to be called once enough\n * bytes have arrived.\n * @param {number} size\n * @param {function} parser\n */\n _parse (size, parser) {\n this._parserSize = size\n this._parser = parser\n }\n\n _parseUntil (pattern, maxBytes) {\n this._cryptoSyncPattern = pattern\n this._waitMaxBytes = maxBytes\n }\n\n /**\n * Handle the first 4 bytes of a message, to determine the length of bytes that must be\n * waited for in order to have the whole message.\n * @param {Uint8Array} buffer\n */\n _onMessageLength (buffer) {\n const length = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getUint32(0)\n if (length > 0) {\n this._parse(length, this._onMessage)\n } else {\n this._onKeepAlive()\n this._parse(4, this._onMessageLength)\n }\n }\n\n /**\n * Handle a message from the remote peer.\n * @param {Uint8Array} buffer\n */\n _onMessage (buffer) {\n this._parse(4, this._onMessageLength)\n const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)\n switch (buffer[0]) {\n case 0:\n return this._onChoke()\n case 1:\n return this._onUnchoke()\n case 2:\n return this._onInterested()\n case 3:\n return this._onUninterested()\n case 4:\n return this._onHave(view.getUint32(1))\n case 5:\n return this._onBitField(buffer.slice(1))\n case 6:\n return this._onRequest(\n view.getUint32(1),\n view.getUint32(5),\n view.getUint32(9)\n )\n case 7:\n return this._onPiece(\n view.getUint32(1),\n view.getUint32(5),\n buffer.slice(9)\n )\n case 8:\n return this._onCancel(\n view.getUint32(1),\n view.getUint32(5),\n view.getUint32(9)\n )\n case 9:\n return this._onPort(view.getUint16(1))\n case 0x0D:\n return this._onSuggest(view.getUint32(1))\n case 0x0E:\n return this._onHaveAll()\n case 0x0F:\n return this._onHaveNone()\n case 0x10:\n return this._onReject(\n view.getUint32(1),\n view.getUint32(5),\n view.getUint32(9)\n )\n case 0x11:\n return this._onAllowedFast(view.getUint32(1))\n case 20:\n return this._onExtended(buffer[1], buffer.slice(2))\n default:\n this._debug('got unknown message')\n return this.emit('unknownmessage', buffer)\n }\n }\n\n _determineHandshakeType () {\n this._parse(1, pstrLenBuffer => {\n const pstrlen = pstrLenBuffer[0]\n if (pstrlen === 19) {\n this._parse(pstrlen + 48, this._onHandshakeBuffer)\n } else {\n this._parsePe1(pstrLenBuffer)\n }\n })\n }\n\n _parsePe1 (pubKeyPrefix) {\n this._parse(95, pubKeySuffix => {\n this._onPe1(concat([pubKeyPrefix, pubKeySuffix]))\n this._parsePe3()\n })\n }\n\n _parsePe2 () {\n this._parse(96, pubKey => {\n this._onPe2(pubKey)\n while (!this._setGenerators) {\n // Wait until generators have been set\n }\n this._parsePe4()\n })\n }\n\n // Handles the unencrypted portion of step 4\n async _parsePe3 () {\n const hash1Buffer = await hash(hex2arr(this._utfToHex('req1') + this._sharedSecret))\n // synchronize on HASH('req1', S)\n this._parseUntil(hash1Buffer, 512)\n this._parse(20, buffer => {\n this._onPe3(buffer)\n while (!this._setGenerators) {\n // Wait until generators have been set\n }\n this._parsePe3Encrypted()\n })\n }\n\n _parsePe3Encrypted () {\n this._parse(14, buffer => {\n const vcBuffer = this._decryptHandshake(buffer.slice(0, 8))\n const peerProvideBuffer = this._decryptHandshake(buffer.slice(8, 12))\n const padCLen = new DataView(this._decryptHandshake(buffer.slice(12, 14)).buffer).getUint16(0)\n this._parse(padCLen, padCBuffer => {\n padCBuffer = this._decryptHandshake(padCBuffer)\n this._parse(2, iaLenBuf => {\n const iaLen = new DataView(this._decryptHandshake(iaLenBuf).buffer).getUint16(0)\n this._parse(iaLen, iaBuffer => {\n iaBuffer = this._decryptHandshake(iaBuffer)\n this._onPe3Encrypted(vcBuffer, peerProvideBuffer, padCBuffer, iaBuffer)\n const pstrlen = iaLen ? iaBuffer[0] : null\n const protocol = iaLen ? iaBuffer.slice(1, 20) : null\n if (pstrlen === 19 && arr2text(protocol) === 'BitTorrent protocol') {\n this._onHandshakeBuffer(iaBuffer.slice(1))\n } else {\n this._parseHandshake()\n }\n })\n })\n })\n })\n }\n\n _parsePe4 () {\n // synchronize on ENCRYPT(VC).\n // since we encrypt using bitwise xor, decryption and encryption are the same operation.\n // calling _decryptHandshake here advances the decrypt generator keystream forward 8 bytes\n const vcBufferEncrypted = this._decryptHandshake(VC)\n this._parseUntil(vcBufferEncrypted, 512)\n this._parse(6, buffer => {\n const peerSelectBuffer = this._decryptHandshake(buffer.slice(0, 4))\n const padDLen = new DataView(this._decryptHandshake(buffer.slice(4, 6)).buffer).getUint16(0)\n this._parse(padDLen, padDBuf => {\n this._decryptHandshake(padDBuf)\n this._onPe4(peerSelectBuffer)\n this._parseHandshake(null)\n })\n })\n }\n\n /**\n * Reads the handshake as specified by the bittorrent wire protocol.\n */\n _parseHandshake () {\n this._parse(1, buffer => {\n const pstrlen = buffer[0]\n if (pstrlen !== 19) {\n this._debug('Error: wire not speaking BitTorrent protocol (%s)', pstrlen.toString())\n this.end()\n return\n }\n this._parse(pstrlen + 48, this._onHandshakeBuffer)\n })\n }\n\n _onHandshakeBuffer (handshake) {\n const protocol = handshake.slice(0, 19)\n if (arr2text(protocol) !== 'BitTorrent protocol') {\n this._debug('Error: wire not speaking BitTorrent protocol (%s)', arr2text(protocol))\n this.end()\n return\n }\n handshake = handshake.slice(19)\n this._onHandshake(handshake.slice(8, 28), handshake.slice(28, 48), {\n dht: !!(handshake[7] & 0x01), // see bep_0005\n fast: !!(handshake[7] & 0x04), // see bep_0006\n extended: !!(handshake[5] & 0x10) // see bep_0010\n })\n this._parse(4, this._onMessageLength)\n }\n\n _onFinish () {\n this._finished = true\n\n this.push(null) // stream cannot be half open, so signal the end of it\n while (this.read()) {\n // body intentionally empty\n // consume and discard the rest of the stream data\n }\n\n clearInterval(this._keepAliveInterval)\n this._parse(Number.MAX_VALUE, () => {})\n while (this.peerRequests.length) {\n this.peerRequests.pop()\n }\n while (this.requests.length) {\n this._callback(this.requests.pop(), new Error('wire was closed'), null)\n }\n }\n\n _debug (...args) {\n args[0] = `[${this._debugId}] ${args[0]}`\n debug(...args)\n }\n\n _pull (requests, piece, offset, length) {\n for (let i = 0; i < requests.length; i++) {\n const req = requests[i]\n if (req.piece === piece && req.offset === offset && req.length === length) {\n arrayRemove(requests, i)\n return req\n }\n }\n return null\n }\n\n _encryptHandshake (buf) {\n const crypt = new Uint8Array(buf)\n if (!this._encryptGenerator) {\n this._debug('Warning: Encrypting without any generator')\n return crypt\n }\n\n for (let i = 0; i < buf.length; i++) {\n const keystream = this._encryptGenerator.randomByte()\n crypt[i] = crypt[i] ^ keystream\n }\n\n return crypt\n }\n\n _encrypt (buf) {\n const crypt = new Uint8Array(buf)\n\n if (!this._encryptGenerator || this._encryptionMethod !== 2) {\n return crypt\n }\n for (let i = 0; i < buf.length; i++) {\n const keystream = this._encryptGenerator.randomByte()\n crypt[i] = crypt[i] ^ keystream\n }\n\n return crypt\n }\n\n _decryptHandshake (buf) {\n const decrypt = new Uint8Array(buf)\n\n if (!this._decryptGenerator) {\n this._debug('Warning: Decrypting without any generator')\n return decrypt\n }\n for (let i = 0; i < buf.length; i++) {\n const keystream = this._decryptGenerator.randomByte()\n decrypt[i] = decrypt[i] ^ keystream\n }\n\n return decrypt\n }\n\n _decrypt (buf) {\n const decrypt = new Uint8Array(buf)\n\n if (!this._decryptGenerator || this._encryptionMethod !== 2) {\n return decrypt\n }\n for (let i = 0; i < buf.length; i++) {\n const keystream = this._decryptGenerator.randomByte()\n decrypt[i] = decrypt[i] ^ keystream\n }\n\n return decrypt\n }\n\n _utfToHex (str) {\n return arr2hex(text2arr(str))\n }\n}\n\nexport default Wire\n","/* Common package for dealing with hex/string/uint8 conversions (and sha1 hashing)\r\n*\r\n* @author Jimmy Wärting (https://jimmy.warting.se/opensource)\r\n* @license MIT\r\n*/\r\nexport const alphabet = '0123456789abcdef'\r\nconst encodeLookup = []\r\nconst decodeLookup = []\r\n\r\nfor (let i = 0; i < 256; i++) {\r\n encodeLookup[i] = alphabet[i >> 4 & 0xf] + alphabet[i & 0xf]\r\n if (i < 16) {\r\n if (i < 10) {\r\n decodeLookup[0x30 + i] = i\r\n } else {\r\n decodeLookup[0x61 - 10 + i] = i\r\n }\r\n }\r\n}\r\n\r\nexport const arr2hex = data => {\r\n const length = data.length\r\n let string = ''\r\n let i = 0\r\n while (i < length) {\r\n string += encodeLookup[data[i++]]\r\n }\r\n return string\r\n}\r\n\r\nexport const hex2arr = str => {\r\n const sizeof = str.length >> 1\r\n const length = sizeof << 1\r\n const array = new Uint8Array(sizeof)\r\n let n = 0\r\n let i = 0\r\n while (i < length) {\r\n array[n++] = decodeLookup[str.charCodeAt(i++)] << 4 | decodeLookup[str.charCodeAt(i++)]\r\n }\r\n return array\r\n}\r\n\r\nexport const concat = (chunks, size = 0) => {\r\n const length = chunks.length || 0\r\n if (!size) {\r\n let i = length\r\n while (i--) size += chunks[i].length\r\n }\r\n const b = new Uint8Array(size)\r\n let offset = size\r\n let i = length\r\n while (i--) {\r\n offset -= chunks[i].length\r\n b.set(chunks[i], offset)\r\n }\r\n\r\n return b\r\n}\r\n\r\nexport const equal = (a, b) => {\r\n if (a.length !== b.length) return false\r\n for (let i = a.length; i > -1; i -= 1) {\r\n if ((a[i] !== b[i])) return false\r\n }\r\n return true\r\n}\r\n","/*\n * base64-arraybuffer 1.0.2 \n * Copyright (c) 2022 Niklas von Hertzen \n * Released under MIT License\n */\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n// Use a lookup table to find the index.\nvar lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);\nfor (var i = 0; i < chars.length; i++) {\n lookup[chars.charCodeAt(i)] = i;\n}\nvar encode = function (arraybuffer) {\n var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';\n for (i = 0; i < len; i += 3) {\n base64 += chars[bytes[i] >> 2];\n base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n base64 += chars[bytes[i + 2] & 63];\n }\n if (len % 3 === 2) {\n base64 = base64.substring(0, base64.length - 1) + '=';\n }\n else if (len % 3 === 1) {\n base64 = base64.substring(0, base64.length - 2) + '==';\n }\n return base64;\n};\nvar decode = function (base64) {\n var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;\n if (base64[base64.length - 1] === '=') {\n bufferLength--;\n if (base64[base64.length - 2] === '=') {\n bufferLength--;\n }\n }\n var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);\n for (i = 0; i < len; i += 4) {\n encoded1 = lookup[base64.charCodeAt(i)];\n encoded2 = lookup[base64.charCodeAt(i + 1)];\n encoded3 = lookup[base64.charCodeAt(i + 2)];\n encoded4 = lookup[base64.charCodeAt(i + 3)];\n bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n }\n return arraybuffer;\n};\n\nexport { decode, encode };\n//# sourceMappingURL=base64-arraybuffer.es5.js.map\n","import { arr2hex, hex2arr, alphabet } from './util.js'\r\nimport { decode, encode } from 'base64-arraybuffer'\r\n\r\nconst decoder = new TextDecoder()\r\n// 50% slower at < 48 chars, but little impact at 4M OPS/s vs 8M OPS/s\r\nexport const arr2text = (data, enc) => {\r\n if (!enc) return decoder.decode(data)\r\n const dec = new TextDecoder(enc)\r\n return dec.decode(data)\r\n}\r\n\r\n// sacrifice ~20% speed for bundle size\r\nconst encoder = new TextEncoder()\r\nexport const text2arr = str => encoder.encode(str)\r\n\r\nexport const arr2base = data => encode(data)\r\n\r\nexport const base2arr = str => new Uint8Array(decode(str))\r\n\r\nexport const bin2hex = str => {\r\n let res = ''\r\n let c\r\n let i = 0\r\n const len = str.length\r\n\r\n while (i < len) {\r\n c = str.charCodeAt(i++)\r\n res += alphabet[c >> 4] + alphabet[c & 0xF]\r\n }\r\n\r\n return res\r\n}\r\n\r\nconst MAX_ARGUMENTS_LENGTH = 0x10000\r\nexport const hex2bin = hex => {\r\n const points = hex2arr(hex)\r\n if (points.length <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode(...points)\r\n\r\n let res = ''\r\n let i = 0\r\n while (i < points.length) {\r\n res += String.fromCharCode(...points.subarray(i, i += MAX_ARGUMENTS_LENGTH))\r\n }\r\n return res\r\n}\r\n\r\nconst scope = typeof window !== 'undefined' ? window : self\r\nconst crypto = scope.crypto || scope.msCrypto || {}\r\nconst subtle = crypto.subtle || crypto.webkitSubtle\r\n\r\nconst formatMap = {\r\n hex: arr2hex,\r\n base64: arr2base\r\n}\r\n\r\nexport const hash = async (data, format, algo = 'sha-1') => {\r\n if (!subtle) throw new Error('no web crypto support')\r\n if (typeof data === 'string') data = text2arr(data)\r\n const out = new Uint8Array(await subtle.digest(algo, data))\r\n return format ? formatMap[format](out) : out\r\n}\r\n\r\nexport const randomBytes = size => {\r\n const view = new Uint8Array(size)\r\n return crypto.getRandomValues(view)\r\n}\r\n\r\nexport * from './util.js'\r\n","/*!\n * Fast node `require('process')` for modern browsers\n *\n * @author Mathias Rasmussen \n * @license MIT\n */\nimport queueMicrotask from 'queue-microtask'\n\nconst title = 'browser'\nconst browser = true\nconst env = {}\nconst argv = []\nconst version = ''\nconst versions = {}\n\nfunction noop () {}\n\nconst on = noop\nconst addListener = noop\nconst once = noop\nconst off = noop\nconst removeListener = noop\nconst removeAllListeners = noop\nconst emit = noop\nconst prependListener = noop\nconst prependOnceListener = noop\n\nconst nextTick = (func, ...args) => queueMicrotask(() => func(...args))\n\nconst listeners = (name) => []\n\nconst cwd = () => '/'\nconst umask = () => 0\nconst binding = (name) => { throw new Error('process.binding is not supported') }\nconst chdir = (dir) => { throw new Error('process.chdir is not supported') }\n\nexport {\n title, browser, env, argv, version, versions, on, addListener, once, off, removeListener,\n removeAllListeners, emit, prependListener, prependOnceListener, nextTick, listeners, cwd, umask, binding, chdir\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export function assertPath (path) {\r\n if (typeof path !== 'string') {\r\n throw new TypeError('Path must be a string. Received ' + JSON.stringify(path))\r\n }\r\n}\r\n\r\n// Resolves . and .. elements in a path with directory names\r\nexport function normalizeStringPosix (path, allowAboveRoot) {\r\n let res = ''\r\n let lastSegmentLength = 0\r\n let lastSlash = -1\r\n let dots = 0\r\n let code\r\n for (let i = 0; i <= path.length; ++i) {\r\n if (i < path.length) { code = path.charCodeAt(i) } else if (code === 47) { break } else { code = 47 }\r\n if (code === 47) {\r\n if (lastSlash === i - 1 || dots === 1) {\r\n // NOOP\r\n } else if (lastSlash !== i - 1 && dots === 2) {\r\n if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {\r\n if (res.length > 2) {\r\n const lastSlashIndex = res.lastIndexOf('/')\r\n if (lastSlashIndex !== res.length - 1) {\r\n if (lastSlashIndex === -1) {\r\n res = ''\r\n lastSegmentLength = 0\r\n } else {\r\n res = res.slice(0, lastSlashIndex)\r\n lastSegmentLength = res.length - 1 - res.lastIndexOf('/')\r\n }\r\n lastSlash = i\r\n dots = 0\r\n continue\r\n }\r\n } else if (res.length === 2 || res.length === 1) {\r\n res = ''\r\n lastSegmentLength = 0\r\n lastSlash = i\r\n dots = 0\r\n continue\r\n }\r\n }\r\n if (allowAboveRoot) {\r\n if (res.length > 0) { res += '/..' } else { res = '..' }\r\n lastSegmentLength = 2\r\n }\r\n } else {\r\n if (res.length > 0) { res += '/' + path.slice(lastSlash + 1, i) } else { res = path.slice(lastSlash + 1, i) }\r\n lastSegmentLength = i - lastSlash - 1\r\n }\r\n lastSlash = i\r\n dots = 0\r\n } else if (code === 46 && dots !== -1) {\r\n ++dots\r\n } else {\r\n dots = -1\r\n }\r\n }\r\n return res\r\n}\r\n\r\nexport function _format (sep, pathObject) {\r\n const dir = pathObject.dir || pathObject.root\r\n const base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '')\r\n if (!dir) {\r\n return base\r\n }\r\n if (dir === pathObject.root) {\r\n return dir + base\r\n }\r\n return dir + sep + base\r\n}\r\n","import { assertPath } from './util.js'\r\nimport normalize from './normalize.js'\r\n\r\nexport default function join () {\r\n if (arguments.length === 0) { return '.' }\r\n let joined\r\n for (let i = 0; i < arguments.length; ++i) {\r\n const arg = arguments[i]\r\n assertPath(arg)\r\n if (arg.length > 0) {\r\n if (joined === undefined) { joined = arg } else { joined += '/' + arg }\r\n }\r\n }\r\n if (joined === undefined) { return '.' }\r\n return normalize(joined)\r\n}\r\n","import { assertPath, normalizeStringPosix } from './util.js'\r\n\r\nexport default function normalize (path) {\r\n assertPath(path)\r\n\r\n if (path.length === 0) return '.'\r\n\r\n const isAbsolute = path.charCodeAt(0) === 47\r\n const trailingSeparator = path.charCodeAt(path.length - 1) === 47\r\n\r\n // Normalize the path\r\n path = normalizeStringPosix(path, !isAbsolute)\r\n\r\n if (path.length === 0 && !isAbsolute) path = '.'\r\n if (path.length > 0 && trailingSeparator) path += '/'\r\n\r\n if (isAbsolute) return '/' + path\r\n return path\r\n}\r\n","export const _makeLong = a => a\r\nexport const sep = '/'\r\nexport const delimiter = ':'\r\n\r\nexport { default as basename } from './lib/basename.js'\r\nexport { default as dirname } from './lib/dirname.js'\r\nexport { default as extname } from './lib/extname.js'\r\nexport { default as format } from './lib/format.js'\r\nexport { default as isAbsolute } from './lib/isAbsolute.js'\r\nexport { default as join } from './lib/join.js'\r\nexport { default as normalize } from './lib/normalize.js'\r\nexport { default as parse } from './lib/parse.js'\r\nexport { default as relative } from './lib/relative.js'\r\nexport { default as resolve } from './lib/resolve.js'\r\n\r\nexport * as default from './index.js'\r\nexport * as win32 from './index.js'\r\nexport * as posix from './index.js'\r\n","const ignoreList = [\n\t// # All\n\t'^npm-debug\\\\.log$', // Error log for npm\n\t'^\\\\..*\\\\.swp$', // Swap file for vim state\n\n\t// # macOS\n\t'^\\\\.DS_Store$', // Stores custom folder attributes\n\t'^\\\\.AppleDouble$', // Stores additional file resources\n\t'^\\\\.LSOverride$', // Contains the absolute path to the app to be used\n\t'^Icon\\\\r$', // Custom Finder icon: http://superuser.com/questions/298785/icon-file-on-os-x-desktop\n\t'^\\\\._.*', // Thumbnail\n\t'^\\\\.Spotlight-V100(?:$|\\\\/)', // Directory that might appear on external disk\n\t'\\\\.Trashes', // File that might appear on external disk\n\t'^__MACOSX$', // Resource fork\n\n\t// # Linux\n\t'~$', // Backup file\n\n\t// # Windows\n\t'^Thumbs\\\\.db$', // Image file cache\n\t'^ehthumbs\\\\.db$', // Folder config file\n\t'^[Dd]esktop\\\\.ini$', // Stores custom folder attributes\n\t'@eaDir$', // Synology Diskstation \"hidden\" folder where the server stores thumbnails\n];\n\nexport const junkRegex = new RegExp(ignoreList.join('|'));\n\nexport function isJunk(filename) {\n\treturn junkRegex.test(filename);\n}\n\nexport function isNotJunk(filename) {\n\treturn !isJunk(filename);\n}\n","/*! create-torrent. MIT License. WebTorrent LLC */\nimport bencode from 'bencode'\nimport blockIterator from 'block-iterator'\nimport calcPieceLength from 'piece-length'\nimport corePath from 'path'\nimport isFile from 'is-file'\nimport { isJunk } from 'junk'\nimport joinIterator from 'join-async-iterator'\nimport parallel from 'run-parallel'\nimport queueMicrotask from 'queue-microtask'\nimport { hash, hex2arr } from 'uint8-util'\nimport 'fast-readable-async-iterator'\n\nimport getFiles from './get-files.js' // browser exclude\n\nconst announceList = [\n ['udp://tracker.leechers-paradise.org:6969'],\n ['udp://tracker.coppersurfer.tk:6969'],\n ['udp://tracker.opentrackr.org:1337'],\n ['udp://explodie.org:6969'],\n ['udp://tracker.empire-js.us:1337'],\n ['wss://tracker.btorrent.xyz'],\n ['wss://tracker.openwebtorrent.com'],\n ['wss://tracker.webtorrent.dev']\n]\n\n/**\n * Create a torrent.\n * @param {string|File|FileList|Buffer|Stream|Array.} input\n * @param {Object} opts\n * @param {string=} opts.name\n * @param {Date=} opts.creationDate\n * @param {string=} opts.comment\n * @param {string=} opts.createdBy\n * @param {boolean|number=} opts.private\n * @param {number=} opts.pieceLength\n * @param {number=} opts.maxPieceLength\n * @param {Array.>=} opts.announceList\n * @param {Array.=} opts.urlList\n * @param {Object=} opts.info\n * @param {Function} opts.onProgress\n * @param {function} cb\n * @return {Buffer} buffer of .torrent file data\n */\nfunction createTorrent (input, opts, cb) {\n if (typeof opts === 'function') [opts, cb] = [cb, opts]\n opts = opts ? Object.assign({}, opts) : {}\n\n _parseInput(input, opts, (err, files, singleFileTorrent) => {\n if (err) return cb(err)\n opts.singleFileTorrent = singleFileTorrent\n onFiles(files, opts, cb)\n })\n}\n\nfunction parseInput (input, opts, cb) {\n if (typeof opts === 'function') [opts, cb] = [cb, opts]\n opts = opts ? Object.assign({}, opts) : {}\n _parseInput(input, opts, cb)\n}\n\nconst pathSymbol = Symbol('itemPath')\n\n/**\n * Parse input file and return file information.\n */\nfunction _parseInput (input, opts, cb) {\n if (isFileList(input)) input = Array.from(input)\n if (!Array.isArray(input)) input = [input]\n\n if (input.length === 0) throw new Error('invalid input type')\n\n input.forEach(item => {\n if (item == null) throw new Error(`invalid input type: ${item}`)\n })\n\n // In Electron, use the true file path\n input = input.map(item => {\n if (isBlob(item) && typeof item.path === 'string' && typeof getFiles === 'function') return item.path\n return item\n })\n\n // If there's just one file, allow the name to be set by `opts.name`\n if (input.length === 1 && typeof input[0] !== 'string' && !input[0].name) input[0].name = opts.name\n\n let commonPrefix = null\n input.forEach((item, i) => {\n if (typeof item === 'string') {\n return\n }\n\n let path = item.fullPath || item.name\n if (!path) {\n path = `Unknown File ${i + 1}`\n item.unknownName = true\n }\n\n item[pathSymbol] = path.split('/')\n\n // Remove initial slash\n if (!item[pathSymbol][0]) {\n item[pathSymbol].shift()\n }\n\n if (item[pathSymbol].length < 2) { // No real prefix\n commonPrefix = null\n } else if (i === 0 && input.length > 1) { // The first file has a prefix\n commonPrefix = item[pathSymbol][0]\n } else if (item[pathSymbol][0] !== commonPrefix) { // The prefix doesn't match\n commonPrefix = null\n }\n })\n\n const filterJunkFiles = opts.filterJunkFiles === undefined ? true : opts.filterJunkFiles\n if (filterJunkFiles) {\n // Remove junk files\n input = input.filter(item => {\n if (typeof item === 'string') {\n return true\n }\n return !isJunkPath(item[pathSymbol])\n })\n }\n\n if (commonPrefix) {\n input.forEach(item => {\n const pathless = (ArrayBuffer.isView(item) || isReadable(item)) && !item[pathSymbol]\n if (typeof item === 'string' || pathless) return\n item[pathSymbol].shift()\n })\n }\n\n if (!opts.name && commonPrefix) {\n opts.name = commonPrefix\n }\n\n if (!opts.name) {\n // use first user-set file name\n input.some(item => {\n if (typeof item === 'string') {\n opts.name = corePath.basename(item)\n return true\n } else if (!item.unknownName) {\n opts.name = item[pathSymbol][item[pathSymbol].length - 1]\n return true\n }\n return false\n })\n }\n\n if (!opts.name) {\n opts.name = `Unnamed Torrent ${Date.now()}`\n }\n\n if (!opts.maxPieceLength) {\n opts.maxPieceLength = 4 * 1024 * 1024\n }\n\n const numPaths = input.reduce((sum, item) => sum + Number(typeof item === 'string'), 0)\n\n let isSingleFileTorrent = (input.length === 1)\n\n if (input.length === 1 && typeof input[0] === 'string') {\n if (typeof getFiles !== 'function') {\n throw new Error('filesystem paths do not work in the browser')\n }\n // If there's a single path, verify it's a file before deciding this is a single\n // file torrent\n isFile(input[0], (err, pathIsFile) => {\n if (err) return cb(err)\n isSingleFileTorrent = pathIsFile\n processInput()\n })\n } else {\n queueMicrotask(processInput)\n }\n\n function processInput () {\n parallel(input.map(item => cb => {\n const file = {}\n\n if (isBlob(item)) {\n file.getStream = item.stream()\n file.length = item.size\n } else if (ArrayBuffer.isView(item)) {\n file.getStream = [item] // wrap in iterable to write entire buffer at once instead of unwrapping all bytes\n file.length = item.length\n } else if (isReadable(item)) {\n file.getStream = getStreamStream(item, file)\n file.length = 0\n } else if (typeof item === 'string') {\n if (typeof getFiles !== 'function') {\n throw new Error('filesystem paths do not work in the browser')\n }\n const keepRoot = numPaths > 1 || isSingleFileTorrent\n getFiles(item, keepRoot, cb)\n return // early return!\n } else {\n throw new Error('invalid input type')\n }\n file.path = item[pathSymbol]\n cb(null, file)\n }), (err, files) => {\n if (err) return cb(err)\n files = files.flat()\n cb(null, files, isSingleFileTorrent)\n })\n }\n}\n\nconst MAX_OUTSTANDING_HASHES = 5\n\nasync function getPieceList (files, pieceLength, estimatedTorrentLength, opts, cb) {\n const pieces = []\n let length = 0\n let hashedLength = 0\n\n const streams = files.map(file => file.getStream)\n\n const onProgress = opts.onProgress\n\n let remainingHashes = 0\n let pieceNum = 0\n let ended = false\n\n const iterator = blockIterator(joinIterator(streams), pieceLength, { zeroPadding: false })\n try {\n for await (const chunk of iterator) {\n await new Promise(resolve => {\n length += chunk.length\n const i = pieceNum\n ++pieceNum\n if (++remainingHashes < MAX_OUTSTANDING_HASHES) resolve()\n hash(chunk, 'hex').then(hash => {\n pieces[i] = hash\n --remainingHashes\n hashedLength += chunk.length\n if (onProgress) onProgress(hashedLength, estimatedTorrentLength)\n resolve()\n if (ended && remainingHashes === 0) cb(null, hex2arr(pieces.join('')), length)\n })\n })\n }\n if (remainingHashes === 0) return cb(null, hex2arr(pieces.join('')), length)\n ended = true\n } catch (err) {\n cb(err)\n }\n}\n\nfunction onFiles (files, opts, cb) {\n let _announceList = opts.announceList\n\n if (!_announceList) {\n if (typeof opts.announce === 'string') _announceList = [[opts.announce]]\n else if (Array.isArray(opts.announce)) {\n _announceList = opts.announce.map(u => [u])\n }\n }\n\n if (!_announceList) _announceList = []\n\n if (globalThis.WEBTORRENT_ANNOUNCE) {\n if (typeof globalThis.WEBTORRENT_ANNOUNCE === 'string') {\n _announceList.push([[globalThis.WEBTORRENT_ANNOUNCE]])\n } else if (Array.isArray(globalThis.WEBTORRENT_ANNOUNCE)) {\n _announceList = _announceList.concat(globalThis.WEBTORRENT_ANNOUNCE.map(u => [u]))\n }\n }\n\n // When no trackers specified, use some reasonable defaults\n if (opts.announce === undefined && opts.announceList === undefined) {\n _announceList = _announceList.concat(announceList)\n }\n\n if (typeof opts.urlList === 'string') opts.urlList = [opts.urlList]\n\n const torrent = {\n info: {\n name: opts.name\n },\n 'creation date': Math.ceil((Number(opts.creationDate) || Date.now()) / 1000),\n encoding: 'UTF-8'\n }\n\n if (_announceList.length !== 0) {\n torrent.announce = _announceList[0][0]\n torrent['announce-list'] = _announceList\n }\n\n if (opts.comment !== undefined) torrent.comment = opts.comment\n\n if (opts.createdBy !== undefined) torrent['created by'] = opts.createdBy\n\n if (opts.private !== undefined) torrent.info.private = Number(opts.private)\n\n if (opts.info !== undefined) Object.assign(torrent.info, opts.info)\n\n // \"ssl-cert\" key is for SSL torrents, see:\n // - http://blog.libtorrent.org/2012/01/bittorrent-over-ssl/\n // - http://www.libtorrent.org/manual-ref.html#ssl-torrents\n // - http://www.libtorrent.org/reference-Create_Torrents.html\n if (opts.sslCert !== undefined) torrent.info['ssl-cert'] = opts.sslCert\n\n if (opts.urlList !== undefined) torrent['url-list'] = opts.urlList\n\n const estimatedTorrentLength = files.reduce(sumLength, 0)\n const pieceLength = opts.pieceLength || Math.min(calcPieceLength(estimatedTorrentLength), opts.maxPieceLength)\n torrent.info['piece length'] = pieceLength\n\n getPieceList(\n files,\n pieceLength,\n estimatedTorrentLength,\n opts,\n (err, pieces, torrentLength) => {\n if (err) return cb(err)\n torrent.info.pieces = pieces\n\n files.forEach(file => {\n delete file.getStream\n })\n\n if (opts.singleFileTorrent) {\n torrent.info.length = torrentLength\n } else {\n torrent.info.files = files\n }\n\n cb(null, bencode.encode(torrent))\n }\n )\n}\n\n/**\n * Determine if a a file is junk based on its path\n * (defined as hidden OR recognized by the `junk` package)\n *\n * @param {string} path\n * @return {boolean}\n */\nfunction isJunkPath (path) {\n const filename = path[path.length - 1]\n return filename[0] === '.' && isJunk(filename)\n}\n\n/**\n * Accumulator to sum file lengths\n * @param {number} sum\n * @param {Object} file\n * @return {number}\n */\nfunction sumLength (sum, file) {\n return sum + file.length\n}\n\n/**\n * Check if `obj` is a W3C `Blob` object (which `File` inherits from)\n * @param {*} obj\n * @return {boolean}\n */\nfunction isBlob (obj) {\n return typeof Blob !== 'undefined' && obj instanceof Blob\n}\n\n/**\n * Check if `obj` is a W3C `FileList` object\n * @param {*} obj\n * @return {boolean}\n */\nfunction isFileList (obj) {\n return typeof FileList !== 'undefined' && obj instanceof FileList\n}\n\n/**\n * Check if `obj` is a node Readable stream\n * @param {*} obj\n * @return {boolean}\n */\nfunction isReadable (obj) {\n return typeof obj === 'object' && obj != null && typeof obj.pipe === 'function'\n}\n\n/**\n * Convert a readable stream to a lazy async iterator. Adds instrumentation to track\n * the number of bytes in the stream and set `file.length`.\n *\n * @generator\n * @param {Stream} readable\n * @param {Object} file\n * @return {Uint8Array} stream data/chunk\n */\nasync function * getStreamStream (readable, file) {\n for await (const chunk of readable) {\n file.length += chunk.length\n yield chunk\n }\n}\n\nexport default createTorrent\nexport { parseInput, announceList, isJunkPath }\n","import { assertPath } from './util.js'\r\n\r\nexport default function basename (path, ext) {\r\n if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string')\r\n assertPath(path)\r\n\r\n let start = 0\r\n let end = -1\r\n let matchedSlash = true\r\n let i\r\n\r\n if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\r\n if (ext.length === path.length && ext === path) return ''\r\n let extIdx = ext.length - 1\r\n let firstNonSlashEnd = -1\r\n for (i = path.length - 1; i >= 0; --i) {\r\n const code = path.charCodeAt(i)\r\n if (code === 47) {\r\n // If we reached a path separator that was not part of a set of path\r\n // separators at the end of the string, stop now\r\n if (!matchedSlash) {\r\n start = i + 1\r\n break\r\n }\r\n } else {\r\n if (firstNonSlashEnd === -1) {\r\n // We saw the first non-path separator, remember this index in case\r\n // we need it if the extension ends up not matching\r\n matchedSlash = false\r\n firstNonSlashEnd = i + 1\r\n }\r\n if (extIdx >= 0) {\r\n // Try to match the explicit extension\r\n if (code === ext.charCodeAt(extIdx)) {\r\n if (--extIdx === -1) {\r\n // We matched the extension, so mark this as the end of our path\r\n // component\r\n end = i\r\n }\r\n } else {\r\n // Extension does not match, so our result is the entire path\r\n // component\r\n extIdx = -1\r\n end = firstNonSlashEnd\r\n }\r\n }\r\n }\r\n }\r\n\r\n if (start === end) end = firstNonSlashEnd; else if (end === -1) end = path.length\r\n return path.slice(start, end)\r\n } else {\r\n for (i = path.length - 1; i >= 0; --i) {\r\n if (path.charCodeAt(i) === 47) {\r\n // If we reached a path separator that was not part of a set of path\r\n // separators at the end of the string, stop now\r\n if (!matchedSlash) {\r\n start = i + 1\r\n break\r\n }\r\n } else if (end === -1) {\r\n // We saw the first non-path separator, mark this as the end of our\r\n // path component\r\n matchedSlash = false\r\n end = i + 1\r\n }\r\n }\r\n\r\n if (end === -1) return ''\r\n return path.slice(start, end)\r\n }\r\n}\r\n","export const Blob = self.Blob\r\nexport const File = self.File\r\nexport const FormData = self.FormData\r\nexport const Headers = self.Headers\r\nexport const Request = self.Request\r\nexport const Response = self.Response\r\nexport const AbortController = self.AbortController\r\nexport const AbortSignal = self.AbortSignal\r\n\r\nexport const fetch = self.fetch || (() => { throw new Error('global fetch is not available!') })\r\nexport default fetch\r\n","import { text2arr } from 'uint8-util'\r\n/*\r\nCopyright (c) 2011, Chris Umbel\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy\r\nof this software and associated documentation files (the \"Software\"), to deal\r\nin the Software without restriction, including without limitation the rights\r\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\ncopies of the Software, and to permit persons to whom the Software is\r\nfurnished to do so, subject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in\r\nall copies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\nTHE SOFTWARE.\r\n*/\r\nconst charTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\r\nconst byteTable = [\r\n 0xff, 0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,\r\n 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r\n 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,\r\n 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,\r\n 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,\r\n 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,\r\n 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,\r\n 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,\r\n 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,\r\n 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff\r\n]\r\nfunction quintetCount (buff) {\r\n const quintets = Math.floor(buff.length / 5)\r\n return buff.length % 5 === 0 ? quintets : quintets + 1\r\n}\r\nconst encode = function (plain) {\r\n if (!ArrayBuffer.isView(plain) && typeof plain !== 'string') {\r\n throw new TypeError('base32.encode only takes Buffer or string as parameter')\r\n }\r\n if (!ArrayBuffer.isView(plain)) {\r\n plain = text2arr(plain)\r\n }\r\n let i = 0\r\n let j = 0\r\n let shiftIndex = 0\r\n let digit = 0\r\n const encoded = new Uint8Array(quintetCount(plain) * 8)\r\n /* byte by byte isn't as pretty as quintet by quintet but tests a bit\r\n faster. will have to revisit. */\r\n while (i < plain.length) {\r\n const current = plain[i]\r\n if (shiftIndex > 3) {\r\n digit = current & (0xff >> shiftIndex)\r\n shiftIndex = (shiftIndex + 5) % 8\r\n digit = (digit << shiftIndex) | ((i + 1 < plain.length)\r\n ? plain[i + 1]\r\n : 0) >> (8 - shiftIndex)\r\n i++\r\n } else {\r\n digit = (current >> (8 - (shiftIndex + 5))) & 0x1f\r\n shiftIndex = (shiftIndex + 5) % 8\r\n if (shiftIndex === 0) { i++ }\r\n }\r\n encoded[j] = charTable.charCodeAt(digit)\r\n j++\r\n }\r\n for (i = j; i < encoded.length; i++) {\r\n encoded[i] = 0x3d // '='.charCodeAt(0)\r\n }\r\n return encoded\r\n}\r\nconst decode = function (encoded) {\r\n if (!ArrayBuffer.isView(encoded) && typeof encoded !== 'string') {\r\n throw new TypeError('base32.decode only takes Buffer or string as parameter')\r\n }\r\n let shiftIndex = 0\r\n let plainDigit = 0\r\n let plainChar\r\n let plainPos = 0\r\n if (!ArrayBuffer.isView(encoded)) {\r\n encoded = text2arr(encoded)\r\n }\r\n const decoded = new Uint8Array(Math.ceil(encoded.length * 5 / 8))\r\n /* byte by byte isn't as pretty as octet by octet but tests a bit\r\n faster. will have to revisit. */\r\n for (let i = 0; i < encoded.length; i++) {\r\n if (encoded[i] === 0x3d) { // '='\r\n break\r\n }\r\n const encodedByte = encoded[i] - 0x30\r\n if (encodedByte < byteTable.length) {\r\n plainDigit = byteTable[encodedByte]\r\n if (shiftIndex <= 3) {\r\n shiftIndex = (shiftIndex + 5) % 8\r\n if (shiftIndex === 0) {\r\n plainChar |= plainDigit\r\n decoded[plainPos] = plainChar\r\n plainPos++\r\n plainChar = 0\r\n } else {\r\n plainChar |= 0xff & (plainDigit << (8 - shiftIndex))\r\n }\r\n } else {\r\n shiftIndex = (shiftIndex + 5) % 8\r\n plainChar |= 0xff & (plainDigit >>> shiftIndex)\r\n decoded[plainPos] = plainChar\r\n plainPos++\r\n plainChar = 0xff & (plainDigit << (8 - shiftIndex))\r\n }\r\n } else {\r\n throw new Error('Invalid input - it is not base32 encoded string')\r\n }\r\n }\r\n return decoded.subarray(0, plainPos)\r\n}\r\nexport default { encode, decode }\r\nexport { encode, decode }\r\n","function composeRange (range) {\n return range\n .reduce((acc, cur, idx, arr) => {\n if (idx === 0 || cur !== arr[idx - 1] + 1) acc.push([])\n acc[acc.length - 1].push(cur)\n return acc\n }, [])\n .map((cur) => {\n return cur.length > 1 ? `${cur[0]}-${cur[cur.length - 1]}` : `${cur[0]}`\n })\n}\n\nfunction parseRange (range) {\n const generateRange = (start, end = start) => Array.from({ length: end - start + 1 }, (cur, idx) => idx + start)\n\n return range\n .reduce((acc, cur, idx, arr) => {\n const r = cur.split('-').map(cur => parseInt(cur))\n return acc.concat(generateRange(...r))\n }, [])\n}\n\nexport default parseRange\n\nexport {\n parseRange as parse,\n composeRange as compose\n}\n","/*! magnet-uri. MIT License. WebTorrent LLC */\nimport { decode } from '@thaunknown/thirty-two'\nimport { parse, compose } from 'bep53-range'\nimport { hex2arr, arr2hex } from 'uint8-util'\n\n/**\n * Parse a magnet URI and return an object of keys/values\n *\n * @param {string} uri\n * @return {Object} parsed uri\n */\nfunction magnetURIDecode (uri) {\n const result = {}\n\n // Support 'magnet:' and 'stream-magnet:' uris\n const data = uri.split('magnet:?')[1]\n\n const params = (data && data.length >= 0)\n ? data.split('&')\n : []\n\n params.forEach(param => {\n const keyval = param.split('=')\n\n // This keyval is invalid, skip it\n if (keyval.length !== 2) return\n\n const key = keyval[0]\n let val = keyval[1]\n\n // Clean up torrent name\n if (key === 'dn') val = decodeURIComponent(val).replace(/\\+/g, ' ')\n\n // Address tracker (tr), exact source (xs), and acceptable source (as) are encoded\n // URIs, so decode them\n if (key === 'tr' || key === 'xs' || key === 'as' || key === 'ws') {\n val = decodeURIComponent(val)\n }\n\n // Return keywords as an array\n if (key === 'kt') val = decodeURIComponent(val).split('+')\n\n // Cast file index (ix) to a number\n if (key === 'ix') val = Number(val)\n\n // bep53\n if (key === 'so') val = parse(decodeURIComponent(val).split(','))\n\n // If there are repeated parameters, return an array of values\n if (result[key]) {\n if (!Array.isArray(result[key])) {\n result[key] = [result[key]]\n }\n\n result[key].push(val)\n } else {\n result[key] = val\n }\n })\n\n // Convenience properties for parity with `parse-torrent-file` module\n let m\n if (result.xt) {\n const xts = Array.isArray(result.xt) ? result.xt : [result.xt]\n xts.forEach(xt => {\n if ((m = xt.match(/^urn:btih:(.{40})/))) {\n result.infoHash = m[1].toLowerCase()\n } else if ((m = xt.match(/^urn:btih:(.{32})/))) {\n result.infoHash = arr2hex(decode(m[1]))\n } else if ((m = xt.match(/^urn:btmh:1220(.{64})/))) {\n result.infoHashV2 = m[1].toLowerCase()\n }\n })\n }\n\n if (result.xs) {\n const xss = Array.isArray(result.xs) ? result.xs : [result.xs]\n xss.forEach(xs => {\n if ((m = xs.match(/^urn:btpk:(.{64})/))) {\n result.publicKey = m[1].toLowerCase()\n }\n })\n }\n\n if (result.infoHash) result.infoHashBuffer = hex2arr(result.infoHash)\n if (result.infoHashV2) result.infoHashV2Buffer = hex2arr(result.infoHashV2)\n if (result.publicKey) result.publicKeyBuffer = hex2arr(result.publicKey)\n\n if (result.dn) result.name = result.dn\n if (result.kt) result.keywords = result.kt\n\n result.announce = []\n if (typeof result.tr === 'string' || Array.isArray(result.tr)) {\n result.announce = result.announce.concat(result.tr)\n }\n\n result.urlList = []\n if (typeof result.as === 'string' || Array.isArray(result.as)) {\n result.urlList = result.urlList.concat(result.as)\n }\n if (typeof result.ws === 'string' || Array.isArray(result.ws)) {\n result.urlList = result.urlList.concat(result.ws)\n }\n\n result.peerAddresses = []\n if (typeof result['x.pe'] === 'string' || Array.isArray(result['x.pe'])) {\n result.peerAddresses = result.peerAddresses.concat(result['x.pe'])\n }\n\n // remove duplicates by converting to Set and back\n result.announce = Array.from(new Set(result.announce))\n result.urlList = Array.from(new Set(result.urlList))\n result.peerAddresses = Array.from(new Set(result.peerAddresses))\n\n return result\n}\n\nfunction magnetURIEncode (obj) {\n obj = Object.assign({}, obj) // clone obj, so we can mutate it\n\n // support using convenience names, in addition to spec names\n // (example: `infoHash` for `xt`, `name` for `dn`)\n\n // Deduplicate xt by using a set\n let xts = new Set()\n if (obj.xt && typeof obj.xt === 'string') xts.add(obj.xt)\n if (obj.xt && Array.isArray(obj.xt)) xts = new Set(obj.xt)\n if (obj.infoHashBuffer) xts.add(`urn:btih:${arr2hex(obj.infoHashBuffer)}`)\n if (obj.infoHash) xts.add(`urn:btih:${obj.infoHash}`)\n if (obj.infoHashV2Buffer) xts.add(obj.xt = `urn:btmh:1220${arr2hex(obj.infoHashV2Buffer)}`)\n if (obj.infoHashV2) xts.add(`urn:btmh:1220${obj.infoHashV2}`)\n const xtsDeduped = Array.from(xts)\n if (xtsDeduped.length === 1) obj.xt = xtsDeduped[0]\n if (xtsDeduped.length > 1) obj.xt = xtsDeduped\n\n if (obj.publicKeyBuffer) obj.xs = `urn:btpk:${arr2hex(obj.publicKeyBuffer)}`\n if (obj.publicKey) obj.xs = `urn:btpk:${obj.publicKey}`\n if (obj.name) obj.dn = obj.name\n if (obj.keywords) obj.kt = obj.keywords\n if (obj.announce) obj.tr = obj.announce\n if (obj.urlList) {\n obj.ws = obj.urlList\n delete obj.as\n }\n if (obj.peerAddresses) obj['x.pe'] = obj.peerAddresses\n\n let result = 'magnet:?'\n Object.keys(obj)\n .filter(key => key.length === 2 || key === 'x.pe')\n .forEach((key, i) => {\n const values = Array.isArray(obj[key]) ? obj[key] : [obj[key]]\n values.forEach((val, j) => {\n if ((i > 0 || j > 0) && ((key !== 'kt' && key !== 'so') || j === 0)) result += '&'\n\n if (key === 'dn') val = encodeURIComponent(val).replace(/%20/g, '+')\n if (key === 'tr' || key === 'as' || key === 'ws') {\n val = encodeURIComponent(val)\n }\n // Don't URI encode BEP46 keys\n if (key === 'xs' && !val.startsWith('urn:btpk:')) {\n val = encodeURIComponent(val)\n }\n if (key === 'kt') val = encodeURIComponent(val)\n if (key === 'so') return\n\n if (key === 'kt' && j > 0) result += `+${val}`\n else result += `${key}=${val}`\n })\n if (key === 'so') result += `${key}=${compose(values)}`\n })\n\n return result\n}\n\nexport default magnetURIDecode\nexport { magnetURIDecode as decode, magnetURIEncode as encode }\n","/*! parse-torrent. MIT License. WebTorrent LLC */\n\nimport bencode from 'bencode'\nimport fs from 'fs' // browser exclude\nimport fetch from 'cross-fetch-ponyfill'\nimport magnet, { encode } from 'magnet-uri'\nimport path from 'path'\nimport { hash, arr2hex, text2arr, arr2text } from 'uint8-util'\nimport queueMicrotask from 'queue-microtask'\n\n/**\n * Parse a torrent identifier (magnet uri, .torrent file, info hash)\n * @param {string|ArrayBufferView|Object} torrentId\n * @return {Object}\n */\nasync function parseTorrent (torrentId) {\n if (typeof torrentId === 'string' && /^(stream-)?magnet:/.test(torrentId)) {\n // if magnet uri (string)\n const torrentObj = magnet(torrentId)\n\n // infoHash won't be defined if a non-bittorrent magnet is passed\n if (!torrentObj.infoHash) {\n throw new Error('Invalid torrent identifier')\n }\n\n return torrentObj\n } else if (typeof torrentId === 'string' && (/^[a-f0-9]{40}$/i.test(torrentId) || /^[a-z2-7]{32}$/i.test(torrentId))) {\n // if info hash (hex/base-32 string)\n return magnet(`magnet:?xt=urn:btih:${torrentId}`)\n } else if (ArrayBuffer.isView(torrentId) && torrentId.length === 20) {\n // if info hash (buffer)\n return magnet(`magnet:?xt=urn:btih:${arr2hex(torrentId)}`)\n } else if (ArrayBuffer.isView(torrentId)) {\n // if .torrent file (buffer)\n return await decodeTorrentFile(torrentId) // might throw\n } else if (torrentId && torrentId.infoHash) {\n // if parsed torrent (from `parse-torrent` or `magnet-uri`)\n torrentId.infoHash = torrentId.infoHash.toLowerCase()\n\n if (!torrentId.announce) torrentId.announce = []\n\n if (typeof torrentId.announce === 'string') {\n torrentId.announce = [torrentId.announce]\n }\n\n if (!torrentId.urlList) torrentId.urlList = []\n\n return torrentId\n } else {\n throw new Error('Invalid torrent identifier')\n }\n}\n\nasync function parseTorrentRemote (torrentId, opts, cb) {\n if (typeof opts === 'function') return parseTorrentRemote(torrentId, {}, opts)\n if (typeof cb !== 'function') throw new Error('second argument must be a Function')\n\n let parsedTorrent\n try {\n parsedTorrent = await parseTorrent(torrentId)\n } catch (err) {\n // If torrent fails to parse, it could be a Blob, http/https URL or\n // filesystem path, so don't consider it an error yet.\n }\n\n if (parsedTorrent && parsedTorrent.infoHash) {\n queueMicrotask(() => {\n cb(null, parsedTorrent)\n })\n } else if (isBlob(torrentId)) {\n try {\n const torrentBuf = new Uint8Array(await torrentId.arrayBuffer())\n parseOrThrow(torrentBuf)\n } catch (err) {\n return cb(new Error(`Error converting Blob: ${err.message}`))\n }\n } else if (/^https?:/.test(torrentId)) {\n try {\n const res = await fetch(torrentId, {\n headers: { 'user-agent': 'WebTorrent (https://webtorrent.io)' },\n signal: AbortSignal.timeout(30 * 1000),\n ...opts\n })\n const torrentBuf = new Uint8Array(await res.arrayBuffer())\n parseOrThrow(torrentBuf)\n } catch (err) {\n return cb(new Error(`Error downloading torrent: ${err.message}`))\n }\n } else if (typeof fs.readFile === 'function' && typeof torrentId === 'string') {\n // assume it's a filesystem path\n fs.readFile(torrentId, (err, torrentBuf) => {\n if (err) return cb(new Error('Invalid torrent identifier'))\n parseOrThrow(torrentBuf)\n })\n } else {\n queueMicrotask(() => {\n cb(new Error('Invalid torrent identifier'))\n })\n }\n\n async function parseOrThrow (torrentBuf) {\n try {\n parsedTorrent = await parseTorrent(torrentBuf)\n } catch (err) {\n return cb(err)\n }\n if (parsedTorrent && parsedTorrent.infoHash) cb(null, parsedTorrent)\n else cb(new Error('Invalid torrent identifier'))\n }\n}\n\n/**\n * Parse a torrent. Throws an exception if the torrent is missing required fields.\n * @param {ArrayBufferView|Object} torrent\n * @return {Object} parsed torrent\n */\nasync function decodeTorrentFile (torrent) {\n if (ArrayBuffer.isView(torrent)) {\n torrent = bencode.decode(torrent)\n }\n\n // sanity check\n ensure(torrent.info, 'info')\n ensure(torrent.info['name.utf-8'] || torrent.info.name, 'info.name')\n ensure(torrent.info['piece length'], 'info[\\'piece length\\']')\n ensure(torrent.info.pieces, 'info.pieces')\n\n if (torrent.info.files) {\n torrent.info.files.forEach(file => {\n ensure(typeof file.length === 'number', 'info.files[0].length')\n ensure(file['path.utf-8'] || file.path, 'info.files[0].path')\n })\n } else {\n ensure(typeof torrent.info.length === 'number', 'info.length')\n }\n\n const result = {\n info: torrent.info,\n infoBuffer: bencode.encode(torrent.info),\n name: arr2text(torrent.info['name.utf-8'] || torrent.info.name),\n announce: []\n }\n\n result.infoHashBuffer = await hash(result.infoBuffer)\n result.infoHash = arr2hex(result.infoHashBuffer)\n\n if (torrent.info.private !== undefined) result.private = !!torrent.info.private\n\n if (torrent['creation date']) result.created = new Date(torrent['creation date'] * 1000)\n if (torrent['created by']) result.createdBy = arr2text(torrent['created by'])\n\n if (ArrayBuffer.isView(torrent.comment)) result.comment = arr2text(torrent.comment)\n\n // announce and announce-list will be missing if metadata fetched via ut_metadata\n if (Array.isArray(torrent['announce-list']) && torrent['announce-list'].length > 0) {\n torrent['announce-list'].forEach(urls => {\n urls.forEach(url => {\n result.announce.push(arr2text(url))\n })\n })\n } else if (torrent.announce) {\n result.announce.push(arr2text(torrent.announce))\n }\n\n // handle url-list (BEP19 / web seeding)\n if (ArrayBuffer.isView(torrent['url-list'])) {\n // some clients set url-list to empty string\n torrent['url-list'] = torrent['url-list'].length > 0\n ? [torrent['url-list']]\n : []\n }\n result.urlList = (torrent['url-list'] || []).map(url => arr2text(url))\n\n // remove duplicates by converting to Set and back\n result.announce = Array.from(new Set(result.announce))\n result.urlList = Array.from(new Set(result.urlList))\n\n const files = torrent.info.files || [torrent.info]\n result.files = files.map((file, i) => {\n const parts = [].concat(result.name, file['path.utf-8'] || file.path || []).map(p => ArrayBuffer.isView(p) ? arr2text(p) : p)\n return {\n path: path.join.apply(null, [path.sep].concat(parts)).slice(1),\n name: parts[parts.length - 1],\n length: file.length,\n offset: files.slice(0, i).reduce(sumLength, 0)\n }\n })\n\n result.length = files.reduce(sumLength, 0)\n\n const lastFile = result.files[result.files.length - 1]\n\n result.pieceLength = torrent.info['piece length']\n result.lastPieceLength = ((lastFile.offset + lastFile.length) % result.pieceLength) || result.pieceLength\n result.pieces = splitPieces(torrent.info.pieces)\n\n return result\n}\n\n/**\n * Convert a parsed torrent object back into a .torrent file buffer.\n * @param {Object} parsed parsed torrent\n * @return {Uint8Array}\n */\nfunction encodeTorrentFile (parsed) {\n const torrent = {\n info: parsed.info\n }\n\n torrent['announce-list'] = (parsed.announce || []).map(url => {\n if (!torrent.announce) torrent.announce = url\n url = text2arr(url)\n return [url]\n })\n\n torrent['url-list'] = parsed.urlList || []\n\n if (parsed.private !== undefined) {\n torrent.private = Number(parsed.private)\n }\n\n if (parsed.created) {\n torrent['creation date'] = (parsed.created.getTime() / 1000) | 0\n }\n\n if (parsed.createdBy) {\n torrent['created by'] = parsed.createdBy\n }\n\n if (parsed.comment) {\n torrent.comment = parsed.comment\n }\n\n return bencode.encode(torrent)\n}\n\n/**\n * Check if `obj` is a W3C `Blob` or `File` object\n * @param {*} obj\n * @return {boolean}\n */\nfunction isBlob (obj) {\n return typeof Blob !== 'undefined' && obj instanceof Blob\n}\n\nfunction sumLength (sum, file) {\n return sum + file.length\n}\n\nfunction splitPieces (buf) {\n const pieces = []\n for (let i = 0; i < buf.length; i += 20) {\n pieces.push(arr2hex(buf.slice(i, i + 20)))\n }\n return pieces\n}\n\nfunction ensure (bool, fieldName) {\n if (!bool) throw new Error(`Torrent is missing required field: ${fieldName}`)\n}\n\nexport default parseTorrent\nconst toMagnetURI = encode\nexport { parseTorrentRemote as remote, encodeTorrentFile as toTorrentFile, toMagnetURI }\n","const scope = typeof window !== 'undefined' ? window : self\r\n\r\n// @ts-ignore\r\nexport const RTCPeerConnection = scope.RTCPeerConnection || scope.mozRTCPeerConnection || scope.webkitRTCPeerConnection\r\n// @ts-ignore\r\nexport const RTCSessionDescription = scope.RTCSessionDescription || scope.mozRTCSessionDescription || scope.webkitRTCSessionDescription\r\n// @ts-ignore\r\nexport const RTCIceCandidate = scope.RTCIceCandidate || scope.mozRTCIceCandidate || scope.webkitRTCIceCandidate\r\nexport const RTCIceTransport = scope.RTCIceTransport\r\nexport const RTCDataChannel = scope.RTCDataChannel\r\nexport const RTCSctpTransport = scope.RTCSctpTransport\r\nexport const RTCDtlsTransport = scope.RTCDtlsTransport\r\nexport const RTCCertificate = scope.RTCCertificate\r\nexport const MediaStream = scope.MediaStream\r\nexport const MediaStreamTrack = scope.MediaStreamTrack\r\nexport const MediaStreamTrackEvent = scope.MediaStreamTrackEvent\r\nexport const RTCPeerConnectionIceEvent = scope.RTCPeerConnectionIceEvent\r\nexport const RTCDataChannelEvent = scope.RTCDataChannelEvent\r\nexport const RTCTrackEvent = scope.RTCTrackEvent\r\nexport const RTCError = scope.RTCError\r\nexport const RTCErrorEvent = scope.RTCErrorEvent\r\nexport const RTCRtpTransceiver = scope.RTCRtpTransceiver\r\nexport const RTCRtpReceiver = scope.RTCRtpReceiver\r\nexport const RTCRtpSender = scope.RTCRtpSender\r\n\r\nexport * as default from './browser.js'\r\n","/*! simple-peer. MIT License. Feross Aboukhadijeh */\r\nimport debug from 'debug'\r\nimport { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'webrtc-polyfill'\r\nimport { Duplex } from 'streamx'\r\nimport errCode from 'err-code'\r\nimport { randomBytes, arr2hex, text2arr } from 'uint8-util'\r\n\r\nconst Debug = debug('simple-peer')\r\n\r\nconst MAX_BUFFERED_AMOUNT = 64 * 1024\r\nconst ICECOMPLETE_TIMEOUT = 5 * 1000\r\nconst CHANNEL_CLOSING_TIMEOUT = 5 * 1000\r\n\r\n// HACK: Filter trickle lines when trickle is disabled #354\r\nfunction filterTrickle (sdp) {\r\n return sdp.replace(/a=ice-options:trickle\\s\\n/g, '')\r\n}\r\n\r\nfunction warn (message) {\r\n console.warn(message)\r\n}\r\n\r\n/**\r\n * WebRTC peer connection. Same API as node core `net.Socket`, plus a few extra methods.\r\n * Duplex stream.\r\n * @param {Object} opts\r\n */\r\nclass Peer extends Duplex {\r\n /** @type {RTCPeerConnection} */\r\n _pc\r\n constructor (opts) {\r\n opts = Object.assign({\r\n allowHalfOpen: false\r\n }, opts)\r\n\r\n super(opts)\r\n\r\n this.__objectMode = !!opts.objectMode // streamx is objectMode by default, so implement readable's fuctionality\r\n\r\n this._id = arr2hex(randomBytes(4)).slice(0, 7)\r\n this._debug('new peer %o', opts)\r\n\r\n this.channelName = opts.initiator\r\n ? opts.channelName || arr2hex(randomBytes(20))\r\n : null\r\n\r\n this.initiator = opts.initiator || false\r\n this.channelConfig = opts.channelConfig || Peer.channelConfig\r\n this.channelNegotiated = this.channelConfig.negotiated\r\n this.config = Object.assign({}, Peer.config, opts.config)\r\n this.offerOptions = opts.offerOptions || {}\r\n this.answerOptions = opts.answerOptions || {}\r\n this.sdpTransform = opts.sdpTransform || (sdp => sdp)\r\n this.trickle = opts.trickle !== undefined ? opts.trickle : true\r\n this.allowHalfTrickle = opts.allowHalfTrickle !== undefined ? opts.allowHalfTrickle : false\r\n this.iceCompleteTimeout = opts.iceCompleteTimeout || ICECOMPLETE_TIMEOUT\r\n\r\n this._destroying = false\r\n this._connected = false\r\n\r\n this.remoteAddress = undefined\r\n this.remoteFamily = undefined\r\n this.remotePort = undefined\r\n this.localAddress = undefined\r\n this.localFamily = undefined\r\n this.localPort = undefined\r\n\r\n if (!RTCPeerConnection) {\r\n if (typeof window === 'undefined') {\r\n throw errCode(new Error('No WebRTC support: Specify `opts.wrtc` option in this environment'), 'ERR_WEBRTC_SUPPORT')\r\n } else {\r\n throw errCode(new Error('No WebRTC support: Not a supported browser'), 'ERR_WEBRTC_SUPPORT')\r\n }\r\n }\r\n\r\n this._pcReady = false\r\n this._channelReady = false\r\n this._iceComplete = false // ice candidate trickle done (got null candidate)\r\n this._iceCompleteTimer = null // send an offer/answer anyway after some timeout\r\n this._channel = null\r\n this._pendingCandidates = []\r\n\r\n this._isNegotiating = false // is this peer waiting for negotiation to complete?\r\n this._firstNegotiation = true\r\n this._batchedNegotiation = false // batch synchronous negotiations\r\n this._queuedNegotiation = false // is there a queued negotiation request?\r\n this._sendersAwaitingStable = []\r\n this._closingInterval = null\r\n\r\n this._remoteTracks = []\r\n this._remoteStreams = []\r\n\r\n this._chunk = null\r\n this._cb = null\r\n this._interval = null\r\n\r\n try {\r\n this._pc = new RTCPeerConnection(this.config)\r\n } catch (err) {\r\n this.__destroy(errCode(err, 'ERR_PC_CONSTRUCTOR'))\r\n return\r\n }\r\n\r\n // We prefer feature detection whenever possible, but sometimes that's not\r\n // possible for certain implementations.\r\n this._isReactNativeWebrtc = typeof this._pc._peerConnectionId === 'number'\r\n\r\n this._pc.oniceconnectionstatechange = () => {\r\n this._onIceStateChange()\r\n }\r\n this._pc.onicegatheringstatechange = () => {\r\n this._onIceStateChange()\r\n }\r\n this._pc.onconnectionstatechange = () => {\r\n this._onConnectionStateChange()\r\n }\r\n this._pc.onsignalingstatechange = () => {\r\n this._onSignalingStateChange()\r\n }\r\n this._pc.onicecandidate = event => {\r\n this._onIceCandidate(event)\r\n }\r\n\r\n // HACK: Fix for odd Firefox behavior, see: https://github.com/feross/simple-peer/pull/783\r\n if (typeof this._pc.peerIdentity === 'object') {\r\n this._pc.peerIdentity.catch(err => {\r\n this.__destroy(errCode(err, 'ERR_PC_PEER_IDENTITY'))\r\n })\r\n }\r\n\r\n // Other spec events, unused by this implementation:\r\n // - onconnectionstatechange\r\n // - onicecandidateerror\r\n // - onfingerprintfailure\r\n // - onnegotiationneeded\r\n\r\n if (this.initiator || this.channelNegotiated) {\r\n this._setupData({\r\n channel: this._pc.createDataChannel(this.channelName, this.channelConfig)\r\n })\r\n } else {\r\n this._pc.ondatachannel = event => {\r\n this._setupData(event)\r\n }\r\n }\r\n\r\n this._debug('initial negotiation')\r\n this._needsNegotiation()\r\n\r\n this._onFinishBound = () => {\r\n this._onFinish()\r\n }\r\n this.once('finish', this._onFinishBound)\r\n }\r\n\r\n get bufferSize () {\r\n return (this._channel && this._channel.bufferedAmount) || 0\r\n }\r\n\r\n // HACK: it's possible channel.readyState is \"closing\" before peer.destroy() fires\r\n // https://bugs.chromium.org/p/chromium/issues/detail?id=882743\r\n get connected () {\r\n return (this._connected && this._channel.readyState === 'open')\r\n }\r\n\r\n address () {\r\n return { port: this.localPort, family: this.localFamily, address: this.localAddress }\r\n }\r\n\r\n signal (data) {\r\n if (this._destroying) return\r\n if (this.destroyed) throw errCode(new Error('cannot signal after peer is destroyed'), 'ERR_DESTROYED')\r\n if (typeof data === 'string') {\r\n try {\r\n data = JSON.parse(data)\r\n } catch (err) {\r\n data = {}\r\n }\r\n }\r\n this._debug('signal()')\r\n\r\n if (data.renegotiate && this.initiator) {\r\n this._debug('got request to renegotiate')\r\n this._needsNegotiation()\r\n }\r\n if (data.transceiverRequest && this.initiator) {\r\n this._debug('got request for transceiver')\r\n this.addTransceiver(data.transceiverRequest.kind, data.transceiverRequest.init)\r\n }\r\n if (data.candidate) {\r\n if (this._pc.remoteDescription && this._pc.remoteDescription.type) {\r\n this._addIceCandidate(data.candidate)\r\n } else {\r\n this._pendingCandidates.push(data.candidate)\r\n }\r\n }\r\n if (data.sdp) {\r\n this._pc.setRemoteDescription(new RTCSessionDescription(data))\r\n .then(() => {\r\n if (this.destroyed) return\r\n\r\n this._pendingCandidates.forEach(candidate => {\r\n this._addIceCandidate(candidate)\r\n })\r\n this._pendingCandidates = []\r\n\r\n if (this._pc.remoteDescription.type === 'offer') this._createAnswer()\r\n })\r\n .catch(err => {\r\n this.__destroy(errCode(err, 'ERR_SET_REMOTE_DESCRIPTION'))\r\n })\r\n }\r\n if (!data.sdp && !data.candidate && !data.renegotiate && !data.transceiverRequest) {\r\n this.__destroy(errCode(new Error('signal() called with invalid signal data'), 'ERR_SIGNALING'))\r\n }\r\n }\r\n\r\n _addIceCandidate (candidate) {\r\n const iceCandidateObj = new RTCIceCandidate(candidate)\r\n this._pc.addIceCandidate(iceCandidateObj)\r\n .catch(err => {\r\n if (!iceCandidateObj.address || iceCandidateObj.address.endsWith('.local')) {\r\n warn('Ignoring unsupported ICE candidate.')\r\n } else {\r\n this.__destroy(errCode(err, 'ERR_ADD_ICE_CANDIDATE'))\r\n }\r\n })\r\n }\r\n\r\n /**\r\n * Send text/binary data to the remote peer.\r\n * @param {ArrayBufferView|ArrayBuffer|Uint8Array|string|Blob} chunk\r\n */\r\n send (chunk) {\r\n if (this._destroying) return\r\n if (this.destroyed) throw errCode(new Error('cannot send after peer is destroyed'), 'ERR_DESTROYED')\r\n this._channel.send(chunk)\r\n }\r\n\r\n _needsNegotiation () {\r\n this._debug('_needsNegotiation')\r\n if (this._batchedNegotiation) return // batch synchronous renegotiations\r\n this._batchedNegotiation = true\r\n queueMicrotask(() => {\r\n this._batchedNegotiation = false\r\n if (this.initiator || !this._firstNegotiation) {\r\n this._debug('starting batched negotiation')\r\n this.negotiate()\r\n } else {\r\n this._debug('non-initiator initial negotiation request discarded')\r\n }\r\n this._firstNegotiation = false\r\n })\r\n }\r\n\r\n negotiate () {\r\n if (this._destroying) return\r\n if (this.destroyed) throw errCode(new Error('cannot negotiate after peer is destroyed'), 'ERR_DESTROYED')\r\n\r\n if (this.initiator) {\r\n if (this._isNegotiating) {\r\n this._queuedNegotiation = true\r\n this._debug('already negotiating, queueing')\r\n } else {\r\n this._debug('start negotiation')\r\n setTimeout(() => { // HACK: Chrome crashes if we immediately call createOffer\r\n this._createOffer()\r\n }, 0)\r\n }\r\n } else {\r\n if (this._isNegotiating) {\r\n this._queuedNegotiation = true\r\n this._debug('already negotiating, queueing')\r\n } else {\r\n this._debug('requesting negotiation from initiator')\r\n this.emit('signal', { // request initiator to renegotiate\r\n type: 'renegotiate',\r\n renegotiate: true\r\n })\r\n }\r\n }\r\n this._isNegotiating = true\r\n }\r\n\r\n _final (cb) {\r\n if (!this._readableState.ended) this.push(null)\r\n cb(null)\r\n }\r\n\r\n __destroy (err) {\r\n this.end()\r\n this._destroy(() => {}, err)\r\n }\r\n\r\n _destroy (cb, err) {\r\n if (this.destroyed || this._destroying) return\r\n this._destroying = true\r\n\r\n this._debug('destroying (error: %s)', err && (err.message || err))\r\n\r\n setTimeout(() => { // allow events concurrent with the call to _destroy() to fire (see #692)\r\n this._connected = false\r\n this._pcReady = false\r\n this._channelReady = false\r\n this._remoteTracks = null\r\n this._remoteStreams = null\r\n this._senderMap = null\r\n\r\n clearInterval(this._closingInterval)\r\n this._closingInterval = null\r\n\r\n clearInterval(this._interval)\r\n this._interval = null\r\n this._chunk = null\r\n this._cb = null\r\n\r\n if (this._onFinishBound) this.removeListener('finish', this._onFinishBound)\r\n this._onFinishBound = null\r\n\r\n if (this._channel) {\r\n try {\r\n this._channel.close()\r\n } catch (err) {}\r\n\r\n // allow events concurrent with destruction to be handled\r\n this._channel.onmessage = null\r\n this._channel.onopen = null\r\n this._channel.onclose = null\r\n this._channel.onerror = null\r\n }\r\n if (this._pc) {\r\n try {\r\n this._pc.close()\r\n } catch (err) {}\r\n\r\n // allow events concurrent with destruction to be handled\r\n this._pc.oniceconnectionstatechange = null\r\n this._pc.onicegatheringstatechange = null\r\n this._pc.onsignalingstatechange = null\r\n this._pc.onicecandidate = null\r\n this._pc.ontrack = null\r\n this._pc.ondatachannel = null\r\n }\r\n this._pc = null\r\n this._channel = null\r\n if (err) this.emit('error', err)\r\n cb()\r\n }, 0)\r\n }\r\n\r\n _setupData (event) {\r\n if (!event.channel) {\r\n // In some situations `pc.createDataChannel()` returns `undefined` (in wrtc),\r\n // which is invalid behavior. Handle it gracefully.\r\n // See: https://github.com/feross/simple-peer/issues/163\r\n return this.__destroy(errCode(new Error('Data channel event is missing `channel` property'), 'ERR_DATA_CHANNEL'))\r\n }\r\n\r\n this._channel = event.channel\r\n this._channel.binaryType = 'arraybuffer'\r\n\r\n if (typeof this._channel.bufferedAmountLowThreshold === 'number') {\r\n this._channel.bufferedAmountLowThreshold = MAX_BUFFERED_AMOUNT\r\n }\r\n\r\n this.channelName = this._channel.label\r\n\r\n this._channel.onmessage = event => {\r\n this._onChannelMessage(event)\r\n }\r\n this._channel.onbufferedamountlow = () => {\r\n this._onChannelBufferedAmountLow()\r\n }\r\n this._channel.onopen = () => {\r\n this._onChannelOpen()\r\n }\r\n this._channel.onclose = () => {\r\n this._onChannelClose()\r\n }\r\n this._channel.onerror = event => {\r\n const err = event.error instanceof Error\r\n ? event.error\r\n : new Error(`Datachannel error: ${event.message} ${event.filename}:${event.lineno}:${event.colno}`)\r\n this.__destroy(errCode(err, 'ERR_DATA_CHANNEL'))\r\n }\r\n\r\n // HACK: Chrome will sometimes get stuck in readyState \"closing\", let's check for this condition\r\n // https://bugs.chromium.org/p/chromium/issues/detail?id=882743\r\n let isClosing = false\r\n this._closingInterval = setInterval(() => { // No \"onclosing\" event\r\n if (this._channel && this._channel.readyState === 'closing') {\r\n if (isClosing) this._onChannelClose() // closing timed out: equivalent to onclose firing\r\n isClosing = true\r\n } else {\r\n isClosing = false\r\n }\r\n }, CHANNEL_CLOSING_TIMEOUT)\r\n }\r\n\r\n _write (chunk, cb) {\r\n if (this.destroyed) return cb(errCode(new Error('cannot write after peer is destroyed'), 'ERR_DATA_CHANNEL'))\r\n\r\n if (this._connected) {\r\n try {\r\n this.send(chunk)\r\n } catch (err) {\r\n return this.__destroy(errCode(err, 'ERR_DATA_CHANNEL'))\r\n }\r\n if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n this._debug('start backpressure: bufferedAmount %d', this._channel.bufferedAmount)\r\n this._cb = cb\r\n } else {\r\n cb(null)\r\n }\r\n } else {\r\n this._debug('write before connect')\r\n this._chunk = chunk\r\n this._cb = cb\r\n }\r\n }\r\n\r\n // When stream finishes writing, close socket. Half open connections are not\r\n // supported.\r\n _onFinish () {\r\n if (this.destroyed) return\r\n\r\n // Wait a bit before destroying so the socket flushes.\r\n // TODO: is there a more reliable way to accomplish this?\r\n const destroySoon = () => {\r\n setTimeout(() => this.__destroy(), 1000)\r\n }\r\n\r\n if (this._connected) {\r\n destroySoon()\r\n } else {\r\n this.once('connect', destroySoon)\r\n }\r\n }\r\n\r\n _startIceCompleteTimeout () {\r\n if (this.destroyed) return\r\n if (this._iceCompleteTimer) return\r\n this._debug('started iceComplete timeout')\r\n this._iceCompleteTimer = setTimeout(() => {\r\n if (!this._iceComplete) {\r\n this._iceComplete = true\r\n this._debug('iceComplete timeout completed')\r\n this.emit('iceTimeout')\r\n this.emit('_iceComplete')\r\n }\r\n }, this.iceCompleteTimeout)\r\n }\r\n\r\n _createOffer () {\r\n if (this.destroyed) return\r\n\r\n this._pc.createOffer(this.offerOptions)\r\n .then(offer => {\r\n if (this.destroyed) return\r\n if (!this.trickle && !this.allowHalfTrickle) offer.sdp = filterTrickle(offer.sdp)\r\n offer.sdp = this.sdpTransform(offer.sdp)\r\n\r\n const sendOffer = () => {\r\n if (this.destroyed) return\r\n const signal = this._pc.localDescription || offer\r\n this._debug('signal')\r\n this.emit('signal', {\r\n type: signal.type,\r\n sdp: signal.sdp\r\n })\r\n }\r\n\r\n const onSuccess = () => {\r\n this._debug('createOffer success')\r\n if (this.destroyed) return\r\n if (this.trickle || this._iceComplete) sendOffer()\r\n else this.once('_iceComplete', sendOffer) // wait for candidates\r\n }\r\n\r\n const onError = err => {\r\n this.__destroy(errCode(err, 'ERR_SET_LOCAL_DESCRIPTION'))\r\n }\r\n\r\n this._pc.setLocalDescription(offer)\r\n .then(onSuccess)\r\n .catch(onError)\r\n })\r\n .catch(err => {\r\n this.__destroy(errCode(err, 'ERR_CREATE_OFFER'))\r\n })\r\n }\r\n\r\n _createAnswer () {\r\n if (this.destroyed) return\r\n\r\n this._pc.createAnswer(this.answerOptions)\r\n .then(answer => {\r\n if (this.destroyed) return\r\n if (!this.trickle && !this.allowHalfTrickle) answer.sdp = filterTrickle(answer.sdp)\r\n answer.sdp = this.sdpTransform(answer.sdp)\r\n\r\n const sendAnswer = () => {\r\n if (this.destroyed) return\r\n const signal = this._pc.localDescription || answer\r\n this._debug('signal')\r\n this.emit('signal', {\r\n type: signal.type,\r\n sdp: signal.sdp\r\n })\r\n if (!this.initiator) this._requestMissingTransceivers?.()\r\n }\r\n\r\n const onSuccess = () => {\r\n if (this.destroyed) return\r\n if (this.trickle || this._iceComplete) sendAnswer()\r\n else this.once('_iceComplete', sendAnswer)\r\n }\r\n\r\n const onError = err => {\r\n this.__destroy(errCode(err, 'ERR_SET_LOCAL_DESCRIPTION'))\r\n }\r\n\r\n this._pc.setLocalDescription(answer)\r\n .then(onSuccess)\r\n .catch(onError)\r\n })\r\n .catch(err => {\r\n this.__destroy(errCode(err, 'ERR_CREATE_ANSWER'))\r\n })\r\n }\r\n\r\n _onConnectionStateChange () {\r\n if (this.destroyed || this._destroying) return\r\n if (this._pc.connectionState === 'failed') {\r\n this.__destroy(errCode(new Error('Connection failed.'), 'ERR_CONNECTION_FAILURE'))\r\n }\r\n }\r\n\r\n _onIceStateChange () {\r\n if (this.destroyed) return\r\n const iceConnectionState = this._pc.iceConnectionState\r\n const iceGatheringState = this._pc.iceGatheringState\r\n\r\n this._debug(\r\n 'iceStateChange (connection: %s) (gathering: %s)',\r\n iceConnectionState,\r\n iceGatheringState\r\n )\r\n this.emit('iceStateChange', iceConnectionState, iceGatheringState)\r\n\r\n if (iceConnectionState === 'connected' || iceConnectionState === 'completed') {\r\n this._pcReady = true\r\n this._maybeReady()\r\n }\r\n if (iceConnectionState === 'failed') {\r\n this.__destroy(errCode(new Error('Ice connection failed.'), 'ERR_ICE_CONNECTION_FAILURE'))\r\n }\r\n if (iceConnectionState === 'closed') {\r\n this.__destroy(errCode(new Error('Ice connection closed.'), 'ERR_ICE_CONNECTION_CLOSED'))\r\n }\r\n }\r\n\r\n getStats (cb) {\r\n // statreports can come with a value array instead of properties\r\n const flattenValues = report => {\r\n if (Object.prototype.toString.call(report.values) === '[object Array]') {\r\n report.values.forEach(value => {\r\n Object.assign(report, value)\r\n })\r\n }\r\n return report\r\n }\r\n\r\n // Promise-based getStats() (standard)\r\n if (this._pc.getStats.length === 0 || this._isReactNativeWebrtc) {\r\n this._pc.getStats()\r\n .then(res => {\r\n const reports = []\r\n res.forEach(report => {\r\n reports.push(flattenValues(report))\r\n })\r\n cb(null, reports)\r\n }, err => cb(err))\r\n\r\n // Single-parameter callback-based getStats() (non-standard)\r\n } else if (this._pc.getStats.length > 0) {\r\n this._pc.getStats(res => {\r\n // If we destroy connection in `connect` callback this code might happen to run when actual connection is already closed\r\n if (this.destroyed) return\r\n\r\n const reports = []\r\n res.result().forEach(result => {\r\n const report = {}\r\n result.names().forEach(name => {\r\n report[name] = result.stat(name)\r\n })\r\n report.id = result.id\r\n report.type = result.type\r\n report.timestamp = result.timestamp\r\n reports.push(flattenValues(report))\r\n })\r\n cb(null, reports)\r\n }, err => cb(err))\r\n\r\n // Unknown browser, skip getStats() since it's anyone's guess which style of\r\n // getStats() they implement.\r\n } else {\r\n cb(null, [])\r\n }\r\n }\r\n\r\n _maybeReady () {\r\n this._debug('maybeReady pc %s channel %s', this._pcReady, this._channelReady)\r\n if (this._connected || this._connecting || !this._pcReady || !this._channelReady) return\r\n\r\n this._connecting = true\r\n\r\n // HACK: We can't rely on order here, for details see https://github.com/js-platform/node-webrtc/issues/339\r\n const findCandidatePair = () => {\r\n if (this.destroyed || this._destroying) return\r\n\r\n this.getStats((err, items) => {\r\n if (this.destroyed || this._destroying) return\r\n\r\n // Treat getStats error as non-fatal. It's not essential.\r\n if (err) items = []\r\n\r\n const remoteCandidates = {}\r\n const localCandidates = {}\r\n const candidatePairs = {}\r\n let foundSelectedCandidatePair = false\r\n\r\n items.forEach(item => {\r\n // TODO: Once all browsers support the hyphenated stats report types, remove\r\n // the non-hypenated ones\r\n if (item.type === 'remotecandidate' || item.type === 'remote-candidate') {\r\n remoteCandidates[item.id] = item\r\n }\r\n if (item.type === 'localcandidate' || item.type === 'local-candidate') {\r\n localCandidates[item.id] = item\r\n }\r\n if (item.type === 'candidatepair' || item.type === 'candidate-pair') {\r\n candidatePairs[item.id] = item\r\n }\r\n })\r\n\r\n const setSelectedCandidatePair = selectedCandidatePair => {\r\n foundSelectedCandidatePair = true\r\n\r\n let local = localCandidates[selectedCandidatePair.localCandidateId]\r\n\r\n if (local && (local.ip || local.address)) {\r\n // Spec\r\n this.localAddress = local.ip || local.address\r\n this.localPort = Number(local.port)\r\n } else if (local && local.ipAddress) {\r\n // Firefox\r\n this.localAddress = local.ipAddress\r\n this.localPort = Number(local.portNumber)\r\n } else if (typeof selectedCandidatePair.googLocalAddress === 'string') {\r\n // TODO: remove this once Chrome 58 is released\r\n local = selectedCandidatePair.googLocalAddress.split(':')\r\n this.localAddress = local[0]\r\n this.localPort = Number(local[1])\r\n }\r\n if (this.localAddress) {\r\n this.localFamily = this.localAddress.includes(':') ? 'IPv6' : 'IPv4'\r\n }\r\n\r\n let remote = remoteCandidates[selectedCandidatePair.remoteCandidateId]\r\n\r\n if (remote && (remote.ip || remote.address)) {\r\n // Spec\r\n this.remoteAddress = remote.ip || remote.address\r\n this.remotePort = Number(remote.port)\r\n } else if (remote && remote.ipAddress) {\r\n // Firefox\r\n this.remoteAddress = remote.ipAddress\r\n this.remotePort = Number(remote.portNumber)\r\n } else if (typeof selectedCandidatePair.googRemoteAddress === 'string') {\r\n // TODO: remove this once Chrome 58 is released\r\n remote = selectedCandidatePair.googRemoteAddress.split(':')\r\n this.remoteAddress = remote[0]\r\n this.remotePort = Number(remote[1])\r\n }\r\n if (this.remoteAddress) {\r\n this.remoteFamily = this.remoteAddress.includes(':') ? 'IPv6' : 'IPv4'\r\n }\r\n\r\n this._debug(\r\n 'connect local: %s:%s remote: %s:%s',\r\n this.localAddress,\r\n this.localPort,\r\n this.remoteAddress,\r\n this.remotePort\r\n )\r\n }\r\n\r\n items.forEach(item => {\r\n // Spec-compliant\r\n if (item.type === 'transport' && item.selectedCandidatePairId) {\r\n setSelectedCandidatePair(candidatePairs[item.selectedCandidatePairId])\r\n }\r\n\r\n // Old implementations\r\n if (\r\n (item.type === 'googCandidatePair' && item.googActiveConnection === 'true') ||\r\n ((item.type === 'candidatepair' || item.type === 'candidate-pair') && item.selected)\r\n ) {\r\n setSelectedCandidatePair(item)\r\n }\r\n })\r\n\r\n // Ignore candidate pair selection in browsers like Safari 11 that do not have any local or remote candidates\r\n // But wait until at least 1 candidate pair is available\r\n if (!foundSelectedCandidatePair && (!Object.keys(candidatePairs).length || Object.keys(localCandidates).length)) {\r\n setTimeout(findCandidatePair, 100)\r\n return\r\n } else {\r\n this._connecting = false\r\n this._connected = true\r\n }\r\n\r\n if (this._chunk) {\r\n try {\r\n this.send(this._chunk)\r\n } catch (err) {\r\n return this.__destroy(errCode(err, 'ERR_DATA_CHANNEL'))\r\n }\r\n this._chunk = null\r\n this._debug('sent chunk from \"write before connect\"')\r\n\r\n const cb = this._cb\r\n this._cb = null\r\n cb(null)\r\n }\r\n\r\n // If `bufferedAmountLowThreshold` and 'onbufferedamountlow' are unsupported,\r\n // fallback to using setInterval to implement backpressure.\r\n if (typeof this._channel.bufferedAmountLowThreshold !== 'number') {\r\n this._interval = setInterval(() => this._onInterval(), 150)\r\n if (this._interval.unref) this._interval.unref()\r\n }\r\n\r\n this._debug('connect')\r\n this.emit('connect')\r\n })\r\n }\r\n findCandidatePair()\r\n }\r\n\r\n _onInterval () {\r\n if (!this._cb || !this._channel || this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n return\r\n }\r\n this._onChannelBufferedAmountLow()\r\n }\r\n\r\n _onSignalingStateChange () {\r\n if (this.destroyed) return\r\n\r\n if (this._pc.signalingState === 'stable') {\r\n this._isNegotiating = false\r\n\r\n // HACK: Firefox doesn't yet support removing tracks when signalingState !== 'stable'\r\n this._debug('flushing sender queue', this._sendersAwaitingStable)\r\n this._sendersAwaitingStable.forEach(sender => {\r\n this._pc.removeTrack(sender)\r\n this._queuedNegotiation = true\r\n })\r\n this._sendersAwaitingStable = []\r\n\r\n if (this._queuedNegotiation) {\r\n this._debug('flushing negotiation queue')\r\n this._queuedNegotiation = false\r\n this._needsNegotiation() // negotiate again\r\n } else {\r\n this._debug('negotiated')\r\n this.emit('negotiated')\r\n }\r\n }\r\n\r\n this._debug('signalingStateChange %s', this._pc.signalingState)\r\n this.emit('signalingStateChange', this._pc.signalingState)\r\n }\r\n\r\n _onIceCandidate (event) {\r\n if (this.destroyed) return\r\n if (event.candidate && this.trickle) {\r\n this.emit('signal', {\r\n type: 'candidate',\r\n candidate: {\r\n candidate: event.candidate.candidate,\r\n sdpMLineIndex: event.candidate.sdpMLineIndex,\r\n sdpMid: event.candidate.sdpMid\r\n }\r\n })\r\n } else if (!event.candidate && !this._iceComplete) {\r\n this._iceComplete = true\r\n this.emit('_iceComplete')\r\n }\r\n // as soon as we've received one valid candidate start timeout\r\n if (event.candidate) {\r\n this._startIceCompleteTimeout()\r\n }\r\n }\r\n\r\n _onChannelMessage (event) {\r\n if (this.destroyed) return\r\n let data = event.data\r\n if (data instanceof ArrayBuffer) {\r\n data = new Uint8Array(data)\r\n } else if (this.__objectMode === false) {\r\n data = text2arr(data)\r\n }\r\n this.push(data)\r\n }\r\n\r\n _onChannelBufferedAmountLow () {\r\n if (this.destroyed || !this._cb) return\r\n this._debug('ending backpressure: bufferedAmount %d', this._channel.bufferedAmount)\r\n const cb = this._cb\r\n this._cb = null\r\n cb(null)\r\n }\r\n\r\n _onChannelOpen () {\r\n if (this._connected || this.destroyed) return\r\n this._debug('on channel open')\r\n this._channelReady = true\r\n this._maybeReady()\r\n }\r\n\r\n _onChannelClose () {\r\n if (this.destroyed) return\r\n this._debug('on channel close')\r\n this.__destroy()\r\n }\r\n\r\n _debug () {\r\n const args = [].slice.call(arguments)\r\n args[0] = '[' + this._id + '] ' + args[0]\r\n Debug.apply(null, args)\r\n }\r\n}\r\n\r\nPeer.WEBRTC_SUPPORT = !!RTCPeerConnection\r\n\r\n/**\r\n * Expose peer and data channel config for overriding all Peer\r\n * instances. Otherwise, just set opts.config or opts.channelConfig\r\n * when constructing a Peer.\r\n */\r\nPeer.config = {\r\n iceServers: [\r\n {\r\n urls: [\r\n 'stun:stun.l.google.com:19302',\r\n 'stun:global.stun.twilio.com:3478'\r\n ]\r\n }\r\n ],\r\n sdpSemantics: 'unified-plan'\r\n}\r\n\r\nPeer.channelConfig = {}\r\n\r\nexport default Peer\r\n","const ADDR_RE = /^\\[?([^\\]]+)]?:(\\d+)$/ // ipv4/ipv6/hostname + port\n\nlet cache = new Map()\n\n// reset cache when it gets to 100,000 elements (~ 600KB of ipv4 addresses)\n// so it will not grow to consume all memory in long-running processes\nexport default function addrToIPPort (addr) {\n if (cache.size === 100000) cache.clear()\n if (!cache.has(addr)) {\n const m = ADDR_RE.exec(addr)\n if (!m) throw new Error(`invalid addr: ${addr}`)\n cache.set(addr, [ m[1], Number(m[2]) ])\n }\n return cache.get(addr)\n}\n","import blockIterator from 'block-iterator'\r\n\r\nasync function * chunkStoreRead (store, opts = {}) {\r\n if (store?.[Symbol.asyncIterator]) {\r\n yield * store[Symbol.asyncIterator](opts.offset)\r\n return\r\n }\r\n if (!store?.get) throw new Error('First argument must be an abstract-chunk-store compliant store')\r\n\r\n const chunkLength = opts.chunkLength || store.chunkLength\r\n if (!chunkLength) throw new Error('missing required `chunkLength` property')\r\n\r\n let length = opts.length || store.length\r\n if (!Number.isFinite(length)) throw new Error('missing required `length` property')\r\n\r\n const offset = opts.offset || 0\r\n\r\n const get = (i, length, offset) => new Promise((resolve, reject) => {\r\n store.get(i, { offset, length }, (err, chunk) => {\r\n if (err) reject(err)\r\n resolve(chunk)\r\n })\r\n })\r\n\r\n let index = Math.floor(offset / chunkLength)\r\n const chunkOffset = offset % chunkLength\r\n if (offset) {\r\n const target = Math.min(length, chunkLength - chunkOffset)\r\n length -= target\r\n yield get(index++, target, chunkOffset)\r\n }\r\n\r\n for (let remainingLength = length; remainingLength > 0; ++index, remainingLength -= chunkLength) {\r\n yield get(index, Math.min(remainingLength, chunkLength))\r\n }\r\n}\r\n\r\nasync function chunkStoreWrite (store, stream, opts = {}) {\r\n if (!store?.put) throw new Error('First argument must be an abstract-chunk-store compliant store')\r\n\r\n const chunkLength = opts.chunkLength || store.chunkLength\r\n if (!chunkLength) throw new Error('missing required `chunkLength` property')\r\n\r\n const storeMaxOutstandingPuts = opts.storeMaxOutstandingPuts || 16\r\n let outstandingPuts = 0\r\n\r\n let index = 0\r\n\r\n let cb = () => {}\r\n let ended = false\r\n\r\n for await (const chunk of blockIterator(stream, chunkLength, { zeroPadding: opts.zeroPadding || false })) {\r\n await new Promise(resolve => {\r\n if (outstandingPuts++ <= storeMaxOutstandingPuts) resolve()\r\n store.put(index++, chunk, err => {\r\n if (err) throw err\r\n --outstandingPuts\r\n resolve()\r\n if (ended && outstandingPuts === 0) cb()\r\n })\r\n })\r\n }\r\n if (outstandingPuts === 0) return\r\n ended = new Promise(resolve => { cb = resolve })\r\n await ended\r\n}\r\n\r\nexport { chunkStoreRead, chunkStoreWrite }\r\nexport default { chunkStoreRead, chunkStoreWrite }\r\n","/**\n * Functions/constants needed by both the client and server.\n */\nimport * as common from './common-node.js'\nexport * from './common-node.js'\n\nexport const DEFAULT_ANNOUNCE_PEERS = 50\nexport const MAX_ANNOUNCE_PEERS = 82\n\n// HACK: Fix for WHATWG URL object not parsing non-standard URL schemes like\n// 'udp:'. Just replace it with 'http:' since we only need a few properties.\n//\n// Note: Only affects Chrome and Firefox. Works fine in Node.js, Safari, and\n// Edge.\n//\n// Note: UDP trackers aren't used in the normal browser build, but they are\n// used in a Chrome App build (i.e. by Brave Browser).\n//\n// Bug reports:\n// - Chrome: https://bugs.chromium.org/p/chromium/issues/detail?id=734880\n// - Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1374505\nexport const parseUrl = str => {\n const url = new URL(str.replace(/^udp:/, 'http:'))\n\n if (str.match(/^udp:/)) {\n Object.defineProperties(url, {\n href: { value: url.href.replace(/^http/, 'udp') },\n protocol: { value: url.protocol.replace(/^http/, 'udp') },\n origin: { value: url.origin.replace(/^http/, 'udp') }\n })\n }\n\n return url\n}\n\nexport default {\n DEFAULT_ANNOUNCE_PEERS,\n MAX_ANNOUNCE_PEERS,\n parseUrl,\n ...common\n}\n","/*! simple-websocket. MIT License. Feross Aboukhadijeh */\r\n/* global WebSocket */\r\n\r\nimport Debug from 'debug'\r\nimport queueMicrotask from 'queue-microtask' // TODO: remove when Node 10 is not supported\r\nimport ws from 'ws' // websockets in node - will be empty object in browser\r\nimport { Duplex } from 'streamx'\r\nimport { text2arr, randomBytes, arr2hex } from 'uint8-util'\r\n\r\nconst debug = Debug('simple-websocket')\r\n\r\nconst _WebSocket = typeof ws !== 'function' ? WebSocket : ws\r\n\r\nconst MAX_BUFFERED_AMOUNT = 64 * 1024\r\n\r\n/**\r\n * WebSocket. Same API as node core `net.Socket`. Duplex stream.\r\n * @param {Object} opts\r\n * @param {string=} opts.url websocket server url\r\n * @param {string=} opts.socket raw websocket instance to wrap\r\n */\r\nexport default class Socket extends Duplex {\r\n constructor (opts = {}) {\r\n // Support simple usage: `new Socket(url)`\r\n if (typeof opts === 'string') {\r\n opts = { url: opts }\r\n }\r\n\r\n opts = Object.assign({\r\n allowHalfOpen: false\r\n }, opts)\r\n\r\n super(opts)\r\n\r\n this.__objectMode = !!opts.objectMode // streamx is objectMode by default, so implement readable's fuctionality\r\n if (opts.objectMode != null) delete opts.objectMode // causes error with ws...\r\n\r\n if (opts.url == null && opts.socket == null) {\r\n throw new Error('Missing required `url` or `socket` option')\r\n }\r\n if (opts.url != null && opts.socket != null) {\r\n throw new Error('Must specify either `url` or `socket` option, not both')\r\n }\r\n\r\n this._id = arr2hex(randomBytes(4)).slice(0, 7)\r\n this._debug('new websocket: %o', opts)\r\n\r\n this.connected = false\r\n\r\n this._chunk = null\r\n this._cb = null\r\n this._interval = null\r\n\r\n if (opts.socket) {\r\n this.url = opts.socket.url\r\n this._ws = opts.socket\r\n this.connected = opts.socket.readyState === _WebSocket.OPEN\r\n } else {\r\n this.url = opts.url\r\n try {\r\n if (typeof ws === 'function') {\r\n // `ws` package accepts options\r\n this._ws = new _WebSocket(opts.url, {\r\n ...opts,\r\n encoding: undefined // encoding option breaks ws internals\r\n })\r\n } else {\r\n this._ws = new _WebSocket(opts.url)\r\n }\r\n } catch (err) {\r\n queueMicrotask(() => this.destroy(err))\r\n return\r\n }\r\n }\r\n\r\n this._ws.binaryType = 'arraybuffer'\r\n\r\n if (opts.socket && this.connected) {\r\n queueMicrotask(() => this._handleOpen())\r\n } else {\r\n this._ws.onopen = () => this._handleOpen()\r\n }\r\n\r\n this._ws.onmessage = event => this._handleMessage(event)\r\n this._ws.onclose = () => this._handleClose()\r\n this._ws.onerror = err => this._handleError(err)\r\n\r\n this._handleFinishBound = () => this._handleFinish()\r\n this.once('finish', this._handleFinishBound)\r\n }\r\n\r\n /**\r\n * Send text/binary data to the WebSocket server.\r\n * @param {TypedArrayView|ArrayBuffer|Uint8Array|string|Blob|Object} chunk\r\n */\r\n send (chunk) {\r\n this._ws.send(chunk)\r\n }\r\n\r\n _final (cb) {\r\n if (!this._readableState.ended) this.push(null)\r\n cb(null)\r\n }\r\n\r\n _destroy (cb) {\r\n if (this.destroyed) return\r\n if (!this._writableState.ended) this.end()\r\n\r\n this.connected = false\r\n\r\n clearInterval(this._interval)\r\n this._interval = null\r\n this._chunk = null\r\n this._cb = null\r\n\r\n if (this._handleFinishBound) {\r\n this.removeListener('finish', this._handleFinishBound)\r\n }\r\n this._handleFinishBound = null\r\n\r\n if (this._ws) {\r\n const ws = this._ws\r\n const onClose = () => {\r\n ws.onclose = null\r\n }\r\n if (ws.readyState === _WebSocket.CLOSED) {\r\n onClose()\r\n } else {\r\n try {\r\n ws.onclose = onClose\r\n ws.close()\r\n } catch (err) {\r\n onClose()\r\n }\r\n }\r\n\r\n ws.onopen = null\r\n ws.onmessage = null\r\n ws.onerror = () => {}\r\n }\r\n this._ws = null\r\n\r\n cb()\r\n }\r\n\r\n _write (chunk, cb) {\r\n if (this.destroyed) return cb(new Error('cannot write after socket is destroyed'))\r\n\r\n if (this.connected) {\r\n try {\r\n this.send(chunk)\r\n } catch (err) {\r\n return this.destroy(err)\r\n }\r\n if (typeof ws !== 'function' && this._ws.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n this._debug('start backpressure: bufferedAmount %d', this._ws.bufferedAmount)\r\n this._cb = cb\r\n } else {\r\n cb(null)\r\n }\r\n } else {\r\n this._debug('write before connect')\r\n this._chunk = chunk\r\n this._cb = cb\r\n }\r\n }\r\n\r\n _handleOpen () {\r\n if (this.connected || this.destroyed) return\r\n this.connected = true\r\n\r\n if (this._chunk) {\r\n try {\r\n this.send(this._chunk)\r\n } catch (err) {\r\n return this.destroy(err)\r\n }\r\n this._chunk = null\r\n this._debug('sent chunk from \"write before connect\"')\r\n\r\n const cb = this._cb\r\n this._cb = null\r\n cb(null)\r\n }\r\n\r\n // Backpressure is not implemented in Node.js. The `ws` module has a buggy\r\n // `bufferedAmount` property. See: https://github.com/websockets/ws/issues/492\r\n if (typeof ws !== 'function') {\r\n this._interval = setInterval(() => this._onInterval(), 150)\r\n if (this._interval.unref) this._interval.unref()\r\n }\r\n\r\n this._debug('connect')\r\n this.emit('connect')\r\n }\r\n\r\n _handleMessage (event) {\r\n if (this.destroyed) return\r\n let data = event.data\r\n if (data instanceof ArrayBuffer) data = new Uint8Array(data)\r\n if (this.__objectMode === false) data = text2arr(data)\r\n this.push(data)\r\n }\r\n\r\n _handleClose () {\r\n if (this.destroyed) return\r\n this._debug('on close')\r\n this.destroy()\r\n }\r\n\r\n _handleError (_) {\r\n this.destroy(new Error(`Error connecting to ${this.url}`))\r\n }\r\n\r\n // When stream finishes writing, close socket. Half open connections are not\r\n // supported.\r\n _handleFinish () {\r\n if (this.destroyed) return\r\n\r\n // Wait a bit before destroying so the socket flushes.\r\n // TODO: is there a more reliable way to accomplish this?\r\n const destroySoon = () => {\r\n setTimeout(() => this.destroy(), 1000)\r\n }\r\n\r\n if (this.connected) {\r\n destroySoon()\r\n } else {\r\n this.once('connect', destroySoon)\r\n }\r\n }\r\n\r\n _onInterval () {\r\n if (!this._cb || !this._ws || this._ws.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n return\r\n }\r\n this._debug('ending backpressure: bufferedAmount %d', this._ws.bufferedAmount)\r\n const cb = this._cb\r\n this._cb = null\r\n cb(null)\r\n }\r\n\r\n _debug () {\r\n const args = [].slice.call(arguments)\r\n args[0] = '[' + this._id + '] ' + args[0]\r\n debug.apply(null, args)\r\n }\r\n}\r\n\r\nSocket.WEBSOCKET_SUPPORT = !!_WebSocket\r\n","import EventEmitter from 'events'\n\nclass Tracker extends EventEmitter {\n constructor (client, announceUrl) {\n super()\n\n this.client = client\n this.announceUrl = announceUrl\n\n this.interval = null\n this.destroyed = false\n }\n\n setInterval (intervalMs) {\n if (intervalMs == null) intervalMs = this.DEFAULT_ANNOUNCE_INTERVAL\n\n clearInterval(this.interval)\n\n if (intervalMs) {\n this.interval = setInterval(() => {\n this.announce(this.client._defaultAnnounceOpts())\n }, intervalMs)\n if (this.interval.unref) this.interval.unref()\n }\n }\n}\n\nexport default Tracker\n","import Debug from 'debug'\nimport Peer from '@thaunknown/simple-peer/lite.js'\nimport Socket from '@thaunknown/simple-websocket'\nimport { arr2text, arr2hex, hex2bin, bin2hex, randomBytes } from 'uint8-util'\n\nimport common from '../common.js'\nimport Tracker from './tracker.js'\n\nconst debug = Debug('bittorrent-tracker:websocket-tracker')\n\n// Use a socket pool, so tracker clients share WebSocket objects for the same server.\n// In practice, WebSockets are pretty slow to establish, so this gives a nice performance\n// boost, and saves browser resources.\nconst socketPool = {}\n\nconst RECONNECT_MINIMUM = 10 * 1000\nconst RECONNECT_MAXIMUM = 60 * 60 * 1000\nconst RECONNECT_VARIANCE = 5 * 60 * 1000\nconst OFFER_TIMEOUT = 50 * 1000\n\nclass WebSocketTracker extends Tracker {\n constructor (client, announceUrl) {\n super(client, announceUrl)\n debug('new websocket tracker %s', announceUrl)\n\n this.peers = {} // peers (offer id -> peer)\n this.socket = null\n\n this.reconnecting = false\n this.retries = 0\n this.reconnectTimer = null\n\n // Simple boolean flag to track whether the socket has received data from\n // the websocket server since the last time socket.send() was called.\n this.expectingResponse = false\n\n this._openSocket()\n }\n\n announce (opts) {\n if (this.destroyed || this.reconnecting) return\n if (!this.socket.connected) {\n this.socket.once('connect', () => {\n this.announce(opts)\n })\n return\n }\n\n const params = Object.assign({}, opts, {\n action: 'announce',\n info_hash: this.client._infoHashBinary,\n peer_id: this.client._peerIdBinary\n })\n if (this._trackerId) params.trackerid = this._trackerId\n\n if (opts.event === 'stopped' || opts.event === 'completed') {\n // Don't include offers with 'stopped' or 'completed' event\n this._send(params)\n } else {\n // Limit the number of offers that are generated, since it can be slow\n const numwant = Math.min(opts.numwant, 5)\n\n this._generateOffers(numwant, offers => {\n params.numwant = numwant\n params.offers = offers\n this._send(params)\n })\n }\n }\n\n scrape (opts) {\n if (this.destroyed || this.reconnecting) return\n if (!this.socket.connected) {\n this.socket.once('connect', () => {\n this.scrape(opts)\n })\n return\n }\n\n const infoHashes = (Array.isArray(opts.infoHash) && opts.infoHash.length > 0)\n ? opts.infoHash.map(infoHash => hex2bin(infoHash))\n : (opts.infoHash && hex2bin(opts.infoHash)) || this.client._infoHashBinary\n const params = {\n action: 'scrape',\n info_hash: infoHashes\n }\n\n this._send(params)\n }\n\n destroy (cb = noop) {\n if (this.destroyed) return cb(null)\n\n this.destroyed = true\n\n clearInterval(this.interval)\n clearTimeout(this.reconnectTimer)\n\n // Destroy peers\n for (const peerId in this.peers) {\n const peer = this.peers[peerId]\n clearTimeout(peer.trackerTimeout)\n peer.destroy()\n }\n this.peers = null\n\n if (this.socket) {\n this.socket.removeListener('connect', this._onSocketConnectBound)\n this.socket.removeListener('data', this._onSocketDataBound)\n this.socket.removeListener('close', this._onSocketCloseBound)\n this.socket.removeListener('error', this._onSocketErrorBound)\n this.socket = null\n }\n\n this._onSocketConnectBound = null\n this._onSocketErrorBound = null\n this._onSocketDataBound = null\n this._onSocketCloseBound = null\n\n if (socketPool[this.announceUrl]) {\n socketPool[this.announceUrl].consumers -= 1\n }\n\n // Other instances are using the socket, so there's nothing left to do here\n if (socketPool[this.announceUrl].consumers > 0) return cb()\n\n let socket = socketPool[this.announceUrl]\n delete socketPool[this.announceUrl]\n socket.on('error', noop) // ignore all future errors\n socket.once('close', cb)\n\n let timeout\n\n // If there is no data response expected, destroy immediately.\n if (!this.expectingResponse) return destroyCleanup()\n\n // Otherwise, wait a short time for potential responses to come in from the\n // server, then force close the socket.\n timeout = setTimeout(destroyCleanup, common.DESTROY_TIMEOUT)\n\n // But, if a response comes from the server before the timeout fires, do cleanup\n // right away.\n socket.once('data', destroyCleanup)\n\n function destroyCleanup () {\n if (timeout) {\n clearTimeout(timeout)\n timeout = null\n }\n socket.removeListener('data', destroyCleanup)\n socket.destroy()\n socket = null\n }\n }\n\n _openSocket () {\n this.destroyed = false\n\n if (!this.peers) this.peers = {}\n\n this._onSocketConnectBound = () => {\n this._onSocketConnect()\n }\n this._onSocketErrorBound = err => {\n this._onSocketError(err)\n }\n this._onSocketDataBound = data => {\n this._onSocketData(data)\n }\n this._onSocketCloseBound = () => {\n this._onSocketClose()\n }\n\n this.socket = socketPool[this.announceUrl]\n if (this.socket) {\n socketPool[this.announceUrl].consumers += 1\n if (this.socket.connected) {\n this._onSocketConnectBound()\n }\n } else {\n const parsedUrl = new URL(this.announceUrl)\n let agent\n if (this.client._proxyOpts) {\n agent = parsedUrl.protocol === 'wss:' ? this.client._proxyOpts.httpsAgent : this.client._proxyOpts.httpAgent\n if (!agent && this.client._proxyOpts.socksProxy) {\n agent = this.client._proxyOpts.socksProxy\n }\n }\n this.socket = socketPool[this.announceUrl] = new Socket({ url: this.announceUrl, agent })\n this.socket.consumers = 1\n this.socket.once('connect', this._onSocketConnectBound)\n }\n\n this.socket.on('data', this._onSocketDataBound)\n this.socket.once('close', this._onSocketCloseBound)\n this.socket.once('error', this._onSocketErrorBound)\n }\n\n _onSocketConnect () {\n if (this.destroyed) return\n\n if (this.reconnecting) {\n this.reconnecting = false\n this.retries = 0\n this.announce(this.client._defaultAnnounceOpts())\n }\n }\n\n _onSocketData (data) {\n if (this.destroyed) return\n\n this.expectingResponse = false\n\n try {\n data = JSON.parse(arr2text(data))\n } catch (err) {\n this.client.emit('warning', new Error('Invalid tracker response'))\n return\n }\n\n if (data.action === 'announce') {\n this._onAnnounceResponse(data)\n } else if (data.action === 'scrape') {\n this._onScrapeResponse(data)\n } else {\n this._onSocketError(new Error(`invalid action in WS response: ${data.action}`))\n }\n }\n\n _onAnnounceResponse (data) {\n if (data.info_hash !== this.client._infoHashBinary) {\n debug(\n 'ignoring websocket data from %s for %s (looking for %s: reused socket)',\n this.announceUrl, bin2hex(data.info_hash), this.client.infoHash\n )\n return\n }\n\n if (data.peer_id && data.peer_id === this.client._peerIdBinary) {\n // ignore offers/answers from this client\n return\n }\n\n debug(\n 'received %s from %s for %s',\n JSON.stringify(data), this.announceUrl, this.client.infoHash\n )\n\n const failure = data['failure reason']\n if (failure) return this.client.emit('warning', new Error(failure))\n\n const warning = data['warning message']\n if (warning) this.client.emit('warning', new Error(warning))\n\n const interval = data.interval || data['min interval']\n if (interval) this.setInterval(interval * 1000)\n\n const trackerId = data['tracker id']\n if (trackerId) {\n // If absent, do not discard previous trackerId value\n this._trackerId = trackerId\n }\n\n if (data.complete != null) {\n const response = Object.assign({}, data, {\n announce: this.announceUrl,\n infoHash: bin2hex(data.info_hash)\n })\n this.client.emit('update', response)\n }\n\n let peer\n if (data.offer && data.peer_id) {\n debug('creating peer (from remote offer)')\n peer = this._createPeer()\n peer.id = bin2hex(data.peer_id)\n peer.once('signal', answer => {\n const params = {\n action: 'announce',\n info_hash: this.client._infoHashBinary,\n peer_id: this.client._peerIdBinary,\n to_peer_id: data.peer_id,\n answer,\n offer_id: data.offer_id\n }\n if (this._trackerId) params.trackerid = this._trackerId\n this._send(params)\n })\n this.client.emit('peer', peer)\n peer.signal(data.offer)\n }\n\n if (data.answer && data.peer_id) {\n const offerId = bin2hex(data.offer_id)\n peer = this.peers[offerId]\n if (peer) {\n peer.id = bin2hex(data.peer_id)\n this.client.emit('peer', peer)\n peer.signal(data.answer)\n\n clearTimeout(peer.trackerTimeout)\n peer.trackerTimeout = null\n delete this.peers[offerId]\n } else {\n debug(`got unexpected answer: ${JSON.stringify(data.answer)}`)\n }\n }\n }\n\n _onScrapeResponse (data) {\n data = data.files || {}\n\n const keys = Object.keys(data)\n if (keys.length === 0) {\n this.client.emit('warning', new Error('invalid scrape response'))\n return\n }\n\n keys.forEach(infoHash => {\n // TODO: optionally handle data.flags.min_request_interval\n // (separate from announce interval)\n const response = Object.assign(data[infoHash], {\n announce: this.announceUrl,\n infoHash: bin2hex(infoHash)\n })\n this.client.emit('scrape', response)\n })\n }\n\n _onSocketClose () {\n if (this.destroyed) return\n this.destroy()\n this._startReconnectTimer()\n }\n\n _onSocketError (err) {\n if (this.destroyed) return\n this.destroy()\n // errors will often happen if a tracker is offline, so don't treat it as fatal\n this.client.emit('warning', err)\n this._startReconnectTimer()\n }\n\n _startReconnectTimer () {\n const ms = Math.floor(Math.random() * RECONNECT_VARIANCE) + Math.min(Math.pow(2, this.retries) * RECONNECT_MINIMUM, RECONNECT_MAXIMUM)\n\n this.reconnecting = true\n clearTimeout(this.reconnectTimer)\n this.reconnectTimer = setTimeout(() => {\n this.retries++\n this._openSocket()\n }, ms)\n if (this.reconnectTimer.unref) this.reconnectTimer.unref()\n\n debug('reconnecting socket in %s ms', ms)\n }\n\n _send (params) {\n if (this.destroyed) return\n this.expectingResponse = true\n const message = JSON.stringify(params)\n debug('send %s', message)\n this.socket.send(message)\n }\n\n _generateOffers (numwant, cb) {\n const self = this\n const offers = []\n debug('generating %s offers', numwant)\n\n for (let i = 0; i < numwant; ++i) {\n generateOffer()\n }\n checkDone()\n\n function generateOffer () {\n const offerId = arr2hex(randomBytes(20))\n debug('creating peer (from _generateOffers)')\n const peer = self.peers[offerId] = self._createPeer({ initiator: true })\n peer.once('signal', offer => {\n offers.push({\n offer,\n offer_id: hex2bin(offerId)\n })\n checkDone()\n })\n peer.trackerTimeout = setTimeout(() => {\n debug('tracker timeout: destroying peer')\n peer.trackerTimeout = null\n delete self.peers[offerId]\n peer.destroy()\n }, OFFER_TIMEOUT)\n if (peer.trackerTimeout.unref) peer.trackerTimeout.unref()\n }\n\n function checkDone () {\n if (offers.length === numwant) {\n debug('generated %s offers', numwant)\n cb(offers)\n }\n }\n }\n\n _createPeer (opts) {\n const self = this\n\n opts = Object.assign({\n trickle: false,\n config: self.client._rtcConfig,\n wrtc: self.client._wrtc\n }, opts)\n\n const peer = new Peer(opts)\n\n peer.once('error', onError)\n peer.once('connect', onConnect)\n\n return peer\n\n // Handle peer 'error' events that are fired *before* the peer is emitted in\n // a 'peer' event.\n function onError (err) {\n self.client.emit('warning', new Error(`Connection error: ${err.message}`))\n peer.destroy()\n }\n\n // Once the peer is emitted in a 'peer' event, then it's the consumer's\n // responsibility to listen for errors, so the listeners are removed here.\n function onConnect () {\n peer.removeListener('error', onError)\n peer.removeListener('connect', onConnect)\n }\n }\n}\n\nWebSocketTracker.prototype.DEFAULT_ANNOUNCE_INTERVAL = 30 * 1000 // 30 seconds\n// Normally this shouldn't be accessed but is occasionally useful\nWebSocketTracker._socketPool = socketPool\n\nfunction noop () {}\n\nexport default WebSocketTracker\n","import Debug from 'debug'\nimport EventEmitter from 'events'\nimport once from 'once'\nimport parallel from 'run-parallel'\nimport Peer from '@thaunknown/simple-peer/lite.js'\nimport queueMicrotask from 'queue-microtask'\nimport { hex2arr, hex2bin, text2arr, arr2hex, arr2text } from 'uint8-util'\n\nimport common from './lib/common.js'\nimport HTTPTracker from './lib/client/http-tracker.js' // empty object in browser\nimport UDPTracker from './lib/client/udp-tracker.js' // empty object in browser\nimport WebSocketTracker from './lib/client/websocket-tracker.js'\n\nconst debug = Debug('bittorrent-tracker:client')\n\n/**\n * BitTorrent tracker client.\n *\n * Find torrent peers, to help a torrent client participate in a torrent swarm.\n *\n * @param {Object} opts options object\n * @param {string|Uint8Array} opts.infoHash torrent info hash\n * @param {string|Uint8Array} opts.peerId peer id\n * @param {string|Array.} opts.announce announce\n * @param {number} opts.port torrent client listening port\n * @param {function} opts.getAnnounceOpts callback to provide data to tracker\n * @param {number} opts.rtcConfig RTCPeerConnection configuration object\n * @param {number} opts.userAgent User-Agent header for http requests\n * @param {number} opts.wrtc custom webrtc impl (useful in node.js)\n * @param {object} opts.proxyOpts proxy options (useful in node.js)\n */\nclass Client extends EventEmitter {\n constructor (opts = {}) {\n super()\n\n if (!opts.peerId) throw new Error('Option `peerId` is required')\n if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n if (!opts.announce) throw new Error('Option `announce` is required')\n if (!process.browser && !opts.port) throw new Error('Option `port` is required')\n\n this.peerId = typeof opts.peerId === 'string'\n ? opts.peerId\n : arr2hex(opts.peerId)\n this._peerIdBuffer = hex2arr(this.peerId)\n this._peerIdBinary = hex2bin(this.peerId)\n\n this.infoHash = typeof opts.infoHash === 'string'\n ? opts.infoHash.toLowerCase()\n : arr2hex(opts.infoHash)\n this._infoHashBuffer = hex2arr(this.infoHash)\n this._infoHashBinary = hex2bin(this.infoHash)\n\n debug('new client %s', this.infoHash)\n\n this.destroyed = false\n\n this._port = opts.port\n this._getAnnounceOpts = opts.getAnnounceOpts\n this._rtcConfig = opts.rtcConfig\n this._userAgent = opts.userAgent\n this._proxyOpts = opts.proxyOpts\n\n // Support lazy 'wrtc' module initialization\n // See: https://github.com/webtorrent/webtorrent-hybrid/issues/46\n this._wrtc = typeof opts.wrtc === 'function' ? opts.wrtc() : opts.wrtc\n\n let announce = typeof opts.announce === 'string'\n ? [opts.announce]\n : opts.announce == null ? [] : opts.announce\n\n // Remove trailing slash from trackers to catch duplicates\n announce = announce.map(announceUrl => {\n if (ArrayBuffer.isView(announceUrl)) announceUrl = arr2text(announceUrl)\n if (announceUrl[announceUrl.length - 1] === '/') {\n announceUrl = announceUrl.substring(0, announceUrl.length - 1)\n }\n return announceUrl\n })\n // remove duplicates by converting to Set and back\n announce = Array.from(new Set(announce))\n\n const webrtcSupport = this._wrtc !== false && (!!this._wrtc || Peer.WEBRTC_SUPPORT)\n\n const nextTickWarn = err => {\n queueMicrotask(() => {\n this.emit('warning', err)\n })\n }\n\n this._trackers = announce\n .map(announceUrl => {\n let parsedUrl\n try {\n parsedUrl = common.parseUrl(announceUrl)\n } catch (err) {\n nextTickWarn(new Error(`Invalid tracker URL: ${announceUrl}`))\n return null\n }\n\n const port = parsedUrl.port\n if (port < 0 || port > 65535) {\n nextTickWarn(new Error(`Invalid tracker port: ${announceUrl}`))\n return null\n }\n\n const protocol = parsedUrl.protocol\n if ((protocol === 'http:' || protocol === 'https:') &&\n typeof HTTPTracker === 'function') {\n return new HTTPTracker(this, announceUrl)\n } else if (protocol === 'udp:' && typeof UDPTracker === 'function') {\n return new UDPTracker(this, announceUrl)\n } else if ((protocol === 'ws:' || protocol === 'wss:') && webrtcSupport) {\n // Skip ws:// trackers on https:// sites because they throw SecurityError\n if (protocol === 'ws:' && typeof window !== 'undefined' &&\n window.location.protocol === 'https:') {\n nextTickWarn(new Error(`Unsupported tracker protocol: ${announceUrl}`))\n return null\n }\n return new WebSocketTracker(this, announceUrl)\n } else {\n nextTickWarn(new Error(`Unsupported tracker protocol: ${announceUrl}`))\n return null\n }\n })\n .filter(Boolean)\n }\n\n /**\n * Send a `start` announce to the trackers.\n * @param {Object} opts\n * @param {number=} opts.uploaded\n * @param {number=} opts.downloaded\n * @param {number=} opts.left (if not set, calculated automatically)\n */\n start (opts) {\n opts = this._defaultAnnounceOpts(opts)\n opts.event = 'started'\n debug('send `start` %o', opts)\n this._announce(opts)\n\n // start announcing on intervals\n this._trackers.forEach(tracker => {\n tracker.setInterval()\n })\n }\n\n /**\n * Send a `stop` announce to the trackers.\n * @param {Object} opts\n * @param {number=} opts.uploaded\n * @param {number=} opts.downloaded\n * @param {number=} opts.numwant\n * @param {number=} opts.left (if not set, calculated automatically)\n */\n stop (opts) {\n opts = this._defaultAnnounceOpts(opts)\n opts.event = 'stopped'\n debug('send `stop` %o', opts)\n this._announce(opts)\n }\n\n /**\n * Send a `complete` announce to the trackers.\n * @param {Object} opts\n * @param {number=} opts.uploaded\n * @param {number=} opts.downloaded\n * @param {number=} opts.numwant\n * @param {number=} opts.left (if not set, calculated automatically)\n */\n complete (opts) {\n if (!opts) opts = {}\n opts = this._defaultAnnounceOpts(opts)\n opts.event = 'completed'\n debug('send `complete` %o', opts)\n this._announce(opts)\n }\n\n /**\n * Send a `update` announce to the trackers.\n * @param {Object} opts\n * @param {number=} opts.uploaded\n * @param {number=} opts.downloaded\n * @param {number=} opts.numwant\n * @param {number=} opts.left (if not set, calculated automatically)\n */\n update (opts) {\n opts = this._defaultAnnounceOpts(opts)\n if (opts.event) delete opts.event\n debug('send `update` %o', opts)\n this._announce(opts)\n }\n\n _announce (opts) {\n this._trackers.forEach(tracker => {\n // tracker should not modify `opts` object, it's passed to all trackers\n tracker.announce(opts)\n })\n }\n\n /**\n * Send a scrape request to the trackers.\n * @param {Object} opts\n */\n scrape (opts) {\n debug('send `scrape`')\n if (!opts) opts = {}\n this._trackers.forEach(tracker => {\n // tracker should not modify `opts` object, it's passed to all trackers\n tracker.scrape(opts)\n })\n }\n\n setInterval (intervalMs) {\n debug('setInterval %d', intervalMs)\n this._trackers.forEach(tracker => {\n tracker.setInterval(intervalMs)\n })\n }\n\n destroy (cb) {\n if (this.destroyed) return\n this.destroyed = true\n debug('destroy')\n\n const tasks = this._trackers.map(tracker => cb => {\n tracker.destroy(cb)\n })\n\n parallel(tasks, cb)\n\n this._trackers = []\n this._getAnnounceOpts = null\n }\n\n _defaultAnnounceOpts (opts = {}) {\n if (opts.numwant == null) opts.numwant = common.DEFAULT_ANNOUNCE_PEERS\n\n if (opts.uploaded == null) opts.uploaded = 0\n if (opts.downloaded == null) opts.downloaded = 0\n\n if (this._getAnnounceOpts) opts = Object.assign({}, opts, this._getAnnounceOpts())\n\n return opts\n }\n}\n\n/**\n * Simple convenience function to scrape a tracker for an info hash without needing to\n * create a Client, pass it a parsed torrent, etc. Support scraping a tracker for multiple\n * torrents at the same time.\n * @params {Object} opts\n * @param {string|Array.} opts.infoHash\n * @param {string} opts.announce\n * @param {function} cb\n */\nClient.scrape = (opts, cb) => {\n cb = once(cb)\n\n if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n if (!opts.announce) throw new Error('Option `announce` is required')\n\n const clientOpts = Object.assign({}, opts, {\n infoHash: Array.isArray(opts.infoHash) ? opts.infoHash[0] : opts.infoHash,\n peerId: text2arr('01234567890123456789'), // dummy value\n port: 6881 // dummy value\n })\n\n const client = new Client(clientOpts)\n client.once('error', cb)\n client.once('warning', cb)\n\n let len = Array.isArray(opts.infoHash) ? opts.infoHash.length : 1\n const results = {}\n client.on('scrape', data => {\n len -= 1\n results[data.infoHash] = data\n if (len === 0) {\n client.destroy()\n const keys = Object.keys(results)\n if (keys.length === 1) {\n cb(null, results[keys[0]])\n } else {\n cb(null, results)\n }\n }\n })\n\n client.scrape({ infoHash: opts.infoHash })\n return client\n}\n\nexport default Client\n","/*! torrent-discovery. MIT License. WebTorrent LLC */\nimport Debug from 'debug'\nimport { Client as DHT } from 'bittorrent-dht' // empty object in browser\nimport { EventEmitter } from 'events'\nimport parallel from 'run-parallel'\nimport { Client as Tracker } from 'bittorrent-tracker'\nimport LSD from 'bittorrent-lsd'\n\nconst debug = Debug('torrent-discovery')\n\nclass Discovery extends EventEmitter {\n constructor (opts) {\n super()\n\n if (!opts.peerId) throw new Error('Option `peerId` is required')\n if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n if (!process.browser && !opts.port) throw new Error('Option `port` is required')\n\n this.peerId = typeof opts.peerId === 'string'\n ? opts.peerId\n : opts.peerId.toString('hex')\n this.infoHash = typeof opts.infoHash === 'string'\n ? opts.infoHash.toLowerCase()\n : opts.infoHash.toString('hex')\n this._port = opts.port // torrent port\n this._userAgent = opts.userAgent // User-Agent header for http requests\n\n this.destroyed = false\n\n this._announce = opts.announce || []\n this._intervalMs = opts.intervalMs || (15 * 60 * 1000)\n this._trackerOpts = null\n this._dhtAnnouncing = false\n this._dhtTimeout = false\n this._internalDHT = false // is the DHT created internally?\n\n this._onWarning = err => {\n this.emit('warning', err)\n }\n this._onError = err => {\n this.emit('error', err)\n }\n this._onDHTPeer = (peer, infoHash) => {\n if (infoHash.toString('hex') !== this.infoHash) return\n this.emit('peer', `${peer.host}:${peer.port}`, 'dht')\n }\n this._onTrackerPeer = peer => {\n this.emit('peer', peer, 'tracker')\n }\n this._onTrackerAnnounce = () => {\n this.emit('trackerAnnounce')\n }\n this._onLSDPeer = (peer, infoHash) => {\n this.emit('peer', peer, 'lsd')\n }\n\n const createDHT = (port, opts) => {\n const dht = new DHT(opts)\n dht.on('warning', this._onWarning)\n dht.on('error', this._onError)\n dht.listen(port)\n this._internalDHT = true\n return dht\n }\n\n if (opts.tracker === false) {\n this.tracker = null\n } else if (opts.tracker && typeof opts.tracker === 'object') {\n this._trackerOpts = Object.assign({}, opts.tracker)\n this.tracker = this._createTracker()\n } else {\n this.tracker = this._createTracker()\n }\n\n if (opts.dht === false || typeof DHT !== 'function') {\n this.dht = null\n } else if (opts.dht && typeof opts.dht.addNode === 'function') {\n this.dht = opts.dht\n } else if (opts.dht && typeof opts.dht === 'object') {\n this.dht = createDHT(opts.dhtPort, opts.dht)\n } else {\n this.dht = createDHT(opts.dhtPort)\n }\n\n if (this.dht) {\n this.dht.on('peer', this._onDHTPeer)\n this._dhtAnnounce()\n }\n\n if (opts.lsd === false || typeof LSD !== 'function') {\n this.lsd = null\n } else {\n this.lsd = this._createLSD()\n }\n }\n\n updatePort (port) {\n if (port === this._port) return\n this._port = port\n\n if (this.dht) this._dhtAnnounce()\n\n if (this.tracker) {\n this.tracker.stop()\n this.tracker.destroy(() => {\n this.tracker = this._createTracker()\n })\n }\n }\n\n complete (opts) {\n if (this.tracker) {\n this.tracker.complete(opts)\n }\n }\n\n destroy (cb) {\n if (this.destroyed) return\n this.destroyed = true\n\n clearTimeout(this._dhtTimeout)\n\n const tasks = []\n\n if (this.tracker) {\n this.tracker.stop()\n this.tracker.removeListener('warning', this._onWarning)\n this.tracker.removeListener('error', this._onError)\n this.tracker.removeListener('peer', this._onTrackerPeer)\n this.tracker.removeListener('update', this._onTrackerAnnounce)\n tasks.push(cb => {\n this.tracker.destroy(cb)\n })\n }\n\n if (this.dht) {\n this.dht.removeListener('peer', this._onDHTPeer)\n }\n\n if (this._internalDHT) {\n this.dht.removeListener('warning', this._onWarning)\n this.dht.removeListener('error', this._onError)\n tasks.push(cb => {\n this.dht.destroy(cb)\n })\n }\n\n if (this.lsd) {\n this.lsd.removeListener('warning', this._onWarning)\n this.lsd.removeListener('error', this._onError)\n this.lsd.removeListener('peer', this._onLSDPeer)\n tasks.push(cb => {\n this.lsd.destroy(cb)\n })\n }\n\n parallel(tasks, cb)\n\n // cleanup\n this.dht = null\n this.tracker = null\n this.lsd = null\n this._announce = null\n }\n\n _createTracker () {\n const opts = Object.assign({}, this._trackerOpts, {\n infoHash: this.infoHash,\n announce: this._announce,\n peerId: this.peerId,\n port: this._port,\n userAgent: this._userAgent\n })\n\n const tracker = new Tracker(opts)\n tracker.on('warning', this._onWarning)\n tracker.on('error', this._onError)\n tracker.on('peer', this._onTrackerPeer)\n tracker.on('update', this._onTrackerAnnounce)\n tracker.setInterval(this._intervalMs)\n tracker.start()\n return tracker\n }\n\n _dhtAnnounce () {\n if (this._dhtAnnouncing) return\n debug('dht announce')\n\n this._dhtAnnouncing = true\n clearTimeout(this._dhtTimeout)\n\n this.dht.announce(this.infoHash, this._port, err => {\n this._dhtAnnouncing = false\n debug('dht announce complete')\n\n if (err) this.emit('warning', err)\n this.emit('dhtAnnounce')\n\n if (!this.destroyed) {\n this._dhtTimeout = setTimeout(() => {\n this._dhtAnnounce()\n }, this._intervalMs + Math.floor(Math.random() * this._intervalMs / 5))\n if (this._dhtTimeout.unref) this._dhtTimeout.unref()\n }\n })\n }\n\n _createLSD () {\n const opts = Object.assign({}, {\n infoHash: this.infoHash,\n peerId: this.peerId,\n port: this._port\n })\n\n const lsd = new LSD(opts)\n lsd.on('warning', this._onWarning)\n lsd.on('error', this._onError)\n lsd.on('peer', this._onLSDPeer)\n lsd.start()\n return lsd\n }\n}\n\nexport default Discovery\n","const INVALID = ['seeking position failed.', 'InvalidStateError']\r\nconst GONE = ['A requested file or directory could not be found at the time an operation was processed.', 'NotFoundError']\r\nconst SYNTAX = m => [`Failed to execute 'write' on 'UnderlyingSinkBase': Invalid params passed. ${m}`, 'SyntaxError']\r\n\r\nclass _FileSystemWritableFileStream extends WritableStream {\r\n constructor (writer) {\r\n super(writer)\r\n // Stupid Safari hack to extend native classes\r\n // https://bugs.webkit.org/show_bug.cgi?id=226201\r\n Object.setPrototypeOf(this, FileSystemWritableFileStream.prototype)\r\n\r\n /** @private */\r\n this._closed = false\r\n }\r\n\r\n async close () {\r\n this._closed = true\r\n const w = this.getWriter()\r\n const p = w.close()\r\n w.releaseLock()\r\n return p\r\n // return super.close ? super.close() : this.getWriter().close()\r\n }\r\n\r\n /** @param {number} position */\r\n seek (position) {\r\n return this.write({ type: 'seek', position })\r\n }\r\n\r\n /** @param {number} size */\r\n truncate (size) {\r\n return this.write({ type: 'truncate', size })\r\n }\r\n\r\n // The write(data) method steps are:\r\n write (data) {\r\n if (this._closed) {\r\n return Promise.reject(new TypeError('Cannot write to a CLOSED writable stream'))\r\n }\r\n\r\n // 1. Let writer be the result of getting a writer for this.\r\n const writer = this.getWriter()\r\n\r\n // 2. Let result be the result of writing a chunk to writer given data.\r\n const result = writer.write(data)\r\n\r\n // 3. Release writer.\r\n writer.releaseLock()\r\n\r\n // 4. Return result.\r\n return result\r\n }\r\n}\r\n\r\nObject.defineProperty(_FileSystemWritableFileStream.prototype, Symbol.toStringTag, {\r\n value: 'FileSystemWritableFileStream',\r\n writable: false,\r\n enumerable: false,\r\n configurable: true\r\n})\r\n\r\nObject.defineProperties(_FileSystemWritableFileStream.prototype, {\r\n close: { enumerable: true },\r\n seek: { enumerable: true },\r\n truncate: { enumerable: true },\r\n write: { enumerable: true }\r\n})\r\n\r\n// Safari safari doesn't support writable streams yet.\r\nif (\r\n globalThis.FileSystemFileHandle &&\r\n !globalThis.FileSystemFileHandle.prototype.createWritable &&\r\n !globalThis.FileSystemWritableFileStream\r\n) {\r\n globalThis.FileSystemWritableFileStream = _FileSystemWritableFileStream\r\n}\r\n\r\n// Safari doesn't support async createWritable streams yet.\r\nif (\r\n globalThis.FileSystemFileHandle &&\r\n !globalThis.FileSystemFileHandle.prototype.createWritable\r\n) {\r\n const wm = new WeakMap()\r\n\r\n let workerUrl\r\n\r\n // Worker code that should be inlined (can't use any external functions)\r\n const code = () => {\r\n let fileHandle, handle\r\n\r\n onmessage = async evt => {\r\n const port = evt.ports[0]\r\n const cmd = evt.data\r\n switch (cmd.type) {\r\n case 'open': {\r\n const file = cmd.name\r\n\r\n let dir = await navigator.storage.getDirectory()\r\n\r\n for (const folder of cmd.path) {\r\n dir = await dir.getDirectoryHandle(folder)\r\n }\r\n\r\n fileHandle = await dir.getFileHandle(file)\r\n // @ts-ignore\r\n handle = await fileHandle.createSyncAccessHandle()\r\n break\r\n }\r\n case 'write':\r\n handle.write(cmd.data, { at: cmd.position })\r\n handle.flush()\r\n break\r\n case 'truncate':\r\n handle.truncate(cmd.size)\r\n break\r\n case 'abort':\r\n case 'close':\r\n handle.close()\r\n break\r\n }\r\n\r\n port.postMessage(0)\r\n }\r\n }\r\n\r\n globalThis.FileSystemFileHandle.prototype.createWritable = async function (options) {\r\n // Safari only support writing data in a worker with sync access handle.\r\n if (!workerUrl) {\r\n const stringCode = `(${code.toString()})()`\r\n const blob = new Blob([stringCode], {\r\n type: 'text/javascript'\r\n })\r\n workerUrl = URL.createObjectURL(blob)\r\n }\r\n const worker = new Worker(workerUrl, { type: 'module' })\r\n\r\n let position = 0\r\n const textEncoder = new TextEncoder()\r\n let size = await this.getFile().then(file => file.size)\r\n\r\n const send = message => new Promise((resolve, reject) => {\r\n const mc = new MessageChannel()\r\n mc.port1.onmessage = evt => {\r\n if (evt.data instanceof Error) reject(evt.data)\r\n else resolve(evt.data)\r\n mc.port1.close()\r\n mc.port2.close()\r\n mc.port1.onmessage = null\r\n }\r\n worker.postMessage(message, [mc.port2])\r\n })\r\n\r\n // Safari also don't support transferable file system handles.\r\n // So we need to pass the path to the worker. This is a bit hacky and ugly.\r\n const root = await navigator.storage.getDirectory()\r\n const parent = await wm.get(this)\r\n const path = await root.resolve(parent)\r\n\r\n // Should likely never happen, but just in case...\r\n if (path === null) throw new DOMException(...GONE)\r\n\r\n await send({ type: 'open', path, name: this.name })\r\n\r\n if (options?.keepExistingData === false) {\r\n await send({ type: 'truncate', size: 0 })\r\n size = 0\r\n }\r\n\r\n return new _FileSystemWritableFileStream({\r\n async write (chunk) {\r\n const isPlainObject = chunk?.constructor === Object\r\n\r\n if (isPlainObject) {\r\n chunk = { ...chunk }\r\n } else {\r\n chunk = { type: 'write', data: chunk, position }\r\n }\r\n\r\n if (chunk.type === 'write') {\r\n if (!('data' in chunk)) {\r\n await send({ type: 'close' })\r\n throw new DOMException(...SYNTAX('write requires a data argument'))\r\n }\r\n\r\n chunk.position ??= position\r\n\r\n if (typeof chunk.data === 'string') {\r\n chunk.data = textEncoder.encode(chunk.data)\r\n } else if (chunk.data instanceof ArrayBuffer) {\r\n chunk.data = new Uint8Array(chunk.data)\r\n } else if (!(chunk.data instanceof Uint8Array) && ArrayBuffer.isView(chunk.data)) {\r\n chunk.data = new Uint8Array(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength)\r\n } else if (!(chunk.data instanceof Uint8Array)) {\r\n const ab = await new Response(chunk.data).arrayBuffer()\r\n chunk.data = new Uint8Array(ab)\r\n }\r\n\r\n if (Number.isInteger(chunk.position) && chunk.position >= 0) {\r\n position = chunk.position\r\n }\r\n position += chunk.data.byteLength\r\n size += chunk.data.byteLength\r\n } else if (chunk.type === 'seek') {\r\n if (Number.isInteger(chunk.position) && chunk.position >= 0) {\r\n if (size < chunk.position) {\r\n throw new DOMException(...INVALID)\r\n }\r\n position = chunk.position\r\n return // Don't need to enqueue seek...\r\n } else {\r\n await send({ type: 'close' })\r\n throw new DOMException(...SYNTAX('seek requires a position argument'))\r\n }\r\n } else if (chunk.type === 'truncate') {\r\n if (Number.isInteger(chunk.size) && chunk.size >= 0) {\r\n size = chunk.size\r\n if (position > size) { position = size }\r\n } else {\r\n await send({ type: 'close' })\r\n throw new DOMException(...SYNTAX('truncate requires a size argument'))\r\n }\r\n }\r\n\r\n await send(chunk)\r\n },\r\n async close () {\r\n await send({ type: 'close' })\r\n worker.terminate()\r\n },\r\n async abort (reason) {\r\n await send({ type: 'abort', reason })\r\n worker.terminate()\r\n }\r\n })\r\n }\r\n\r\n const orig = FileSystemDirectoryHandle.prototype.getFileHandle\r\n FileSystemDirectoryHandle.prototype.getFileHandle = async function (...args) {\r\n const handle = await orig.call(this, ...args)\r\n wm.set(handle, this)\r\n return handle\r\n }\r\n}\r\n","import getFileRegex from 'filename-reserved-regex'\r\nimport './createWritable.js'\r\n\r\nconst RESERVED_FILENAME_REGEX = getFileRegex()\r\n\r\n// this can be bad when multiple instances of this app are running\r\nif (globalThis.navigator?.storage?.getDirectory) {\r\n navigator.storage.getDirectory().then(storageDir => {\r\n storageDir.removeEntry('chunks', { recursive: true }).catch(() => {})\r\n })\r\n}\r\n\r\nconst noop = (_, __) => {}\r\nconst err = (cb = noop, err) => queueMicrotask(() => cb(new Error(err)))\r\nexport default class FSAChunkStore {\r\n name = ''\r\n\r\n chunks = [] // individual chunks, required for reads :/\r\n chunkMap = [] // full files\r\n directoryMap = {}\r\n files\r\n\r\n rootDirPromise\r\n storageDirPromise\r\n chunksDirPromise\r\n\r\n closing = false\r\n closed = false\r\n\r\n /**\r\n * @param {number} chunkLength\r\n * @param {{ name?: string, rootDir?: Promise, length?: number, files?: {path: string, length: number, offset?: number, handle?: Promise, blob?: Promise, stream?: Promise }[] }} [opts]\r\n */\r\n constructor (chunkLength, opts = {}) {\r\n this.chunkLength = Number(chunkLength)\r\n\r\n if (!this.chunkLength) {\r\n throw new Error('First argument must be a chunk length')\r\n }\r\n\r\n if (!globalThis.navigator?.storage?.getDirectory) {\r\n throw new Error('FSA API is not supported')\r\n }\r\n\r\n this.closed = false\r\n\r\n this.name = opts.name || crypto.randomUUID()\r\n\r\n this.rootDirPromise = opts.rootDir || navigator.storage.getDirectory()\r\n this.storageDirPromise = (async () => {\r\n const rootDir = await this.rootDirPromise\r\n return rootDir.getDirectoryHandle(this.name, { create: true })\r\n })()\r\n // if there are no files the chunks are the storage\r\n this.chunksDirPromise = this.storageDirPromise\r\n\r\n if (opts.files && opts.rootDir) {\r\n // if files exist, use throwaway, wipeable folder for chunks which are a cache\r\n this.chunksDirPromise = this._getChunksDirHandle()\r\n this.files = opts.files.map((file, i, files) => {\r\n if (file.path == null) throw new Error('File is missing `path` property')\r\n if (file.length == null) throw new Error('File is missing `length` property')\r\n if (file.offset == null) {\r\n if (i === 0) {\r\n file.offset = 0\r\n } else {\r\n const prevFile = files[i - 1]\r\n file.offset = prevFile.offset + prevFile.length\r\n }\r\n }\r\n\r\n // file handles\r\n if (file.handle == null) file.handle = this._createFileHandle({ path: file.path })\r\n file.blob = this._createBlobReference(file.handle)\r\n\r\n // file chunkMap\r\n const fileStart = file.offset\r\n const fileEnd = file.offset + file.length\r\n\r\n const firstChunk = Math.floor(fileStart / this.chunkLength)\r\n const lastChunk = Math.floor((fileEnd - 1) / this.chunkLength)\r\n\r\n for (let i = firstChunk; i <= lastChunk; ++i) {\r\n const chunkStart = i * this.chunkLength\r\n const chunkEnd = chunkStart + this.chunkLength\r\n\r\n const from = (fileStart < chunkStart) ? 0 : fileStart - chunkStart\r\n const to = (fileEnd > chunkEnd) ? this.chunkLength : fileEnd - chunkStart\r\n const offset = (fileStart > chunkStart) ? 0 : chunkStart - fileStart\r\n\r\n if (!this.chunkMap[i]) this.chunkMap[i] = []\r\n\r\n this.chunkMap[i].push({ from, to, offset, file })\r\n }\r\n\r\n return file\r\n })\r\n\r\n // close streams is page is frozen/unloaded, they will re-open if the user returns via BFC\r\n window.addEventListener('pagehide', () => this.cleanup())\r\n\r\n this.length = this.files.reduce((sum, file) => sum + file.length, 0)\r\n if (opts.length != null && opts.length !== this.length) {\r\n throw new Error('total `files` length is not equal to explicit `length` option')\r\n }\r\n } else {\r\n this.length = Number(opts.length) || Infinity\r\n }\r\n\r\n if (this.length !== Infinity) {\r\n this.lastChunkLength = this.length % this.chunkLength || this.chunkLength\r\n this.lastChunkIndex = Math.ceil(this.length / this.chunkLength) - 1\r\n }\r\n }\r\n\r\n async _getChunkHandle (index) {\r\n let chunk = this.chunks[index]\r\n if (!chunk) {\r\n const storageDir = await this.chunksDirPromise\r\n this.chunks[index] = chunk = await storageDir.getFileHandle(index, { create: true })\r\n }\r\n return chunk\r\n }\r\n\r\n /**\r\n * @param {{path: string}} opts\r\n */\r\n async _createFileHandle (opts) {\r\n const fileName = opts.path.slice(opts.path.lastIndexOf('/') + 1)\r\n return (await this._getDirectoryHandle(opts)).getFileHandle(fileName.replace(RESERVED_FILENAME_REGEX, ''), { create: true })\r\n }\r\n\r\n async _createBlobReference (handle) {\r\n return (await handle).getFile()\r\n }\r\n\r\n /**\r\n * recursive, equiv of cd and mkdirp\r\n * @param {{path: string}} opts\r\n * @returns {Promise}\r\n */\r\n async _getDirectoryHandle (opts) {\r\n const lastIndex = opts.path.lastIndexOf('/')\r\n if (lastIndex === -1 || lastIndex === 0) return this.storageDirPromise\r\n const path = opts.path = opts.path.slice(0, lastIndex)\r\n if (!this.directoryMap[path]) {\r\n this.directoryMap[path] = (async () => {\r\n const parent = await this._getDirectoryHandle(opts)\r\n return parent.getDirectoryHandle(path.slice(path.lastIndexOf('/') + 1), { create: true })\r\n })()\r\n }\r\n return this.directoryMap[path]\r\n }\r\n\r\n async _getChunksDirHandle () {\r\n const storageDir = await navigator.storage.getDirectory()\r\n const chunksDir = await storageDir.getDirectoryHandle('chunks', { create: true })\r\n return chunksDir.getDirectoryHandle(this.name, { create: true })\r\n }\r\n\r\n async put (index, buf, cb = noop) {\r\n try {\r\n await this._put(index, buf)\r\n cb(null)\r\n return null\r\n } catch (e) {\r\n queueMicrotask(() => cb(e))\r\n return e\r\n }\r\n }\r\n\r\n /**\r\n * @param {Promise} handle\r\n */\r\n async getStreamForHandle (handle) {\r\n return (await handle).createWritable({ keepExistingData: true })\r\n }\r\n\r\n // wrapped in prep for callback drop\r\n async _put (index, buf) {\r\n if (this.closed) throw new Error('Storage is closed')\r\n\r\n const isLastChunk = index === this.lastChunkIndex\r\n if (isLastChunk && buf.length !== this.lastChunkLength) throw new Error(`Last chunk length must be ${this.lastChunkLength}`)\r\n if (!isLastChunk && buf.length !== this.chunkLength) throw new Error(`Chunk length must be ${this.chunkLength}`)\r\n\r\n const chunkWrite = (async () => {\r\n const chunk = await this._getChunkHandle(index)\r\n const stream = await chunk.createWritable({ keepExistingData: false })\r\n await stream.write(buf)\r\n await stream.close()\r\n })()\r\n\r\n if (!this.files) return chunkWrite\r\n\r\n const targets = this.chunkMap[index]\r\n if (!targets) throw new Error('No files matching the request range')\r\n const promises = targets.map(async ({ file, offset, from, to }) => {\r\n if (!file.stream) {\r\n file.stream = this.getStreamForHandle(file.handle)\r\n }\r\n await (await file.stream).write({ type: 'write', position: offset, data: buf.slice(from, to) })\r\n })\r\n promises.push(chunkWrite)\r\n await Promise.all(promises)\r\n }\r\n\r\n async get (index, opts, cb = noop) {\r\n if (opts == null) opts = {}\r\n try {\r\n const data = await this._get(index, opts)\r\n cb(null, data)\r\n return data\r\n } catch (e) {\r\n cb(e)\r\n return e\r\n }\r\n }\r\n\r\n // wrapped in prep for callback drop\r\n async _get (index, opts) {\r\n if (typeof opts === 'function') return this.get(index, undefined, opts)\r\n if (this.closed) throw new Error('Storage is closed')\r\n\r\n const isLastChunk = index === this.lastChunkIndex\r\n const chunkLength = isLastChunk ? /** @type {number} */(this.lastChunkLength) : this.chunkLength\r\n\r\n const rangeFrom = opts.offset || 0\r\n const rangeTo = opts.length ? rangeFrom + opts.length : chunkLength\r\n const len = opts.length || chunkLength - rangeFrom\r\n\r\n if (rangeFrom < 0 || rangeFrom < 0 || rangeTo > chunkLength) throw new Error('Invalid offset and/or length')\r\n\r\n if (rangeFrom === rangeTo) return new Uint8Array(0)\r\n\r\n if (!this.files || this.chunks[index]) {\r\n const chunk = await this._getChunkHandle(index)\r\n let file = await chunk.getFile()\r\n if (rangeFrom !== 0 || len !== chunkLength) {\r\n file = file.slice(rangeFrom, len + rangeFrom)\r\n }\r\n const buf = await file.arrayBuffer()\r\n\r\n if (buf.byteLength === 0) throw new Error(`Index ${index} does not exist`)\r\n return new Uint8Array(buf)\r\n }\r\n\r\n // if chunk was GC'ed\r\n let targets = this.chunkMap[index]\r\n if (!targets) throw new Error('No files matching the request range')\r\n if (opts) {\r\n targets = targets.filter(({ from, to }) => to > rangeFrom && from < rangeTo)\r\n if (targets.length === 0) throw new Error('No files matching the request range')\r\n }\r\n\r\n const promises = targets.map(async ({ from, to, offset, file }) => {\r\n if (opts) {\r\n if (to > rangeTo) to = rangeTo\r\n if (from < rangeFrom) {\r\n offset += (rangeFrom - from)\r\n from = rangeFrom\r\n }\r\n }\r\n const blob = await file.blob\r\n return blob.slice(offset, offset + to - from)\r\n })\r\n const values = await Promise.all(promises)\r\n const buf = values.length === 1 ? await values[0].arrayBuffer() : await new Blob(values).arrayBuffer()\r\n if (buf.byteLength === 0) throw new Error(`Index ${index} does not exist`)\r\n return new Uint8Array(buf)\r\n }\r\n\r\n async close (cb = noop) {\r\n if (this.closing) return err(cb, 'Storage is closed')\r\n\r\n this.closing = true\r\n this.chunkMap = undefined\r\n this.directoryMap = undefined\r\n if (this.files) await this.cleanup()\r\n this.closed = true\r\n queueMicrotask(() => cb(null))\r\n }\r\n\r\n async cleanup () {\r\n if (this.closed || !this.files) return\r\n const streams = []\r\n for (const file of this.files) {\r\n if (file.stream) {\r\n streams.push(file.stream.then(stream => stream.close()))\r\n file.stream = undefined\r\n }\r\n }\r\n const clearChunks = (async () => {\r\n const storageDir = await this.chunksDirPromise\r\n this.chunks = []\r\n // .remove() doesnt exist on firefox or safari\r\n for await (const key of storageDir.keys()) {\r\n await storageDir.removeEntry(key, { recursive: true })\r\n }\r\n this.chunksDirPromise = this._getChunksDirHandle()\r\n await this.chunksDirPromise\r\n })()\r\n await Promise.all(streams)\r\n for (const file of this.files) {\r\n file.blob = this._createBlobReference(file.handle)\r\n }\r\n await clearChunks\r\n }\r\n\r\n async destroy (cb = noop) {\r\n this.close(async (err) => {\r\n if (err) return cb(err)\r\n try {\r\n const rootDir = await this.rootDirPromise\r\n // .remove() doesnt exist on firefox or safari\r\n await rootDir.removeEntry(this.name, { recursive: true })\r\n } catch (err) {\r\n return cb(err)\r\n }\r\n cb(null)\r\n })\r\n }\r\n}\r\n","/* eslint-disable no-control-regex */\n\nexport default function filenameReservedRegex() {\n\treturn /[<>:\"/\\\\|?*\\u0000-\\u001F]/g;\n}\n\nexport function windowsReservedNameRegex() {\n\treturn /^(con|prn|aux|nul|com\\d|lpt\\d)$/i;\n}\n","/*! lt_donthave. MIT License. WebTorrent LLC */\nimport arrayRemove from 'unordered-array-remove'\nimport { EventEmitter } from 'events'\nimport debugFactory from 'debug'\n\nconst debug = debugFactory('lt_donthave')\n\nexport default () => {\n class ltDontHave extends EventEmitter {\n constructor (wire) {\n super()\n\n this._peerSupports = false\n this._wire = wire\n }\n\n onExtendedHandshake () {\n this._peerSupports = true\n }\n\n onMessage (buf) {\n let index\n try {\n const view = new DataView(buf.buffer)\n index = view.getUint32(0)\n } catch (err) {\n // drop invalid messages\n return\n }\n\n if (!this._wire.peerPieces.get(index)) return\n debug('got donthave %d', index)\n this._wire.peerPieces.set(index, false)\n\n this.emit('donthave', index)\n this._failRequests(index)\n }\n\n donthave (index) {\n if (!this._peerSupports) return\n\n debug('donthave %d', index)\n const buf = new Uint8Array(4)\n const view = new DataView(buf.buffer)\n view.setUint32(0, index)\n\n this._wire.extended('lt_donthave', buf)\n }\n\n _failRequests (index) {\n const requests = this._wire.requests\n for (let i = 0; i < requests.length; i++) {\n const req = requests[i]\n if (req.piece === index) {\n arrayRemove(requests, i)\n i -= 1 // Check the new value at the same slot\n this._wire._callback(req, new Error('peer sent donthave'), null)\n }\n }\n }\n }\n\n // Name of the bittorrent-protocol extension\n ltDontHave.prototype.name = 'lt_donthave'\n\n return ltDontHave\n}\n","/*! torrent-piece. MIT License. WebTorrent LLC */\nimport { concat } from 'uint8-util'\n\nconst BLOCK_LENGTH = 1 << 14\n\nexport default class Piece {\n constructor (length) {\n this.length = length\n this.missing = length\n this.sources = null\n\n this._chunks = Math.ceil(length / BLOCK_LENGTH)\n this._remainder = (length % BLOCK_LENGTH) || BLOCK_LENGTH\n this._buffered = 0\n this._buffer = null\n this._cancellations = null\n this._reservations = 0\n this._flushed = false\n }\n\n chunkLength (i) {\n return i === this._chunks - 1 ? this._remainder : BLOCK_LENGTH\n }\n\n chunkLengthRemaining (i) {\n return this.length - (i * BLOCK_LENGTH)\n }\n\n chunkOffset (i) {\n return i * BLOCK_LENGTH\n }\n\n reserve () {\n if (!this.init()) return -1\n if (this._cancellations.length) return this._cancellations.pop()\n if (this._reservations < this._chunks) return this._reservations++\n return -1\n }\n\n reserveRemaining () {\n if (!this.init()) return -1\n if (this._cancellations.length || this._reservations < this._chunks) {\n let min = this._reservations\n while (this._cancellations.length) {\n min = Math.min(min, this._cancellations.pop())\n }\n this._reservations = this._chunks\n return min\n }\n return -1\n }\n\n cancel (i) {\n if (!this.init()) return\n this._cancellations.push(i)\n }\n\n cancelRemaining (i) {\n if (!this.init()) return\n this._reservations = i\n }\n\n get (i) {\n if (!this.init()) return null\n return this._buffer[i]\n }\n\n set (i, data, source) {\n if (!this.init()) return false\n const len = data.length\n const blocks = Math.ceil(len / BLOCK_LENGTH)\n for (let j = 0; j < blocks; j++) {\n if (!this._buffer[i + j]) {\n const offset = j * BLOCK_LENGTH\n const splitData = data.slice(offset, offset + BLOCK_LENGTH)\n this._buffered++\n this._buffer[i + j] = splitData\n this.missing -= splitData.length\n if (!this.sources.includes(source)) {\n this.sources.push(source)\n }\n }\n }\n return this._buffered === this._chunks\n }\n\n flush () {\n if (!this._buffer || this._chunks !== this._buffered) return null\n const buffer = concat(this._buffer, this.length)\n this._buffer = null\n this._cancellations = null\n this.sources = null\n this._flushed = true\n return buffer\n }\n\n init () {\n if (this._flushed) return false\n if (this._buffer) return true\n this._buffer = new Array(this._chunks)\n this._cancellations = []\n this.sources = []\n return true\n }\n}\n\nPiece.BLOCK_LENGTH = BLOCK_LENGTH\n","/*! ut_metadata. MIT License. WebTorrent LLC */\nimport { EventEmitter } from 'events'\nimport bencode from 'bencode'\nimport BitField from 'bitfield'\nimport Debug from 'debug'\nimport { hash, arr2text, concat } from 'uint8-util'\n\nconst debug = Debug('ut_metadata')\n\nconst MAX_METADATA_SIZE = 1E7 // 10 MB\nconst BITFIELD_GROW = 1E3\nconst PIECE_LENGTH = 1 << 14 // 16 KiB\n\nexport default metadata => {\n class utMetadata extends EventEmitter {\n constructor (wire) {\n super()\n\n this._wire = wire\n\n this._fetching = false\n this._metadataComplete = false\n this._metadataSize = null\n // how many reject messages to tolerate before quitting\n this._remainingRejects = null\n\n // The largest torrent file that I know of is ~1-2MB, which is ~100\n // pieces. Therefore, cap the bitfield to 10x that (1000 pieces) so a\n // malicious peer can't make it grow to fill all memory.\n this._bitfield = new BitField(0, { grow: BITFIELD_GROW })\n\n if (ArrayBuffer.isView(metadata)) {\n this.setMetadata(metadata)\n }\n }\n\n onHandshake (infoHash, peerId, extensions) {\n this._infoHash = infoHash\n }\n\n onExtendedHandshake (handshake) {\n if (!handshake.m || !handshake.m.ut_metadata) {\n return this.emit('warning', new Error('Peer does not support ut_metadata'))\n }\n if (!handshake.metadata_size) {\n return this.emit('warning', new Error('Peer does not have metadata'))\n }\n if (typeof handshake.metadata_size !== 'number' ||\n MAX_METADATA_SIZE < handshake.metadata_size ||\n handshake.metadata_size <= 0) {\n return this.emit('warning', new Error('Peer gave invalid metadata size'))\n }\n\n this._metadataSize = handshake.metadata_size\n this._numPieces = Math.ceil(this._metadataSize / PIECE_LENGTH)\n this._remainingRejects = this._numPieces * 2\n\n this._requestPieces()\n }\n\n onMessage (buf) {\n let dict\n let trailer\n try {\n const str = arr2text(buf)\n const trailerIndex = str.indexOf('ee') + 2\n dict = bencode.decode(str.substring(0, trailerIndex))\n trailer = buf.slice(trailerIndex)\n } catch (err) {\n // drop invalid messages\n return\n }\n\n switch (dict.msg_type) {\n case 0:\n // ut_metadata request (from peer)\n // example: { 'msg_type': 0, 'piece': 0 }\n this._onRequest(dict.piece)\n break\n case 1:\n // ut_metadata data (in response to our request)\n // example: { 'msg_type': 1, 'piece': 0, 'total_size': 3425 }\n this._onData(dict.piece, trailer, dict.total_size)\n break\n case 2:\n // ut_metadata reject (peer doesn't have piece we requested)\n // { 'msg_type': 2, 'piece': 0 }\n this._onReject(dict.piece)\n break\n }\n }\n\n /**\n * Ask the peer to send metadata.\n * @public\n */\n fetch () {\n if (this._metadataComplete) {\n return\n }\n this._fetching = true\n if (this._metadataSize) {\n this._requestPieces()\n }\n }\n\n /**\n * Stop asking the peer to send metadata.\n * @public\n */\n cancel () {\n this._fetching = false\n }\n\n async setMetadata (metadata) {\n if (this._metadataComplete) return true\n debug('set metadata')\n\n // if full torrent dictionary was passed in, pull out just `info` key\n try {\n const info = bencode.decode(metadata).info\n if (info) {\n metadata = bencode.encode(info)\n }\n } catch (err) {}\n\n // check hash\n if (this._infoHash && this._infoHash !== await hash(metadata, 'hex')) {\n return false\n }\n\n this.cancel()\n\n this.metadata = metadata\n this._metadataComplete = true\n this._metadataSize = this.metadata.length\n this._wire.extendedHandshake.metadata_size = this._metadataSize\n\n this.emit('metadata', bencode.encode({\n info: bencode.decode(this.metadata)\n }))\n\n return true\n }\n\n _send (dict, trailer) {\n let buf = bencode.encode(dict)\n if (ArrayBuffer.isView(trailer)) {\n buf = concat([buf, trailer])\n }\n this._wire.extended('ut_metadata', buf)\n }\n\n _request (piece) {\n this._send({ msg_type: 0, piece })\n }\n\n _data (piece, buf, totalSize) {\n const msg = { msg_type: 1, piece }\n if (typeof totalSize === 'number') {\n msg.total_size = totalSize\n }\n this._send(msg, buf)\n }\n\n _reject (piece) {\n this._send({ msg_type: 2, piece })\n }\n\n _onRequest (piece) {\n if (!this._metadataComplete) {\n this._reject(piece)\n return\n }\n const start = piece * PIECE_LENGTH\n let end = start + PIECE_LENGTH\n if (end > this._metadataSize) {\n end = this._metadataSize\n }\n const buf = this.metadata.slice(start, end)\n this._data(piece, buf, this._metadataSize)\n }\n\n _onData (piece, buf, totalSize) {\n if (buf.length > PIECE_LENGTH || !this._fetching) {\n return\n }\n this.metadata.set(buf, piece * PIECE_LENGTH)\n this._bitfield.set(piece)\n this._checkDone()\n }\n\n _onReject (piece) {\n if (this._remainingRejects > 0 && this._fetching) {\n // If we haven't been rejected too much,\n // then try to request the piece again\n this._request(piece)\n this._remainingRejects -= 1\n } else {\n this.emit('warning', new Error('Peer sent \"reject\" too much'))\n }\n }\n\n _requestPieces () {\n if (!this._fetching) return\n this.metadata = new Uint8Array(this._metadataSize)\n for (let piece = 0; piece < this._numPieces; piece++) {\n this._request(piece)\n }\n }\n\n async _checkDone () {\n let done = true\n for (let piece = 0; piece < this._numPieces; piece++) {\n if (!this._bitfield.get(piece)) {\n done = false\n break\n }\n }\n if (!done) return\n\n // attempt to set metadata -- may fail sha1 check\n const success = await this.setMetadata(this.metadata)\n\n if (!success) {\n this._failedMetadata()\n }\n }\n\n _failedMetadata () {\n // reset bitfield & try again\n this._bitfield = new BitField(0, { grow: BITFIELD_GROW })\n this._remainingRejects -= this._numPieces\n if (this._remainingRejects > 0) {\n this._requestPieces()\n } else {\n this.emit('warning', new Error('Peer sent invalid metadata'))\n }\n }\n }\n\n // Name of the bittorrent-protocol extension\n utMetadata.prototype.name = 'ut_metadata'\n\n return utMetadata\n}\n","import debugFactory from 'debug'\nimport EventEmitter from 'events'\n\nconst debug = debugFactory('webtorrent:file-iterator')\n\n/**\n * Async iterator of a torrent file\n *\n * @param {File} file\n * @param {Object} opts\n * @param {number} opts.start iterator slice of file, starting from this byte (inclusive)\n * @param {number} opts.end iterator slice of file, ending with this byte (inclusive)\n */\nexport default class FileIterator extends EventEmitter {\n constructor (file, { start, end }) {\n super()\n\n this._torrent = file._torrent\n\n this._pieceLength = file._torrent.pieceLength\n\n this._startPiece = (start + file.offset) / this._pieceLength | 0\n this._endPiece = (end + file.offset) / this._pieceLength | 0\n\n this._piece = this._startPiece\n this._offset = (start + file.offset) - (this._startPiece * this._pieceLength)\n\n this._missing = end - start + 1\n this._criticalLength = Math.min((1024 * 1024 / this._pieceLength) | 0, 2)\n\n this._torrent._select(this._startPiece, this._endPiece, 1, null, true)\n this.destroyed = false\n }\n\n [Symbol.asyncIterator] () {\n return this\n }\n\n next () {\n return new Promise((resolve, reject) => {\n if (this._missing === 0 || this.destroyed) {\n resolve({ done: true })\n return this.destroy()\n }\n const pump = (index, opts) => {\n if (!this._torrent.bitfield.get(index)) {\n const listener = i => {\n if (i === index || this.destroyed) {\n this._torrent.removeListener('verified', listener)\n pump(index, opts)\n }\n }\n this._torrent.on('verified', listener)\n return this._torrent.critical(index, index + this._criticalLength)\n }\n\n if (this._torrent.destroyed) return reject(new Error('Torrent removed'))\n\n this._torrent.store.get(index, opts, (err, buffer) => {\n if (this.destroyed) return resolve({ done: true }) // prevent hanging\n debug('read %s and yielding (length %s) (err %s)', index, buffer?.length, err?.message)\n\n if (err) return reject(err)\n\n // prevent re-wrapping outside of promise\n resolve({ value: buffer, done: false })\n })\n }\n\n const length = Math.min(this._missing, this._pieceLength - this._offset)\n\n pump(this._piece++, { length, offset: this._offset })\n this._missing -= length\n this._offset = 0\n })\n }\n\n async return () {\n this.destroy()\n return { done: true }\n }\n\n async throw (err) {\n throw err\n }\n\n destroy (cb = () => {}, err) {\n if (this.destroyed) return\n this.destroyed = true\n if (!this._torrent.destroyed) {\n this._torrent._deselect(this._startPiece, this._endPiece, true)\n }\n this.emit('return')\n cb(err)\n }\n}\n","import EventEmitter from 'events'\nimport { Readable } from 'streamx'\nimport { chunkStoreRead } from 'chunk-store-iterator'\nimport mime from 'mime/lite.js'\nimport FileIterator from './file-iterator.js'\n\nexport default class File extends EventEmitter {\n constructor (torrent, file) {\n super()\n\n this._torrent = torrent\n this._destroyed = false\n this._fileStreams = new Set()\n this._iterators = new Set()\n\n this.name = file.name\n this.path = file.path\n this.length = file.length\n this.size = file.length\n this.type = mime.getType(this.name) || 'application/octet-stream'\n this.offset = file.offset\n\n this.done = false\n\n const start = file.offset\n const end = start + file.length - 1\n\n this._startPiece = start / this._torrent.pieceLength | 0\n this._endPiece = end / this._torrent.pieceLength | 0\n\n if (this.length === 0) {\n this.done = true\n this.emit('done')\n }\n\n this._client = torrent.client\n }\n\n get downloaded () {\n if (this._destroyed || !this._torrent.bitfield) return 0\n\n const { pieces, bitfield, pieceLength, lastPieceLength } = this._torrent\n const { _startPiece: start, _endPiece: end } = this\n\n const getPieceLength = (pieceIndex) => (\n pieceIndex === pieces.length - 1 ? lastPieceLength : pieceLength\n )\n\n const getPieceDownloaded = (pieceIndex) => {\n const len = pieceIndex === pieces.length - 1 ? lastPieceLength : pieceLength\n if (bitfield.get(pieceIndex)) {\n // verified data\n return len\n } else {\n // \"in progress\" data\n return len - pieces[pieceIndex].missing\n }\n }\n\n let downloaded = 0\n for (let index = start; index <= end; index += 1) {\n const pieceDownloaded = getPieceDownloaded(index)\n downloaded += pieceDownloaded\n\n if (index === start) {\n // First piece may have an offset, e.g. irrelevant bytes from the end of\n // the previous file\n const irrelevantFirstPieceBytes = this.offset % pieceLength\n downloaded -= Math.min(irrelevantFirstPieceBytes, pieceDownloaded)\n }\n\n if (index === end) {\n // Last piece may have an offset, e.g. irrelevant bytes from the start\n // of the next file\n const irrelevantLastPieceBytes = getPieceLength(end) - (this.offset + this.length) % pieceLength\n downloaded -= Math.min(irrelevantLastPieceBytes, pieceDownloaded)\n }\n }\n\n return downloaded\n }\n\n get progress () {\n return this.length ? this.downloaded / this.length : 0\n }\n\n select (priority) {\n if (this.length === 0) return\n this._torrent.select(this._startPiece, this._endPiece, priority)\n }\n\n deselect () {\n if (this.length === 0) return\n this._torrent.deselect(this._startPiece, this._endPiece)\n }\n\n [Symbol.asyncIterator] (opts = {}) {\n if (this.length === 0) return (async function * empty () {})()\n\n const { start = 0 } = opts ?? {}\n const end = (opts?.end && opts.end < this.length)\n ? opts.end\n : this.length - 1\n\n if (this.done) {\n return chunkStoreRead(this._torrent.store, { offset: start + this.offset, length: end - start + 1 })\n }\n\n const iterator = new FileIterator(this, { start, end })\n this._iterators.add(iterator)\n iterator.once('return', () => {\n this._iterators.delete(iterator)\n })\n\n return iterator\n }\n\n createReadStream (opts) {\n const iterator = this[Symbol.asyncIterator](opts)\n const fileStream = Readable.from(iterator)\n\n this._fileStreams.add(fileStream)\n fileStream.once('close', () => {\n this._fileStreams.delete(fileStream)\n })\n\n return fileStream\n }\n\n async arrayBuffer (opts = {}) {\n const { start = 0 } = opts\n const end = (opts?.end && opts.end < this.length)\n ? opts.end\n : this.length - 1\n\n const data = new Uint8Array(end - start + 1)\n let offset = 0\n for await (const chunk of this[Symbol.asyncIterator]({ start, end })) {\n data.set(chunk, offset)\n offset += chunk.length\n }\n return data.buffer\n }\n\n async blob (opts) {\n return new Blob([await this.arrayBuffer(opts)], { type: this.type })\n }\n\n stream (opts) {\n let iterator\n return new ReadableStream({\n start: () => {\n iterator = this[Symbol.asyncIterator](opts)\n },\n async pull (controller) {\n const { value, done } = await iterator.next()\n if (done) {\n controller.close()\n } else {\n controller.enqueue(value)\n }\n },\n cancel () {\n iterator.return()\n }\n })\n }\n\n get streamURL () {\n if (!this._client._server) throw new Error('No server created')\n return `${this._client._server.pathname}/${this._torrent.infoHash}/${this.path}`\n }\n\n streamTo (elem) {\n elem.src = this.streamURL\n return elem\n }\n\n includes (piece) {\n return this._startPiece <= piece && this._endPiece >= piece\n }\n\n _destroy () {\n this._destroyed = true\n this._torrent = null\n\n for (const fileStream of this._fileStreams) {\n fileStream.destroy()\n }\n this._fileStreams.clear()\n for (const iterator of this._iterators) {\n iterator.destroy()\n }\n this._iterators.clear()\n }\n}\n","/**\n * Mapping of torrent pieces to their respective availability in the torrent swarm. Used\n * by the torrent manager for implementing the rarest piece first selection strategy.\n */\nexport default class RarityMap {\n constructor (torrent) {\n this._torrent = torrent\n this._numPieces = torrent.pieces.length\n this._pieces = new Array(this._numPieces)\n\n this._onWire = wire => {\n this.recalculate()\n this._initWire(wire)\n }\n this._onWireHave = index => {\n this._pieces[index] += 1\n }\n this._onWireBitfield = () => {\n this.recalculate()\n }\n\n this._torrent.wires.forEach(wire => {\n this._initWire(wire)\n })\n this._torrent.on('wire', this._onWire)\n this.recalculate()\n }\n\n /**\n * Get the index of the rarest piece. Optionally, pass a filter function to exclude\n * certain pieces (for instance, those that we already have).\n *\n * @param {function} pieceFilterFunc\n * @return {number} index of rarest piece, or -1\n */\n getRarestPiece (pieceFilterFunc) {\n let candidates = []\n let min = Infinity\n\n for (let i = 0; i < this._numPieces; ++i) {\n if (pieceFilterFunc && !pieceFilterFunc(i)) continue\n\n const availability = this._pieces[i]\n if (availability === min) {\n candidates.push(i)\n } else if (availability < min) {\n candidates = [i]\n min = availability\n }\n }\n\n if (candidates.length) {\n // if there are multiple pieces with the same availability, choose one randomly\n return candidates[Math.random() * candidates.length | 0]\n } else {\n return -1\n }\n }\n\n destroy () {\n this._torrent.removeListener('wire', this._onWire)\n this._torrent.wires.forEach(wire => {\n this._cleanupWireEvents(wire)\n })\n this._torrent = null\n this._pieces = null\n\n this._onWire = null\n this._onWireHave = null\n this._onWireBitfield = null\n }\n\n _initWire (wire) {\n wire._onClose = () => {\n this._cleanupWireEvents(wire)\n for (let i = 0; i < this._numPieces; ++i) {\n this._pieces[i] -= wire.peerPieces.get(i)\n }\n }\n\n wire.on('have', this._onWireHave)\n wire.on('bitfield', this._onWireBitfield)\n wire.once('close', wire._onClose)\n }\n\n /**\n * Recalculates piece availability across all peers in the torrent.\n */\n recalculate () {\n this._pieces.fill(0)\n\n for (const wire of this._torrent.wires) {\n for (let i = 0; i < this._numPieces; ++i) {\n this._pieces[i] += wire.peerPieces.get(i)\n }\n }\n }\n\n _cleanupWireEvents (wire) {\n wire.removeListener('have', this._onWireHave)\n wire.removeListener('bitfield', this._onWireBitfield)\n if (wire._onClose) wire.removeListener('close', wire._onClose)\n wire._onClose = null\n }\n}\n","import BitField from 'bitfield'\nimport debugFactory from 'debug'\nimport fetch from 'cross-fetch-ponyfill'\nimport ltDontHave from 'lt_donthave'\nimport { hash, concat } from 'uint8-util'\nimport Wire from 'bittorrent-protocol'\nimport once from 'once'\n\nimport VERSION from '../version.cjs'\n\nconst debug = debugFactory('webtorrent:webconn')\n\nconst SOCKET_TIMEOUT = 60000\nconst RETRY_DELAY = 10000\n\n/**\n * Converts requests for torrent blocks into http range requests.\n * @param {string} url web seed url\n * @param {Object} torrent\n */\nexport default class WebConn extends Wire {\n constructor (url, torrent) {\n super()\n\n this.url = url\n this.connId = url // Unique id to deduplicate web seeds\n this._torrent = torrent\n\n this._init(url)\n }\n\n _init (url) {\n this.setKeepAlive(true)\n\n this.use(ltDontHave())\n\n this.once('handshake', async (infoHash, peerId) => {\n const hex = await hash(url, 'hex') // Used as the peerId for this fake remote peer\n if (this.destroyed) return\n this.handshake(infoHash, hex)\n\n const numPieces = this._torrent.pieces.length\n const bitfield = new BitField(numPieces)\n for (let i = 0; i <= numPieces; i++) {\n bitfield.set(i, true)\n }\n this.bitfield(bitfield)\n })\n\n this.once('interested', () => {\n debug('interested')\n this.unchoke()\n })\n\n this.on('uninterested', () => { debug('uninterested') })\n this.on('choke', () => { debug('choke') })\n this.on('unchoke', () => { debug('unchoke') })\n this.on('bitfield', () => { debug('bitfield') })\n this.lt_donthave.on('donthave', () => { debug('donthave') })\n\n this.on('request', (pieceIndex, offset, length, callback) => {\n debug('request pieceIndex=%d offset=%d length=%d', pieceIndex, offset, length)\n this.httpRequest(pieceIndex, offset, length, (err, data) => {\n if (err) {\n // Cancel all in progress requests for this piece\n this.lt_donthave.donthave(pieceIndex)\n\n // Wait a little while before saying the webseed has the failed piece again\n const retryTimeout = setTimeout(() => {\n if (this.destroyed) return\n\n this.have(pieceIndex)\n }, RETRY_DELAY)\n if (retryTimeout.unref) retryTimeout.unref()\n }\n\n callback(err, data)\n })\n })\n }\n\n async httpRequest (pieceIndex, offset, length, cb) {\n cb = once(cb)\n const pieceOffset = pieceIndex * this._torrent.pieceLength\n const rangeStart = pieceOffset + offset /* offset within whole torrent */\n const rangeEnd = rangeStart + length - 1\n\n // Web seed URL format:\n // For single-file torrents, make HTTP range requests directly to the web seed URL\n // For multi-file torrents, add the torrent folder and file name to the URL\n const files = this._torrent.files\n let requests\n if (files.length <= 1) {\n requests = [{\n url: this.url,\n start: rangeStart,\n end: rangeEnd\n }]\n } else {\n const requestedFiles = files.filter(file => file.offset <= rangeEnd && (file.offset + file.length) > rangeStart)\n if (requestedFiles.length < 1) {\n return cb(new Error('Could not find file corresponding to web seed range request'))\n }\n\n requests = requestedFiles.map(requestedFile => {\n const fileEnd = requestedFile.offset + requestedFile.length - 1\n const url = this.url +\n (this.url[this.url.length - 1] === '/' ? '' : '/') +\n requestedFile.path.replace(this._torrent.path, '')\n return {\n url,\n fileOffsetInRange: Math.max(requestedFile.offset - rangeStart, 0),\n start: Math.max(rangeStart - requestedFile.offset, 0),\n end: Math.min(fileEnd, rangeEnd - requestedFile.offset)\n }\n })\n }\n let chunks\n try {\n chunks = await Promise.all(requests.map(async ({ start, end, url }) => {\n debug(\n 'Requesting url=%s pieceIndex=%d offset=%d length=%d start=%d end=%d',\n url, pieceIndex, offset, length, start, end\n )\n const res = await fetch(url, {\n cache: 'no-store',\n method: 'GET',\n headers: {\n 'Cache-Control': 'no-store',\n 'user-agent': `WebTorrent/${VERSION} (https://webtorrent.io)`,\n range: `bytes=${start}-${end}`\n },\n signal: AbortSignal.timeout(SOCKET_TIMEOUT)\n })\n if (!res.ok) throw new Error(`Unexpected HTTP status code ${res.status}`)\n const data = new Uint8Array(await res.arrayBuffer())\n\n debug('Got data of length %d', data.length)\n\n return data\n }))\n } catch (e) {\n return cb(e)\n }\n\n cb(null, concat(chunks))\n }\n\n destroy () {\n super.destroy()\n this._torrent = null\n }\n}\n","/**\n * @typedef {Object} MinimalSelectionItem\n * @property {number} from\n * @property {number} to\n */\n\n/** A selection of pieces to download.\n * @typedef {MinimalSelectionItem & {\n * offset: number,\n * priority: number,\n * notify?: function\n * isStreamSelection?: boolean\n * }} SelectionItem\n */\n\n/**\n * @typedef {MinimalSelectionItem & {notify: function}} NotificationItem\n */\n\nexport class Selections {\n /** @type {Array} */\n _items = []\n\n /**\n * @param {MinimalSelectionItem & {isStreamSelection?: boolean}} item Interval to be removed from the selection\n */\n remove (item) {\n for (let i = 0; i < this._items.length; i++) {\n const existing = this._items[i]\n if (existing.isStreamSelection) {\n if (item.isStreamSelection) {\n // If both are stream selections and they match, then we remove the first matching item, then we break the loop\n if (existing.from === item.from && existing.to === item.to) {\n this._items.splice(i, 1)\n // for stream selections, we only remove one item at a time\n // ergo we break the loop after removing the first matching item\n break\n }\n } else {\n // we only remove stream selections when the `isStreamSelection` flag is true and they match\n continue\n }\n } else {\n if (isLowerIntersecting(item, existing)) {\n existing.to = Math.max(item.from - 1, 0)\n } else if (isUpperIntersecting(item, existing)) {\n existing.from = item.to + 1\n } else if (isInsideExisting(item, existing)) {\n const replacingItems = []\n const existingStart = { ...existing, to: Math.max(item.from - 1, 0) }\n if (existingStart.to - existingStart.from >= 0 && item.from !== 0) replacingItems.push(existingStart)\n const existingEnd = { ...existing, from: item.to + 1 }\n if (existingEnd.to - existingEnd.from >= 0) replacingItems.push(existingEnd)\n this._items.splice(i, 1, ...replacingItems)\n i = i - 1 + replacingItems.length // decrement i to offset splice\n } else if (isCoveringExisting(item, existing)) {\n this._items.splice(i, 1)\n i--\n }\n }\n }\n }\n\n /**\n * @param {SelectionItem & NotificationItem} newItem\n */\n insert (newItem) {\n if (newItem.from > newItem.to) {\n throw new Error('Invalid interval')\n }\n if (!newItem.isStreamSelection) {\n const { notify: oldNotify } = newItem\n // Merge notifications of intersecting items into the new item's notify function\n const intersectingNotifyFunctions = []\n for (const existing of this._items) {\n if (existing.notify && isIntersecting(newItem, existing)) {\n intersectingNotifyFunctions.push(existing.notify)\n }\n }\n if (intersectingNotifyFunctions.length > 0) {\n newItem.notify = () => {\n intersectingNotifyFunctions.forEach(fn => fn())\n oldNotify?.()\n }\n }\n // Remove or truncate intersecting items to make room for the new item\n this.remove(newItem)\n }\n this._items.push(newItem)\n }\n\n /** @param {(a: SelectionItem, b: SelectionItem) => number} sortFn */\n sort (sortFn = (a, b) => a.from - b.from) {\n this._items.sort(sortFn)\n }\n\n get length () {\n return this._items.length\n }\n\n /** @param {number} index */\n get (index) {\n return this._items[index]\n }\n\n swap (i, j) {\n const temp = this._items[i]\n this._items[i] = this._items[j]\n this._items[j] = temp\n }\n\n clear () {\n this._items.length = 0\n }\n\n /** @returns {Generator void, replaceWith: (MinimalSelectionItem[]) => void}>} */\n * [Symbol.iterator] () {\n for (let i = 0; i < this._items.length; i++) {\n const item = this._items[i]\n\n item.remove = () => {\n this._items.splice(i, 1)\n i--\n }\n yield item\n delete item.remove\n }\n }\n}\n\n/**\n * Examples:\n * existing: 1-10 | 1-10\n * new_item: 8-12 | 10-15\n * @param {MinimalSelectionItem} newItem\n * @param {MinimalSelectionItem} existing\n * @returns {boolean} returns true if the new item's lower end is intersecting with the existing item\n */\nexport function isLowerIntersecting (newItem, existing) {\n return (newItem.from <= existing.to) && (newItem.from > existing.from) && (newItem.to > existing.to)\n}\n\n/**\n * Examples:\n * existing: 20-25 | 20-25\n * new_item: 15-22 | 15-20\n * @param {MinimalSelectionItem} newItem\n * @param {MinimalSelectionItem} existing\n * @returns {boolean} returns true if the new item's upper end is intersecting with the existing item\n */\nexport function isUpperIntersecting (newItem, existing) {\n return (newItem.to >= existing.from) && (newItem.to < existing.to) && (newItem.from < existing.from)\n}\n\n/**\n * Examples:\n * existing: 10-20 | 10-20 | 10-20\n * new_item: 12-15 | 20-20 | 15-20\n * @param {MinimalSelectionItem} newItem\n * @param {MinimalSelectionItem} existing\n * @returns {boolean} returns true if the new item is completely inside the existing item\n */\nexport function isInsideExisting (newItem, existing) {\n const existingIntervalSize = existing.to - existing.from\n const newItemIntervalSize = newItem.to - newItem.from\n return newItem.from >= existing.from && newItem.to <= existing.to && (newItemIntervalSize < existingIntervalSize)\n}\n\n/**\n * Examples:\n * existing: 10-20 | 10-20 | 10-20\n * new_item: 10-21 | 09-20 | 10-20\n * @param {MinimalSelectionItem} newItem\n * @param {MinimalSelectionItem} existing\n * @returns {boolean} returns true if the new item is covering the existing item\n */\nexport function isCoveringExisting (newItem, existing) {\n return newItem.from <= existing.from && newItem.to >= existing.to\n}\n\nexport const isIntersecting = (newItem, existing) => () =>\n isLowerIntersecting(newItem, existing) ||\n isUpperIntersecting(newItem, existing) ||\n isInsideExisting(newItem, existing) ||\n isCoveringExisting(newItem, existing)\n","import EventEmitter from 'events'\nimport fs from 'fs'\nimport net from 'net' // browser exclude\nimport os from 'os' // browser exclude\nimport path from 'path'\nimport addrToIPPort from 'addr-to-ip-port'\nimport BitField from 'bitfield'\nimport CacheChunkStore from 'cache-chunk-store'\nimport { chunkStoreWrite } from 'chunk-store-iterator'\nimport cpus from 'cpus'\nimport debugFactory from 'debug'\nimport Discovery from 'torrent-discovery'\nimport FSChunkStore from 'fs-chunk-store' // browser: `fsa-chunk-store`\nimport fetch from 'cross-fetch-ponyfill'\nimport ImmediateChunkStore from 'immediate-chunk-store'\nimport ltDontHave from 'lt_donthave'\nimport MemoryChunkStore from 'memory-chunk-store'\nimport joinIterator from 'join-async-iterator'\nimport parallel from 'run-parallel'\nimport parallelLimit from 'run-parallel-limit'\nimport parseTorrent, { toMagnetURI, toTorrentFile, remote } from 'parse-torrent'\nimport Piece from 'torrent-piece'\nimport queueMicrotask from 'queue-microtask'\nimport randomIterate from 'random-iterate'\nimport { hash, arr2hex } from 'uint8-util'\nimport throughput from 'throughput'\nimport utMetadata from 'ut_metadata'\nimport utPex from 'ut_pex' // browser exclude\n\nimport File from './file.js'\nimport Peer from './peer.js'\nimport RarityMap from './rarity-map.js'\nimport utp from './utp.cjs' // browser exclude\nimport WebConn from './webconn.js'\nimport { Selections } from './selections.js'\n\nimport VERSION from '../version.cjs'\n\nconst debug = debugFactory('webtorrent:torrent')\nconst MAX_BLOCK_LENGTH = 128 * 1024\nconst PIECE_TIMEOUT = 30_000\nconst CHOKE_TIMEOUT = 5_000\nconst SPEED_THRESHOLD = 3 * Piece.BLOCK_LENGTH\n\nconst PIPELINE_MIN_DURATION = 0.5\nconst PIPELINE_MAX_DURATION = 1\n\nconst RECHOKE_INTERVAL = 10_000 // 10 seconds\nconst RECHOKE_OPTIMISTIC_DURATION = 2 // 30 seconds\n\nconst DEFAULT_NO_PEERS_INTERVAL = 30_000 // 30 seconds\n\n// IndexedDB chunk stores used in the browser benefit from high concurrency\nconst FILESYSTEM_CONCURRENCY = process.browser ? cpus().length : 2\n\nconst RECONNECT_WAIT = [1_000, 5_000, 15_000]\n\nconst USER_AGENT = `WebTorrent/${VERSION} (https://webtorrent.io)`\n\n// if nodejs or browser that supports FSA\nconst SUPPORTS_FSA = globalThis.navigator?.storage?.getDirectory && globalThis.FileSystemFileHandle?.prototype?.createWritable\nconst FALLBACK_STORE = !process.browser || SUPPORTS_FSA\n ? FSChunkStore // Node or browser with FSA\n : MemoryChunkStore\n\nlet TMP\ntry {\n TMP = path.join(fs.statSync('/tmp') && '/tmp', 'webtorrent')\n} catch (err) {\n TMP = path.join(typeof os.tmpdir === 'function' ? os.tmpdir() : '/', 'webtorrent')\n}\n\nconst IDLE_CALLBACK = typeof window !== 'undefined' && typeof window.requestIdleCallback === 'function' && window.requestIdleCallback\n\nexport default class Torrent extends EventEmitter {\n constructor (torrentId, client, opts) {\n super()\n\n this._debugId = 'unknown infohash'\n this.client = client\n\n this.announce = opts.announce\n this.urlList = opts.urlList\n\n this.path = opts.path || TMP\n this.addUID = opts.addUID || false\n this.rootDir = opts.rootDir || null\n this.skipVerify = !!opts.skipVerify\n this._store = opts.store || FALLBACK_STORE\n this._preloadedStore = opts.preloadedStore || null\n this._storeCacheSlots = opts.storeCacheSlots !== undefined ? opts.storeCacheSlots : 20\n this._destroyStoreOnDestroy = opts.destroyStoreOnDestroy || false\n this.store = null\n this.storeOpts = opts.storeOpts\n this.alwaysChokeSeeders = opts.alwaysChokeSeeders ?? true\n\n this._getAnnounceOpts = opts.getAnnounceOpts\n\n // if defined, `opts.private` overrides default privacy of torrent\n if (typeof opts.private === 'boolean') this.private = opts.private\n\n this.strategy = opts.strategy || 'sequential'\n\n this.maxWebConns = opts.maxWebConns || 4\n\n this._rechokeNumSlots = (opts.uploads === false || opts.uploads === 0)\n ? 0\n : (+opts.uploads || 10)\n this._rechokeOptimisticWire = null\n this._rechokeOptimisticTime = 0\n this._rechokeIntervalId = null\n this._noPeersIntervalId = null\n this._noPeersIntervalTime = opts.noPeersIntervalTime ? opts.noPeersIntervalTime * 1000 : DEFAULT_NO_PEERS_INTERVAL\n this._startAsDeselected = opts.deselect || false\n\n this.ready = false\n this.destroyed = false\n this.paused = opts.paused || false\n this.done = false\n\n this.metadata = null\n this.files = []\n\n // Pieces that need to be downloaded, indexed by piece index\n this.pieces = []\n\n this._amInterested = false\n this._selections = new Selections()\n this._critical = []\n\n this.wires = [] // open wires (added *after* handshake)\n\n this._queue = [] // queue of outgoing tcp peers to connect to\n this._peers = {} // connected peers (addr/peerId -> Peer)\n this._peersLength = 0 // number of elements in `this._peers` (cache, for perf)\n\n // stats\n this.received = 0\n this.uploaded = 0\n this._downloadSpeed = throughput()\n this._uploadSpeed = throughput()\n\n // for cleanup\n this._servers = []\n this._xsRequests = []\n\n // TODO: remove this and expose a hook instead\n // optimization: don't recheck every file if it hasn't changed\n this._fileModtimes = opts.fileModtimes\n\n if (torrentId !== null) this._onTorrentId(torrentId)\n\n this._debug('new torrent')\n }\n\n get timeRemaining () {\n if (this.done) return 0\n if (this.downloadSpeed === 0) return Infinity\n return ((this.length - this.downloaded) / this.downloadSpeed) * 1000\n }\n\n get downloaded () {\n if (!this.bitfield) return 0\n let downloaded = 0\n for (let index = 0, len = this.pieces.length; index < len; ++index) {\n if (this.bitfield.get(index)) { // verified data\n downloaded += (index === len - 1) ? this.lastPieceLength : this.pieceLength\n } else { // \"in progress\" data\n const piece = this.pieces[index]\n downloaded += (piece.length - piece.missing)\n }\n }\n return downloaded\n }\n\n // TODO: re-enable this. The number of missing pieces. Used to implement 'end game' mode.\n // Object.defineProperty(Storage.prototype, 'numMissing', {\n // get: function () {\n // var self = this\n // var numMissing = self.pieces.length\n // for (var index = 0, len = self.pieces.length; index < len; index++) {\n // numMissing -= self.bitfield.get(index)\n // }\n // return numMissing\n // }\n // })\n\n get downloadSpeed () { return this._downloadSpeed() }\n\n get uploadSpeed () { return this._uploadSpeed() }\n\n get progress () { return this.length ? this.downloaded / this.length : 0 }\n\n get ratio () { return this.uploaded / (this.received || this.length) }\n\n get numPeers () { return this.wires.length }\n\n get torrentFileBlob () {\n if (!this.torrentFile) return null\n return new Blob([this.torrentFile], { type: 'application/x-bittorrent' })\n }\n\n get _numQueued () {\n return this._queue.length + (this._peersLength - this._numConns)\n }\n\n get _numConns () {\n let numConns = 0\n for (const id in this._peers) {\n if (this._peers[id].connected) numConns += 1\n }\n return numConns\n }\n\n async _onTorrentId (torrentId) {\n if (this.destroyed) return\n\n let parsedTorrent\n try { parsedTorrent = await parseTorrent(torrentId) } catch (err) {}\n if (parsedTorrent) {\n // Attempt to set infoHash property synchronously\n this.infoHash = parsedTorrent.infoHash\n this._debugId = arr2hex(parsedTorrent.infoHash).substring(0, 7)\n queueMicrotask(() => {\n if (this.destroyed) return\n this._onParsedTorrent(parsedTorrent)\n })\n } else {\n // If torrentId failed to parse, it could be in a form that requires an async\n // operation, i.e. http/https link, filesystem path, or Blob.\n remote(torrentId, (err, parsedTorrent) => {\n if (this.destroyed) return\n if (err) return this._destroy(err)\n this._onParsedTorrent(parsedTorrent)\n })\n }\n }\n\n _onParsedTorrent (parsedTorrent) {\n if (this.destroyed) return\n\n this._processParsedTorrent(parsedTorrent)\n\n if (!this.infoHash) {\n return this._destroy(new Error('Malformed torrent data: No info hash'))\n }\n\n this._rechokeIntervalId = setInterval(() => {\n this._rechoke()\n }, RECHOKE_INTERVAL)\n if (this._rechokeIntervalId.unref) this._rechokeIntervalId.unref()\n\n // Private 'infoHash' event allows client.add to check for duplicate torrents and\n // destroy them before the normal 'infoHash' event is emitted. Prevents user\n // applications from needing to deal with duplicate 'infoHash' events.\n this.emit('_infoHash', this.infoHash)\n if (this.destroyed) return\n\n this.emit('infoHash', this.infoHash)\n if (this.destroyed) return // user might destroy torrent in event handler\n\n if (this.client.listening) {\n this._onListening()\n } else {\n this.client.once('listening', () => {\n this._onListening()\n })\n }\n }\n\n _processParsedTorrent (parsedTorrent) {\n this._debugId = arr2hex(parsedTorrent.infoHash).substring(0, 7)\n\n if (typeof this.private !== 'undefined') {\n // `private` option overrides default, only if it's defined\n parsedTorrent.private = this.private\n }\n\n if (Array.isArray(this.announce)) {\n // Allow specifying trackers via `opts` parameter\n parsedTorrent.announce = parsedTorrent.announce.concat(this.announce)\n }\n\n if (this.client.tracker && Array.isArray(this.client.tracker.announce) && !parsedTorrent.private) {\n // If the client has a default tracker, add it to the announce list if torrent is not private\n parsedTorrent.announce = parsedTorrent.announce.concat(this.client.tracker.announce)\n }\n\n if (this.client.tracker && global.WEBTORRENT_ANNOUNCE && !parsedTorrent.private) {\n // So `webtorrent-hybrid` can force specific trackers to be used\n parsedTorrent.announce = parsedTorrent.announce.concat(global.WEBTORRENT_ANNOUNCE)\n }\n\n if (this.urlList) {\n // Allow specifying web seeds via `opts` parameter\n parsedTorrent.urlList = parsedTorrent.urlList.concat(this.urlList)\n }\n\n // remove duplicates by converting to Set and back\n parsedTorrent.announce = Array.from(new Set(parsedTorrent.announce))\n parsedTorrent.urlList = Array.from(new Set(parsedTorrent.urlList))\n\n Object.assign(this, parsedTorrent)\n\n this.magnetURI = toMagnetURI(parsedTorrent)\n this.torrentFile = toTorrentFile(parsedTorrent)\n }\n\n _onListening () {\n if (this.destroyed) return\n\n if (this.info) {\n // if full metadata was included in initial torrent id, use it immediately. Otherwise,\n // wait for torrent-discovery to find peers and ut_metadata to get the metadata.\n this._onMetadata(this)\n } else {\n if (this.xs) this._getMetadataFromServer()\n this._startDiscovery()\n }\n }\n\n _startDiscovery () {\n if (this.discovery || this.destroyed) return\n\n let trackerOpts = this.client.tracker\n if (trackerOpts) {\n trackerOpts = Object.assign({}, this.client.tracker, {\n getAnnounceOpts: () => {\n if (this.destroyed) return\n\n const opts = {\n uploaded: this.uploaded,\n downloaded: this.downloaded,\n left: Math.max(this.length - this.downloaded, 0)\n }\n if (this.client.tracker.getAnnounceOpts) {\n Object.assign(opts, this.client.tracker.getAnnounceOpts())\n }\n if (this._getAnnounceOpts) {\n // TODO: consider deprecating this, as it's redundant with the former case\n Object.assign(opts, this._getAnnounceOpts())\n }\n return opts\n }\n })\n }\n\n // add BEP09 peer-address\n if (this.peerAddresses) {\n this.peerAddresses.forEach(peer => this.addPeer(peer, Peer.SOURCE_MANUAL))\n }\n\n // begin discovering peers via DHT and trackers\n this.discovery = new Discovery({\n infoHash: this.infoHash,\n announce: this.announce,\n peerId: this.client.peerId,\n dht: !this.private && this.client.dht,\n tracker: trackerOpts,\n port: this.client.torrentPort,\n userAgent: USER_AGENT,\n lsd: this.client.lsd\n })\n\n this.discovery.on('error', (err) => {\n this._destroy(err)\n })\n\n this.discovery.on('peer', (peer, source) => {\n this._debug('peer %s discovered via %s', peer, source)\n // Don't create new outgoing connections when torrent is done and seedOutgoingConnections is false.\n if (!this.client.seedOutgoingConnections && this.done) {\n this._debug('ignoring peer %s: torrent is done and seedOutgoingConnections is false', peer)\n return\n }\n this.addPeer(peer, source)\n })\n\n this.discovery.on('trackerAnnounce', () => {\n this.emit('trackerAnnounce')\n })\n\n this.discovery.on('dhtAnnounce', () => {\n this.emit('dhtAnnounce')\n })\n\n this.discovery.on('warning', (err) => {\n this.emit('warning', err)\n })\n\n this._noPeersIntervalId = setInterval(() => {\n if (this.destroyed) return\n\n const counters = {\n [Peer.SOURCE_TRACKER]: {\n enabled: !!this.client.tracker,\n numPeers: 0\n },\n [Peer.SOURCE_DHT]: {\n enabled: !!this.client.dht,\n numPeers: 0\n },\n [Peer.SOURCE_LSD]: {\n enabled: !!this.client.lsd,\n numPeers: 0\n },\n [Peer.SOURCE_UT_PEX]: {\n enabled: (this.client.utPex && typeof utPex === 'function'),\n numPeers: 0\n }\n }\n for (const peer of Object.values(this._peers)) {\n const counter = counters[peer.source]\n if (typeof counter !== 'undefined') counter.numPeers++\n }\n for (const source of Object.keys(counters)) {\n const counter = counters[source]\n if (counter.enabled && counter.numPeers === 0) this.emit('noPeers', source)\n }\n }, this._noPeersIntervalTime)\n if (this._noPeersIntervalId.unref) this._noPeersIntervalId.unref()\n }\n\n _getMetadataFromServer () {\n // to allow function hoisting\n const self = this\n\n const urls = Array.isArray(this.xs) ? this.xs : [this.xs]\n\n self._xsRequestsController = new AbortController()\n\n const signal = self._xsRequestsController.signal\n\n const tasks = urls.map(url => cb => {\n getMetadataFromURL(url, cb)\n })\n parallel(tasks)\n\n async function getMetadataFromURL (url, cb) {\n if (url.indexOf('http://') !== 0 && url.indexOf('https://') !== 0) {\n self.emit('warning', new Error(`skipping non-http xs param: ${url}`))\n return cb(null)\n }\n\n const opts = {\n method: 'GET',\n headers: {\n 'user-agent': USER_AGENT\n },\n signal\n }\n let res\n try {\n res = await fetch(url, opts)\n } catch (err) {\n self.emit('warning', new Error(`http error from xs param: ${url}`))\n return cb(null)\n }\n\n if (self.destroyed) return cb(null)\n if (self.metadata) return cb(null)\n\n if (res.status !== 200) {\n self.emit('warning', new Error(`non-200 status code ${res.status} from xs param: ${url}`))\n return cb(null)\n }\n let torrent\n try {\n torrent = new Uint8Array(await res.arrayBuffer())\n } catch (e) {\n self.emit('warning', e)\n return cb(null)\n }\n\n let parsedTorrent\n try {\n parsedTorrent = await parseTorrent(torrent)\n } catch (err) {}\n\n if (!parsedTorrent) {\n self.emit('warning', new Error(`got invalid torrent file from xs param: ${url}`))\n return cb(null)\n }\n\n if (parsedTorrent.infoHash !== self.infoHash) {\n self.emit('warning', new Error(`got torrent file with incorrect info hash from xs param: ${url}`))\n return cb(null)\n }\n self._onMetadata(parsedTorrent)\n cb(null)\n }\n }\n\n /**\n * Called when the full torrent metadata is received.\n */\n async _onMetadata (metadata) {\n if (this.metadata || this.destroyed) return\n this._debug('got metadata')\n\n this._xsRequestsController?.abort()\n this._xsRequestsController = null\n\n let parsedTorrent\n if (metadata && metadata.infoHash) {\n // `metadata` is a parsed torrent (from parse-torrent module)\n parsedTorrent = metadata\n } else {\n try {\n parsedTorrent = await parseTorrent(metadata)\n } catch (err) {\n return this._destroy(err)\n }\n }\n\n this._processParsedTorrent(parsedTorrent)\n this.metadata = this.torrentFile\n\n // add web seed urls (BEP19)\n if (this.client.enableWebSeeds) {\n this.urlList.forEach(url => {\n this.addWebSeed(url)\n })\n }\n\n this._rarityMap = new RarityMap(this)\n\n this.files = this.files.map(file => new File(this, file))\n\n let rawStore = this._preloadedStore\n if (!rawStore) {\n rawStore = new this._store(this.pieceLength, {\n ...this.storeOpts,\n torrent: this,\n path: this.path,\n files: this.files,\n length: this.length,\n name: this.name + ' - ' + this.infoHash.slice(0, 8),\n addUID: this.addUID,\n rootDir: this.rootDir,\n max: this._storeCacheSlots\n })\n }\n\n // don't use the cache if the store is already in memory\n if (this._storeCacheSlots > 0 && !(rawStore instanceof MemoryChunkStore)) {\n rawStore = new CacheChunkStore(rawStore, {\n max: this._storeCacheSlots\n })\n }\n\n this.store = new ImmediateChunkStore(\n rawStore\n )\n\n // Select only specified files (BEP53) http://www.bittorrent.org/beps/bep_0053.html\n if (this.so && !this._startAsDeselected) {\n this.files.forEach((v, i) => {\n if (this.so.includes(i)) {\n this.files[i].select()\n }\n })\n } else {\n // start off selecting the entire torrent with low priority\n if (this.pieces.length !== 0 && !this._startAsDeselected) {\n this.select(0, this.pieces.length - 1, 0)\n }\n }\n\n this._hashes = this.pieces\n\n this.pieces = this.pieces.map((hash, i) => {\n const pieceLength = (i === this.pieces.length - 1)\n ? this.lastPieceLength\n : this.pieceLength\n return new Piece(pieceLength)\n })\n\n this._reservations = this.pieces.map(() => [])\n\n this.bitfield = new BitField(this.pieces.length)\n\n // Emit 'metadata' before 'ready' and 'done'\n this.emit('metadata')\n\n // User might destroy torrent in response to 'metadata' event\n if (this.destroyed) return\n\n if (this.skipVerify) {\n // Skip verifying exisitng data and just assume it's correct\n this._markAllVerified()\n this._onStore()\n } else {\n const onPiecesVerified = (err) => {\n if (err) return this._destroy(err)\n this._debug('done verifying')\n this._onStore()\n }\n\n this._debug('verifying existing torrent data')\n if (this._fileModtimes && this._store === FSChunkStore) {\n // don't verify if the files haven't been modified since we last checked\n this.getFileModtimes((err, fileModtimes) => {\n if (err) return this._destroy(err)\n\n const unchanged = this.files.map((_, index) => fileModtimes[index] === this._fileModtimes[index]).every(x => x)\n\n if (unchanged) {\n this._markAllVerified()\n this._onStore()\n } else {\n this._verifyPieces(onPiecesVerified)\n }\n })\n } else {\n this._verifyPieces(onPiecesVerified)\n }\n }\n }\n\n /*\n * TODO: remove this\n * Gets the last modified time of every file on disk for this torrent.\n * Only valid in Node, not in the browser.\n */\n getFileModtimes (cb) {\n const ret = []\n parallelLimit(this.files.map((file, index) => cb => {\n const filePath = this.addUID ? path.join(this.name + ' - ' + this.infoHash.slice(0, 8)) : path.join(this.path, file.path)\n fs.stat(filePath, (err, stat) => {\n if (err && err.code !== 'ENOENT') return cb(err)\n ret[index] = stat && stat.mtime.getTime()\n cb(null)\n })\n }), FILESYSTEM_CONCURRENCY, err => {\n this._debug('done getting file modtimes')\n cb(err, ret)\n })\n }\n\n _verifyPieces (cb) {\n parallelLimit(this.pieces.map((piece, index) => cb => {\n if (this.destroyed) return cb(new Error('torrent is destroyed'))\n\n const getOpts = {}\n // Specify length for the last piece in case it is zero-padded\n if (index === this.pieces.length - 1) {\n getOpts.length = this.lastPieceLength\n }\n this.store.get(index, getOpts, async (err, buf) => {\n if (this.destroyed) return cb(new Error('torrent is destroyed'))\n\n if (err) return queueMicrotask(() => cb(null)) // ignore error\n\n const hex = await hash(buf, 'hex')\n if (this.destroyed) return cb(new Error('torrent is destroyed'))\n\n if (hex === this._hashes[index]) {\n this._debug('piece verified %s', index)\n this._markVerified(index)\n } else {\n this._markUnverified(index)\n this._debug('piece invalid %s', index)\n }\n cb(null)\n })\n }), FILESYSTEM_CONCURRENCY, cb)\n }\n\n rescanFiles (cb) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n if (!cb) cb = noop\n\n this._verifyPieces((err) => {\n if (err) {\n this._destroy(err)\n return cb(err)\n }\n\n this._checkDone()\n cb(null)\n })\n }\n\n _markAllVerified () {\n for (let index = 0; index < this.pieces.length; index++) {\n this._markVerified(index)\n }\n }\n\n _markVerified (index) {\n this.pieces[index] = null\n this._reservations[index] = null\n this.bitfield.set(index, true)\n this.emit('verified', index)\n }\n\n _markUnverified (index) {\n const len = (index === this.pieces.length - 1)\n ? this.lastPieceLength\n : this.pieceLength\n this.pieces[index] = new Piece(len)\n this.bitfield.set(index, false)\n if (!this._startAsDeselected) this.select(index, index, 1)\n this.files.forEach(file => {\n if (file.done && file.includes(index)) file.done = false\n })\n }\n\n _hasAllPieces () {\n for (let index = 0; index < this.pieces.length; index++) {\n if (!this.bitfield.get(index)) return false\n }\n return true\n }\n\n _hasNoPieces () {\n return !this._hasMorePieces(0)\n }\n\n _hasMorePieces (threshold) {\n let count = 0\n for (let index = 0; index < this.pieces.length; index++) {\n if (this.bitfield.get(index)) {\n count += 1\n if (count > threshold) return true\n }\n }\n return false\n }\n\n /**\n * Called when the metadata, listening server, and underlying chunk store is initialized.\n */\n _onStore () {\n if (this.destroyed) return\n this._debug('on store')\n\n // Start discovery before emitting 'ready'\n this._startDiscovery()\n\n this.ready = true\n this.emit('ready')\n\n // Files may start out done if the file was already in the store\n this._checkDone()\n\n // In case any selections were made before torrent was ready\n this._updateSelections()\n\n // Start requesting pieces after we have initially verified them\n this.wires.forEach(wire => {\n // If we didn't have the metadata at the time ut_metadata was initialized for this\n // wire, we still want to make it available to the peer in case they request it.\n if (wire.ut_metadata) wire.ut_metadata.setMetadata(this.metadata)\n\n this._onWireWithMetadata(wire)\n })\n }\n\n destroy (opts, cb) {\n if (typeof opts === 'function') return this.destroy(null, opts)\n\n this._destroy(null, opts, cb)\n }\n\n _destroy (err, opts, cb) {\n if (typeof opts === 'function') return this._destroy(err, null, opts)\n if (this.destroyed) return\n this.destroyed = true\n this._debug('destroy')\n\n this.client._remove(this)\n\n this._selections.clear()\n\n clearInterval(this._rechokeIntervalId)\n\n clearInterval(this._noPeersIntervalId)\n\n this._xsRequestsController?.abort()\n\n if (this._rarityMap) {\n this._rarityMap.destroy()\n }\n\n for (const id in this._peers) {\n this.removePeer(id)\n }\n\n this.files.forEach(file => {\n if (file instanceof File) file._destroy()\n })\n\n const tasks = this._servers.map(server => cb => {\n server.destroy(cb)\n })\n\n if (this.discovery) {\n tasks.push(cb => {\n this.discovery.destroy(cb)\n })\n }\n\n if (this.store) {\n let destroyStore = this._destroyStoreOnDestroy\n if (opts && opts.destroyStore !== undefined) {\n destroyStore = opts.destroyStore\n }\n tasks.push(cb => {\n if (destroyStore) {\n this.store.destroy(cb)\n } else {\n this.store.close(cb)\n }\n })\n }\n\n parallel(tasks, cb)\n\n if (err) {\n // Torrent errors are emitted at `torrent.on('error')`. If there are no 'error'\n // event handlers on the torrent instance, then the error will be emitted at\n // `client.on('error')`. This prevents throwing an uncaught exception\n // (unhandled 'error' event), but it makes it impossible to distinguish client\n // errors versus torrent errors. Torrent errors are not fatal, and the client\n // is still usable afterwards. Therefore, always listen for errors in both\n // places (`client.on('error')` and `torrent.on('error')`).\n if (this.listenerCount('error') === 0) {\n this.client.emit('error', err)\n } else {\n this.emit('error', err)\n }\n }\n\n this.emit('close')\n\n this.client = null\n this.files = []\n this.discovery = null\n this.store = null\n this._rarityMap = null\n this._peers = null\n this._servers = null\n this._xsRequests = null\n }\n\n addPeer (peer, source) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n if (!this.infoHash) throw new Error('addPeer() must not be called before the `infoHash` event')\n\n let host\n\n if (typeof peer === 'string') {\n let parts\n try {\n parts = addrToIPPort(peer)\n } catch (e) {\n this._debug('ignoring peer: invalid %s', peer)\n this.emit('invalidPeer', peer)\n return false\n }\n host = parts[0]\n } else if (typeof peer.remoteAddress === 'string') {\n host = peer.remoteAddress\n }\n\n if (this.client.blocked && host && this.client.blocked.contains(host)) {\n this._debug('ignoring peer: blocked %s', peer)\n if (typeof peer !== 'string') peer.destroy()\n this.emit('blockedPeer', peer)\n return false\n }\n\n // if the utp connection fails to connect, then it is replaced with a tcp connection to the same ip:port\n\n const type = (this.client.utp && this._isIPv4(host)) ? 'utp' : 'tcp'\n const wasAdded = !!this._addPeer(peer, type, source)\n\n if (wasAdded) {\n this.emit('peer', peer)\n } else {\n this.emit('invalidPeer', peer)\n }\n return wasAdded\n }\n\n _addPeer (peer, type, source) {\n if (this.destroyed) {\n if (typeof peer !== 'string') peer.destroy()\n return null\n }\n if (typeof peer === 'string' && !this._validAddr(peer)) {\n this._debug('ignoring peer: invalid %s', peer)\n return null\n }\n\n const id = (peer && peer.id) || peer\n if (this._peers[id]) {\n this._debug('ignoring peer: duplicate (%s)', id)\n if (typeof peer !== 'string') peer.destroy()\n return null\n }\n\n if (this.paused) {\n this._debug('ignoring peer: torrent is paused')\n if (typeof peer !== 'string') peer.destroy()\n return null\n }\n\n this._debug('add peer %s', id)\n\n let newPeer\n if (typeof peer === 'string') {\n // `peer` is an addr (\"ip:port\" string)\n newPeer = type === 'utp'\n ? Peer.createUTPOutgoingPeer(peer, this, this.client.throttleGroups)\n : Peer.createTCPOutgoingPeer(peer, this, this.client.throttleGroups)\n } else {\n // `peer` is a WebRTC connection (simple-peer)\n newPeer = Peer.createWebRTCPeer(peer, this, this.client.throttleGroups)\n }\n\n this._registerPeer(newPeer)\n\n if (typeof peer === 'string') {\n // `peer` is an addr (\"ip:port\" string)\n this._queue.push(newPeer)\n this._drain()\n }\n\n return newPeer\n }\n\n addWebSeed (urlOrConn) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n\n let id\n let conn\n if (typeof urlOrConn === 'string') {\n id = urlOrConn\n\n if (!/^https?:\\/\\/.+/.test(id)) {\n this.emit('warning', new Error(`ignoring invalid web seed: ${id}`))\n this.emit('invalidPeer', id)\n return\n }\n\n if (this._peers[id]) {\n this.emit('warning', new Error(`ignoring duplicate web seed: ${id}`))\n this.emit('invalidPeer', id)\n return\n }\n\n conn = new WebConn(id, this)\n } else if (urlOrConn && typeof urlOrConn.connId === 'string') {\n conn = urlOrConn\n id = conn.connId\n\n if (this._peers[id]) {\n this.emit('warning', new Error(`ignoring duplicate web seed: ${id}`))\n this.emit('invalidPeer', id)\n return\n }\n } else {\n this.emit('warning', new Error('addWebSeed must be passed a string or connection object with id property'))\n return\n }\n\n this._debug('add web seed %s', id)\n\n const newPeer = Peer.createWebSeedPeer(conn, id, this, this.client.throttleGroups)\n\n this._registerPeer(newPeer)\n\n this.emit('peer', id)\n }\n\n /**\n * Called whenever a new incoming TCP peer connects to this torrent swarm. Called with a\n * peer that has already sent a handshake.\n */\n _addIncomingPeer (peer) {\n if (this.destroyed) return peer.destroy(new Error('torrent is destroyed'))\n if (this.paused) return peer.destroy(new Error('torrent is paused'))\n\n this._debug('add incoming peer %s', peer.id)\n\n this._registerPeer(peer)\n }\n\n _registerPeer (newPeer) {\n newPeer.on('download', downloaded => {\n if (this.destroyed) return\n this.received += downloaded\n this._downloadSpeed(downloaded)\n this.client._downloadSpeed(downloaded)\n this.emit('download', downloaded)\n if (this.destroyed) return\n this.client.emit('download', downloaded)\n })\n\n newPeer.on('upload', uploaded => {\n if (this.destroyed) return\n this.uploaded += uploaded\n this._uploadSpeed(uploaded)\n this.client._uploadSpeed(uploaded)\n this.emit('upload', uploaded)\n if (this.destroyed) return\n this.client.emit('upload', uploaded)\n })\n\n this._peers[newPeer.id] = newPeer\n this._peersLength += 1\n }\n\n removePeer (peer) {\n const id = peer?.id || peer\n if (peer && !peer.id) peer = this._peers?.[id]\n\n if (!peer) return\n peer.destroy()\n\n if (this.destroyed) return\n\n this._debug('removePeer %s', id)\n\n delete this._peers[id]\n this._peersLength -= 1\n\n // If torrent swarm was at capacity before, try to open a new connection now\n this._drain()\n }\n\n _select (start, end, priority, notify, isStreamSelection = false) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n\n if (start < 0 || end < start || this.pieces.length <= end) {\n throw new Error(`invalid selection ${start} : ${end}`)\n }\n priority = Number(priority) || 0\n\n this._debug('select %s-%s (priority %s)', start, end, priority)\n\n this._selections.insert({\n from: start,\n to: end,\n offset: 0,\n priority,\n notify,\n isStreamSelection\n })\n\n this._selections.sort((a, b) => b.priority - a.priority)\n\n this._updateSelections()\n }\n\n select (start, end, priority, notify) {\n this._select(start, end, priority, notify, false)\n }\n\n _deselect (from, to, isStreamSelection = false) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n\n this._debug('deselect %s-%s', from, to)\n\n this._selections.remove({ from, to, isStreamSelection })\n\n this._updateSelections()\n }\n\n deselect (start, end) {\n this._deselect(start, end, false)\n }\n\n critical (start, end) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n\n this._debug('critical %s-%s', start, end)\n\n for (let i = start; i <= end; ++i) {\n this._critical[i] = true\n }\n\n this._updateSelections()\n }\n\n _onWire (wire, addr) {\n this._debug('got wire %s (%s)', wire._debugId, addr || 'Unknown')\n\n this.wires.push(wire)\n\n if (addr) {\n // Sometimes RTCPeerConnection.getStats() doesn't return an ip:port for peers\n const parts = addrToIPPort(addr)\n wire.remoteAddress = parts[0]\n wire.remotePort = parts[1]\n }\n\n // When peer sends PORT message, add that DHT node to routing table\n if (this.client.dht && this.client.dht.listening) {\n wire.on('port', port => {\n if (this.destroyed || this.client.dht.destroyed) {\n return\n }\n if (!wire.remoteAddress) {\n return this._debug('ignoring PORT from peer with no address')\n }\n if (port === 0 || port > 65536) {\n return this._debug('ignoring invalid PORT from peer')\n }\n\n this._debug('port: %s (from %s)', port, addr)\n this.client.dht.addNode({ host: wire.remoteAddress, port })\n })\n }\n\n wire.on('timeout', () => {\n this._debug('wire timeout (%s)', addr)\n // TODO: this might be destroying wires too eagerly\n wire.destroy()\n })\n\n // Timeout for piece requests to this peer\n if (wire.type !== 'webSeed') { // webseeds always send 'unhave' on http timeout\n wire.setTimeout(PIECE_TIMEOUT, true)\n }\n\n // Send KEEP-ALIVE (every 60s) so peers will not disconnect the wire\n wire.setKeepAlive(true)\n\n // use ut_metadata extension\n wire.use(utMetadata(this.metadata))\n\n wire.ut_metadata.on('warning', err => {\n this._debug('ut_metadata warning: %s', err.message)\n })\n\n if (!this.metadata) {\n wire.ut_metadata.on('metadata', metadata => {\n this._debug('got metadata via ut_metadata')\n this._onMetadata(metadata)\n })\n wire.ut_metadata.fetch()\n }\n\n // use ut_pex extension if the torrent is not flagged as private\n if (this.client.utPex && typeof utPex === 'function' && !this.private) {\n wire.use(utPex())\n\n wire.ut_pex.on('peer', peer => {\n // Only add potential new peers when we're not seeding\n if (this.done) return\n this._debug('ut_pex: got peer: %s (from %s)', peer, addr)\n this.addPeer(peer, Peer.SOURCE_UT_PEX)\n })\n\n wire.ut_pex.on('dropped', peer => {\n // the remote peer believes a given peer has been dropped from the torrent swarm.\n // if we're not currently connected to it, then remove it from the queue.\n const peerObj = this._peers[peer]\n if (peerObj && !peerObj.connected) {\n this._debug('ut_pex: dropped peer: %s (from %s)', peer, addr)\n this.removePeer(peer)\n }\n })\n\n wire.once('close', () => {\n // Stop sending updates to remote peer\n wire.ut_pex.reset()\n })\n }\n\n wire.use(ltDontHave())\n\n // Hook to allow user-defined `bittorrent-protocol` extensions\n // More info: https://github.com/webtorrent/bittorrent-protocol#extension-api\n this.emit('wire', wire, addr)\n\n if (this.ready) {\n queueMicrotask(() => {\n // This allows wire.handshake() to be called (by Peer.onHandshake) before any\n // messages get sent on the wire\n this._onWireWithMetadata(wire)\n })\n }\n }\n\n _onWireWithMetadata (wire) {\n let timeoutId = null\n\n const onChokeTimeout = () => {\n if (this.destroyed || wire.destroyed) return\n\n if (this._numQueued > 2 * (this._numConns - this.numPeers) &&\n wire.amInterested) {\n wire.destroy()\n } else {\n timeoutId = setTimeout(onChokeTimeout, CHOKE_TIMEOUT)\n if (timeoutId.unref) timeoutId.unref()\n }\n }\n\n let i\n const updateSeedStatus = () => {\n if (wire.peerPieces.buffer.length !== this.bitfield.buffer.length) return\n for (i = 0; i < this.pieces.length; ++i) {\n if (!wire.peerPieces.get(i)) return\n }\n wire.isSeeder = true\n if (this.alwaysChokeSeeders) wire.choke() // always choke seeders\n }\n\n wire.on('bitfield', () => {\n updateSeedStatus()\n this._update()\n this._updateWireInterest(wire)\n })\n\n wire.on('have', () => {\n updateSeedStatus()\n this._update()\n this._updateWireInterest(wire)\n })\n\n wire.lt_donthave.on('donthave', () => {\n updateSeedStatus()\n this._update()\n this._updateWireInterest(wire)\n })\n\n // fast extension (BEP6)\n wire.on('have-all', () => {\n wire.isSeeder = true\n if (this.alwaysChokeSeeders) wire.choke() // always choke seeders\n this._update()\n this._updateWireInterest(wire)\n })\n\n // fast extension (BEP6)\n wire.on('have-none', () => {\n wire.isSeeder = false\n this._update()\n this._updateWireInterest(wire)\n })\n\n // fast extension (BEP6)\n wire.on('allowed-fast', (index) => {\n this._update()\n })\n\n wire.once('interested', () => {\n wire.unchoke()\n })\n\n wire.once('close', () => {\n clearTimeout(timeoutId)\n })\n\n wire.on('choke', () => {\n clearTimeout(timeoutId)\n timeoutId = setTimeout(onChokeTimeout, CHOKE_TIMEOUT)\n if (timeoutId.unref) timeoutId.unref()\n })\n\n wire.on('unchoke', () => {\n clearTimeout(timeoutId)\n this._update()\n })\n\n wire.on('request', (index, offset, length, cb) => {\n if (length > MAX_BLOCK_LENGTH) {\n // Per spec, disconnect from peers that request >128KB\n return wire.destroy()\n }\n if (this.pieces[index]) return\n this.store.get(index, { offset, length }, cb)\n })\n\n // always send bitfield or equivalent fast extension message (required)\n if (wire.hasFast && this._hasAllPieces()) wire.haveAll()\n else if (wire.hasFast && this._hasNoPieces()) wire.haveNone()\n else wire.bitfield(this.bitfield)\n\n // initialize interest in case bitfield message was already received before above handler was registered\n this._updateWireInterest(wire)\n\n // Send PORT message to peers that support DHT\n if (wire.peerExtensions.dht && this.client.dht && this.client.dht.listening) {\n wire.port(this.client.dht.address().port)\n }\n\n if (wire.type !== 'webSeed') { // do not choke on webseeds\n timeoutId = setTimeout(onChokeTimeout, CHOKE_TIMEOUT)\n if (timeoutId.unref) timeoutId.unref()\n }\n\n wire.isSeeder = false\n updateSeedStatus()\n }\n\n /**\n * Called on selection changes.\n */\n _updateSelections () {\n if (!this.ready || this.destroyed) return\n\n queueMicrotask(() => {\n this._gcSelections()\n })\n this._updateInterest()\n this._update()\n }\n\n /**\n * Garbage collect selections with respect to the store's current state.\n */\n _gcSelections () {\n for (const s of this._selections) {\n const oldOffset = s.offset\n\n // check for newly downloaded pieces in selection\n while (this.bitfield.get(s.from + s.offset) && s.from + s.offset < s.to) {\n s.offset += 1\n }\n\n if (oldOffset !== s.offset) s.notify?.()\n if (s.to !== s.from + s.offset) continue\n if (!this.bitfield.get(s.from + s.offset)) continue\n\n s.remove() // remove fully downloaded selection\n s.notify?.()\n this._updateInterest()\n }\n\n if (!this._selections.length) this.emit('idle')\n }\n\n /**\n * Update interested status for all peers.\n */\n _updateInterest () {\n const prev = this._amInterested\n this._amInterested = !!this._selections.length\n\n this.wires.forEach(wire => this._updateWireInterest(wire))\n\n if (prev === this._amInterested) return\n if (this._amInterested) this.emit('interested')\n else this.emit('uninterested')\n }\n\n _updateWireInterest (wire) {\n let interested = false\n for (let index = 0; index < this.pieces.length; ++index) {\n if (this.pieces[index] && wire.peerPieces.get(index)) {\n interested = true\n break\n }\n }\n\n if (interested) wire.interested()\n else wire.uninterested()\n }\n\n /**\n * Heartbeat to update all peers and their requests.\n */\n _update () {\n if (IDLE_CALLBACK) {\n IDLE_CALLBACK(() => this._updateWireWrapper(), { timeout: 250 })\n } else {\n this._updateWireWrapper()\n }\n }\n\n _updateWireWrapper () {\n if (this.destroyed) return\n // update wires in random order for better request distribution\n const ite = randomIterate(this.wires)\n let wire\n while ((wire = ite())) {\n this._updateWire(wire)\n }\n }\n\n /**\n * Attempts to update a peer's requests\n */\n _updateWire (wire) {\n if (wire.destroyed) return false\n // to allow function hoisting\n const self = this\n\n const minOutstandingRequests = getBlockPipelineLength(wire, PIPELINE_MIN_DURATION)\n if (wire.requests.length >= minOutstandingRequests) return\n const maxOutstandingRequests = getBlockPipelineLength(wire, PIPELINE_MAX_DURATION)\n\n if (wire.peerChoking) {\n if (wire.hasFast && wire.peerAllowedFastSet.length > 0 &&\n !this._hasMorePieces(wire.peerAllowedFastSet.length - 1)) {\n requestAllowedFastSet()\n }\n return\n }\n\n if (!wire.downloaded) return validateWire()\n\n trySelectWire(false) || trySelectWire(true)\n\n function requestAllowedFastSet () {\n if (wire.requests.length >= maxOutstandingRequests) return false\n\n for (const piece of wire.peerAllowedFastSet) {\n if (wire.peerPieces.get(piece) && !self.bitfield.get(piece)) {\n while (self._request(wire, piece, false) &&\n wire.requests.length < maxOutstandingRequests) {\n // body intentionally empty\n // request all non-reserved blocks in this piece\n }\n }\n\n if (wire.requests.length < maxOutstandingRequests) continue\n\n return true\n }\n\n return false\n }\n\n function genPieceFilterFunc (start, end, tried, rank) {\n return i => i >= start && i <= end && !(i in tried) && wire.peerPieces.get(i) && (!rank || rank(i))\n }\n\n // TODO: Do we need both validateWire and trySelectWire?\n function validateWire () {\n if (wire.requests.length) return\n\n let i = self._selections.length\n while (i--) {\n const next = self._selections.get(i)\n let piece\n if (self.strategy === 'rarest') {\n const start = next.from + next.offset\n const end = next.to\n const len = end - start + 1\n const tried = {}\n let tries = 0\n const filter = genPieceFilterFunc(start, end, tried)\n\n while (tries < len) {\n piece = self._rarityMap.getRarestPiece(filter)\n if (piece < 0) break\n if (self._request(wire, piece, false)) return\n tried[piece] = true\n tries += 1\n }\n } else {\n for (piece = next.to; piece >= next.from + next.offset; --piece) {\n if (!wire.peerPieces.get(piece)) continue\n if (self._request(wire, piece, false)) return\n }\n }\n }\n\n // TODO: wire failed to validate as useful; should we close it?\n // probably not, since 'have' and 'bitfield' messages might be coming\n }\n\n function speedRanker () {\n const speed = wire.downloadSpeed() || 1\n if (speed > SPEED_THRESHOLD) return () => true\n\n const secs = Math.max(1, wire.requests.length) * Piece.BLOCK_LENGTH / speed\n let tries = 10\n let ptr = 0\n\n return index => {\n if (!tries || self.bitfield.get(index)) return true\n\n let missing = self.pieces[index].missing\n\n for (; ptr < self.wires.length; ptr++) {\n const otherWire = self.wires[ptr]\n const otherSpeed = otherWire.downloadSpeed()\n\n if (otherSpeed < SPEED_THRESHOLD) continue\n if (otherSpeed <= speed) continue\n if (!otherWire.peerPieces.get(index)) continue\n if ((missing -= otherSpeed * secs) > 0) continue\n\n tries--\n return false\n }\n\n return true\n }\n }\n\n function shufflePriority (i) {\n let last = i\n for (let j = i; j < self._selections.length && self._selections.get(j).priority; j++) {\n last = j\n }\n self._selections.swap(i, last)\n }\n\n function trySelectWire (hotswap) {\n if (wire.requests.length >= maxOutstandingRequests) return true\n const rank = speedRanker()\n\n for (let i = 0; i < self._selections.length; i++) {\n const next = self._selections.get(i)\n\n let piece\n if (self.strategy === 'rarest') {\n const start = next.from + next.offset\n const end = next.to\n const len = end - start + 1\n const tried = {}\n let tries = 0\n const filter = genPieceFilterFunc(start, end, tried, rank)\n\n while (tries < len) {\n piece = self._rarityMap.getRarestPiece(filter)\n if (piece < 0) break\n\n while (self._request(wire, piece, self._critical[piece] || hotswap) &&\n wire.requests.length < maxOutstandingRequests) {\n // body intentionally empty\n // request all non-reserved blocks in this piece\n }\n\n if (wire.requests.length < maxOutstandingRequests) {\n tried[piece] = true\n tries++\n continue\n }\n\n if (next.priority) shufflePriority(i)\n return true\n }\n } else {\n for (piece = next.from + next.offset; piece <= next.to; piece++) {\n if (!wire.peerPieces.get(piece) || !rank(piece)) continue\n\n while (self._request(wire, piece, self._critical[piece] || hotswap) &&\n wire.requests.length < maxOutstandingRequests) {\n // body intentionally empty\n // request all non-reserved blocks in piece\n }\n\n if (wire.requests.length < maxOutstandingRequests) continue\n\n if (next.priority) shufflePriority(i)\n return true\n }\n }\n }\n\n return false\n }\n }\n\n /**\n * Called periodically to update the choked status of all peers, handling optimistic\n * unchoking as described in BEP3.\n */\n _rechoke () {\n if (!this.ready) return\n\n // wires in increasing order of quality (pop() gives next best peer)\n const wireStack =\n this.wires\n .map(wire => ({ wire, random: Math.random() })) // insert a random seed for randomizing the sort\n .sort((objA, objB) => {\n const wireA = objA.wire\n const wireB = objB.wire\n\n // prefer peers that send us data faster\n if (wireA.downloadSpeed() !== wireB.downloadSpeed()) {\n return wireA.downloadSpeed() - wireB.downloadSpeed()\n }\n\n // then prefer peers that can download data from us faster\n if (wireA.uploadSpeed() !== wireB.uploadSpeed()) {\n return wireA.uploadSpeed() - wireB.uploadSpeed()\n }\n\n // then prefer already unchoked peers (to minimize fibrillation)\n if (wireA.amChoking !== wireB.amChoking) {\n return wireA.amChoking ? -1 : 1 // choking < unchoked\n }\n\n // otherwise random order\n return objA.random - objB.random\n })\n .map(obj => obj.wire) // return array of wires (remove random seed)\n\n if (this._rechokeOptimisticTime <= 0) {\n // clear old optimistic peer, so it can be rechoked normally and then replaced\n this._rechokeOptimisticWire = null\n } else {\n this._rechokeOptimisticTime -= 1\n }\n\n let numInterestedUnchoked = 0\n // leave one rechoke slot open for optimistic unchoking\n while (wireStack.length > 0 && numInterestedUnchoked < this._rechokeNumSlots - 1) {\n const wire = wireStack.pop() // next best quality peer\n\n if (wire.isSeeder || wire === this._rechokeOptimisticWire) {\n continue\n }\n\n wire.unchoke()\n\n // only stop unchoking once we fill the slots with interested peers that will actually download\n if (wire.peerInterested) {\n numInterestedUnchoked++\n }\n }\n\n // fill optimistic unchoke slot if empty\n if (this._rechokeOptimisticWire === null && this._rechokeNumSlots > 0) {\n // don't optimistically unchoke uninterested peers\n const remaining = wireStack.filter(wire => wire.peerInterested)\n\n if (remaining.length > 0) {\n // select random remaining (not yet unchoked) peer\n const newOptimisticPeer = remaining[randomInt(remaining.length)]\n\n newOptimisticPeer.unchoke()\n\n this._rechokeOptimisticWire = newOptimisticPeer\n\n this._rechokeOptimisticTime = RECHOKE_OPTIMISTIC_DURATION\n }\n }\n\n // choke the rest\n wireStack\n .filter(wire => wire !== this._rechokeOptimisticWire) // except the optimistically unchoked peer\n .forEach(wire => wire.choke())\n }\n\n /**\n * Attempts to cancel a slow block request from another wire such that the\n * given wire may effectively swap out the request for one of its own.\n */\n _hotswap (wire, index) {\n const speed = wire.downloadSpeed()\n if (speed < Piece.BLOCK_LENGTH) return false\n if (!this._reservations[index]) return false\n\n const r = this._reservations[index]\n if (!r) {\n return false\n }\n\n let minSpeed = Infinity\n let minWire\n\n let i\n for (i = 0; i < r.length; i++) {\n const otherWire = r[i]\n if (!otherWire || otherWire === wire) continue\n\n const otherSpeed = otherWire.downloadSpeed()\n if (otherSpeed >= SPEED_THRESHOLD) continue\n if (2 * otherSpeed > speed || otherSpeed > minSpeed) continue\n\n minWire = otherWire\n minSpeed = otherSpeed\n }\n\n if (!minWire) return false\n\n for (i = 0; i < r.length; i++) {\n if (r[i] === minWire) r[i] = null\n }\n\n for (i = 0; i < minWire.requests.length; i++) {\n const req = minWire.requests[i]\n if (req.piece !== index) continue\n\n this.pieces[index].cancel((req.offset / Piece.BLOCK_LENGTH) | 0)\n }\n\n this.emit('hotswap', minWire, wire, index)\n return true\n }\n\n /**\n * Attempts to request a block from the given wire.\n */\n _request (wire, index, hotswap) {\n const self = this\n const numRequests = wire.requests.length\n const isWebSeed = wire.type === 'webSeed'\n\n if (self.bitfield.get(index)) return false\n\n const maxOutstandingRequests = isWebSeed\n ? Math.min(\n getPiecePipelineLength(wire, PIPELINE_MAX_DURATION, self.pieceLength),\n self.maxWebConns\n )\n : getBlockPipelineLength(wire, PIPELINE_MAX_DURATION)\n\n if (numRequests >= maxOutstandingRequests) return false\n // var endGame = (wire.requests.length === 0 && self.store.numMissing < 30)\n\n const piece = self.pieces[index]\n let reservation = isWebSeed ? piece.reserveRemaining() : piece.reserve()\n\n if (reservation === -1 && hotswap && self._hotswap(wire, index)) {\n reservation = isWebSeed ? piece.reserveRemaining() : piece.reserve()\n }\n if (reservation === -1) return false\n\n let r = self._reservations[index]\n if (!r) r = self._reservations[index] = []\n let i = r.indexOf(null)\n if (i === -1) i = r.length\n r[i] = wire\n\n const chunkOffset = piece.chunkOffset(reservation)\n const chunkLength = isWebSeed ? piece.chunkLengthRemaining(reservation) : piece.chunkLength(reservation)\n\n wire.request(index, chunkOffset, chunkLength, async function onChunk (err, chunk) {\n if (self.destroyed) return\n\n // TODO: what is this for?\n if (!self.ready) return self.once('ready', () => { onChunk(err, chunk) })\n\n if (r[i] === wire) r[i] = null\n\n if (piece !== self.pieces[index]) return onUpdateTick()\n\n if (err) {\n self._debug(\n 'error getting piece %s (offset: %s length: %s) from %s: %s',\n index, chunkOffset, chunkLength, `${wire.remoteAddress}:${wire.remotePort}`,\n err.message\n )\n isWebSeed ? piece.cancelRemaining(reservation) : piece.cancel(reservation)\n onUpdateTick()\n return\n }\n\n self._debug(\n 'got piece %s (offset: %s length: %s) from %s',\n index, chunkOffset, chunkLength, `${wire.remoteAddress}:${wire.remotePort}`\n )\n\n if (!piece.set(reservation, chunk, wire)) return onUpdateTick()\n\n const buf = piece.flush()\n\n // TODO: might need to set self.pieces[index] = null here since sha1 is async\n\n const hex = await hash(buf, 'hex')\n if (self.destroyed) return\n\n if (hex === self._hashes[index]) {\n self._debug('piece verified %s', index)\n\n self.store.put(index, buf, err => {\n if (err) {\n self._destroy(err)\n return\n } else {\n self.pieces[index] = null\n self._markVerified(index)\n self.wires.forEach(wire => {\n wire.have(index)\n })\n }\n // We also check `self.destroyed` since `torrent.destroy()` could have been\n // called in the `torrent.on('done')` handler, triggered by `_checkDone()`.\n if (self._checkDone() && !self.destroyed) self.discovery.complete()\n onUpdateTick()\n })\n } else {\n self.pieces[index] = new Piece(piece.length)\n self.emit('warning', new Error(`Piece ${index} failed verification`))\n onUpdateTick()\n }\n })\n\n function onUpdateTick () {\n queueMicrotask(() => { self._update() })\n }\n\n return true\n }\n\n _checkDone () {\n if (this.destroyed) return\n\n // are any new files done?\n this.files.forEach(file => {\n if (file.done) return\n for (let i = file._startPiece; i <= file._endPiece; ++i) {\n if (!this.bitfield.get(i)) return\n }\n file.done = true\n file.emit('done')\n this._debug(`file done: ${file.name}`)\n })\n\n // is the torrent done? (if all current selections are satisfied, or there are\n // no selections, then torrent is done)\n let done = true\n\n for (const selection of this._selections) {\n for (let piece = selection.from; piece <= selection.to; piece++) {\n if (!this.bitfield.get(piece)) {\n done = false\n break\n }\n }\n if (!done) break\n }\n\n if (!this.done && done) {\n this.done = true\n this._debug(`torrent done: ${this.infoHash}`)\n this.emit('done')\n } else {\n this.done = false\n }\n this._gcSelections()\n\n return done\n }\n\n async load (streams, cb) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n if (!this.ready) return this.once('ready', () => { this.load(streams, cb) })\n\n if (!Array.isArray(streams)) streams = [streams]\n if (!cb) cb = noop\n\n try {\n await chunkStoreWrite(this.store, joinIterator(streams), { chunkLength: this.pieceLength })\n this._markAllVerified()\n this._checkDone()\n cb(null)\n } catch (err) {\n cb(err)\n return err\n }\n }\n\n pause () {\n if (this.destroyed) return\n this._debug('pause')\n this.paused = true\n }\n\n resume () {\n if (this.destroyed) return\n this._debug('resume')\n this.paused = false\n this._drain()\n }\n\n _debug () {\n const args = [].slice.call(arguments)\n args[0] = `[${this.client ? this.client._debugId : 'No Client'}] [${this._debugId}] ${args[0]}`\n debug(...args)\n }\n\n /**\n * Pop a peer off the FIFO queue and connect to it. When _drain() gets called,\n * the queue will usually have only one peer in it, except when there are too\n * many peers (over `this.maxConns`) in which case they will just sit in the\n * queue until another connection closes.\n */\n _drain () {\n this._debug('_drain numConns %s maxConns %s', this._numConns, this.client.maxConns)\n if (typeof net.connect !== 'function' || this.destroyed || this.paused ||\n this._numConns >= this.client.maxConns) {\n return\n }\n this._debug('drain (%s queued, %s/%s peers)', this._numQueued, this.numPeers, this.client.maxConns)\n\n const peer = this._queue.shift()\n if (!peer) return // queue could be empty\n\n this._debug('%s connect attempt to %s', peer.type, peer.addr)\n\n const parts = addrToIPPort(peer.addr)\n const opts = {\n host: parts[0],\n port: parts[1]\n }\n\n if (this.client.utp && peer.type === Peer.TYPE_UTP_OUTGOING) {\n peer.conn = utp.connect(opts.port, opts.host)\n } else {\n peer.conn = net.connect(opts)\n }\n\n const conn = peer.conn\n\n conn.once('connect', () => { if (!this.destroyed) peer.onConnect() })\n conn.once('error', err => { peer.destroy(err) })\n peer.startConnectTimeout()\n\n // When connection closes, attempt reconnect after timeout (with exponential backoff)\n conn.on('close', () => {\n if (this.destroyed) return\n\n if (peer.retries >= RECONNECT_WAIT.length) {\n if (this.client.utp) {\n const newPeer = this._addPeer(peer.addr, 'tcp', peer.source)\n if (newPeer) newPeer.retries = 0\n } else {\n this._debug(\n 'conn %s closed: will not re-add (max %s attempts)',\n peer.addr, RECONNECT_WAIT.length\n )\n }\n return\n }\n\n const ms = RECONNECT_WAIT[peer.retries]\n this._debug(\n 'conn %s closed: will re-add to queue in %sms (attempt %s)',\n peer.addr, ms, peer.retries + 1\n )\n\n const reconnectTimeout = setTimeout(() => {\n if (this.destroyed) return\n const host = addrToIPPort(peer.addr)[0]\n const type = (this.client.utp && this._isIPv4(host)) ? 'utp' : 'tcp'\n const newPeer = this._addPeer(peer.addr, type, peer.source)\n if (newPeer) newPeer.retries = peer.retries + 1\n }, ms)\n if (reconnectTimeout.unref) reconnectTimeout.unref()\n })\n }\n\n /**\n * Returns `true` if string is valid IPv4/6 address.\n * @param {string} addr\n * @return {boolean}\n */\n _validAddr (addr) {\n let parts\n try {\n parts = addrToIPPort(addr)\n } catch (e) {\n return false\n }\n const host = parts[0]\n const port = parts[1]\n return port > 0 && port < 65535 &&\n !(host === '127.0.0.1' && port === this.client.torrentPort)\n }\n\n /**\n * Return `true` if string is a valid IPv4 address.\n * @param {string} addr\n * @return {boolean}\n */\n _isIPv4 (addr) {\n const IPv4Pattern = /^((?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$/\n return IPv4Pattern.test(addr)\n }\n}\n\nfunction getBlockPipelineLength (wire, duration) {\n let length = 2 + Math.ceil(duration * wire.downloadSpeed() / Piece.BLOCK_LENGTH)\n\n // Honor reqq (maximum number of outstanding request messages) if specified by peer\n if (wire.peerExtendedHandshake) {\n const reqq = wire.peerExtendedHandshake.reqq\n if (typeof reqq === 'number' && reqq > 0) {\n length = Math.min(length, reqq)\n }\n }\n\n return length\n}\n\nfunction getPiecePipelineLength (wire, duration, pieceLength) {\n return 1 + Math.ceil(duration * wire.downloadSpeed() / pieceLength)\n}\n\n/**\n * Returns a random integer in [0,high)\n */\nfunction randomInt (high) {\n return Math.random() * high | 0\n}\n\nfunction noop () {}\n","import http from 'http'\nimport escapeHtml from 'escape-html'\nimport pump from 'pump'\nimport rangeParser from 'range-parser'\nimport queueMicrotask from 'queue-microtask'\nimport { Readable } from 'streamx'\n\nconst keepAliveTime = 20000\n\nclass ServerBase {\n constructor (client, opts = {}) {\n this.client = client\n if (!opts.origin) opts.origin = '*' // allow all origins by default\n this.opts = opts\n this.pendingReady = new Set()\n }\n\n static serveIndexPage (res, torrents, pathname) {\n const listHtml = torrents\n .map(torrent => (\n `
  • \n \n ${escapeHtml(torrent.name)}\n \n (${escapeHtml(torrent.length)} bytes)\n
    • `\n ))\n .join('
    ')\n\n res.status = 200\n res.headers['Content-Type'] = 'text/html'\n res.body = getPageHTML(\n 'WebTorrent',\n `

    WebTorrent

    \n
      ${listHtml}
    `\n )\n\n return res\n }\n\n isOriginAllowed (req) {\n // When `origin` option is `false`, deny all cross-origin requests\n if (this.opts.origin === false) return false\n\n // The user allowed all origins\n if (this.opts.origin === '*') return true\n\n // Allow requests where the 'Origin' header matches the `opts.origin` setting\n return req.headers.origin === this.opts.origin\n }\n\n static serveMethodNotAllowed (res) {\n res.status = 405\n res.headers['Content-Type'] = 'text/html'\n\n res.body = getPageHTML(\n '405 - Method Not Allowed',\n '

    405 - Method Not Allowed

    '\n )\n\n return res\n }\n\n static serve404Page (res) {\n res.status = 404\n res.headers['Content-Type'] = 'text/html'\n\n res.body = getPageHTML(\n '404 - Not Found',\n '

    404 - Not Found

    '\n )\n return res\n }\n\n static serveTorrentPage (torrent, res, pathname) {\n const listHtml = torrent.files\n .map(file => (\n `
  • \n \n ${escapeHtml(file.path)}\n \n (${escapeHtml(file.length)} bytes)\n
    • `\n ))\n .join('
    ')\n\n res.status = 200\n res.headers['Content-Type'] = 'text/html'\n\n res.body = getPageHTML(\n `${escapeHtml(torrent.name)} - WebTorrent`,\n `

    ${escapeHtml(torrent.name)}

    \n
      ${listHtml}
    `\n )\n\n return res\n }\n\n static serveOptionsRequest (req, res) {\n res.status = 204 // no content\n res.headers['Access-Control-Max-Age'] = '600'\n res.headers['Access-Control-Allow-Methods'] = 'GET,HEAD'\n\n if (req.headers['access-control-request-headers']) {\n res.headers['Access-Control-Allow-Headers'] = req.headers['access-control-request-headers']\n }\n return res\n }\n\n static serveFile (file, req, res) {\n res.status = 200\n\n // Disable caching as data is local anyways\n res.headers.Expires = '0'\n res.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate, max-age=0'\n // Support range-requests\n res.headers['Accept-Ranges'] = 'bytes'\n res.headers['Content-Type'] = file.type\n // Support DLNA streaming\n res.headers['transferMode.dlna.org'] = 'Streaming'\n res.headers['contentFeatures.dlna.org'] = 'DLNA.ORG_OP=01;DLNA.ORG_CI=0;DLNA.ORG_FLAGS=01700000000000000000000000000000'\n\n // Force the browser to download the file if if it's opened in a new tab\n // Set name of file (for \"Save Page As...\" dialog)\n if (req.destination === 'document') {\n res.headers['Content-Type'] = 'application/octet-stream'\n res.headers['Content-Disposition'] = `attachment; filename*=UTF-8''${encodeRFC5987(file.name)}`\n res.body = 'DOWNLOAD'\n } else {\n res.headers['Content-Disposition'] = `inline; filename*=UTF-8''${encodeRFC5987(file.name)}`\n }\n\n // `rangeParser` returns an array of ranges, or an error code (number) if\n // there was an error parsing the range.\n let range = rangeParser(file.length, req.headers.range || '')\n\n if (Array.isArray(range)) {\n res.status = 206 // indicates that range-request was understood\n\n // no support for multi-range request, just use the first range\n range = range[0]\n\n res.headers['Content-Range'] = `bytes ${range.start}-${range.end}/${file.length}`\n\n res.headers['Content-Length'] = range.end - range.start + 1\n } else {\n res.statusCode = 200\n range = null\n res.headers['Content-Length'] = file.length\n }\n\n if (req.method === 'GET') {\n const iterator = file[Symbol.asyncIterator](range)\n let transform = null\n file.emit('iterator', { iterator, req, file }, target => {\n transform = target\n })\n\n const stream = Readable.from(transform || iterator)\n let pipe = null\n file.emit('stream', { stream, req, file }, target => {\n pipe = pump(stream, target)\n })\n\n res.body = pipe || stream\n } else {\n res.body = false\n }\n return res\n }\n\n async onRequest (req, cb) {\n let pathname = new URL(req.url, 'http://example.com').pathname\n pathname = pathname.slice(pathname.indexOf(this.pathname) + this.pathname.length + 1)\n\n const res = {\n headers: {\n // Prevent browser mime-type sniffing\n 'X-Content-Type-Options': 'nosniff',\n // Defense-in-depth: Set a strict Content Security Policy to mitigate XSS\n 'Content-Security-Policy': \"base-uri 'none'; frame-ancestors 'none'; form-action 'none';\"\n }\n }\n\n // Allow cross-origin requests (CORS)\n if (this.isOriginAllowed(req)) {\n res.headers['Access-Control-Allow-Origin'] = this.opts.origin === '*' ? '*' : req.headers.origin\n }\n\n if (pathname === 'favicon.ico') {\n return cb(ServerBase.serve404Page(res))\n }\n\n // Allow CORS requests to specify arbitrary headers, e.g. 'Range',\n // by responding to the OPTIONS preflight request with the specified\n // origin and requested headers.\n if (req.method === 'OPTIONS') {\n if (this.isOriginAllowed(req)) return cb(ServerBase.serveOptionsRequest(req, res))\n else return cb(ServerBase.serveMethodNotAllowed(res))\n }\n\n const onReady = async () => {\n this.pendingReady.delete(onReady)\n const res = await handleRequest()\n cb(res)\n }\n\n const handleRequest = async () => {\n if (pathname === '') {\n return ServerBase.serveIndexPage(res, this.client.torrents, this.pathname)\n }\n\n let [infoHash, ...filePath] = pathname.split('/')\n filePath = decodeURI(filePath.join('/'))\n\n const torrent = await this.client.get(infoHash)\n if (!infoHash || !torrent) {\n return ServerBase.serve404Page(res)\n }\n\n if (!filePath) {\n return ServerBase.serveTorrentPage(torrent, res, this.pathname)\n }\n\n const file = torrent.files.find(file => file.path.replace(/\\\\/g, '/') === filePath)\n if (!file) {\n return ServerBase.serve404Page(res)\n }\n return ServerBase.serveFile(file, req, res)\n }\n\n if (req.method === 'GET' || req.method === 'HEAD') {\n if (this.client.ready) {\n const res = await handleRequest()\n return cb(res)\n } else {\n this.pendingReady.add(onReady)\n this.client.once('ready', onReady)\n return\n }\n }\n\n return cb(ServerBase.serveMethodNotAllowed(res))\n }\n\n close (cb = () => {}) {\n this.closed = true\n this.pendingReady.forEach(onReady => {\n this.client.removeListener('ready', onReady)\n })\n this.pendingReady.clear()\n queueMicrotask(cb)\n }\n\n destroy (cb = () => {}) {\n // Only call `server.close` if user has not called it already\n if (this.closed) queueMicrotask(cb)\n else this.close(cb)\n this.client = null\n }\n}\n\nclass NodeServer extends ServerBase {\n constructor (client, opts) {\n super(client, opts)\n\n this.server = http.createServer()\n this._listen = this.server.listen\n this.server.listen = this.listen.bind(this)\n this._close = this.server.close\n this.server.close = this.close.bind(this)\n\n this.sockets = new Set()\n this.closed = false\n this.pathname = opts?.pathname || '/webtorrent'\n }\n\n wrapRequest (req, res) {\n // If a 'hostname' string is specified, deny requests with a 'Host'\n // header that does not match the origin of the torrent server to prevent\n // DNS rebinding attacks.\n if (this.opts.hostname && req.headers.host !== `${this.opts.hostname}:${this.server.address().port}`) {\n return req.destroy()\n }\n\n if (!new URL(req.url, 'http://example.com').pathname.startsWith(this.pathname)) {\n return req.destroy()\n }\n\n this.onRequest(req, ({ status, headers, body }) => {\n res.writeHead(status, headers)\n\n if (!!body._readableState || !!body._writableState) { // this is probably a bad way of checking? idk\n pump(body, res)\n } else {\n res.end(body)\n }\n })\n }\n\n onConnection (socket) {\n socket.setTimeout(36000000)\n this.sockets.add(socket)\n socket.once('close', () => {\n this.sockets.delete(socket)\n })\n }\n\n address () {\n return this.server.address()\n }\n\n listen (...args) {\n this.closed = false\n this.server.on('connection', this.onConnection.bind(this))\n this.server.on('request', this.wrapRequest.bind(this))\n return this._listen.apply(this.server, args)\n }\n\n close (cb = () => {}) {\n this.server.removeAllListeners('connection')\n this.server.removeAllListeners('request')\n this.server.removeAllListeners('listening')\n super.close()\n this._close.call(this.server, cb)\n }\n\n destroy (cb) {\n this.sockets.forEach(socket => {\n socket.destroy()\n })\n super.destroy(cb)\n }\n}\n\nclass BrowserServer extends ServerBase {\n constructor (client, opts) {\n super(client, opts)\n\n this.registration = opts.controller\n this.workerKeepAliveInterval = null\n this.workerPortCount = 0\n\n const scope = new URL(opts.controller.scope)\n this.pathname = scope.pathname + 'webtorrent'\n this._address = {\n port: scope.port,\n family: 'IPv4', // might be a bad idea?\n address: scope.hostname\n }\n\n this.boundHandler = this.wrapRequest.bind(this)\n navigator.serviceWorker.addEventListener('message', this.boundHandler)\n // test if browser supports cancelling sw Readable Streams\n fetch(`${this.pathname}/cancel/`).then(res => {\n res.body.cancel()\n })\n }\n\n wrapRequest (event) {\n const req = event.data\n\n if (!req?.type === 'webtorrent' || !req.url) return null\n\n const [port] = event.ports\n this.onRequest(req, ({ status, headers, body }) => {\n const asyncIterator = body[Symbol.asyncIterator]?.()\n\n const cleanup = () => {\n port.onmessage = null\n if (body?.destroy) body.destroy()\n this.workerPortCount--\n if (!this.workerPortCount) {\n clearInterval(this.workerKeepAliveInterval)\n this.workerKeepAliveInterval = null\n }\n }\n\n port.onmessage = async msg => {\n if (msg.data) {\n let chunk\n try {\n chunk = (await asyncIterator.next()).value\n } catch (e) {\n // chunk is yet to be downloaded or it somehow failed, should this be logged?\n }\n port.postMessage(chunk)\n if (!chunk) cleanup()\n if (!this.workerKeepAliveInterval) {\n this.workerKeepAliveInterval = setInterval(() => fetch(`${this.pathname}/keepalive/`), keepAliveTime)\n }\n } else {\n cleanup()\n }\n }\n this.workerPortCount++\n port.postMessage({\n status,\n headers,\n body: asyncIterator ? 'STREAM' : body\n })\n })\n }\n\n // for compatibility with node version\n listen (_, cb) {\n cb()\n }\n\n address () {\n return this._address\n }\n\n close (cb) {\n navigator.serviceWorker.removeEventListener('message', this.boundHandler)\n super.close(cb)\n }\n\n destroy (cb) {\n super.destroy(cb)\n }\n}\n\n// NOTE: Arguments must already be HTML-escaped\nfunction getPageHTML (title, pageHtml) {\n return `\n \n \n \n \n ${title}\n \n \n ${pageHtml}\n \n \n `\n}\n\n// From https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent\nfunction encodeRFC5987 (str) {\n return encodeURIComponent(str)\n // Note that although RFC3986 reserves \"!\", RFC5987 does not,\n // so we do not need to escape it\n .replace(/['()]/g, escape) // i.e., %27 %28 %29\n .replace(/\\*/g, '%2A')\n // The following are not required for percent-encoding per RFC5987,\n // so we can allow for a little better readability over the wire: |`^\n .replace(/%(?:7C|60|5E)/g, unescape)\n}\n\nexport { NodeServer, BrowserServer }\n","/*! webtorrent. MIT License. WebTorrent LLC */\nimport EventEmitter from 'events'\nimport path from 'path'\nimport createTorrent, { parseInput } from 'create-torrent'\nimport debugFactory from 'debug'\nimport { Client as DHT } from 'bittorrent-dht' // browser exclude\nimport loadIPSet from 'load-ip-set' // browser exclude\nimport parallel from 'run-parallel'\nimport parseTorrent from 'parse-torrent'\nimport Peer from '@thaunknown/simple-peer/lite.js'\nimport queueMicrotask from 'queue-microtask'\nimport { hash, hex2arr, arr2hex, arr2base, text2arr, randomBytes, concat } from 'uint8-util'\nimport throughput from 'throughput'\nimport { ThrottleGroup } from 'speed-limiter'\nimport NatAPI from '@silentbot1/nat-api' // browser exclude\nimport ConnPool from './lib/conn-pool.js' // browser exclude\nimport Torrent from './lib/torrent.js'\nimport { NodeServer, BrowserServer } from './lib/server.js'\n\nimport VERSION from './version.cjs'\n\nconst debug = debugFactory('webtorrent')\n\n/**\n * Version number in Azureus-style. Generated from major and minor semver version.\n * For example:\n * '0.16.1' -> '0016'\n * '1.2.5' -> '0102'\n */\nconst VERSION_STR = VERSION\n .replace(/\\d*./g, v => `0${v % 100}`.slice(-2))\n .slice(0, 4)\n\n/**\n * Version prefix string (used in peer ID). WebTorrent uses the Azureus-style\n * encoding: '-', two characters for client id ('WW'), four ascii digits for version\n * number, '-', followed by random numbers.\n * For example:\n * '-WW0102-'...\n */\nconst VERSION_PREFIX = `-WW${VERSION_STR}-`\n\n/**\n * WebTorrent Client\n * @param {Object=} opts\n */\nexport default class WebTorrent extends EventEmitter {\n constructor (opts = {}) {\n super()\n\n if (typeof opts.peerId === 'string') {\n this.peerId = opts.peerId\n } else if (ArrayBuffer.isView(opts.peerId)) {\n this.peerId = arr2hex(opts.peerId)\n } else {\n this.peerId = arr2hex(text2arr(VERSION_PREFIX + arr2base(randomBytes(9))))\n }\n this.peerIdBuffer = hex2arr(this.peerId)\n\n if (typeof opts.nodeId === 'string') {\n this.nodeId = opts.nodeId\n } else if (ArrayBuffer.isView(opts.nodeId)) {\n this.nodeId = arr2hex(opts.nodeId)\n } else {\n this.nodeId = arr2hex(randomBytes(20))\n }\n this.nodeIdBuffer = hex2arr(this.nodeId)\n\n this._debugId = this.peerId.substring(0, 7)\n\n this.destroyed = false\n this.listening = false\n this.torrentPort = opts.torrentPort || 0\n this.dhtPort = opts.dhtPort || 0\n this.tracker = opts.tracker !== undefined ? opts.tracker : {}\n this.lsd = opts.lsd !== false\n this.utPex = opts.utPex !== false\n this.natUpnp = opts.natUpnp ?? true\n this.natPmp = opts.natPmp ?? true\n this.torrents = []\n this.maxConns = Number(opts.maxConns) || 55\n this.utp = WebTorrent.UTP_SUPPORT && opts.utp !== false\n this.seedOutgoingConnections = opts.seedOutgoingConnections ?? true\n\n this._downloadLimit = Math.max((typeof opts.downloadLimit === 'number') ? opts.downloadLimit : -1, -1)\n this._uploadLimit = Math.max((typeof opts.uploadLimit === 'number') ? opts.uploadLimit : -1, -1)\n\n if ((this.natUpnp || this.natPmp) && typeof NatAPI === 'function') {\n this.natTraversal = new NatAPI({\n enableUPNP: this.natUpnp,\n enablePMP: this.natPmp,\n upnpPermanentFallback: opts.natUpnp === 'permanent'\n })\n }\n\n if (opts.secure === true) {\n import('./lib/peer.js').then(({ enableSecure }) => enableSecure())\n }\n\n this._debug(\n 'new webtorrent (peerId %s, nodeId %s, port %s)',\n this.peerId, this.nodeId, this.torrentPort\n )\n\n this.throttleGroups = {\n down: new ThrottleGroup({ rate: Math.max(this._downloadLimit, 0), enabled: this._downloadLimit >= 0 }),\n up: new ThrottleGroup({ rate: Math.max(this._uploadLimit, 0), enabled: this._uploadLimit >= 0 })\n }\n\n if (this.tracker) {\n if (typeof this.tracker !== 'object') this.tracker = {}\n if (globalThis.WRTC && !this.tracker.wrtc) this.tracker.wrtc = globalThis.WRTC\n }\n\n if (typeof ConnPool === 'function') {\n this._connPool = new ConnPool(this)\n } else {\n queueMicrotask(() => {\n this._onListening()\n })\n }\n\n // stats\n this._downloadSpeed = throughput()\n this._uploadSpeed = throughput()\n\n if (opts.dht !== false && typeof DHT === 'function' /* browser exclude */) {\n // use a single DHT instance for all torrents, so the routing table can be reused\n this.dht = new DHT(Object.assign({}, { nodeId: this.nodeId }, opts.dht))\n\n this.dht.once('error', err => {\n this._destroy(err)\n })\n\n this.dht.once('listening', () => {\n const address = this.dht.address()\n if (address) {\n this.dhtPort = address.port\n if (this.natTraversal) {\n this.natTraversal.map({\n publicPort: this.dhtPort,\n privatePort: this.dhtPort,\n protocol: 'udp',\n description: 'WebTorrent DHT'\n }).catch(err => {\n debug('error mapping DHT port via UPnP/PMP: %o', err)\n })\n }\n }\n })\n\n // Ignore warning when there are > 10 torrents in the client\n this.dht.setMaxListeners(0)\n\n this.dht.listen(this.dhtPort)\n } else {\n this.dht = false\n }\n\n // Enable or disable BEP19 (Web Seeds). Enabled by default:\n this.enableWebSeeds = opts.webSeeds !== false\n\n const ready = () => {\n if (this.destroyed) return\n this.ready = true\n this.emit('ready')\n }\n\n if (typeof loadIPSet === 'function' && opts.blocklist != null) {\n loadIPSet(opts.blocklist, {\n headers: {\n 'user-agent': `WebTorrent/${VERSION} (https://webtorrent.io)`\n }\n }, (err, ipSet) => {\n if (err) return console.error(`Failed to load blocklist: ${err.message}`)\n this.blocked = ipSet\n ready()\n })\n } else {\n queueMicrotask(ready)\n }\n }\n\n /**\n * Creates an http server to serve the contents of this torrent,\n * dynamically fetching the needed torrent pieces to satisfy http requests.\n * Range requests are supported.\n *\n * @param {Object} options\n * @param {String} force\n * @return {BrowserServer||NodeServer}\n */\n createServer (options, force) {\n if (this.destroyed) throw new Error('torrent is destroyed')\n if (this._server) throw new Error('server already created')\n if ((typeof window === 'undefined' || force === 'node') && force !== 'browser') {\n // node implementation\n this._server = new NodeServer(this, options)\n return this._server\n } else {\n // browser implementation\n if (!(options?.controller instanceof ServiceWorkerRegistration)) throw new Error('Invalid worker registration')\n if (options.controller.active.state !== 'activated') throw new Error('Worker isn\\'t activated')\n this._server = new BrowserServer(this, options)\n return this._server\n }\n }\n\n get downloadSpeed () { return this._downloadSpeed() }\n\n get uploadSpeed () { return this._uploadSpeed() }\n\n get progress () {\n const torrents = this.torrents.filter(torrent => torrent.progress !== 1)\n const downloaded = torrents.reduce((total, torrent) => total + torrent.downloaded, 0)\n const length = torrents.reduce((total, torrent) => total + (torrent.length || 0), 0) || 1\n return downloaded / length\n }\n\n get ratio () {\n const uploaded = this.torrents.reduce((total, torrent) => total + torrent.uploaded, 0)\n const received = this.torrents.reduce((total, torrent) => total + torrent.received, 0) || 1\n return uploaded / received\n }\n\n /**\n * Returns the torrent with the given `torrentId`. Convenience method. Easier than\n * searching through the `client.torrents` array. Returns `null` if no matching torrent\n * found.\n *\n * @param {string|Buffer|Object|Torrent} torrentId\n * @return {Promise}\n */\n async get (torrentId) {\n if (torrentId instanceof Torrent) {\n if (this.torrents.includes(torrentId)) return torrentId\n } else {\n const torrents = this.torrents\n let parsed\n try { parsed = await parseTorrent(torrentId) } catch (err) {}\n if (!parsed) return null\n if (!parsed.infoHash) throw new Error('Invalid torrent identifier')\n\n for (const torrent of torrents) {\n if (torrent.infoHash === parsed.infoHash) return torrent\n }\n }\n return null\n }\n\n /**\n * Start downloading a new torrent. Aliased as `client.download`.\n * @param {string|Buffer|Object} torrentId\n * @param {Object} opts torrent-specific options\n * @param {function=} ontorrent called when the torrent is ready (has metadata)\n */\n add (torrentId, opts = {}, ontorrent = () => {}) {\n if (this.destroyed) throw new Error('client is destroyed')\n if (typeof opts === 'function') [opts, ontorrent] = [{}, opts]\n\n const onInfoHash = () => {\n if (this.destroyed) return\n for (const t of this.torrents) {\n if (t.infoHash === torrent.infoHash && t !== torrent) {\n torrent._destroy(new Error(`Cannot add duplicate torrent ${torrent.infoHash}`))\n ontorrent(t)\n return\n }\n }\n }\n\n const onReady = () => {\n if (this.destroyed) return\n ontorrent(torrent)\n this.emit('torrent', torrent)\n }\n\n function onClose () {\n torrent.removeListener('_infoHash', onInfoHash)\n torrent.removeListener('ready', onReady)\n torrent.removeListener('close', onClose)\n }\n\n this._debug('add')\n opts = opts ? Object.assign({}, opts) : {}\n\n const torrent = new Torrent(torrentId, this, opts)\n this.torrents.push(torrent)\n\n torrent.once('_infoHash', onInfoHash)\n torrent.once('ready', onReady)\n torrent.once('close', onClose)\n\n this.emit('add', torrent)\n return torrent\n }\n\n /**\n * Start seeding a new file/folder.\n * @param {string|File|FileList|Buffer|Array.} input\n * @param {Object=} opts\n * @param {function=} onseed called when torrent is seeding\n */\n seed (input, opts, onseed) {\n if (this.destroyed) throw new Error('client is destroyed')\n if (typeof opts === 'function') [opts, onseed] = [{}, opts]\n\n this._debug('seed')\n opts = opts ? Object.assign({}, opts) : {}\n\n // no need to verify the hashes we create\n opts.skipVerify = true\n\n const isFilePath = typeof input === 'string'\n\n // When seeding from fs path, initialize store from that path to avoid a copy\n if (isFilePath) opts.path = path.dirname(input)\n if (!opts.createdBy) opts.createdBy = `WebTorrent/${VERSION_STR}`\n\n const onTorrent = torrent => {\n const tasks = [\n cb => {\n // when a filesystem path is specified or the store is preloaded, files are already in the FS store\n if (isFilePath || opts.preloadedStore) return cb()\n torrent.load(streams, cb)\n }\n ]\n if (this.dht) {\n tasks.push(cb => {\n torrent.once('dhtAnnounce', cb)\n })\n }\n parallel(tasks, err => {\n if (this.destroyed) return\n if (err) return torrent._destroy(err)\n _onseed(torrent)\n })\n }\n\n const _onseed = torrent => {\n this._debug('on seed')\n if (typeof onseed === 'function') onseed(torrent)\n torrent.emit('seed')\n this.emit('seed', torrent)\n }\n\n const torrent = this.add(null, opts, onTorrent)\n let streams\n\n if (isFileList(input)) input = Array.from(input)\n else if (!Array.isArray(input)) input = [input]\n\n parallel(input.map(item => async cb => {\n if (!opts.preloadedStore && isReadable(item)) {\n const chunks = []\n try {\n for await (const chunk of item) {\n chunks.push(chunk)\n }\n } catch (err) {\n return cb(err)\n }\n const buf = concat(chunks)\n buf.name = item.name\n cb(null, buf)\n } else {\n cb(null, item)\n }\n }), (err, input) => {\n if (this.destroyed) return\n if (err) return torrent._destroy(err)\n\n parseInput(input, opts, (err, files) => {\n if (this.destroyed) return\n if (err) return torrent._destroy(err)\n\n streams = files.map(file => file.getStream)\n\n createTorrent(input, opts, async (err, torrentBuf) => {\n if (this.destroyed) return\n if (err) return torrent._destroy(err)\n\n const existingTorrent = await this.get(torrentBuf)\n if (existingTorrent) {\n console.warn('A torrent with the same id is already being seeded')\n torrent._destroy()\n if (typeof onseed === 'function') onseed(existingTorrent)\n } else {\n torrent._onTorrentId(torrentBuf)\n }\n })\n })\n })\n\n return torrent\n }\n\n /**\n * Remove a torrent from the client.\n * @param {string|Buffer|Torrent} torrentId\n * @param {function} cb\n */\n async remove (torrentId, opts, cb) {\n if (typeof opts === 'function') return this.remove(torrentId, null, opts)\n\n this._debug('remove')\n const torrent = await this.get(torrentId)\n if (!torrent) throw new Error(`No torrent with id ${torrentId}`)\n this._remove(torrent, opts, cb)\n }\n\n _remove (torrent, opts, cb) {\n if (!torrent) return\n if (typeof opts === 'function') return this._remove(torrent, null, opts)\n const index = this.torrents.indexOf(torrent)\n if (index === -1) return\n this.torrents.splice(index, 1)\n torrent.destroy(opts, cb)\n if (this.dht) {\n this.dht._tables.remove(torrent.infoHash)\n }\n this.emit('remove', torrent)\n }\n\n address () {\n if (!this.listening) return null\n return this._connPool\n ? this._connPool.tcpServer.address()\n : { address: '0.0.0.0', family: 'IPv4', port: 0 }\n }\n\n /**\n * Set global download throttle rate.\n * @param {Number} rate (must be bigger or equal than zero, or -1 to disable throttling)\n */\n throttleDownload (rate) {\n rate = Number(rate)\n if (isNaN(rate) || !isFinite(rate) || rate < -1) return false\n this._downloadLimit = rate\n if (this._downloadLimit < 0) return this.throttleGroups.down.setEnabled(false)\n this.throttleGroups.down.setEnabled(true)\n this.throttleGroups.down.setRate(this._downloadLimit)\n }\n\n /**\n * Set global upload throttle rate\n * @param {Number} rate (must be bigger or equal than zero, or -1 to disable throttling)\n */\n throttleUpload (rate) {\n rate = Number(rate)\n if (isNaN(rate) || !isFinite(rate) || rate < -1) return false\n this._uploadLimit = rate\n if (this._uploadLimit < 0) return this.throttleGroups.up.setEnabled(false)\n this.throttleGroups.up.setEnabled(true)\n this.throttleGroups.up.setRate(this._uploadLimit)\n }\n\n /**\n * Destroy the client, including all torrents and connections to peers.\n * @param {function} cb\n */\n destroy (cb) {\n if (this.destroyed) throw new Error('client already destroyed')\n this._destroy(null, cb)\n }\n\n _destroy (err, cb) {\n this._debug('client destroy')\n this.destroyed = true\n\n const tasks = this.torrents.map(torrent => cb => {\n torrent.destroy(cb)\n })\n\n if (this._connPool) {\n tasks.push(cb => {\n this._connPool.destroy(cb)\n })\n }\n\n if (this.dht) {\n tasks.push(cb => {\n this.dht.destroy(cb)\n })\n }\n\n if (this._server) {\n tasks.push(cb => {\n this._server.destroy(cb)\n })\n }\n\n if (this.natTraversal) {\n tasks.push(cb => {\n this.natTraversal.destroy()\n .then(() => cb())\n })\n }\n\n parallel(tasks, cb)\n\n if (err) this.emit('error', err)\n\n this.torrents = []\n this._connPool = null\n this.dht = null\n\n this.throttleGroups.down.destroy()\n this.throttleGroups.up.destroy()\n }\n\n _onListening () {\n this._debug('listening')\n this.listening = true\n\n if (this._connPool) {\n // Sometimes server.address() returns `null` in Docker.\n const address = this._connPool.tcpServer.address()\n if (address) {\n this.torrentPort = address.port\n if (this.natTraversal) {\n this.natTraversal.map({\n publicPort: this.torrentPort,\n privatePort: this.torrentPort,\n protocol: this.utp ? null : 'tcp',\n description: 'WebTorrent Torrent'\n }).catch(err => {\n debug('error mapping WebTorrent port via UPnP/PMP: %o', err)\n })\n }\n }\n }\n\n this.emit('listening')\n }\n\n _debug () {\n const args = [].slice.call(arguments)\n args[0] = `[${this._debugId}] ${args[0]}`\n debug(...args)\n }\n\n async _getByHash (infoHashHash) {\n for (const torrent of this.torrents) {\n if (!torrent.infoHashHash) {\n torrent.infoHashHash = await hash(hex2arr('72657132' /* 'req2' */ + torrent.infoHash), 'hex')\n }\n if (infoHashHash === torrent.infoHashHash) {\n return torrent\n }\n }\n\n return null\n }\n}\n\nWebTorrent.WEBRTC_SUPPORT = Peer.WEBRTC_SUPPORT\nWebTorrent.UTP_SUPPORT = ConnPool.UTP_SUPPORT\nWebTorrent.VERSION = VERSION\n\n/**\n * Check if `obj` is a node Readable stream\n * @param {*} obj\n * @return {boolean}\n */\nfunction isReadable (obj) {\n return typeof obj === 'object' && obj != null && typeof obj.pipe === 'function'\n}\n\n/**\n * Check if `obj` is a W3C `FileList` object\n * @param {*} obj\n * @return {boolean}\n */\nfunction isFileList (obj) {\n return typeof FileList !== 'undefined' && obj instanceof FileList\n}\n","import { assertPath } from './util.js'\r\n\r\nexport default function dirname (path) {\r\n assertPath(path)\r\n if (path.length === 0) return '.'\r\n let code = path.charCodeAt(0)\r\n const hasRoot = code === 47\r\n let end = -1\r\n let matchedSlash = true\r\n for (let i = path.length - 1; i >= 1; --i) {\r\n code = path.charCodeAt(i)\r\n if (code === 47) {\r\n if (!matchedSlash) {\r\n end = i\r\n break\r\n }\r\n } else {\r\n // We saw the first non-path separator\r\n matchedSlash = false\r\n }\r\n }\r\n\r\n if (end === -1) return hasRoot ? '/' : '.'\r\n if (hasRoot && end === 1) return '//'\r\n return path.slice(0, end)\r\n}\r\n"],"names":["leafPrototypes","getProto","concat","chunks","size","join","Uint8Array","b","offset","i","l","length","chunk","set","byteLength","module","exports","async","iterator","opts","nopad","zeroPadding","buffered","bufferedBytes","value","push","slice","LRU","queueMicrotask","constructor","store","this","chunkLength","inProgressGets","Map","get","put","Error","cache","index","buf","cb","remove","len","waiters","getAlreadyStarted","err","inProgressEntry","delete","slicedBuf","close","destroy","num","navigator","hardwareConcurrency","cpus","model","speed","times","user","nice","sys","idle","irq","formatArgs","args","useColors","namespace","humanize","diff","c","color","splice","lastC","replace","match","save","namespaces","storage","setItem","removeItem","error","load","r","getItem","process","env","DEBUG","window","type","__nwjs","userAgent","toLowerCase","m","document","documentElement","style","WebkitAppearance","console","firebug","exception","table","parseInt","localStorage","localstorage","warned","warn","colors","log","debug","formatters","j","v","JSON","stringify","message","createDebug","prevTime","namespacesCache","enabledCache","enableOverride","enabled","self","curr","Number","Date","ms","prev","coerce","unshift","format","formatter","val","call","apply","selectColor","extend","Object","defineProperty","enumerable","configurable","init","delimiter","newDebug","matchesTemplate","search","template","searchIndex","templateIndex","starIndex","matchIndex","default","stack","disable","names","skips","map","enable","split","trim","filter","Boolean","ns","name","skip","keys","forEach","key","hash","charCodeAt","Math","abs","once","noop","eos","stream","callback","ws","_writableState","rs","_readableState","readable","writable","cancelled","onlegacyfinish","onfinish","onend","onexit","exitCode","onerror","onclose","nextTick","onclosenexttick","ended","destroyed","onrequest","req","on","setHeader","abort","isRequest","stdio","Array","isArray","isChildProcess","removeListener","assign","obj","props","code","TypeError","_","ErrClass","prototype","create","getPrototypeOf","matchHtmlRegExp","string","escape","str","exec","html","lastIndex","substring","objectCreate","proto","F","objectKeys","k","hasOwnProperty","bind","Function","context","fn","arguments","EventEmitter","_events","_eventsCount","_maxListeners","undefined","hasDefineProperty","defaultMaxListeners","o","x","$getMaxListeners","that","_addListener","target","listener","prepend","events","existing","newListener","emit","w","String","emitter","count","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","_listeners","unwrap","evlistener","arr","ret","unwrapListeners","arrayClone","listenerCount","n","copy","arg","setMaxListeners","isNaN","getMaxListeners","er","handler","doError","isFn","listeners","emitNone","arg1","emitOne","arg2","emitTwo","arg3","emitThree","emitMany","addListener","prependListener","prependOnceListener","list","position","originalListener","shift","pop","spliceOne","removeAllListeners","rawListeners","eventNames","Reflect","ownKeys","hwm","buffer","mask","top","btm","next","clear","fill","data","last","peek","isEmpty","FixedFIFO","head","tail","ReadableStream","Symbol","asyncIterator","preventCancel","reader","getReader","read","temp","releaseLock","cancel","done","return","getIterator","mem","ctor","superCtor","super_","TempCtor","iterators","RateLimiter","TokenBucket","hrtime","seconds","nanoseconds","floor","getTime","getMilliseconds","tokensPerInterval","interval","fireImmediately","tokenBucket","content","curIntervalStart","tokensThisInterval","removeTokens","bucketSize","now","waitInterval","ceil","setTimeout","afterTokensRemoved","tokensRemaining","tryRemoveTokens","removed","getTokensRemaining","drip","parentBucket","lastDrip","comeBackLater","remainingTokens","min","POSITIVE_INFINITY","deltaMS","max","dripAmount","inherits","maxAge","element","_unlink","_checkAge","modified","evict","Storage","closed","Infinity","lastChunkLength","lastChunkIndex","isLastChunk","notFound","Mime","_types","_extensions","define","getType","getExtension","typeMap","force","extensions","t","ext","substr","path","hasPath","test","RegExp","$1","s","h","d","y","plural","msAbs","isPlural","round","options","parseFloat","parse","isFinite","long","fmtLong","fmtShort","wrappy","f","called","onceStrict","onceError","strict","bytes","log2","fs","e","ancient","version","destroyer","reading","writing","ReadStream","WriteStream","isFS","pipe","from","to","streams","destroys","reduce","promise","Promise","resolve","then","catch","random","el","tmp","mapWithIndex","range","start","end","mapWithoutIndex","sortByRangeIndex","a","sortByRangeStart","indexOf","ranges","combine","ordered","sort","current","combined","combineRanges","isInteger","createRC4","N","seed","every","keylen","identityPermutation","RC4","randomNative","randomUInt32","randomByte","randomFloat","currentState","setState","RC4small","ordA","ord0","toHex","fromCharCode","fromHex","currentStateString","setStateString","stateString","tasks","limit","results","pending","isErrored","isSync","each","result","some","task","Throttle","ThrottleGroup","throttles","setEnabled","setRate","rate","chunksize","getEnabled","_enabled","getRate","bucket","getChunksize","throttle","setChunksize","group","_addThrottle","_removeThrottle","Transform","wait","super","params","_setEnabled","_group","_emitter","_destroyed","getGroup","_transform","_processChunk","_waitForTokens","amount","reject","isDone","_areBothEnabled","pos","time","STREAM_DESTROYED","PREMATURE_CLOSE","queueTick","FIFO","TextDecoder","MAX","NOT_OPENING","NOT_PREDESTROYING","READ_PRIMARY","READ_QUEUED","READ_RESUMED","READ_ENDING","READ_EMIT_DATA","READ_EMIT_READABLE","READ_EMITTED_READABLE","READ_DONE","READ_NEXT_TICK","READ_READ_AHEAD","READ_RESUMED_READ_AHEAD","READ_NOT_ACTIVE","READ_PUSHED","READ_PIPE_NOT_DRAINED","READ_NOT_NEXT_TICK","READ_NOT_UPDATING","READ_NO_READ_AHEAD","WRITE_ACTIVE","WRITE_UPDATING","WRITE_PRIMARY","WRITE_QUEUED","WRITE_UNDRAINED","WRITE_DONE","WRITE_EMIT_DRAIN","WRITE_NEXT_TICK","WRITE_WRITING","WRITE_FINISHING","WRITE_CORKED","WRITE_NON_PRIMARY","WRITE_NOT_NEXT_TICK","WRITE_NOT_CORKED","ACTIVE","READ_ACTIVE","NOT_ACTIVE","DONE","DESTROY_STATUS","DESTROYING","OPEN_STATUS","AUTO_DESTROY","ACTIVE_OR_TICKING","IS_OPENING","WRITE_QUEUED_AND_ACTIVE","WRITE_STATUS","WritableState","highWaterMark","mapWritable","byteLengthWritable","queue","pipeline","drains","defaultByteLength","afterWrite","afterUpdateNextTick","updateWriteNT","_duplexState","autoBatch","_writev","update","_write","updateNonPrimary","continueUpdate","_final","afterFinal","_open","afterOpen","_destroy","afterDestroy","updateCallback","updateNextTick","ReadableState","mapReadable","byteLengthReadable","readAhead","pipeTo","afterRead","updateReadNT","Pipeline","isStreamx","finished","afterDrain","write","drain","_read","READ_UPDATING","TransformState","afterTransform","src","dst","afterPipe","pipeToFinished","writes","tickDrains","Stream","open","predestroy","_predestroy","signal","addEventListener","destroying","Readable","OPENING","eagerOpen","encoding","setEncoding","dec","echo","remaining","dest","resume","pause","_fromAsyncIterator","ite","isBackpressured","isPaused","promiseResolve","promiseReject","ondata","throw","Writable","writev","final","cork","uncork","batch","drained","Duplex","_transformState","transform","flush","_flush","transformAfterFlush","all","errorHandle","fin","autoDestroy","rd","wr","isStream","isTypedArray","pipelinePromise","isEnded","isFinished","getStreamError","PassThrough","PassThroughDecoder","UTF8Decoder","normalizeEncoding","decoder","decode","getTick","pointer","delta","tick","dist","wrapper","TYPE_TCP_INCOMING","TYPE_TCP_OUTGOING","TYPE_UTP_INCOMING","TYPE_UTP_OUTGOING","TYPE_WEBSEED","secure","enableSecure","Peer","id","addr","conn","swarm","wire","source","connected","timeout","retries","sentPe1","sentPe2","sentPe3","sentPe4","sentHandshake","onConnect","clearTimeout","connectTimeout","onPe1","onPe2","onPe3","onPe4","infoHash","peerId","onHandshake","startHandshakeTimeout","setThrottlePipes","sendPe1","handshake","sendPe2","sendPe3","infoHashHash","sendPe4","clearPipes","unpipe","throttleGroups","down","up","handshakeTimeout","remoteAddress","remotePort","_onWire","dht","private","client","fast","startConnectTimeout","connectTimeoutValues","webrtc","tcpOutgoing","utpOutgoing","unref","wires","removePeer","TYPE_WEBRTC","SOURCE_MANUAL","SOURCE_TRACKER","SOURCE_DHT","SOURCE_LSD","SOURCE_UT_PEX","createWebRTCPeer","peer","cleanup","onError","createTCPIncomingPeer","_createIncomingPeer","createUTPIncomingPeer","createTCPOutgoingPeer","_createOutgoingPeer","createUTPOutgoingPeer","createWebSeedPeer","digitCount","sign","log10","ArrayBuffer","isView","Set","encode","buffers","_encode","_floatConversionDetected","dict","dictMap","listSet","number","byteOffset","buffE","buffD","buffL","BigInt","maxLo","trace","kl","item","getIntFromBuffer","sum","dictionary","integer","find","chr","toString","includes","lst","sep","encodingLength","arrayBufferLength","stringLength","listLength","keyLength","objectLength","mapLength","bitsToBytes","numberOfBits","BitField","grow","bitIndex","byteIndex","newLength","newBuffer","setAll","array","targetLength","bitMask","callbackfn","MESSAGE_PROTOCOL","MESSAGE_KEEP_ALIVE","MESSAGE_CHOKE","MESSAGE_UNCHOKE","MESSAGE_INTERESTED","MESSAGE_UNINTERESTED","MESSAGE_RESERVED","MESSAGE_PORT","MESSAGE_HAVE_ALL","MESSAGE_HAVE_NONE","VC","CRYPTO_PROVIDE","CRYPTO_SELECT","xor","Request","piece","HaveAllBitField","Wire","peEnabled","_debugId","_debug","peerIdBuffer","amChoking","amInterested","peerChoking","peerInterested","peerPieces","peerExtensions","requests","peerRequests","extendedMapping","peerExtendedMapping","extendedHandshake","peerExtendedHandshake","hasFast","allowedFastSet","peerAllowedFastSet","_ext","_nextExt","uploaded","downloaded","uploadSpeed","downloadSpeed","_keepAliveInterval","_timeout","_timeoutMs","_timeoutExpiresAt","_finished","_parserSize","_parser","_buffer","_bufferSize","_peEnabled","_dh","_myPubKey","generateKeys","_peerPubKey","_sharedSecret","_peerCryptoProvide","_cryptoHandshakeDone","_cryptoSyncPattern","_waitMaxBytes","_encryptionMethod","_encryptGenerator","_decryptGenerator","_setGenerators","_onFinish","_determineHandshakeType","_parsePe2","_parseHandshake","setKeepAlive","clearInterval","setInterval","keepAlive","_timeoutUnref","_resetTimeout","_onUninterested","_onChoke","use","Extension","onExtendedHandshake","onMessage","_push","padALen","padA","padBLen","padB","setEncrypt","hash1Buffer","_utfToHex","hashesXorBuffer","padCLen","DataView","getUint16","padCBuffer","vcAndProvideBuffer","view","setInt16","_encryptHandshake","padDLen","padDBuffer","vcAndSelectBuffer","infoHashBuffer","_infoHash","reserved","extended","_handshakeSent","_extendedHandshakeSent","_sendExtendedHandshake","msg","choke","allowedCount","request","unchoke","interested","uninterested","have","_message","bitfield","_callback","_pull","port","setUint16","suggest","haveAll","haveNone","allowedFast","extId","sharedSecret","encryptKeyBuf","encryptKeyIntArray","decryptKeyBuf","decryptKeyIntArray","values","numbers","dataLength","setUint32","_encrypt","_onKeepAlive","_onPe1","pubKeyBuffer","computeSecret","_onPe2","_onPe3","hash3","sKeyHash","_onPe3Encrypted","vcBuffer","peerProvideBuffer","provideByte","_onPe4","peerSelectBuffer","_onHandshake","_onUnchoke","_onInterested","_onHave","_onBitField","_onRequest","respond","_onPiece","_onCancel","_onPort","_onSuggest","_onHaveAll","_onHaveNone","_onReject","_onAllowedFast","_onExtended","info","_onTimeout","_decrypt","setAgain","timeoutExpiresAt","_parse","parser","_parseUntil","pattern","maxBytes","_onMessageLength","getUint32","_onMessage","pstrLenBuffer","pstrlen","_onHandshakeBuffer","_parsePe1","pubKeyPrefix","pubKeySuffix","_parsePe3","pubKey","_parsePe4","_parsePe3Encrypted","_decryptHandshake","iaLenBuf","iaLen","iaBuffer","protocol","vcBufferEncrypted","padDBuf","MAX_VALUE","crypt","keystream","decrypt","alphabet","encodeLookup","decodeLookup","arr2hex","hex2arr","sizeof","equal","chars","lookup","arr2text","enc","encoder","TextEncoder","text2arr","arr2base","arraybuffer","base64","bin2hex","res","hex2bin","hex","points","subarray","scope","crypto","msCrypto","subtle","webkitSubtle","formatMap","algo","out","digest","randomBytes","getRandomValues","title","browser","argv","versions","off","func","cwd","umask","binding","chdir","dir","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","mode","__esModule","def","getOwnPropertyNames","definition","prop","toStringTag","allowAboveRoot","lastSegmentLength","lastSlash","dots","lastSlashIndex","lastIndexOf","joined","isAbsolute","trailingSeparator","filename","input","FileList","commonPrefix","fullPath","unknownName","filterJunkFiles","pathless","matchedSlash","extIdx","firstNonSlashEnd","maxPieceLength","numPaths","isSingleFileTorrent","pathIsFile","processInput","file","getStream","files","flat","Blob","singleFileTorrent","_announceList","announceList","announce","u","globalThis","WEBTORRENT_ANNOUNCE","urlList","torrent","creationDate","comment","createdBy","sslCert","estimatedTorrentLength","pieceLength","pieces","hashedLength","onProgress","remainingHashes","pieceNum","torrentLength","File","FormData","Headers","Response","AbortController","AbortSignal","fetch","encoded","plainChar","shiftIndex","plainDigit","plainPos","decoded","encodedByte","acc","cur","idx","generateRange","uri","param","keyval","decodeURIComponent","xt","infoHashV2","xs","publicKey","infoHashV2Buffer","publicKeyBuffer","dn","kt","keywords","tr","as","peerAddresses","torrentId","torrentObj","infoBuffer","created","urls","url","parts","p","lastFile","lastPieceLength","parsedTorrent","parseOrThrow","arrayBuffer","headers","torrentBuf","bool","fieldName","xts","add","xtsDeduped","encodeURIComponent","startsWith","RTCPeerConnection","mozRTCPeerConnection","webkitRTCPeerConnection","RTCSessionDescription","mozRTCSessionDescription","webkitRTCSessionDescription","RTCIceCandidate","mozRTCIceCandidate","webkitRTCIceCandidate","RTCIceTransport","RTCDataChannel","RTCSctpTransport","RTCDtlsTransport","RTCCertificate","MediaStream","MediaStreamTrack","MediaStreamTrackEvent","RTCPeerConnectionIceEvent","RTCDataChannelEvent","RTCTrackEvent","RTCError","RTCErrorEvent","RTCRtpTransceiver","RTCRtpReceiver","RTCRtpSender","sdp","_pc","allowHalfOpen","__objectMode","objectMode","_id","channelName","initiator","channelConfig","channelNegotiated","negotiated","config","offerOptions","answerOptions","sdpTransform","trickle","allowHalfTrickle","iceCompleteTimeout","_destroying","_connected","remoteFamily","localAddress","localFamily","localPort","_pcReady","_channelReady","_iceComplete","_iceCompleteTimer","_channel","_pendingCandidates","_isNegotiating","_firstNegotiation","_batchedNegotiation","_queuedNegotiation","_sendersAwaitingStable","_closingInterval","_remoteTracks","_remoteStreams","_chunk","_cb","_interval","__destroy","_isReactNativeWebrtc","_peerConnectionId","oniceconnectionstatechange","_onIceStateChange","onicegatheringstatechange","onconnectionstatechange","_onConnectionStateChange","onsignalingstatechange","_onSignalingStateChange","onicecandidate","event","_onIceCandidate","peerIdentity","_setupData","channel","createDataChannel","ondatachannel","_needsNegotiation","_onFinishBound","bufferSize","bufferedAmount","readyState","address","family","renegotiate","transceiverRequest","addTransceiver","kind","candidate","remoteDescription","_addIceCandidate","setRemoteDescription","_createAnswer","iceCandidateObj","addIceCandidate","endsWith","send","negotiate","_createOffer","_senderMap","onmessage","onopen","ontrack","binaryType","bufferedAmountLowThreshold","label","_onChannelMessage","onbufferedamountlow","_onChannelBufferedAmountLow","_onChannelOpen","_onChannelClose","lineno","colno","isClosing","destroySoon","_startIceCompleteTimeout","createOffer","offer","sendOffer","localDescription","setLocalDescription","createAnswer","answer","sendAnswer","_requestMissingTransceivers","connectionState","iceConnectionState","iceGatheringState","_maybeReady","getStats","flattenValues","report","reports","stat","timestamp","_connecting","findCandidatePair","items","remoteCandidates","localCandidates","candidatePairs","foundSelectedCandidatePair","setSelectedCandidatePair","selectedCandidatePair","local","localCandidateId","ip","ipAddress","portNumber","googLocalAddress","remote","remoteCandidateId","googRemoteAddress","selectedCandidatePairId","googActiveConnection","selected","_onInterval","signalingState","sender","removeTrack","sdpMLineIndex","sdpMid","WEBRTC_SUPPORT","iceServers","sdpSemantics","has","chunkOffset","remainingLength","storeMaxOutstandingPuts","outstandingPuts","DEFAULT_ANNOUNCE_PEERS","MAX_ANNOUNCE_PEERS","parseUrl","URL","defineProperties","href","origin","WebSocket","socket","_ws","OPEN","_handleOpen","_handleMessage","_handleClose","_handleError","_handleFinishBound","_handleFinish","onClose","CLOSED","WEBSOCKET_SUPPORT","announceUrl","intervalMs","DEFAULT_ANNOUNCE_INTERVAL","_defaultAnnounceOpts","peers","reconnecting","reconnectTimer","expectingResponse","_openSocket","action","info_hash","_infoHashBinary","peer_id","_peerIdBinary","_trackerId","trackerid","_send","numwant","_generateOffers","offers","scrape","trackerTimeout","_onSocketConnectBound","_onSocketDataBound","_onSocketCloseBound","_onSocketErrorBound","consumers","destroyCleanup","DESTROY_TIMEOUT","_onSocketConnect","_onSocketError","_onSocketData","_onSocketClose","parsedUrl","agent","_proxyOpts","httpsAgent","httpAgent","socksProxy","_onAnnounceResponse","_onScrapeResponse","failure","warning","trackerId","complete","response","_createPeer","to_peer_id","offer_id","offerId","_startReconnectTimer","pow","generateOffer","checkDone","_rtcConfig","wrtc","_wrtc","_socketPool","_peerIdBuffer","_infoHashBuffer","_port","_getAnnounceOpts","getAnnounceOpts","rtcConfig","_userAgent","proxyOpts","webrtcSupport","nextTickWarn","_trackers","location","_announce","tracker","stop","clientOpts","_intervalMs","_trackerOpts","_dhtAnnouncing","_dhtTimeout","_internalDHT","_onWarning","_onError","_onDHTPeer","host","_onTrackerPeer","_onTrackerAnnounce","_onLSDPeer","createDHT","listen","_createTracker","addNode","dhtPort","_dhtAnnounce","lsd","_createLSD","updatePort","WritableStream","writer","setPrototypeOf","FileSystemWritableFileStream","_closed","getWriter","seek","truncate","FileSystemFileHandle","createWritable","wm","WeakMap","workerUrl","fileHandle","handle","evt","ports","cmd","getDirectory","folder","getDirectoryHandle","getFileHandle","createSyncAccessHandle","at","postMessage","stringCode","blob","createObjectURL","worker","Worker","textEncoder","getFile","mc","MessageChannel","port1","port2","root","parent","DOMException","keepExistingData","ab","terminate","reason","orig","FileSystemDirectoryHandle","storageDir","removeEntry","recursive","__","chunkMap","directoryMap","rootDirPromise","storageDirPromise","chunksDirPromise","closing","randomUUID","rootDir","_getChunksDirHandle","prevFile","_createFileHandle","_createBlobReference","fileStart","fileEnd","firstChunk","lastChunk","chunkStart","_getChunkHandle","fileName","_getDirectoryHandle","_put","getStreamForHandle","chunkWrite","targets","promises","_get","rangeFrom","rangeTo","clearChunks","ltDontHave","_peerSupports","_wire","_failRequests","donthave","missing","sources","_chunks","_remainder","_buffered","_cancellations","_reservations","_flushed","chunkLengthRemaining","reserve","reserveRemaining","cancelRemaining","blocks","splitData","BLOCK_LENGTH","metadata","utMetadata","_fetching","_metadataComplete","_metadataSize","_remainingRejects","_bitfield","setMetadata","ut_metadata","metadata_size","_numPieces","_requestPieces","trailer","trailerIndex","msg_type","_onData","total_size","_request","_data","totalSize","_reject","_checkDone","_failedMetadata","_torrent","_pieceLength","_startPiece","_endPiece","_piece","_offset","_missing","_criticalLength","_select","pump","critical","_deselect","_fileStreams","_iterators","_client","getPieceDownloaded","pieceIndex","pieceDownloaded","irrelevantFirstPieceBytes","irrelevantLastPieceBytes","progress","select","priority","deselect","createReadStream","fileStream","pull","controller","enqueue","streamURL","_server","pathname","streamTo","elem","_pieces","recalculate","_initWire","_onWireHave","_onWireBitfield","getRarestPiece","pieceFilterFunc","candidates","availability","_cleanupWireEvents","_onClose","connId","_init","numPieces","lt_donthave","httpRequest","retryTimeout","rangeStart","rangeEnd","requestedFiles","requestedFile","fileOffsetInRange","method","ok","status","_items","isStreamSelection","replacingItems","existingStart","existingEnd","insert","newItem","notify","oldNotify","intersectingNotifyFunctions","sortFn","swap","existingIntervalSize","newItemIntervalSize","requestIdleCallback","addUID","skipVerify","_store","_preloadedStore","preloadedStore","_storeCacheSlots","storeCacheSlots","_destroyStoreOnDestroy","destroyStoreOnDestroy","storeOpts","alwaysChokeSeeders","strategy","maxWebConns","_rechokeNumSlots","uploads","_rechokeOptimisticWire","_rechokeOptimisticTime","_rechokeIntervalId","_noPeersIntervalId","_noPeersIntervalTime","noPeersIntervalTime","_startAsDeselected","ready","paused","_amInterested","_selections","_critical","_queue","_peers","_peersLength","received","_downloadSpeed","_uploadSpeed","_servers","_xsRequests","_fileModtimes","fileModtimes","_onTorrentId","timeRemaining","ratio","numPeers","torrentFileBlob","torrentFile","_numQueued","_numConns","numConns","_onParsedTorrent","_processParsedTorrent","_rechoke","listening","_onListening","magnetURI","parsed","_onMetadata","_getMetadataFromServer","_startDiscovery","discovery","trackerOpts","left","addPeer","torrentPort","seedOutgoingConnections","counters","utPex","counter","_xsRequestsController","getMetadataFromURL","enableWebSeeds","addWebSeed","_rarityMap","rawStore","so","_hashes","_markAllVerified","_onStore","onPiecesVerified","getFileModtimes","_verifyPieces","filePath","mtime","getOpts","_markVerified","_markUnverified","rescanFiles","_hasAllPieces","_hasNoPieces","_hasMorePieces","threshold","_updateSelections","_onWireWithMetadata","_remove","server","destroyStore","blocked","contains","utp","_isIPv4","wasAdded","_addPeer","_validAddr","newPeer","_registerPeer","_drain","urlOrConn","_addIncomingPeer","ut_pex","peerObj","reset","timeoutId","onChokeTimeout","updateSeedStatus","isSeeder","_update","_updateWireInterest","_gcSelections","_updateInterest","oldOffset","_updateWireWrapper","_updateWire","minOutstandingRequests","maxOutstandingRequests","requestAllowedFastSet","tried","tries","genPieceFilterFunc","validateWire","trySelectWire","rank","shufflePriority","hotswap","secs","ptr","otherWire","otherSpeed","speedRanker","wireStack","objA","objB","wireA","wireB","numInterestedUnchoked","newOptimisticPeer","high","_hotswap","minWire","minSpeed","numRequests","isWebSeed","duration","reservation","onUpdateTick","onChunk","selection","maxConns","reconnectTimeout","reqq","pendingReady","serveIndexPage","torrents","listHtml","body","isOriginAllowed","serveMethodNotAllowed","serve404Page","serveTorrentPage","serveOptionsRequest","serveFile","Expires","destination","statusCode","onRequest","onReady","handleRequest","decodeURI","_listen","_close","sockets","wrapRequest","hostname","writeHead","onConnection","registration","workerKeepAliveInterval","workerPortCount","_address","boundHandler","serviceWorker","removeEventListener","pageHtml","unescape","nodeId","nodeIdBuffer","natUpnp","natPmp","UTP_SUPPORT","_downloadLimit","downloadLimit","_uploadLimit","uploadLimit","natTraversal","enableUPNP","enablePMP","upnpPermanentFallback","WRTC","_connPool","publicPort","privatePort","description","webSeeds","blocklist","ipSet","createServer","ServiceWorkerRegistration","active","total","ontorrent","onInfoHash","onseed","isFilePath","hasRoot","_onseed","existingTorrent","_tables","tcpServer","throttleDownload","throttleUpload","_getByHash","VERSION"],"sourceRoot":""} -js/gridHealth.js:234:const PROBE_POLL_COUNT = 3; -js/gridHealth.js:352: badge.classList.contains("mt-sm") || badge.classList.contains("mt-3"); -js/utils/qrcode.js:54: byteArray[3] = 0x80 | (code & 0x3F); -js/utils/qrcode.js:103: return pattern;},createMovieClip:function(target_mc,instance_name,depth){var qr_mc=target_mc.createEmptyMovieClip(instance_name,depth);var cs=1;this.make();for(var row=0;row>i)&1)==1);this.modules[Math.floor(i/3)][i%3+this.moduleCount-8-3]=mod;} -js/utils/qrcode.js:109: for(var i=0;i<18;i++){var mod=(!test&&((bits>>i)&1)==1);this.modules[i%3+this.moduleCount-8-3][Math.floor(i/3)]=mod;}},setupTypeInfo:function(test,maskPattern){var data=(this.errorCorrectLevel<<3)|maskPattern;var bits=QRUtil.getBCHTypeInfo(data);for(var i=0;i<15;i++){var mod=(!test&&((bits>>i)&1)==1);if(i<6){this.modules[i][8]=mod;}else if(i<8){this.modules[i+1][8]=mod;}else{this.modules[this.moduleCount-15+i][8]=mod;}} -js/utils/qrcode.js:131: return data;};var QRMode={MODE_NUMBER:1<<0,MODE_ALPHA_NUM:1<<1,MODE_8BIT_BYTE:1<<2,MODE_KANJI:1<<3};var QRErrorCorrectLevel={L:1,M:0,Q:3,H:2};var QRMaskPattern={PATTERN000:0,PATTERN001:1,PATTERN010:2,PATTERN011:3,PATTERN100:4,PATTERN101:5,PATTERN110:6,PATTERN111:7};var QRUtil={PATTERN_POSITION_TABLE:[[],[6,18],[6,22],[6,26],[6,30],[6,34],[6,22,38],[6,24,42],[6,26,46],[6,28,50],[6,30,54],[6,32,58],[6,34,62],[6,26,46,66],[6,26,48,70],[6,26,50,74],[6,30,54,78],[6,30,56,82],[6,30,58,86],[6,34,62,90],[6,28,50,72,94],[6,26,50,74,98],[6,30,54,78,102],[6,28,54,80,106],[6,32,58,84,110],[6,30,58,86,114],[6,34,62,90,118],[6,26,50,74,98,122],[6,30,54,78,102,126],[6,26,52,78,104,130],[6,30,56,82,108,134],[6,34,60,86,112,138],[6,30,58,86,114,142],[6,34,62,90,118,146],[6,30,54,78,102,126,150],[6,24,50,76,102,128,154],[6,28,54,80,106,132,158],[6,32,58,84,110,136,162],[6,26,54,82,110,138,166],[6,30,58,86,114,142,170]],G15:(1<<10)|(1<<8)|(1<<5)|(1<<4)|(1<<2)|(1<<1)|(1<<0),G18:(1<<12)|(1<<11)|(1<<10)|(1<<9)|(1<<8)|(1<<5)|(1<<2)|(1<<0),G15_MASK:(1<<14)|(1<<12)|(1<<10)|(1<<4)|(1<<1),getBCHTypeInfo:function(data){var d=data<<10;while(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G15)>=0){d^=(QRUtil.G15<<(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G15)));} -js/utils/qrcode.js:134: return digit;},getPatternPosition:function(typeNumber){return QRUtil.PATTERN_POSITION_TABLE[typeNumber-1];},getMask:function(maskPattern,i,j){switch(maskPattern){case QRMaskPattern.PATTERN000:return(i+j)%2==0;case QRMaskPattern.PATTERN001:return i%2==0;case QRMaskPattern.PATTERN010:return j%3==0;case QRMaskPattern.PATTERN011:return(i+j)%3==0;case QRMaskPattern.PATTERN100:return(Math.floor(i/2)+Math.floor(j/3))%2==0;case QRMaskPattern.PATTERN101:return(i*j)%2+(i*j)%3==0;case QRMaskPattern.PATTERN110:return((i*j)%2+(i*j)%3)%2==0;case QRMaskPattern.PATTERN111:return((i*j)%3+(i+j)%2)%2==0;default:throw new Error("bad maskPattern:"+maskPattern);}},getErrorCorrectPolynomial:function(errorCorrectLength){var a=new QRPolynomial([1],0);for(var i=0;i5){lostPoint+=(3+sameCount-5);}}} -js/utils/qrcode.js:140: for(var row=0;row= 3)) { -js/utils/profileMedia.js:3:const LOCALHOST_PATTERN = /^(?:localhost|(?:\d{1,3}\.){3}\d{1,3})(?::\d+)?(?:[/?#].*)?$/i; -js/utils/hashtagNormalization.js:11: * 3) Lowercase the remaining value. -js/utils/formatters.js:111: const v = n % 100; -js/utils/lruCache.js:13: * @param {number} [options.maxSize=100] - Maximum number of entries. -js/utils/lruCache.js:15: constructor({ maxSize = 100 } = {}) { -js/utils/lruCache.js:16: this.maxSize = maxSize > 0 ? maxSize : 100; -js/reactionCounter.js:675: if (Array.isArray(pointer) && pointer.length >= 3) { -js/channelProfile.js:488: d: "M10 18a8 8 0 100-16 8 8 0 000 16zm3.78-9.72a.75.75 0 00-1.06-1.06L9 11.94l-1.72-1.72a.75.75 0 10-1.06 1.06l2.25 2.25a.75.75 0 001.06 0l3.25-3.25z", -js/channelProfile.js:495: d: "M10 18a8 8 0 100-16 8 8 0 000 16zm-.75-11.75a.75.75 0 011.5 0v4.5a.75.75 0 01-1.5 0v-4.5zm.75 8.5a1 1 0 100-2 1 1 0 000 2z", -js/channelProfile.js:2358: "rounded border border-border bg-overlay-panel-soft p-3 text-text"; -js/channelProfile.js:2374: li.className = "rounded border border-border bg-overlay-panel-soft p-3"; -js/channelProfile.js:2883: const overrideFee = share.type === "platform" ? 100 : 0; -js/channelProfile.js:3793: // 3) Load subscription state when logged in, but always render the toggle UI -js/channelProfile.js:4174: icon.className = "w-5 h-5"; -js/userBlocks.js:85:const FAST_BLOCKLIST_RELAY_LIMIT = 3; -js/userBlocks.js:95:const MAX_BLOCKLIST_ENTRIES = 5000; -js/userBlocks.js:491: chk = ((chk & 0x1ffffff) << 5) ^ value; -js/userBlocks.js:506: expanded.push(code >>> 5); -js/userBlocks.js:595: const bytes = convertBits(decoded.words, 5, 8, false); -js/userBlocks.js:916: const nip07DecryptTimeoutMs = allowPermissionPrompt ? 15000 : 8000; -js/userBlocks.js:1265: // Legacy Block: Kind 10000 with d=user-blocks OR Kind 30002 -js/userBlocks.js:1270: // Standard Mute: Kind 10000 WITHOUT d=user-blocks -js/userBlocks.js:1339: // The first scheme to succeed wins, avoiding sequential 3-15s timeouts -js/userBlocks.js:1556: // We prioritize standard NIP-51 lists (Kind 10000) to ensure the UI loads quickly. -js/userBlocks.js:1564: timeoutMs: 10000, -js/subscriptions.js:45: getNostrEventSchema(NOTE_TYPES.SUBSCRIPTION_LIST)?.kind ?? 30000; -js/subscriptions.js:339: * Manages the user's subscription list (kind=30000 follow set) *privately*, -js/subscriptions.js:391: * Decrypt the subscription list from kind=30000 (d="subscriptions"). -js/subscriptions.js:912: // scheme × up to 3 schemes = ~18s) = ~30s. Reduced from 45s to prevent -js/subscriptions.js:1096: const nip07DecryptTimeoutMs = allowPermissionPrompt ? 12000 : 5000; -js/subscriptions.js:1216: // The first scheme to succeed wins, avoiding sequential 3-15s timeouts -js/subscriptions.js:1334: * as kind=30000 with ["d", "subscriptions"] to be replaceable. -js/subscriptions.js:2288: // Fetch all kind 30000 events for this user to find backups and old versions -js/webtorrent.js:179: this.TIMEOUT_DURATION = 60000; -js/webtorrent.js:199: { timeoutMs = 8000, maxWebConns = 2, polls = 3, urlList = [] } = {} -js/webtorrent.js:236: const safePolls = Math.max(1, Math.floor(normalizeNumber(polls, 3))); -js/webtorrent.js:839: if (videoElement.readyState >= 3) { -js/webtorrent.js:964: // 3) Add the torrent to the client and handle accordingly. -js/webtorrent.min.js:1:var e,t,s={1467:e=>{function t(e,t){if("string"==typeof e[0])return e.join("");if("number"==typeof e[0])return new Uint8Array(e);const s=new Uint8Array(t);let i=0;for(let t=0,n=e.length;t=s){const e=t(o,a);let i=0;for(;a>=s;)yield e.slice(i,i+s),a-=s,i+=s;o=[e.slice(i,e.length)]}a&&(yield t(o,r?s:a))}},4497:(e,t,s)=>{const i=s(8454),n=s(9596);e.exports=class{constructor(e,t){if(this.store=e,this.chunkLength=e.chunkLength,this.inProgressGets=new Map,!this.store||!this.store.get||!this.store.put)throw new Error("First argument must be abstract-chunk-store compliant");this.cache=new i(t)}put(e,t,s=()=>{}){if(!this.cache)return n((()=>s(new Error("CacheStore closed"))));this.cache.remove(e),this.store.put(e,t,s)}get(e,t,s=()=>{}){if("function"==typeof t)return this.get(e,null,t);if(!this.cache)return n((()=>s(new Error("CacheStore closed"))));t||(t={});let i=this.cache.get(e);if(i){const e=t.offset||0,r=t.length||i.length-e;return 0===e&&r===i.length||(i=i.slice(e,r+e)),n((()=>s(null,i)))}let r=this.inProgressGets.get(e);const o=!!r;r||(r=[],this.inProgressGets.set(e,r)),r.push({opts:t,cb:s}),o||this.store.get(e,((t,s)=>{t||null==this.cache||this.cache.set(e,s);const i=this.inProgressGets.get(e);this.inProgressGets.delete(e);for(const{opts:e,cb:n}of i)if(t)n(t);else{const t=e.offset||0,i=e.length||s.length-t;let r=s;0===t&&i===s.length||(r=s.slice(t,i+t)),n(null,r)}}))}close(e=()=>{}){if(!this.cache)return n((()=>e(new Error("CacheStore closed"))));this.cache=null,this.store.close(e)}destroy(e=()=>{}){if(!this.cache)return n((()=>e(new Error("CacheStore closed"))));this.cache=null,this.store.destroy(e)}}},4018:e=>{e.exports=function(){for(var e=navigator.hardwareConcurrency||1,t=[],s=0;s{var i=s(717);t.formatArgs=function(t){if(t[0]=(this.useColors?"%c":"")+this.namespace+(this.useColors?" %c":" ")+t[0]+(this.useColors?"%c ":" ")+"+"+e.exports.humanize(this.diff),!this.useColors)return;const s="color: "+this.color;t.splice(1,0,s,"color: inherit");let i=0,n=0;t[0].replace(/%[a-zA-Z%]/g,(e=>{"%%"!==e&&(i++,"%c"===e&&(n=i))})),t.splice(n,0,s)},t.save=function(e){try{e?t.storage.setItem("debug",e):t.storage.removeItem("debug")}catch(e){}},t.load=function(){let e;try{e=t.storage.getItem("debug")}catch(e){}!e&&void 0!==i&&"env"in i&&(e=i.env.DEBUG);return e},t.useColors=function(){if("undefined"!=typeof window&&window.process&&("renderer"===window.process.type||window.process.__nwjs))return!0;if("undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))return!1;let e;return"undefined"!=typeof document&&document.documentElement&&document.documentElement.style&&document.documentElement.style.WebkitAppearance||"undefined"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||"undefined"!=typeof navigator&&navigator.userAgent&&(e=navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/))&&parseInt(e[1],10)>=31||"undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)},t.storage=function(){try{return localStorage}catch(e){}}(),t.destroy=(()=>{let e=!1;return()=>{e||(e=!0,console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."))}})(),t.colors=["#0000CC","#0000FF","#0033CC","#0033FF","#0066CC","#0066FF","#0099CC","#0099FF","#00CC00","#00CC33","#00CC66","#00CC99","#00CCCC","#00CCFF","#3300CC","#3300FF","#3333CC","#3333FF","#3366CC","#3366FF","#3399CC","#3399FF","#33CC00","#33CC33","#33CC66","#33CC99","#33CCCC","#33CCFF","#6600CC","#6600FF","#6633CC","#6633FF","#66CC00","#66CC33","#9900CC","#9900FF","#9933CC","#9933FF","#99CC00","#99CC33","#CC0000","#CC0033","#CC0066","#CC0099","#CC00CC","#CC00FF","#CC3300","#CC3333","#CC3366","#CC3399","#CC33CC","#CC33FF","#CC6600","#CC6633","#CC9900","#CC9933","#CCCC00","#CCCC33","#FF0000","#FF0033","#FF0066","#FF0099","#FF00CC","#FF00FF","#FF3300","#FF3333","#FF3366","#FF3399","#FF33CC","#FF33FF","#FF6600","#FF6633","#FF9900","#FF9933","#FFCC00","#FFCC33"],t.log=console.debug||console.log||(()=>{}),e.exports=s(736)(t);const{formatters:n}=e.exports;n.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}}},736:(e,t,s)=>{e.exports=function(e){function t(e){let s,n,r,o=null;function a(...e){if(!a.enabled)return;const i=a,n=Number(new Date),r=n-(s||n);i.diff=r,i.prev=s,i.curr=n,s=n,e[0]=t.coerce(e[0]),"string"!=typeof e[0]&&e.unshift("%O");let o=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,((s,n)=>{if("%%"===s)return"%";o++;const r=t.formatters[n];if("function"==typeof r){const t=e[o];s=r.call(i,t),e.splice(o,1),o--}return s})),t.formatArgs.call(i,e);(i.log||t.log).apply(i,e)}return a.namespace=e,a.useColors=t.useColors(),a.color=t.selectColor(e),a.extend=i,a.destroy=t.destroy,Object.defineProperty(a,"enabled",{enumerable:!0,configurable:!1,get:()=>null!==o?o:(n!==t.namespaces&&(n=t.namespaces,r=t.enabled(e)),r),set:e=>{o=e}}),"function"==typeof t.init&&t.init(a),a}function i(e,s){const i=t(this.namespace+(void 0===s?":":s)+e);return i.log=this.log,i}function n(e,t){let s=0,i=0,n=-1,r=0;for(;s"-"+e))].join(",");return t.enable(""),e},t.enable=function(e){t.save(e),t.namespaces=e,t.names=[],t.skips=[];const s=("string"==typeof e?e:"").trim().replace(" ",",").split(",").filter(Boolean);for(const e of s)"-"===e[0]?t.skips.push(e.slice(1)):t.names.push(e)},t.enabled=function(e){for(const s of t.skips)if(n(e,s))return!1;for(const s of t.names)if(n(e,s))return!0;return!1},t.humanize=s(6585),t.destroy=function(){console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")},Object.keys(e).forEach((s=>{t[s]=e[s]})),t.names=[],t.skips=[],t.formatters={},t.selectColor=function(e){let s=0;for(let t=0;t{var i=s(717),n=s(3519),r=function(){},o=function(e,t,s){if("function"==typeof t)return o(e,null,t);t||(t={}),s=n(s||r);var a=e._writableState,h=e._readableState,l=t.readable||!1!==t.readable&&e.readable,c=t.writable||!1!==t.writable&&e.writable,d=!1,u=function(){e.writable||p()},p=function(){c=!1,l||s.call(e)},f=function(){l=!1,c||s.call(e)},m=function(t){s.call(e,t?new Error("exited with error code: "+t):null)},_=function(t){s.call(e,t)},g=function(){i.nextTick(y)},y=function(){if(!d)return(!l||h&&h.ended&&!h.destroyed)&&(!c||a&&a.ended&&!a.destroyed)?void 0:s.call(e,new Error("premature close"))},w=function(){e.req.on("finish",p)};return!function(e){return e.setHeader&&"function"==typeof e.abort}(e)?c&&!a&&(e.on("end",u),e.on("close",u)):(e.on("complete",p),e.on("abort",g),e.req?w():e.on("request",w)),function(e){return e.stdio&&Array.isArray(e.stdio)&&3===e.stdio.length}(e)&&e.on("exit",m),e.on("end",f),e.on("finish",p),!1!==t.error&&e.on("error",_),e.on("close",g),function(){d=!0,e.removeListener("complete",p),e.removeListener("abort",g),e.removeListener("request",w),e.req&&e.req.removeListener("finish",p),e.removeListener("end",u),e.removeListener("close",u),e.removeListener("finish",p),e.removeListener("exit",m),e.removeListener("end",f),e.removeListener("error",_),e.removeListener("close",g)}};e.exports=o},6310:e=>{function t(e,t){for(const s in t)Object.defineProperty(e,s,{value:t[s],enumerable:!0,configurable:!0});return e}e.exports=function(e,s,i){if(!e||"string"==typeof e)throw new TypeError("Please pass an Error to err-code");i||(i={}),"object"==typeof s&&(i=s,s=""),s&&(i.code=s);try{return t(e,i)}catch(s){i.message=e.message,i.stack=e.stack;const n=function(){};n.prototype=Object.create(Object.getPrototypeOf(e));return t(new n,i)}}},580:e=>{var t=/["'&<>]/;e.exports=function(e){var s,i=""+e,n=t.exec(i);if(!n)return i;var r="",o=0,a=0;for(o=n.index;o{var t=Object.create||function(e){var t=function(){};return t.prototype=e,new t},s=Object.keys||function(e){var t=[];for(var s in e)Object.prototype.hasOwnProperty.call(e,s)&&t.push(s);return s},i=Function.prototype.bind||function(e){var t=this;return function(){return t.apply(e,arguments)}};function n(){this._events&&Object.prototype.hasOwnProperty.call(this,"_events")||(this._events=t(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0}e.exports=n,n.EventEmitter=n,n.prototype._events=void 0,n.prototype._maxListeners=void 0;var r,o=10;try{var a={};Object.defineProperty&&Object.defineProperty(a,"x",{value:0}),r=0===a.x}catch(e){r=!1}function h(e){return void 0===e._maxListeners?n.defaultMaxListeners:e._maxListeners}function l(e,s,i,n){var r,o,a;if("function"!=typeof i)throw new TypeError('"listener" argument must be a function');if((o=e._events)?(o.newListener&&(e.emit("newListener",s,i.listener?i.listener:i),o=e._events),a=o[s]):(o=e._events=t(null),e._eventsCount=0),a){if("function"==typeof a?a=o[s]=n?[i,a]:[a,i]:n?a.unshift(i):a.push(i),!a.warned&&(r=h(e))&&r>0&&a.length>r){a.warned=!0;var l=new Error("Possible EventEmitter memory leak detected. "+a.length+' "'+String(s)+'" listeners added. Use emitter.setMaxListeners() to increase limit.');l.name="MaxListenersExceededWarning",l.emitter=e,l.type=s,l.count=a.length,"object"==typeof console&&console.warn&&console.warn("%s: %s",l.name,l.message)}}else a=o[s]=i,++e._eventsCount;return e}function c(){if(!this.fired)switch(this.target.removeListener(this.type,this.wrapFn),this.fired=!0,arguments.length){case 0:return this.listener.call(this.target);case 1:return this.listener.call(this.target,arguments[0]);case 2:return this.listener.call(this.target,arguments[0],arguments[1]);case 3:return this.listener.call(this.target,arguments[0],arguments[1],arguments[2]);default:for(var e=new Array(arguments.length),t=0;t1&&(t=arguments[1]),t instanceof Error)throw t;var h=new Error('Unhandled "error" event. ('+t+")");throw h.context=t,h}if(!(s=o[e]))return!1;var l="function"==typeof s;switch(i=arguments.length){case 1:!function(e,t,s){if(t)e.call(s);else for(var i=e.length,n=f(e,i),r=0;r=0;o--)if(i[o]===s||i[o].listener===s){a=i[o].listener,r=o;break}if(r<0)return this;0===r?i.shift():function(e,t){for(var s=t,i=s+1,n=e.length;i=0;r--)this.removeListener(e,i[r]);return this},n.prototype.listeners=function(e){return u(this,e,!0)},n.prototype.rawListeners=function(e){return u(this,e,!1)},n.listenerCount=function(e,t){return"function"==typeof e.listenerCount?e.listenerCount(t):p.call(e,t)},n.prototype.listenerCount=p,n.prototype.eventNames=function(){return this._eventsCount>0?Reflect.ownKeys(this._events):[]}},5809:e=>{e.exports=class{constructor(e){if(!(e>0)||e-1&e)throw new Error("Max size for a FixedFIFO should be a power of two");this.buffer=new Array(e),this.mask=e-1,this.top=0,this.btm=0,this.next=null}clear(){this.top=this.btm=0,this.next=null,this.buffer.fill(void 0)}push(e){return void 0===this.buffer[this.top]&&(this.buffer[this.top]=e,this.top=this.top+1&this.mask,!0)}shift(){const e=this.buffer[this.btm];if(void 0!==e)return this.buffer[this.btm]=void 0,this.btm=this.btm+1&this.mask,e}peek(){return this.buffer[this.btm]}isEmpty(){return void 0===this.buffer[this.btm]}}},6080:(e,t,s)=>{const i=s(5809);e.exports=class{constructor(e){this.hwm=e||16,this.head=new i(this.hwm),this.tail=this.head,this.length=0}clear(){this.head=this.tail,this.head.clear(),this.length=0}push(e){if(this.length++,!this.head.push(e)){const t=this.head;this.head=t.next=new i(2*this.head.buffer.length),this.head.push(e)}}shift(){0!==this.length&&this.length--;const e=this.tail.shift();if(void 0===e&&this.tail.next){const e=this.tail.next;return this.tail.next=null,this.tail=e,this.tail.shift()}return e}peek(){const e=this.tail.peek();return void 0===e&&this.tail.next?this.tail.next.peek():e}isEmpty(){return 0===this.length}}},3468:()=>{"undefined"!=typeof ReadableStream&&(ReadableStream.prototype[Symbol.asyncIterator]||(ReadableStream.prototype[Symbol.asyncIterator]=function({preventCancel:e}={}){const t=this.getReader(),s=this;let i=t.read();return{next(){const e=i;return i=t.read(),e},return:async n=>(await i,t.releaseLock(),e||s.cancel(),{done:!0,value:n}),async throw(e){throw await this.return(),e},[Symbol.asyncIterator](){return this}}}),ReadableStream.prototype.getIterator||(ReadableStream.prototype.getIterator=function({preventCancel:e}={}){return this[Symbol.asyncIterator]({preventCancel:e})}))},3714:(e,t,s)=>{const i=s(9596);e.exports=class{constructor(e){if(this.store=e,this.chunkLength=e.chunkLength,!this.store||!this.store.get||!this.store.put)throw new Error("First argument must be abstract-chunk-store compliant");this.mem=[]}put(e,t,s=()=>{}){this.mem[e]=t,this.store.put(e,t,(t=>{this.mem[e]=null,s(t)}))}get(e,t,s=()=>{}){if("function"==typeof t)return this.get(e,null,t);let n=this.mem[e];if(!n)return this.store.get(e,t,s);t||(t={});const r=t.offset||0,o=t.length||n.length-r;0===r&&o===n.length||(n=n.slice(r,o+r)),i((()=>s(null,n)))}close(e=()=>{}){this.store.close(e)}destroy(e=()=>{}){this.store.destroy(e)}}},6698:e=>{"function"==typeof Object.create?e.exports=function(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}:e.exports=function(e,t){if(t){e.super_=t;var s=function(){};s.prototype=t.prototype,e.prototype=new s,e.prototype.constructor=e}}},405:e=>{e.exports=async function*(e){for(let t of e)"function"==typeof t&&(t=t()),yield*t}},9439:(e,t,s)=>{t.RateLimiter=s(3065),t.TokenBucket=s(5472)},3085:(e,t,s)=>{var i=s(717);e.exports=function(){if(void 0!==i&&i.hrtime){var e=i.hrtime(),t=e[0],s=e[1];return 1e3*t+Math.floor(s/1e6)}return(new Date).getTime()}},3065:(e,t,s)=>{var i=s(717),n=s(5472),r=s(3085),o=function(e,t,s){this.tokenBucket=new n(e,e,t,null),this.tokenBucket.content=e,this.curIntervalStart=r(),this.tokensThisInterval=0,this.fireImmediately=s};o.prototype={tokenBucket:null,curIntervalStart:0,tokensThisInterval:0,fireImmediately:!1,removeTokens:function(e,t){if(e>this.tokenBucket.bucketSize)return i.nextTick(t.bind(null,"Requested tokens "+e+" exceeds maximum tokens per interval "+this.tokenBucket.bucketSize,null)),!1;var s=this,n=r();if((n=this.tokenBucket.interval)&&(this.curIntervalStart=n,this.tokensThisInterval=0),e>this.tokenBucket.tokensPerInterval-this.tokensThisInterval){if(this.fireImmediately)i.nextTick(t.bind(null,null,-1));else{var o=Math.ceil(this.curIntervalStart+this.tokenBucket.interval-n);setTimeout((function(){s.tokenBucket.removeTokens(e,a)}),o)}return!1}return this.tokenBucket.removeTokens(e,a);function a(i,n){if(i)return t(i,null);s.tokensThisInterval+=e,t(null,n)}},tryRemoveTokens:function(e){if(e>this.tokenBucket.bucketSize)return!1;var t=r();if((t=this.tokenBucket.interval)&&(this.curIntervalStart=t,this.tokensThisInterval=0),e>this.tokenBucket.tokensPerInterval-this.tokensThisInterval)return!1;var s=this.tokenBucket.tryRemoveTokens(e);return s&&(this.tokensThisInterval+=e),s},getTokensRemaining:function(){return this.tokenBucket.drip(),this.tokenBucket.content}},e.exports=o},5472:(e,t,s)=>{var i=s(717),n=function(e,t,s,i){if(this.bucketSize=e,this.tokensPerInterval=t,"string"==typeof s)switch(s){case"sec":case"second":this.interval=1e3;break;case"min":case"minute":this.interval=6e4;break;case"hr":case"hour":this.interval=36e5;break;case"day":this.interval=864e5;break;default:throw new Error("Invaid interval "+s)}else this.interval=s;this.parentBucket=i,this.content=0,this.lastDrip=+new Date};n.prototype={bucketSize:1,tokensPerInterval:1,interval:1e3,parentBucket:null,content:0,lastDrip:0,removeTokens:function(e,t){var s=this;return this.bucketSize?e>this.bucketSize?(i.nextTick(t.bind(null,"Requested tokens "+e+" exceeds bucket size "+this.bucketSize,null)),!1):(this.drip(),e>this.content?n():this.parentBucket?this.parentBucket.removeTokens(e,(function(i,r){return i?t(i,null):e>s.content?n():(s.content-=e,void t(null,Math.min(r,s.content)))})):(this.content-=e,i.nextTick(t.bind(null,null,this.content)),!0)):(i.nextTick(t.bind(null,null,e,Number.POSITIVE_INFINITY)),!0);function n(){var i=Math.ceil((e-s.content)*(s.interval/s.tokensPerInterval));return setTimeout((function(){s.removeTokens(e,t)}),i),!1}},tryRemoveTokens:function(e){return!this.bucketSize||!(e>this.bucketSize)&&(this.drip(),!(e>this.content)&&(!(this.parentBucket&&!this.parentBucket.tryRemoveTokens(e))&&(this.content-=e,!0)))},drip:function(){if(this.tokensPerInterval){var e=+new Date,t=Math.max(e-this.lastDrip,0);this.lastDrip=e;var s=t*(this.tokensPerInterval/this.interval);this.content=Math.min(this.content+s,this.bucketSize)}else this.content=this.bucketSize}},e.exports=n},8454:(e,t,s)=>{var i=s(7007),n=s(6698);function r(e){if(!(this instanceof r))return new r(e);"number"==typeof e&&(e={max:e}),e||(e={}),i.EventEmitter.call(this),this.cache={},this.head=this.tail=null,this.length=0,this.max=e.max||1e3,this.maxAge=e.maxAge||0}e.exports=r,n(r,i.EventEmitter),Object.defineProperty(r.prototype,"keys",{get:function(){return Object.keys(this.cache)}}),r.prototype.clear=function(){this.cache={},this.head=this.tail=null,this.length=0},r.prototype.remove=function(e){if("string"!=typeof e&&(e=""+e),this.cache.hasOwnProperty(e)){var t=this.cache[e];return delete this.cache[e],this._unlink(e,t.prev,t.next),t.value}},r.prototype._unlink=function(e,t,s){this.length--,0===this.length?this.head=this.tail=null:this.head===e?(this.head=t,this.cache[this.head].next=null):this.tail===e?(this.tail=s,this.cache[this.tail].prev=null):(this.cache[t].next=s,this.cache[s].prev=t)},r.prototype.peek=function(e){if(this.cache.hasOwnProperty(e)){var t=this.cache[e];if(this._checkAge(e,t))return t.value}},r.prototype.set=function(e,t){var s;if("string"!=typeof e&&(e=""+e),this.cache.hasOwnProperty(e)){if((s=this.cache[e]).value=t,this.maxAge&&(s.modified=Date.now()),e===this.head)return t;this._unlink(e,s.prev,s.next)}else s={value:t,modified:0,next:null,prev:null},this.maxAge&&(s.modified=Date.now()),this.cache[e]=s,this.length===this.max&&this.evict();return this.length++,s.next=null,s.prev=this.head,this.head&&(this.cache[this.head].next=e),this.head=e,this.tail||(this.tail=e),t},r.prototype._checkAge=function(e,t){return!(this.maxAge&&Date.now()-t.modified>this.maxAge)||(this.remove(e),this.emit("evict",{key:e,value:t.value}),!1)},r.prototype.get=function(e){if("string"!=typeof e&&(e=""+e),this.cache.hasOwnProperty(e)){var t=this.cache[e];if(this._checkAge(e,t))return this.head!==e&&(e===this.tail?(this.tail=t.next,this.cache[this.tail].prev=null):this.cache[t.prev].next=t.next,this.cache[t.next].prev=t.prev,this.cache[this.head].next=e,t.prev=this.head,t.next=null,this.head=e),t.value}},r.prototype.evict=function(){if(this.tail){var e=this.tail,t=this.remove(this.tail);this.emit("evict",{key:e,value:t})}}},4862:(e,t,s)=>{e.exports=n;const i=s(9596);function n(e,t){if(!(this instanceof n))return new n(e,t);if(t||(t={}),this.chunkLength=Number(e),!this.chunkLength)throw new Error("First argument must be a chunk length");this.chunks=[],this.closed=!1,this.length=Number(t.length)||1/0,this.length!==1/0&&(this.lastChunkLength=this.length%this.chunkLength||this.chunkLength,this.lastChunkIndex=Math.ceil(this.length/this.chunkLength)-1)}n.prototype.put=function(e,t,s=()=>{}){if(this.closed)return i((()=>s(new Error("Storage is closed"))));const n=e===this.lastChunkIndex;return n&&t.length!==this.lastChunkLength?i((()=>s(new Error("Last chunk length must be "+this.lastChunkLength)))):n||t.length===this.chunkLength?(this.chunks[e]=t,void i((()=>s(null)))):i((()=>s(new Error("Chunk length must be "+this.chunkLength))))},n.prototype.get=function(e,t,s=()=>{}){if("function"==typeof t)return this.get(e,null,t);if(this.closed)return i((()=>s(new Error("Storage is closed"))));let n=this.chunks[e];if(!n){const e=new Error("Chunk not found");return e.notFound=!0,i((()=>s(e)))}t||(t={});const r=t.offset||0,o=t.length||n.length-r;0===r&&o===n.length||(n=n.slice(r,o+r)),i((()=>s(null,n)))},n.prototype.close=n.prototype.destroy=function(e=()=>{}){if(this.closed)return i((()=>e(new Error("Storage is closed"))));this.closed=!0,this.chunks=null,i((()=>e(null)))}},8673:e=>{function t(){this._types=Object.create(null),this._extensions=Object.create(null);for(let e=0;e{let i=s(8673);e.exports=new i(s(8446))},8446:e=>{e.exports={"application/andrew-inset":["ez"],"application/applixware":["aw"],"application/atom+xml":["atom"],"application/atomcat+xml":["atomcat"],"application/atomdeleted+xml":["atomdeleted"],"application/atomsvc+xml":["atomsvc"],"application/atsc-dwd+xml":["dwd"],"application/atsc-held+xml":["held"],"application/atsc-rsat+xml":["rsat"],"application/bdoc":["bdoc"],"application/calendar+xml":["xcs"],"application/ccxml+xml":["ccxml"],"application/cdfx+xml":["cdfx"],"application/cdmi-capability":["cdmia"],"application/cdmi-container":["cdmic"],"application/cdmi-domain":["cdmid"],"application/cdmi-object":["cdmio"],"application/cdmi-queue":["cdmiq"],"application/cu-seeme":["cu"],"application/dash+xml":["mpd"],"application/davmount+xml":["davmount"],"application/docbook+xml":["dbk"],"application/dssc+der":["dssc"],"application/dssc+xml":["xdssc"],"application/ecmascript":["es","ecma"],"application/emma+xml":["emma"],"application/emotionml+xml":["emotionml"],"application/epub+zip":["epub"],"application/exi":["exi"],"application/express":["exp"],"application/fdt+xml":["fdt"],"application/font-tdpfr":["pfr"],"application/geo+json":["geojson"],"application/gml+xml":["gml"],"application/gpx+xml":["gpx"],"application/gxf":["gxf"],"application/gzip":["gz"],"application/hjson":["hjson"],"application/hyperstudio":["stk"],"application/inkml+xml":["ink","inkml"],"application/ipfix":["ipfix"],"application/its+xml":["its"],"application/java-archive":["jar","war","ear"],"application/java-serialized-object":["ser"],"application/java-vm":["class"],"application/javascript":["js","mjs"],"application/json":["json","map"],"application/json5":["json5"],"application/jsonml+json":["jsonml"],"application/ld+json":["jsonld"],"application/lgr+xml":["lgr"],"application/lost+xml":["lostxml"],"application/mac-binhex40":["hqx"],"application/mac-compactpro":["cpt"],"application/mads+xml":["mads"],"application/manifest+json":["webmanifest"],"application/marc":["mrc"],"application/marcxml+xml":["mrcx"],"application/mathematica":["ma","nb","mb"],"application/mathml+xml":["mathml"],"application/mbox":["mbox"],"application/mediaservercontrol+xml":["mscml"],"application/metalink+xml":["metalink"],"application/metalink4+xml":["meta4"],"application/mets+xml":["mets"],"application/mmt-aei+xml":["maei"],"application/mmt-usd+xml":["musd"],"application/mods+xml":["mods"],"application/mp21":["m21","mp21"],"application/mp4":["mp4s","m4p"],"application/msword":["doc","dot"],"application/mxf":["mxf"],"application/n-quads":["nq"],"application/n-triples":["nt"],"application/node":["cjs"],"application/octet-stream":["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","exe","dll","deb","dmg","iso","img","msi","msp","msm","buffer"],"application/oda":["oda"],"application/oebps-package+xml":["opf"],"application/ogg":["ogx"],"application/omdoc+xml":["omdoc"],"application/onenote":["onetoc","onetoc2","onetmp","onepkg"],"application/oxps":["oxps"],"application/p2p-overlay+xml":["relo"],"application/patch-ops-error+xml":["xer"],"application/pdf":["pdf"],"application/pgp-encrypted":["pgp"],"application/pgp-signature":["asc","sig"],"application/pics-rules":["prf"],"application/pkcs10":["p10"],"application/pkcs7-mime":["p7m","p7c"],"application/pkcs7-signature":["p7s"],"application/pkcs8":["p8"],"application/pkix-attr-cert":["ac"],"application/pkix-cert":["cer"],"application/pkix-crl":["crl"],"application/pkix-pkipath":["pkipath"],"application/pkixcmp":["pki"],"application/pls+xml":["pls"],"application/postscript":["ai","eps","ps"],"application/provenance+xml":["provx"],"application/pskc+xml":["pskcxml"],"application/raml+yaml":["raml"],"application/rdf+xml":["rdf","owl"],"application/reginfo+xml":["rif"],"application/relax-ng-compact-syntax":["rnc"],"application/resource-lists+xml":["rl"],"application/resource-lists-diff+xml":["rld"],"application/rls-services+xml":["rs"],"application/route-apd+xml":["rapd"],"application/route-s-tsid+xml":["sls"],"application/route-usd+xml":["rusd"],"application/rpki-ghostbusters":["gbr"],"application/rpki-manifest":["mft"],"application/rpki-roa":["roa"],"application/rsd+xml":["rsd"],"application/rss+xml":["rss"],"application/rtf":["rtf"],"application/sbml+xml":["sbml"],"application/scvp-cv-request":["scq"],"application/scvp-cv-response":["scs"],"application/scvp-vp-request":["spq"],"application/scvp-vp-response":["spp"],"application/sdp":["sdp"],"application/senml+xml":["senmlx"],"application/sensml+xml":["sensmlx"],"application/set-payment-initiation":["setpay"],"application/set-registration-initiation":["setreg"],"application/shf+xml":["shf"],"application/sieve":["siv","sieve"],"application/smil+xml":["smi","smil"],"application/sparql-query":["rq"],"application/sparql-results+xml":["srx"],"application/srgs":["gram"],"application/srgs+xml":["grxml"],"application/sru+xml":["sru"],"application/ssdl+xml":["ssdl"],"application/ssml+xml":["ssml"],"application/swid+xml":["swidtag"],"application/tei+xml":["tei","teicorpus"],"application/thraud+xml":["tfi"],"application/timestamped-data":["tsd"],"application/toml":["toml"],"application/trig":["trig"],"application/ttml+xml":["ttml"],"application/ubjson":["ubj"],"application/urc-ressheet+xml":["rsheet"],"application/urc-targetdesc+xml":["td"],"application/voicexml+xml":["vxml"],"application/wasm":["wasm"],"application/widget":["wgt"],"application/winhlp":["hlp"],"application/wsdl+xml":["wsdl"],"application/wspolicy+xml":["wspolicy"],"application/xaml+xml":["xaml"],"application/xcap-att+xml":["xav"],"application/xcap-caps+xml":["xca"],"application/xcap-diff+xml":["xdf"],"application/xcap-el+xml":["xel"],"application/xcap-ns+xml":["xns"],"application/xenc+xml":["xenc"],"application/xhtml+xml":["xhtml","xht"],"application/xliff+xml":["xlf"],"application/xml":["xml","xsl","xsd","rng"],"application/xml-dtd":["dtd"],"application/xop+xml":["xop"],"application/xproc+xml":["xpl"],"application/xslt+xml":["*xsl","xslt"],"application/xspf+xml":["xspf"],"application/xv+xml":["mxml","xhvml","xvml","xvm"],"application/yang":["yang"],"application/yin+xml":["yin"],"application/zip":["zip"],"audio/3gpp":["*3gpp"],"audio/adpcm":["adp"],"audio/amr":["amr"],"audio/basic":["au","snd"],"audio/midi":["mid","midi","kar","rmi"],"audio/mobile-xmf":["mxmf"],"audio/mp3":["*mp3"],"audio/mp4":["m4a","mp4a"],"audio/mpeg":["mpga","mp2","mp2a","mp3","m2a","m3a"],"audio/ogg":["oga","ogg","spx","opus"],"audio/s3m":["s3m"],"audio/silk":["sil"],"audio/wav":["wav"],"audio/wave":["*wav"],"audio/webm":["weba"],"audio/xm":["xm"],"font/collection":["ttc"],"font/otf":["otf"],"font/ttf":["ttf"],"font/woff":["woff"],"font/woff2":["woff2"],"image/aces":["exr"],"image/apng":["apng"],"image/avif":["avif"],"image/bmp":["bmp"],"image/cgm":["cgm"],"image/dicom-rle":["drle"],"image/emf":["emf"],"image/fits":["fits"],"image/g3fax":["g3"],"image/gif":["gif"],"image/heic":["heic"],"image/heic-sequence":["heics"],"image/heif":["heif"],"image/heif-sequence":["heifs"],"image/hej2k":["hej2"],"image/hsj2":["hsj2"],"image/ief":["ief"],"image/jls":["jls"],"image/jp2":["jp2","jpg2"],"image/jpeg":["jpeg","jpg","jpe"],"image/jph":["jph"],"image/jphc":["jhc"],"image/jpm":["jpm"],"image/jpx":["jpx","jpf"],"image/jxr":["jxr"],"image/jxra":["jxra"],"image/jxrs":["jxrs"],"image/jxs":["jxs"],"image/jxsc":["jxsc"],"image/jxsi":["jxsi"],"image/jxss":["jxss"],"image/ktx":["ktx"],"image/ktx2":["ktx2"],"image/png":["png"],"image/sgi":["sgi"],"image/svg+xml":["svg","svgz"],"image/t38":["t38"],"image/tiff":["tif","tiff"],"image/tiff-fx":["tfx"],"image/webp":["webp"],"image/wmf":["wmf"],"message/disposition-notification":["disposition-notification"],"message/global":["u8msg"],"message/global-delivery-status":["u8dsn"],"message/global-disposition-notification":["u8mdn"],"message/global-headers":["u8hdr"],"message/rfc822":["eml","mime"],"model/3mf":["3mf"],"model/gltf+json":["gltf"],"model/gltf-binary":["glb"],"model/iges":["igs","iges"],"model/mesh":["msh","mesh","silo"],"model/mtl":["mtl"],"model/obj":["obj"],"model/step+xml":["stpx"],"model/step+zip":["stpz"],"model/step-xml+zip":["stpxz"],"model/stl":["stl"],"model/vrml":["wrl","vrml"],"model/x3d+binary":["*x3db","x3dbz"],"model/x3d+fastinfoset":["x3db"],"model/x3d+vrml":["*x3dv","x3dvz"],"model/x3d+xml":["x3d","x3dz"],"model/x3d-vrml":["x3dv"],"text/cache-manifest":["appcache","manifest"],"text/calendar":["ics","ifb"],"text/coffeescript":["coffee","litcoffee"],"text/css":["css"],"text/csv":["csv"],"text/html":["html","htm","shtml"],"text/jade":["jade"],"text/jsx":["jsx"],"text/less":["less"],"text/markdown":["markdown","md"],"text/mathml":["mml"],"text/mdx":["mdx"],"text/n3":["n3"],"text/plain":["txt","text","conf","def","list","log","in","ini"],"text/richtext":["rtx"],"text/rtf":["*rtf"],"text/sgml":["sgml","sgm"],"text/shex":["shex"],"text/slim":["slim","slm"],"text/spdx":["spdx"],"text/stylus":["stylus","styl"],"text/tab-separated-values":["tsv"],"text/troff":["t","tr","roff","man","me","ms"],"text/turtle":["ttl"],"text/uri-list":["uri","uris","urls"],"text/vcard":["vcard"],"text/vtt":["vtt"],"text/xml":["*xml"],"text/yaml":["yaml","yml"],"video/3gpp":["3gp","3gpp"],"video/3gpp2":["3g2"],"video/h261":["h261"],"video/h263":["h263"],"video/h264":["h264"],"video/iso.segment":["m4s"],"video/jpeg":["jpgv"],"video/jpm":["*jpm","jpgm"],"video/mj2":["mj2","mjp2"],"video/mp2t":["ts"],"video/mp4":["mp4","mp4v","mpg4"],"video/mpeg":["mpeg","mpg","mpe","m1v","m2v"],"video/ogg":["ogv"],"video/quicktime":["qt","mov"],"video/webm":["webm"]}},6585:e=>{var t=1e3,s=60*t,i=60*s,n=24*i,r=7*n,o=365.25*n;function a(e,t,s,i){var n=t>=1.5*s;return Math.round(e/s)+" "+i+(n?"s":"")}e.exports=function(e,h){h=h||{};var l=typeof e;if("string"===l&&e.length>0)return function(e){if((e=String(e)).length>100)return;var a=/^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(e);if(!a)return;var h=parseFloat(a[1]);switch((a[2]||"ms").toLowerCase()){case"years":case"year":case"yrs":case"yr":case"y":return h*o;case"weeks":case"week":case"w":return h*r;case"days":case"day":case"d":return h*n;case"hours":case"hour":case"hrs":case"hr":case"h":return h*i;case"minutes":case"minute":case"mins":case"min":case"m":return h*s;case"seconds":case"second":case"secs":case"sec":case"s":return h*t;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return h;default:return}}(e);if("number"===l&&isFinite(e))return h.long?function(e){var r=Math.abs(e);if(r>=n)return a(e,r,n,"day");if(r>=i)return a(e,r,i,"hour");if(r>=s)return a(e,r,s,"minute");if(r>=t)return a(e,r,t,"second");return e+" ms"}(e):function(e){var r=Math.abs(e);if(r>=n)return Math.round(e/n)+"d";if(r>=i)return Math.round(e/i)+"h";if(r>=s)return Math.round(e/s)+"m";if(r>=t)return Math.round(e/t)+"s";return e+"ms"}(e);throw new Error("val is not a non-empty string or a valid number. val="+JSON.stringify(e))}},3519:(e,t,s)=>{var i=s(6587);function n(e){var t=function(){return t.called?t.value:(t.called=!0,t.value=e.apply(this,arguments))};return t.called=!1,t}function r(e){var t=function(){if(t.called)throw new Error(t.onceError);return t.called=!0,t.value=e.apply(this,arguments)},s=e.name||"Function wrapped with `once`";return t.onceError=s+" shouldn't be called more than once",t.called=!1,t}e.exports=i(n),e.exports.strict=i(r),n.proto=n((function(){Object.defineProperty(Function.prototype,"once",{value:function(){return n(this)},configurable:!0}),Object.defineProperty(Function.prototype,"onceStrict",{value:function(){return r(this)},configurable:!0})}))},8444:e=>{e.exports=function(e){return Math.max(16384,1<{var i,n=s(717),r=s(3519),o=s(6611);try{i=s(2376)}catch(e){}var a=function(){},h=/^v?\.0/.test(n.version),l=function(e){return"function"==typeof e},c=function(e,t,s,n){n=r(n);var c=!1;e.on("close",(function(){c=!0})),o(e,{readable:t,writable:s},(function(e){if(e)return n(e);c=!0,n()}));var d=!1;return function(t){if(!c&&!d)return d=!0,function(e){return!!h&&!!i&&(e instanceof(i.ReadStream||a)||e instanceof(i.WriteStream||a))&&l(e.close)}(e)?e.close(a):function(e){return e.setHeader&&l(e.abort)}(e)?e.abort():l(e.destroy)?e.destroy():void n(t||new Error("stream was destroyed"))}},d=function(e){e()},u=function(e,t){return e.pipe(t)};e.exports=function(){var e,t=Array.prototype.slice.call(arguments),s=l(t[t.length-1]||a)&&t.pop()||a;if(Array.isArray(t[0])&&(t=t[0]),t.length<2)throw new Error("pump requires two streams per minimum");var i=t.map((function(n,r){var o=r0,(function(t){e||(e=t),t&&i.forEach(d),o||(i.forEach(d),s(e))}))}));return t.reduce(u)}},9596:e=>{let t;e.exports="function"==typeof queueMicrotask?queueMicrotask.bind("undefined"!=typeof window?window:globalThis):e=>(t||(t=Promise.resolve())).then(e).catch((e=>setTimeout((()=>{throw e}),0)))},2133:e=>{e.exports="function"==typeof queueMicrotask?queueMicrotask:e=>Promise.resolve().then(e)},7373:e=>{e.exports=function(e){var t=0;return function(){if(t===e.length)return null;var s=e.length-t,i=Math.random()*s|0,n=e[t+i],r=e[t];return e[t]=n,e[t+i]=r,t++,n}}},2878:e=>{function t(e,t){return{start:e.start,end:e.end,index:t}}function s(e){return{start:e.start,end:e.end}}function i(e,t){return e.index-t.index}function n(e,t){return e.start-t.start}e.exports=function(e,r,o){if("string"!=typeof r)throw new TypeError("argument str must be a string");var a=r.indexOf("=");if(-1===a)return-2;var h=r.slice(a+1).split(","),l=[];l.type=r.slice(0,a);for(var c=0;ce-1&&(p=e-1),isNaN(u)||isNaN(p)||u>p||u<0||l.push({start:u,end:p})}if(l.length<1)return-1;return o&&o.combine?function(e){for(var r=e.map(t).sort(n),o=0,a=1;al.end+1?r[++o]=h:h.end>l.end&&(l.end=h.end,l.index=Math.min(l.index,h.index))}r.length=o+1;var c=r.sort(i).map(s);return c.type=e.type,c}(l):l}},8727:e=>{function t(e){return parseInt(e,10)===e}function s(e){function s(t){if(void 0===t){t=new Array(e);for(var s=0;s{e.exports=function(e,t,s){if("number"!=typeof t)throw new Error("second argument must be a Number");let n,r,o,a,h,l,c=!0;Array.isArray(e)?(n=[],o=r=e.length):(a=Object.keys(e),n={},o=r=a.length);function d(e){function t(){s&&s(e,n),s=null}c?i(t):t()}function u(t,s,i){if(n[t]=i,s&&(h=!0),0==--o||s)d(s);else if(!h&&l{e.exports=function(e,t){let s,n,r,o=!0;Array.isArray(e)?(s=[],n=e.length):(r=Object.keys(e),s={},n=r.length);function a(e){function n(){t&&t(e,s),t=null}o?i(n):n()}function h(e,t,i){s[e]=i,(0==--n||t)&&a(t)}n?r?r.forEach((function(t){e[t]((function(e,s){h(t,e,s)}))})):e.forEach((function(e,t){e((function(e,s){h(t,e,s)}))})):a(null);o=!1};const i=s(9596)},7541:(e,t,s)=>{const i=s(8765),n=s(8499);e.exports={Throttle:i,ThrottleGroup:n}},8499:(e,t,s)=>{const{TokenBucket:i}=s(9439),n=s(8765);e.exports=class{constructor(e={}){if("object"!=typeof e)throw new Error("Options must be an object");this.throttles=[],this.setEnabled(e.enabled),this.setRate(e.rate,e.chunksize)}getEnabled(){return this._enabled}getRate(){return this.bucket.tokensPerInterval}getChunksize(){return this.chunksize}setEnabled(e=!0){if("boolean"!=typeof e)throw new Error("Enabled must be a boolean");this._enabled=e;for(const t of this.throttles)t.setEnabled(e)}setRate(e,t=null){if(!Number.isInteger(e)||e<0)throw new Error("Rate must be an integer bigger than zero");if(e=parseInt(e),t&&("number"!=typeof t||t<=0))throw new Error("Chunksize must be bigger than zero");if(t=t||Math.max(parseInt(e/10),1),t=parseInt(t),e>0&&t>e)throw new Error("Chunk size must be smaller than rate");this.bucket||(this.bucket=new i(e,e,"second",null)),this.bucket.bucketSize=e,this.bucket.tokensPerInterval=e,this.chunksize=t}setChunksize(e){if(!Number.isInteger(e)||e<=0)throw new Error("Chunk size must be an integer bigger than zero");const t=this.getRate();if(e=parseInt(e),t>0&&e>t)throw new Error("Chunk size must be smaller than rate");this.chunksize=e}throttle(e={}){if("object"!=typeof e)throw new Error("Options must be an object");return new n({...e,group:this})}destroy(){for(const e of this.throttles)e.destroy();this.throttles=[]}_addThrottle(e){if(!(e instanceof n))throw new Error("Throttle must be an instance of Throttle");this.throttles.push(e)}_removeThrottle(e){const t=this.throttles.indexOf(e);t>-1&&this.throttles.splice(t,1)}}},8765:(e,t,s)=>{const{EventEmitter:i}=s(7007),{Transform:n}=s(8179),{wait:r}=s(2072);e.exports=class extends n{constructor(e={}){if(super(),"object"!=typeof e)throw new Error("Options must be an object");const t=Object.assign({},e);if(t.group&&!(t.group instanceof o))throw new Error("Group must be an instanece of ThrottleGroup");t.group||(t.group=new o(t)),this._setEnabled(t.enabled||t.group.enabled),this._group=t.group,this._emitter=new i,this._destroyed=!1,this._group._addThrottle(this)}getEnabled(){return this._enabled}getGroup(){return this._group}_setEnabled(e=!0){if("boolean"!=typeof e)throw new Error("Enabled must be a boolean");this._enabled=e}setEnabled(e){this._setEnabled(e),this._enabled?this._emitter.emit("enabled"):this._emitter.emit("disabled")}_transform(e,t){this._processChunk(e,t)}async _waitForTokens(e){return new Promise(((t,s)=>{let i=!1;const n=this;function r(e){if(n._emitter.removeListener("disabled",r),n._emitter.removeListener("destroyed",r),!i){if(i=!0,e)return s(e);t()}}this._emitter.once("disabled",r),this._emitter.once("destroyed",r),this._group.bucket.removeTokens(e,r)}))}_areBothEnabled(){return this._enabled&&this._group.getEnabled()}async _processChunk(e,t){if(!this._areBothEnabled())return t(null,e);let s=0,i=this._group.getChunksize(),n=e.slice(s,s+i);for(;n.length>0;){if(this._areBothEnabled())try{for(;0===this._group.getRate()&&!this._destroyed&&this._areBothEnabled();)if(await r(1e3),this._destroyed)return;if(this._areBothEnabled()&&!this._group.bucket.tryRemoveTokens(n.length)&&(await this._waitForTokens(n.length),this._destroyed))return}catch(e){return t(e)}this.push(n),s+=i,i=this._areBothEnabled()?this._group.getChunksize():e.length-s,n=e.slice(s,s+i)}return t()}destroy(...e){this._group._removeThrottle(this),this._destroyed=!0,this._emitter.emit("destroyed"),super.destroy(...e)}};const o=s(8499)},2072:e=>{e.exports={wait:function(e){return new Promise((t=>setTimeout(t,e)))}}},8179:(e,t,s)=>{const{EventEmitter:i}=s(7007),n=new Error("Stream was destroyed"),r=new Error("Premature close"),o=s(2133),a=s(6080),h=s(5335),l=536870911,c=1^l,d=2^l,u=64,p=128,f=256,m=1024,_=2048,g=4096,y=8192,w=16384,b=32768,v=131072,k=131328,x=16^l,S=536805375,E=768^l,C=536838143,A=32^l,T=536739839,P=1<<18,I=2<<18,L=4<<18,O=8<<18,R=16<<18,H=32<<18,N=64<<18,M=128<<18,U=256<<18,F=512<<18,j=1024<<18,B=535822335,D=503316479,q=268435455,W=262160,$=536608751,z=8404992,V=14,G=15,K=8405006,Y=33587200,J=33587215,X=2359296,Q=270794767,Z=Symbol.asyncIterator||Symbol("asyncIterator");class ee{constructor(e,{highWaterMark:t=16384,map:s=null,mapWritable:i,byteLength:n,byteLengthWritable:r}={}){this.stream=e,this.queue=new a,this.highWaterMark=t,this.buffered=0,this.error=null,this.pipeline=null,this.drains=null,this.byteLength=r||n||Se,this.map=i||s,this.afterWrite=ae.bind(this),this.afterUpdateNextTick=ce.bind(this)}get ended(){return!!(this.stream._duplexState&H)}push(e){return!(142606350&this.stream._duplexState)&&(null!==this.map&&(e=this.map(e)),this.buffered+=this.byteLength(e),this.queue.push(e),this.buffered0,this.error=null,this.pipeline=null,this.byteLength=r||n||Se,this.map=i||s,this.pipeTo=null,this.afterRead=he.bind(this),this.afterUpdateNextTick=le.bind(this)}get ended(){return!!(this.stream._duplexState&w)}pipe(e,t){if(null!==this.pipeTo)throw new Error("Can only pipe to one destination");if("function"!=typeof t&&(t=null),this.stream._duplexState|=512,this.pipeTo=e,this.pipeline=new ie(this.stream,e,t),t&&this.stream.on("error",Ee),xe(e))e._writableState.pipeline=this.pipeline,t&&e.on("error",Ee),e.on("finish",this.pipeline.finished.bind(this.pipeline));else{const t=this.pipeline.done.bind(this.pipeline,e),s=this.pipeline.done.bind(this.pipeline,e,null);e.on("error",t),e.on("close",s),e.on("finish",this.pipeline.finished.bind(this.pipeline))}e.on("drain",ne.bind(this)),this.stream.emit("piping",e),e.emit("pipe",this.stream)}push(e){const t=this.stream;return null===e?(this.highWaterMark=0,t._duplexState=536805311&t._duplexState|1024,!1):null!==this.map&&null===(e=this.map(e))?(t._duplexState&=S,this.buffered0;)t.push(this.shift());for(let e=0;e0;)i.drains.shift().resolve(!1);null!==i.pipeline&&i.pipeline.done(t,e)}}function ae(e){const t=this.stream;e&&t.destroy(e),t._duplexState&=469499903,null!==this.drains&&function(e){for(let t=0;t0)?null:s(i)},this}_read(e){e(null)}pipe(e,t){return this._readableState.updateNextTick(),this._readableState.pipe(e,t),e}read(){return this._readableState.updateNextTick(),this._readableState.read()}push(e){return this._readableState.updateNextTick(),this._readableState.push(e)}unshift(e){return this._readableState.updateNextTick(),this._readableState.unshift(e)}resume(){return this._duplexState|=k,this._readableState.updateNextTick(),this}pause(){return this._duplexState&=!1===this._readableState.readAhead?536739583:536870655,this}static _fromAsyncIterator(e,t){let s;const i=new me({...t,read(t){e.next().then(n).then(t.bind(null,null)).catch(t)},predestroy(){s=e.return()},destroy(e){if(!s)return e(null);s.then(e.bind(null,null)).catch(e)}});return i;function n(e){e.done?i.push(null):i.push(e.value)}}static from(e,t){if(xe(s=e)&&s.readable)return e;var s;if(e[Z])return this._fromAsyncIterator(e[Z](),t);Array.isArray(e)||(e=void 0===e?[]:[e]);let i=0;return new me({...t,read(t){this.push(i===e.length?null:e[i++]),t(null)}})}static isBackpressured(e){return!!(17422&e._duplexState)||e._readableState.buffered>=e._readableState.highWaterMark}static isPaused(e){return!(e._duplexState&f)}[Z](){const e=this;let t=null,s=null,i=null;return this.on("error",(e=>{t=e})),this.on("readable",(function(){null!==s&&r(e.read())})),this.on("close",(function(){null!==s&&r(null)})),{[Z](){return this},next:()=>new Promise((function(t,n){s=t,i=n;const o=e.read();null!==o?r(o):8&e._duplexState&&r(null)})),return:()=>o(null),throw:e=>o(e)};function r(r){null!==i&&(t?i(t):null!==r||e._duplexState&w?s({value:r,done:null===r}):i(n),i=s=null)}function o(t){return e.destroy(t),new Promise(((s,i)=>{if(8&e._duplexState)return s({value:void 0,done:!0});e.once("close",(function(){t?i(t):s({value:void 0,done:!0})}))}))}}}class _e extends fe{constructor(e){super(e),this._duplexState|=16385,this._writableState=new ee(this,e),e&&(e.writev&&(this._writev=e.writev),e.write&&(this._write=e.write),e.final&&(this._final=e.final),e.eagerOpen&&this._writableState.updateNextTick())}cork(){this._duplexState|=j}uncork(){this._duplexState&=q,this._writableState.updateNextTick()}_writev(e,t){t(null)}_write(e,t){this._writableState.autoBatch(e,t)}_final(e){e(null)}static isBackpressured(e){return!!(146800654&e._duplexState)}static drained(e){if(e.destroyed)return Promise.resolve(!1);const t=e._writableState;var s;const i=((s=e)._writev!==_e.prototype._writev&&s._writev!==ge.prototype._writev?Math.min(1,t.queue.length):t.queue.length)+(e._duplexState&U?1:0);return 0===i?Promise.resolve(!0):(null===t.drains&&(t.drains=[]),new Promise((e=>{t.drains.push({writes:i,resolve:e})})))}write(e){return this._writableState.updateNextTick(),this._writableState.push(e)}end(e){return this._writableState.updateNextTick(),this._writableState.end(e),this}}class ge extends me{constructor(e){super(e),this._duplexState=1|this._duplexState&v,this._writableState=new ee(this,e),e&&(e.writev&&(this._writev=e.writev),e.write&&(this._write=e.write),e.final&&(this._final=e.final))}cork(){this._duplexState|=j}uncork(){this._duplexState&=q,this._writableState.updateNextTick()}_writev(e,t){t(null)}_write(e,t){this._writableState.autoBatch(e,t)}_final(e){e(null)}write(e){return this._writableState.updateNextTick(),this._writableState.push(e)}end(e){return this._writableState.updateNextTick(),this._writableState.end(e),this}}class ye extends ge{constructor(e){super(e),this._transformState=new se(this),e&&(e.transform&&(this._transform=e.transform),e.flush&&(this._flush=e.flush))}_write(e,t){this._readableState.buffered>=this._readableState.highWaterMark?this._transformState.data=e:this._transform(e,this._transformState.afterTransform)}_read(e){if(null!==this._transformState.data){const t=this._transformState.data;this._transformState.data=null,e(null),this._transform(t,this._transformState.afterTransform)}else e(null)}destroy(e){super.destroy(e),null!==this._transformState.data&&(this._transformState.data=null,this._transformState.afterTransform())}_transform(e,t){t(null,e)}_flush(e){e(null)}_final(e){this._transformState.afterFinal=e,this._flush(we.bind(this))}}function we(e,t){const s=this._transformState.afterFinal;if(e)return s(e);null!=t&&this.push(t),this.push(null),s(null)}function be(e,...t){const s=Array.isArray(e)?[...e,...t]:[e,...t],i=s.length&&"function"==typeof s[s.length-1]?s.pop():null;if(s.length<2)throw new Error("Pipeline requires at least 2 streams");let n=s[0],o=null,a=null;for(let e=1;e1,l),n.pipe(o)),n=o;if(i){let e=!1;const t=xe(o)||!(!o._writableState||!o._writableState.autoDestroy);o.on("error",(e=>{null===a&&(a=e)})),o.on("finish",(()=>{e=!0,t||i(a)})),t&&o.on("close",(()=>i(a||(e?null:r))))}return o;function h(e,t,s,i){e.on("error",i),e.on("close",(function(){if(t&&e._readableState&&!e._readableState.ended)return i(r);if(s&&e._writableState&&!e._writableState.ended)return i(r)}))}function l(e){if(e&&!a){a=e;for(const t of s)t.destroy(e)}}}function ve(e){return e}function ke(e){return!!e._readableState||!!e._writableState}function xe(e){return"number"==typeof e._duplexState&&ke(e)}function Se(e){return function(e){return"object"==typeof e&&null!==e&&"number"==typeof e.byteLength}(e)?e.byteLength:1024}function Ee(){}function Ce(){this.destroy(new Error("Stream aborted."))}e.exports={pipeline:be,pipelinePromise:function(...e){return new Promise(((t,s)=>be(...e,(e=>{if(e)return s(e);t()}))))},isStream:ke,isStreamx:xe,isEnded:function(e){return!!e._readableState&&e._readableState.ended},isFinished:function(e){return!!e._writableState&&e._writableState.ended},getStreamError:function(e,t={}){const s=e._readableState&&e._readableState.error||e._writableState&&e._writableState.error;return t.all||s!==n?s:null},Stream:fe,Writable:_e,Readable:me,Duplex:ge,Transform:ye,PassThrough:class extends ye{}}},5335:(e,t,s)=>{const i=s(3198),n=s(3198);e.exports=class{constructor(e="utf8"){switch(this.encoding=function(e){switch(e=e.toLowerCase()){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return e;default:throw new Error("Unknown encoding: "+e)}}(e),this.encoding){case"utf8":this.decoder=new n;break;case"utf16le":case"base64":throw new Error("Unsupported encoding: "+this.encoding);default:this.decoder=new i(this.encoding)}}get remaining(){return this.decoder.remaining}push(e){return"string"==typeof e?e:this.decoder.decode(e)}write(e){return this.push(e)}end(e){let t="";return e&&(t=this.push(e)),t+=this.decoder.flush(),t}}},3198:e=>{e.exports=class{constructor(e){this.decoder=new TextDecoder("utf16le"===e?"utf16-le":e)}get remaining(){return-1}decode(e){return this.decoder.decode(e,{stream:!0})}flush(){return this.decoder.decode(new Uint8Array(0))}}},1035:e=>{function t(e){return(+Date.now()-e)/100&65535}e.exports=function(e){const s=+Date.now(),i=10*(e||5),n=[0];let r=1,o=t(s)-1&65535;return function(e){const a=t(s);let h=a-o&65535;for(h>i&&(h=i),o=a;h--;)r===i&&(r=0),n[r]=n[0===r?i-1:r-1],r++;e&&(n[r-1]+=e);const l=n[r-1],c=n.length{e.exports=function(e,t){if(t>=e.length||t<0)return;var s=e.pop();if(t{e.exports=function e(t,s){if(t&&s)return e(t)(s);if("function"!=typeof t)throw new TypeError("need wrapper function");return Object.keys(t).forEach((function(e){i[e]=t[e]})),i;function i(){for(var e=new Array(arguments.length),s=0;s{},6686:()=>{},4043:()=>{},7828:()=>{},6889:()=>{},8878:()=>{},2701:()=>{},7264:()=>{},1551:()=>{},826:()=>{},61:()=>{},7936:()=>{},2532:()=>{},2123:()=>{},3208:()=>{},2376:()=>{},3970:()=>{},2799:()=>{},8271:()=>{},3278:()=>{},6664:()=>{},1827:()=>{},6819:(e,t,s)=>{e.exports=s(8330).version},5658:(e,t,s)=>{s.r(t),s.d(t,{default:()=>_,enableSecure:()=>m});var i=s(7007),n=s(8179),r=s(1314),o=s(7833),a=s(6458);const h="tcpIncoming",l="tcpOutgoing",c="utpIncoming",d="utpOutgoing",u="webSeed",p=o("webtorrent:peer");let f=!1;const m=()=>{f=!0};class _ extends i{constructor(e,t){super(),this.id=e,this.type=t,p("new %s Peer %s",t,e),this.addr=null,this.conn=null,this.swarm=null,this.wire=null,this.source=null,this.connected=!1,this.destroyed=!1,this.timeout=null,this.retries=0,this.sentPe1=!1,this.sentPe2=!1,this.sentPe3=!1,this.sentPe4=!1,this.sentHandshake=!1}onConnect(){if(this.destroyed)return;this.connected=!0,p("Peer %s connected",this.id),clearTimeout(this.connectTimeout);const e=this.conn;e.once("end",(()=>{this.destroy()})),e.once("close",(()=>{this.destroy()})),e.once("finish",(()=>{this.destroy()})),e.once("error",(e=>{this.destroy(e)}));const t=this.wire=new a.A(this.type,this.retries,f);t.once("end",(()=>{this.destroy()})),t.once("close",(()=>{this.destroy()})),t.once("finish",(()=>{this.destroy()})),t.once("error",(e=>{this.destroy(e)})),t.once("pe1",(()=>{this.onPe1()})),t.once("pe2",(()=>{this.onPe2()})),t.once("pe3",(()=>{this.onPe3()})),t.once("pe4",(()=>{this.onPe4()})),t.once("handshake",((e,t)=>{this.onHandshake(e,t)})),this.startHandshakeTimeout(),this.setThrottlePipes(),this.swarm&&("tcpOutgoing"===this.type?f&&0===this.retries&&!this.sentPe1?this.sendPe1():this.sentHandshake||this.handshake():"tcpIncoming"===this.type||this.sentHandshake||this.handshake())}sendPe1(){this.wire.sendPe1(),this.sentPe1=!0}onPe1(){this.sendPe2()}sendPe2(){this.wire.sendPe2(),this.sentPe2=!0}onPe2(){this.sendPe3()}sendPe3(){this.wire.sendPe3(this.swarm.infoHash),this.sentPe3=!0}onPe3(e){this.swarm&&(this.swarm.infoHashHash!==e&&this.destroy(new Error("unexpected crypto handshake info hash for this swarm")),this.sendPe4())}sendPe4(){this.wire.sendPe4(this.swarm.infoHash),this.sentPe4=!0}onPe4(){this.sentHandshake||this.handshake()}clearPipes(){this.conn.unpipe(),this.wire.unpipe()}setThrottlePipes(){const e=this;(0,n.pipeline)(this.conn,this.throttleGroups.down.throttle(),new n.Transform({transform(t,s){e.emit("download",t.length),e.destroyed||s(null,t)}}),this.wire,this.throttleGroups.up.throttle(),new n.Transform({transform(t,s){e.emit("upload",t.length),e.destroyed||s(null,t)}}),this.conn)}onHandshake(e,t){if(!this.swarm)return;if(this.destroyed)return;if(this.swarm.destroyed)return this.destroy(new Error("swarm already destroyed"));if(e!==this.swarm.infoHash)return this.destroy(new Error("unexpected handshake info hash for this swarm"));if(t===this.swarm.peerId)return this.destroy(new Error("refusing to connect to ourselves"));p("Peer %s got handshake %s",this.id,e),clearTimeout(this.handshakeTimeout),this.retries=0;let s=this.addr;!s&&this.conn.remoteAddress&&this.conn.remotePort&&(s=`${this.conn.remoteAddress}:${this.conn.remotePort}`),this.swarm._onWire(this.wire,s),this.swarm&&!this.swarm.destroyed&&(this.sentHandshake||this.handshake())}handshake(){const e={dht:!this.swarm.private&&!!this.swarm.client.dht,fast:!0};this.wire.handshake(this.swarm.infoHash,this.swarm.client.peerId,e),this.sentHandshake=!0}startConnectTimeout(){clearTimeout(this.connectTimeout);const e={webrtc:25e3,tcpOutgoing:5e3,utpOutgoing:5e3};this.connectTimeout=setTimeout((()=>{this.destroy(new Error("connect timeout"))}),e[this.type]),this.connectTimeout.unref&&this.connectTimeout.unref()}startHandshakeTimeout(){clearTimeout(this.handshakeTimeout),this.handshakeTimeout=setTimeout((()=>{this.destroy(new Error("handshake timeout"))}),25e3),this.handshakeTimeout.unref&&this.handshakeTimeout.unref()}destroy(e){if(this.destroyed)return;this.destroyed=!0,this.connected=!1,p("destroy %s %s (error: %s)",this.type,this.id,e&&(e.message||e)),clearTimeout(this.connectTimeout),clearTimeout(this.handshakeTimeout);const t=this.swarm,s=this.conn,i=this.wire;this.swarm=null,this.conn=null,this.wire=null,t&&i&&r(t.wires,t.wires.indexOf(i)),s&&(s.on("error",(()=>{})),s.destroy()),i&&i.destroy(),t&&t.removePeer(this.id)}}_.TYPE_TCP_INCOMING=h,_.TYPE_TCP_OUTGOING=l,_.TYPE_UTP_INCOMING=c,_.TYPE_UTP_OUTGOING=d,_.TYPE_WEBRTC="webrtc",_.TYPE_WEBSEED=u,_.SOURCE_MANUAL="manual",_.SOURCE_TRACKER="tracker",_.SOURCE_DHT="dht",_.SOURCE_LSD="lsd",_.SOURCE_UT_PEX="ut_pex",_.createWebRTCPeer=(e,t,s)=>{const i=new _(e.id,"webrtc");if(i.conn=e,i.swarm=t,i.throttleGroups=s,i.conn.connected)i.onConnect();else{const e=()=>{i.conn.removeListener("connect",t),i.conn.removeListener("error",s)},t=()=>{e(),i.onConnect()},s=t=>{e(),i.destroy(t)};i.conn.once("connect",t),i.conn.once("error",s),i.startConnectTimeout()}return i},_.createTCPIncomingPeer=(e,t)=>_._createIncomingPeer(e,h,t),_.createUTPIncomingPeer=(e,t)=>_._createIncomingPeer(e,c,t),_.createTCPOutgoingPeer=(e,t,s)=>_._createOutgoingPeer(e,t,l,s),_.createUTPOutgoingPeer=(e,t,s)=>_._createOutgoingPeer(e,t,d,s),_._createIncomingPeer=(e,t,s)=>{const i=`${e.remoteAddress}:${e.remotePort}`,n=new _(i,t);return n.conn=e,n.addr=i,n.throttleGroups=s,n.onConnect(),n},_._createOutgoingPeer=(e,t,s,i)=>{const n=new _(e,s);return n.addr=e,n.swarm=t,n.throttleGroups=i,n},_.createWebSeedPeer=(e,t,s,i)=>{const n=new _(t,u);return n.swarm=s,n.conn=e,n.throttleGroups=i,n.onConnect(),n}},988:(e,t,s)=>{s.d(t,{A:()=>f});var i=s(9639);function n(e){const t=e<0?1:0;return e=Math.abs(Number(e||1)),Math.floor(Math.log10(e))+1+t}function r(e){return ArrayBuffer.isView(e)?"arraybufferview":Array.isArray(e)?"array":e instanceof Number?"number":e instanceof Boolean?"boolean":e instanceof Set?"set":e instanceof Map?"map":e instanceof String?"string":e instanceof ArrayBuffer?"arraybuffer":typeof e}function o(e,t,s){const n=[];let r=null;return o._encode(n,e),r=(0,i.xW)(n),o.bytes=r.length,ArrayBuffer.isView(t)?(t.set(r,s),t):r}o.bytes=-1,o._floatConversionDetected=!1,o._encode=function(e,t){if(null!=t)switch(r(t)){case"object":o.dict(e,t);break;case"map":o.dictMap(e,t);break;case"array":o.list(e,t);break;case"set":o.listSet(e,t);break;case"string":o.string(e,t);break;case"number":case"boolean":o.number(e,t);break;case"arraybufferview":o.buffer(e,new Uint8Array(t.buffer,t.byteOffset,t.byteLength));break;case"arraybuffer":o.buffer(e,new Uint8Array(t))}};const a=new Uint8Array([101]),h=new Uint8Array([100]),l=new Uint8Array([108]);o.buffer=function(e,t){e.push((0,i.L0)(t.length+":"),t)},o.string=function(e,t){e.push((0,i.L0)((0,i.L0)(t).byteLength+":"+t))},o.number=function(e,t){if(Number.isInteger(t))return e.push((0,i.L0)("i"+BigInt(t)+"e"));const s=2147483648,n=(t/s|0)*s+(t%s|0);e.push((0,i.L0)("i"+n+"e")),n===t||o._floatConversionDetected||(o._floatConversionDetected=!0,console.warn('WARNING: Possible data corruption detected with value "'+t+'":','Bencoding only defines support for integers, value was converted to "'+n+'"'),console.trace())},o.dict=function(e,t){e.push(h);let s,i=0;const n=Object.keys(t).sort(),r=n.length;for(;i=48)i=10*i+(s-48);else if(r!==t||43!==s){if(r!==t||45!==s){if(46===s)break;throw new Error("not a number: buffer["+r+"] = "+s)}n=-1}}return i*n}function u(e,t,s,n){return null==e||0===e.length?null:("number"!=typeof t&&null==n&&(n=t,t=void 0),"number"!=typeof s&&null==n&&(n=s,s=void 0),u.position=0,u.encoding=n||null,u.data=ArrayBuffer.isView(e)?new Uint8Array(e.slice(t,s)):(0,i.L0)(e),u.bytes=u.data.length,u.next())}u.bytes=0,u.position=0,u.data=null,u.encoding=null,u.next=function(){switch(u.data[u.position]){case 100:return u.dictionary();case 108:return u.list();case 105:return u.integer();default:return u.buffer()}},u.find=function(e){let t=u.position;const s=u.data.length,i=u.data;for(;t{function i(e){return(e>>3)+Number(e%8!=0)}s.d(t,{A:()=>n});class n{get length(){return this.buffer.length<<3}constructor(e=0,t){const s=null==t?void 0:t.grow;this.grow=s?Number.isFinite(s)?i(s):s:0,this.buffer="number"==typeof e?new Uint8Array(i(e)):e}get(e){const t=e>>3;return t>e%8)}set(e,t=!0){const s=e>>3;if(t){if(s>=this.buffer.length){const e=Math.max(s+1,Math.min(2*this.buffer.length,this.grow));if(e<=this.grow){const t=new Uint8Array(e);t.set(this.buffer),this.buffer=t}}this.buffer[s]|=128>>e%8}else s>e%8))}setAll(e,t=0){const s=Math.min(i(t+e.length),this.grow);if(this.buffer.length>3,r=128>>t%8;for(let t=0;t=this.buffer.length)break;r=128}else r>>=1}forEach(e,t=0,s=8*this.buffer.length){let i=t>>3,n=128>>t%8;for(let r=t;r>=1}isEmpty(){for(let e=0;e{s.d(t,{A:()=>I});var i=s(988),n=s(3033),r=s(7264),o=s(7833),a=s(8727),h=s(8179),l=s(9639),c=s(1035),d=s(1314);const u=o("bittorrent-protocol"),p=(0,l.L0)("BitTorrent protocol"),f=new Uint8Array([0,0,0,0]),m=new Uint8Array([0,0,0,1,0]),_=new Uint8Array([0,0,0,1,1]),g=new Uint8Array([0,0,0,1,2]),y=new Uint8Array([0,0,0,1,3]),w=[0,0,0,0,0,0,0,0],b=[0,0,0,3,9,0,0],v=new Uint8Array([0,0,0,1,14]),k=new Uint8Array([0,0,0,1,15]),x=new Uint8Array([0,0,0,0,0,0,0,0]),S=new Uint8Array([0,0,1,2]),E=new Uint8Array([0,0,0,2]);function C(e,t){for(let s=e.length;s--;)e[s]^=t[s];return e}class A{constructor(e,t,s,i){this.piece=e,this.offset=t,this.length=s,this.callback=i}}class T{constructor(){this.buffer=new Uint8Array}get(e){return!0}set(e){}}class P extends h.Duplex{constructor(e=null,t=0,s=!1){super(),this._debugId=(0,l.V5)((0,l.po)(4)),this._debug("new wire"),this.peerId=null,this.peerIdBuffer=null,this.type=e,this.amChoking=!0,this.amInterested=!1,this.peerChoking=!0,this.peerInterested=!1,this.peerPieces=new n.A(0,{grow:4e5}),this.extensions={},this.peerExtensions={},this.requests=[],this.peerRequests=[],this.extendedMapping={},this.peerExtendedMapping={},this.extendedHandshake={},this.peerExtendedHandshake={},this.hasFast=!1,this.allowedFastSet=[],this.peerAllowedFastSet=[],this._ext={},this._nextExt=1,this.uploaded=0,this.downloaded=0,this.uploadSpeed=c(),this.downloadSpeed=c(),this._keepAliveInterval=null,this._timeout=null,this._timeoutMs=0,this._timeoutExpiresAt=null,this._finished=!1,this._parserSize=0,this._parser=null,this._buffer=[],this._bufferSize=0,this._peEnabled=s,s?(this._dh=r.createDiffieHellman("ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a36210000000000090563","hex",2),this._myPubKey=this._dh.generateKeys("hex")):this._myPubKey=null,this._peerPubKey=null,this._sharedSecret=null,this._peerCryptoProvide=[],this._cryptoHandshakeDone=!1,this._cryptoSyncPattern=null,this._waitMaxBytes=null,this._encryptionMethod=null,this._encryptGenerator=null,this._decryptGenerator=null,this._setGenerators=!1,this.once("finish",(()=>this._onFinish())),this.on("finish",this._onFinish),this._debug("type:",this.type),"tcpIncoming"===this.type&&this._peEnabled?this._determineHandshakeType():"tcpOutgoing"===this.type&&this._peEnabled&&0===t?this._parsePe2():this._parseHandshake(null)}setKeepAlive(e){this._debug("setKeepAlive %s",e),clearInterval(this._keepAliveInterval),!1!==e&&(this._keepAliveInterval=setInterval((()=>{this.keepAlive()}),55e3))}setTimeout(e,t){this._debug("setTimeout ms=%d unref=%s",e,t),this._timeoutMs=e,this._timeoutUnref=!!t,this._resetTimeout(!0)}destroy(){if(!this.destroyed)return this._debug("destroy"),this.end(),this}end(e){if(!this.destroyed&&!this.destroying)return this._debug("end"),this._onUninterested(),this._onChoke(),super.end(e)}use(e){const t=e.prototype.name;if(!t)throw new Error('Extension class requires a "name" property on the prototype');this._debug("use extension.name=%s",t);const s=this._nextExt,i=new e(this);function n(){}"function"!=typeof i.onHandshake&&(i.onHandshake=n),"function"!=typeof i.onExtendedHandshake&&(i.onExtendedHandshake=n),"function"!=typeof i.onMessage&&(i.onMessage=n),this.extendedMapping[s]=t,this._ext[t]=i,this[t]=i,this._nextExt+=1}keepAlive(){this._debug("keep-alive"),this._push(f)}sendPe1(){if(this._peEnabled){const e=Math.floor(513*Math.random()),t=(0,l.po)(e);this._push((0,l.xW)([(0,l.fk)(this._myPubKey),t]))}}sendPe2(){const e=Math.floor(513*Math.random()),t=(0,l.po)(e);this._push((0,l.xW)([(0,l.fk)(this._myPubKey),t]))}async sendPe3(e){await this.setEncrypt(this._sharedSecret,e);const t=await(0,l.tW)((0,l.fk)(this._utfToHex("req1")+this._sharedSecret)),s=C(await(0,l.tW)((0,l.fk)(this._utfToHex("req2")+e)),await(0,l.tW)((0,l.fk)(this._utfToHex("req3")+this._sharedSecret))),i=new DataView((0,l.po)(2).buffer).getUint16(0)%512,n=(0,l.po)(i);let r=new Uint8Array(14+i+2);r.set(x),r.set(S,8);const o=new DataView(r.buffer);o.setInt16(12,i),n.copy(r,14),o.setInt16(14+i,0),r=this._encryptHandshake(r),this._push((0,l.xW)([t,s,r]))}async sendPe4(e){await this.setEncrypt(this._sharedSecret,e);const t=new DataView((0,l.po)(2).buffer).getUint16(0)%512,s=(0,l.po)(t);let i=new Uint8Array(14+t);const n=new DataView(i.buffer);i.set(x),i.set(E,8),n.setInt16(12,t),i.set(s,14),i=this._encryptHandshake(i),this._push(i),this._cryptoHandshakeDone=!0,this._debug("completed crypto handshake")}handshake(e,t,s){let i,n;if("string"==typeof e?(e=e.toLowerCase(),i=(0,l.fk)(e)):(i=e,e=(0,l.V5)(i)),"string"==typeof t?n=(0,l.fk)(t):(n=t,t=(0,l.V5)(n)),this._infoHash=i,20!==i.length||20!==n.length)throw new Error("infoHash and peerId MUST have length 20");this._debug("handshake i=%s p=%s exts=%o",e,t,s);const r=new Uint8Array(w);this.extensions={extended:!0,dht:!(!s||!s.dht),fast:!(!s||!s.fast)},r[5]|=16,this.extensions.dht&&(r[7]|=1),this.extensions.fast&&(r[7]|=4),this.extensions.fast&&this.peerExtensions.fast&&(this._debug("fast extension is enabled"),this.hasFast=!0),this._push((0,l.xW)([p,r,i,n])),this._handshakeSent=!0,this.peerExtensions.extended&&!this._extendedHandshakeSent&&this._sendExtendedHandshake()}_sendExtendedHandshake(){const e=Object.assign({},this.extendedHandshake);e.m={};for(const t in this.extendedMapping){const s=this.extendedMapping[t];e.m[s]=Number(t)}this.extended(0,i.A.encode(e)),this._extendedHandshakeSent=!0}choke(){if(!this.amChoking)if(this.amChoking=!0,this._debug("choke"),this._push(m),this.hasFast){let e=0;for(;this.peerRequests.length>e;){const t=this.peerRequests[e];this.allowedFastSet.includes(t.piece)?++e:this.reject(t.piece,t.offset,t.length)}}else for(;this.peerRequests.length;)this.peerRequests.pop()}unchoke(){this.amChoking&&(this.amChoking=!1,this._debug("unchoke"),this._push(_))}interested(){this.amInterested||(this.amInterested=!0,this._debug("interested"),this._push(g))}uninterested(){this.amInterested&&(this.amInterested=!1,this._debug("uninterested"),this._push(y))}have(e){this._debug("have %d",e),this._message(4,[e],null)}bitfield(e){this._debug("bitfield"),ArrayBuffer.isView(e)||(e=e.buffer),this._message(5,[],e)}request(e,t,s,i){return i||(i=()=>{}),this._finished?i(new Error("wire is closed")):!this.peerChoking||this.hasFast&&this.peerAllowedFastSet.includes(e)?(this._debug("request index=%d offset=%d length=%d",e,t,s),this.requests.push(new A(e,t,s,i)),this._timeout||this._resetTimeout(!0),void this._message(6,[e,t,s],null)):i(new Error("peer is choking"))}piece(e,t,s){this._debug("piece index=%d offset=%d",e,t),this._message(7,[e,t],s),this.uploaded+=s.length,this.uploadSpeed(s.length),this.emit("upload",s.length)}cancel(e,t,s){this._debug("cancel index=%d offset=%d length=%d",e,t,s),this._callback(this._pull(this.requests,e,t,s),new Error("request was cancelled"),null),this._message(8,[e,t,s],null)}port(e){this._debug("port %d",e);const t=new Uint8Array(b);new DataView(t.buffer).setUint16(5,e),this._push(t)}suggest(e){if(!this.hasFast)throw Error("fast extension is disabled");this._debug("suggest %d",e),this._message(13,[e],null)}haveAll(){if(!this.hasFast)throw Error("fast extension is disabled");this._debug("have-all"),this._push(v)}haveNone(){if(!this.hasFast)throw Error("fast extension is disabled");this._debug("have-none"),this._push(k)}reject(e,t,s){if(!this.hasFast)throw Error("fast extension is disabled");this._debug("reject index=%d offset=%d length=%d",e,t,s),this._pull(this.peerRequests,e,t,s),this._message(16,[e,t,s],null)}allowedFast(e){if(!this.hasFast)throw Error("fast extension is disabled");this._debug("allowed-fast %d",e),this.allowedFastSet.includes(e)||this.allowedFastSet.push(e),this._message(17,[e],null)}extended(e,t){if(this._debug("extended ext=%s",e),"string"==typeof e&&this.peerExtendedMapping[e]&&(e=this.peerExtendedMapping[e]),"number"!=typeof e)throw new Error(`Unrecognized extension: ${e}`);{const s=new Uint8Array([e]),n=ArrayBuffer.isView(t)?t:i.A.encode(t);this._message(20,[],(0,l.xW)([s,n]))}}async setEncrypt(e,t){let s,i,n,r;switch(this.type){case"tcpIncoming":s=await(0,l.tW)((0,l.fk)(this._utfToHex("keyB")+e+t)),n=await(0,l.tW)((0,l.fk)(this._utfToHex("keyA")+e+t)),i=[];for(const e of s.values())i.push(e);r=[];for(const e of n.values())r.push(e);this._encryptGenerator=new a(i),this._decryptGenerator=new a(r);break;case"tcpOutgoing":s=await(0,l.tW)((0,l.fk)(this._utfToHex("keyA")+e+t)),n=await(0,l.tW)((0,l.fk)(this._utfToHex("keyB")+e+t)),i=[];for(const e of s.values())i.push(e);r=[];for(const e of n.values())r.push(e);this._encryptGenerator=new a(i),this._decryptGenerator=new a(r);break;default:return!1}for(let e=0;e<1024;e++)this._encryptGenerator.randomByte(),this._decryptGenerator.randomByte();return this._setGenerators=!0,!0}_message(e,t,s){const i=s?s.length:0,n=new Uint8Array(5+4*t.length),r=new DataView(n.buffer);r.setUint32(0,n.length+i-4),n[4]=e;for(let e=0;e{if(n===this._pull(this.peerRequests,e,t,s))return i?(this._debug("error satisfying request index=%d offset=%d length=%d (%s)",e,t,s,i.message),void(this.hasFast&&this.reject(e,t,s))):void this.piece(e,t,r)},n=new A(e,t,s,i);this.peerRequests.push(n),this.emit("request",e,t,s,i)}_onPiece(e,t,s){this._debug("got piece index=%d offset=%d",e,t),this._callback(this._pull(this.requests,e,t,s.length),null,s),this.downloaded+=s.length,this.downloadSpeed(s.length),this.emit("download",s.length),this.emit("piece",e,t,s)}_onCancel(e,t,s){this._debug("got cancel index=%d offset=%d length=%d",e,t,s),this._pull(this.peerRequests,e,t,s),this.emit("cancel",e,t,s)}_onPort(e){this._debug("got port %d",e),this.emit("port",e)}_onSuggest(e){if(!this.hasFast)return this._debug("Error: got suggest whereas fast extension is disabled"),void this.destroy();this._debug("got suggest %d",e),this.emit("suggest",e)}_onHaveAll(){if(!this.hasFast)return this._debug("Error: got have-all whereas fast extension is disabled"),void this.destroy();this._debug("got have-all"),this.peerPieces=new T,this.emit("have-all")}_onHaveNone(){if(!this.hasFast)return this._debug("Error: got have-none whereas fast extension is disabled"),void this.destroy();this._debug("got have-none"),this.emit("have-none")}_onReject(e,t,s){if(!this.hasFast)return this._debug("Error: got reject whereas fast extension is disabled"),void this.destroy();this._debug("got reject index=%d offset=%d length=%d",e,t,s),this._callback(this._pull(this.requests,e,t,s),new Error("request was rejected"),null),this.emit("reject",e,t,s)}_onAllowedFast(e){if(!this.hasFast)return this._debug("Error: got allowed-fast whereas fast extension is disabled"),void this.destroy();this._debug("got allowed-fast %d",e),this.peerAllowedFastSet.includes(e)||this.peerAllowedFastSet.push(e),this.peerAllowedFastSet.length>100&&this.peerAllowedFastSet.shift(),this.emit("allowed-fast",e)}_onExtended(e,t){if(0===e){let e;try{e=i.A.decode(t)}catch(e){this._debug("ignoring invalid extended handshake: %s",e.message||e)}if(!e)return;if(this.peerExtendedHandshake=e,"object"==typeof e.m)for(const t in e.m)this.peerExtendedMapping[t]=Number(e.m[t].toString());for(const e in this._ext)this.peerExtendedMapping[e]&&this._ext[e].onExtendedHandshake(this.peerExtendedHandshake);this._debug("got extended handshake"),this.emit("extended","handshake",this.peerExtendedHandshake)}else this.extendedMapping[e]&&(e=this.extendedMapping[e],this._ext[e]&&this._ext[e].onMessage(t)),this._debug("got extended message ext=%s",e),this.emit("extended",e,t)}_onTimeout(){this._debug("request timed out"),this._callback(this.requests.shift(),new Error("request has timed out"),null),this.emit("timeout")}_write(e,t){if(2===this._encryptionMethod&&this._cryptoHandshakeDone&&(e=this._decrypt(e)),this._bufferSize+=e.length,this._buffer.push(e),this._buffer.length>1&&(this._buffer=[(0,l.xW)(this._buffer,this._bufferSize)]),this._cryptoSyncPattern){const t=this._buffer[0].indexOf(this._cryptoSyncPattern);if(-1!==t)this._buffer[0]=this._buffer[0].slice(t+this._cryptoSyncPattern.length),this._bufferSize-=t+this._cryptoSyncPattern.length,this._cryptoSyncPattern=null;else if(this._bufferSize+e.length>this._waitMaxBytes+this._cryptoSyncPattern.length)return this._debug("Error: could not resynchronize"),void this.destroy()}for(;this._bufferSize>=this._parserSize&&!this._cryptoSyncPattern;)if(0===this._parserSize)this._parser(new Uint8Array);else{const e=this._buffer[0];this._bufferSize-=this._parserSize,this._buffer=this._bufferSize?[e.slice(this._parserSize)]:[],this._parser(e.slice(0,this._parserSize))}t(null)}_callback(e,t,s){e&&(this._resetTimeout(!this.peerChoking&&!this._finished),e.callback(t,s))}_resetTimeout(e){if(!e||!this._timeoutMs||!this.requests.length)return clearTimeout(this._timeout),this._timeout=null,void(this._timeoutExpiresAt=null);const t=Date.now()+this._timeoutMs;if(this._timeout){if(t-this._timeoutExpiresAt<.05*this._timeoutMs)return;clearTimeout(this._timeout)}this._timeoutExpiresAt=t,this._timeout=setTimeout((()=>this._onTimeout()),this._timeoutMs),this._timeoutUnref&&this._timeout.unref&&this._timeout.unref()}_parse(e,t){this._parserSize=e,this._parser=t}_parseUntil(e,t){this._cryptoSyncPattern=e,this._waitMaxBytes=t}_onMessageLength(e){const t=new DataView(e.buffer,e.byteOffset,e.byteLength).getUint32(0);t>0?this._parse(t,this._onMessage):(this._onKeepAlive(),this._parse(4,this._onMessageLength))}_onMessage(e){this._parse(4,this._onMessageLength);const t=new DataView(e.buffer,e.byteOffset,e.byteLength);switch(e[0]){case 0:return this._onChoke();case 1:return this._onUnchoke();case 2:return this._onInterested();case 3:return this._onUninterested();case 4:return this._onHave(t.getUint32(1));case 5:return this._onBitField(e.slice(1));case 6:return this._onRequest(t.getUint32(1),t.getUint32(5),t.getUint32(9));case 7:return this._onPiece(t.getUint32(1),t.getUint32(5),e.slice(9));case 8:return this._onCancel(t.getUint32(1),t.getUint32(5),t.getUint32(9));case 9:return this._onPort(t.getUint16(1));case 13:return this._onSuggest(t.getUint32(1));case 14:return this._onHaveAll();case 15:return this._onHaveNone();case 16:return this._onReject(t.getUint32(1),t.getUint32(5),t.getUint32(9));case 17:return this._onAllowedFast(t.getUint32(1));case 20:return this._onExtended(e[1],e.slice(2));default:return this._debug("got unknown message"),this.emit("unknownmessage",e)}}_determineHandshakeType(){this._parse(1,(e=>{const t=e[0];19===t?this._parse(t+48,this._onHandshakeBuffer):this._parsePe1(e)}))}_parsePe1(e){this._parse(95,(t=>{this._onPe1((0,l.xW)([e,t])),this._parsePe3()}))}_parsePe2(){this._parse(96,(e=>{for(this._onPe2(e);!this._setGenerators;);this._parsePe4()}))}async _parsePe3(){const e=await(0,l.tW)((0,l.fk)(this._utfToHex("req1")+this._sharedSecret));this._parseUntil(e,512),this._parse(20,(e=>{for(this._onPe3(e);!this._setGenerators;);this._parsePe3Encrypted()}))}_parsePe3Encrypted(){this._parse(14,(e=>{const t=this._decryptHandshake(e.slice(0,8)),s=this._decryptHandshake(e.slice(8,12)),i=new DataView(this._decryptHandshake(e.slice(12,14)).buffer).getUint16(0);this._parse(i,(e=>{e=this._decryptHandshake(e),this._parse(2,(i=>{const n=new DataView(this._decryptHandshake(i).buffer).getUint16(0);this._parse(n,(i=>{i=this._decryptHandshake(i),this._onPe3Encrypted(t,s,e,i);const r=n?i[0]:null,o=n?i.slice(1,20):null;19===r&&"BitTorrent protocol"===(0,l.dU)(o)?this._onHandshakeBuffer(i.slice(1)):this._parseHandshake()}))}))}))}))}_parsePe4(){const e=this._decryptHandshake(x);this._parseUntil(e,512),this._parse(6,(e=>{const t=this._decryptHandshake(e.slice(0,4)),s=new DataView(this._decryptHandshake(e.slice(4,6)).buffer).getUint16(0);this._parse(s,(e=>{this._decryptHandshake(e),this._onPe4(t),this._parseHandshake(null)}))}))}_parseHandshake(){this._parse(1,(e=>{const t=e[0];if(19!==t)return this._debug("Error: wire not speaking BitTorrent protocol (%s)",t.toString()),void this.end();this._parse(t+48,this._onHandshakeBuffer)}))}_onHandshakeBuffer(e){const t=e.slice(0,19);if("BitTorrent protocol"!==(0,l.dU)(t))return this._debug("Error: wire not speaking BitTorrent protocol (%s)",(0,l.dU)(t)),void this.end();e=e.slice(19),this._onHandshake(e.slice(8,28),e.slice(28,48),{dht:!!(1&e[7]),fast:!!(4&e[7]),extended:!!(16&e[5])}),this._parse(4,this._onMessageLength)}_onFinish(){for(this._finished=!0,this.push(null);this.read(););for(clearInterval(this._keepAliveInterval),this._parse(Number.MAX_VALUE,(()=>{}));this.peerRequests.length;)this.peerRequests.pop();for(;this.requests.length;)this._callback(this.requests.pop(),new Error("wire was closed"),null)}_debug(...e){e[0]=`[${this._debugId}] ${e[0]}`,u(...e)}_pull(e,t,s,i){for(let n=0;n{s.d(t,{NJ:()=>g,V5:()=>o,dU:()=>f,HB:()=>y,xW:()=>h,LC:()=>l,tW:()=>S,fk:()=>a,Ht:()=>w,po:()=>E,L0:()=>_});const i="0123456789abcdef",n=[],r=[];for(let e=0;e<256;e++)n[e]=i[e>>4&15]+i[15&e],e<16&&(e<10?r[48+e]=e:r[87+e]=e);const o=e=>{const t=e.length;let s="",i=0;for(;i{const t=e.length>>1,s=t<<1,i=new Uint8Array(t);let n=0,o=0;for(;o{const s=e.length||0;if(!t){let i=s;for(;i--;)t+=e[i].length}const i=new Uint8Array(t);let n=t,r=s;for(;r--;)n-=e[r].length,i.set(e[r],n);return i},l=(e,t)=>{if(e.length!==t.length)return!1;for(let s=e.length;s>-1;s-=1)if(e[s]!==t[s])return!1;return!0};for(var c="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",d="undefined"==typeof Uint8Array?[]:new Uint8Array(256),u=0;u<64;u++)d[c.charCodeAt(u)]=u;const p=new TextDecoder,f=(e,t)=>{if(!t)return p.decode(e);return new TextDecoder(t).decode(e)},m=new TextEncoder,_=e=>m.encode(e),g=e=>function(e){var t,s=new Uint8Array(e),i=s.length,n="";for(t=0;t>2],n+=c[(3&s[t])<<4|s[t+1]>>4],n+=c[(15&s[t+1])<<2|s[t+2]>>6],n+=c[63&s[t+2]];return i%3==2?n=n.substring(0,n.length-1)+"=":i%3==1&&(n=n.substring(0,n.length-2)+"=="),n}(e),y=e=>{let t,s="",n=0;const r=e.length;for(;n>4]+i[15&t];return s},w=e=>{const t=a(e);if(t.length<=65536)return String.fromCharCode(...t);let s="",i=0;for(;i{if(!k)throw new Error("no web crypto support");"string"==typeof e&&(e=_(e));const i=new Uint8Array(await k.digest(s,e));return t?x[t](i):i},E=e=>{const t=new Uint8Array(e);return v.getRandomValues(t)}},717:(e,t,s)=>{s.r(t),s.d(t,{addListener:()=>u,argv:()=>a,binding:()=>S,browser:()=>r,chdir:()=>E,cwd:()=>k,emit:()=>g,env:()=>o,listeners:()=>v,nextTick:()=>b,off:()=>f,on:()=>d,once:()=>p,prependListener:()=>y,prependOnceListener:()=>w,removeAllListeners:()=>_,removeListener:()=>m,title:()=>n,umask:()=>x,version:()=>h,versions:()=>l});var i=s(9596);const n="browser",r=!0,o={},a=[],h="",l={};function c(){}const d=c,u=c,p=c,f=c,m=c,_=c,g=c,y=c,w=c,b=(e,...t)=>i((()=>e(...t))),v=e=>[],k=()=>"/",x=()=>0,S=e=>{throw new Error("process.binding is not supported")},E=e=>{throw new Error("process.chdir is not supported")}},8330:e=>{e.exports={version:"2.5.11"}}},i={};function n(e){var t=i[e];if(void 0!==t)return t.exports;var r=i[e]={exports:{}};return s[e](r,r.exports,n),r.exports}t=Object.getPrototypeOf?e=>Object.getPrototypeOf(e):e=>e.__proto__,n.t=function(s,i){if(1&i&&(s=this(s)),8&i)return s;if("object"==typeof s&&s){if(4&i&&s.__esModule)return s;if(16&i&&"function"==typeof s.then)return s}var r=Object.create(null);n.r(r);var o={};e=e||[null,t({}),t([]),t(t)];for(var a=2&i&&s;"object"==typeof a&&!~e.indexOf(a);a=t(a))Object.getOwnPropertyNames(a).forEach((e=>o[e]=()=>s[e]));return o.default=()=>s,n.d(r,o),r},n.d=(e,t)=>{for(var s in t)n.o(t,s)&&!n.o(e,s)&&Object.defineProperty(e,s,{enumerable:!0,get:t[s]})},n.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),n.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var r={};n.d(r,{A:()=>Xt});var o=n(7007);function a(e){if("string"!=typeof e)throw new TypeError("Path must be a string. Received "+JSON.stringify(e))}function h(e,t){let s,i="",n=0,r=-1,o=0;for(let a=0;a<=e.length;++a){if(a2){const e=i.lastIndexOf("/");if(e!==i.length-1){-1===e?(i="",n=0):(i=i.slice(0,e),n=i.length-1-i.lastIndexOf("/")),r=a,o=0;continue}}else if(2===i.length||1===i.length){i="",n=0,r=a,o=0;continue}t&&(i.length>0?i+="/..":i="..",n=2)}else i.length>0?i+="/"+e.slice(r+1,a):i=e.slice(r+1,a),n=a-r-1;r=a,o=0}else 46===s&&-1!==o?++o:o=-1}return i}function l(){if(0===arguments.length)return".";let e;for(let t=0;t0&&(void 0===e?e=s:e+="/"+s)}return void 0===e?".":function(e){if(a(e),0===e.length)return".";const t=47===e.charCodeAt(0),s=47===e.charCodeAt(e.length-1);return 0!==(e=h(e,!t)).length||t||(e="."),e.length>0&&s&&(e+="/"),t?"/"+e:e}(e)}n(717);const c="/";var d=n(988),u=n(1467),p=n(8444),f=n(2123);const m=new RegExp(["^npm-debug\\.log$","^\\..*\\.swp$","^\\.DS_Store$","^\\.AppleDouble$","^\\.LSOverride$","^Icon\\r$","^\\._.*","^\\.Spotlight-V100(?:$|\\/)","\\.Trashes","^__MACOSX$","~$","^Thumbs\\.db$","^ehthumbs\\.db$","^[Dd]esktop\\.ini$","@eaDir$"].join("|"));function _(e){return m.test(e)}var g=n(405),y=n(8190),w=n(9596),b=n(9639),v=(n(3468),n(2532));const k=[["udp://tracker.leechers-paradise.org:6969"],["udp://tracker.coppersurfer.tk:6969"],["udp://tracker.opentrackr.org:1337"],["udp://explodie.org:6969"],["udp://tracker.empire-js.us:1337"],["wss://tracker.btorrent.xyz"],["wss://tracker.openwebtorrent.com"],["wss://tracker.webtorrent.dev"]];const x=Symbol("itemPath");function S(e,t,s){var i;if(i=e,"undefined"!=typeof FileList&&i instanceof FileList&&(e=Array.from(e)),Array.isArray(e)||(e=[e]),0===e.length)throw new Error("invalid input type");e.forEach((e=>{if(null==e)throw new Error(`invalid input type: ${e}`)})),1!==(e=e.map((e=>A(e)&&"string"==typeof e.path&&"function"==typeof v?e.path:e))).length||"string"==typeof e[0]||e[0].name||(e[0].name=t.name);let n=null;e.forEach(((t,s)=>{if("string"==typeof t)return;let i=t.fullPath||t.name;i||(i=`Unknown File ${s+1}`,t.unknownName=!0),t[x]=i.split("/"),t[x][0]||t[x].shift(),t[x].length<2?n=null:0===s&&e.length>1?n=t[x][0]:t[x][0]!==n&&(n=null)}));(void 0===t.filterJunkFiles||t.filterJunkFiles)&&(e=e.filter((e=>"string"==typeof e||!function(e){const t=e[e.length-1];return"."===t[0]&&_(t)}(e[x])))),n&&e.forEach((e=>{const t=(ArrayBuffer.isView(e)||T(e))&&!e[x];"string"==typeof e||t||e[x].shift()})),!t.name&&n&&(t.name=n),t.name||e.some((e=>"string"==typeof e?(t.name=function(e,t){if(void 0!==t&&"string"!=typeof t)throw new TypeError('"ext" argument must be a string');a(e);let s,i=0,n=-1,r=!0;if(void 0!==t&&t.length>0&&t.length<=e.length){if(t.length===e.length&&t===e)return"";let o=t.length-1,a=-1;for(s=e.length-1;s>=0;--s){const h=e.charCodeAt(s);if(47===h){if(!r){i=s+1;break}}else-1===a&&(r=!1,a=s+1),o>=0&&(h===t.charCodeAt(o)?-1==--o&&(n=s):(o=-1,n=a))}return i===n?n=a:-1===n&&(n=e.length),e.slice(i,n)}for(s=e.length-1;s>=0;--s)if(47===e.charCodeAt(s)){if(!r){i=s+1;break}}else-1===n&&(r=!1,n=s+1);return-1===n?"":e.slice(i,n)}(e),!0):!e.unknownName&&(t.name=e[x][e[x].length-1],!0))),t.name||(t.name=`Unnamed Torrent ${Date.now()}`),t.maxPieceLength||(t.maxPieceLength=4194304);const r=e.reduce(((e,t)=>e+Number("string"==typeof t)),0);let o=1===e.length;if(1===e.length&&"string"==typeof e[0]){if("function"!=typeof v)throw new Error("filesystem paths do not work in the browser");f(e[0],((e,t)=>{if(e)return s(e);o=t,h()}))}else w(h);function h(){y(e.map((e=>t=>{const s={};if(A(e))s.getStream=e.stream(),s.length=e.size;else if(ArrayBuffer.isView(e))s.getStream=[e],s.length=e.length;else{if(!T(e)){if("string"==typeof e){if("function"!=typeof v)throw new Error("filesystem paths do not work in the browser");return void v(e,r>1||o,t)}throw new Error("invalid input type")}s.getStream=async function*(e,t){for await(const s of e)t.length+=s.length,yield s}(e,s),s.length=0}s.path=e[x],t(null,s)})),((e,t)=>{if(e)return s(e);t=t.flat(),s(null,t,o)}))}}const E=5;function C(e,t){return e+t.length}function A(e){return"undefined"!=typeof Blob&&e instanceof Blob}function T(e){return"object"==typeof e&&null!=e&&"function"==typeof e.pipe}const P=function(e,t,s){"function"==typeof t&&([t,s]=[s,t]),S(e,t=t?Object.assign({},t):{},((e,i,n)=>{if(e)return s(e);t.singleFileTorrent=n,function(e,t,s){let i=t.announceList;i||("string"==typeof t.announce?i=[[t.announce]]:Array.isArray(t.announce)&&(i=t.announce.map((e=>[e]))));i||(i=[]);globalThis.WEBTORRENT_ANNOUNCE&&("string"==typeof globalThis.WEBTORRENT_ANNOUNCE?i.push([[globalThis.WEBTORRENT_ANNOUNCE]]):Array.isArray(globalThis.WEBTORRENT_ANNOUNCE)&&(i=i.concat(globalThis.WEBTORRENT_ANNOUNCE.map((e=>[e])))));void 0===t.announce&&void 0===t.announceList&&(i=i.concat(k));"string"==typeof t.urlList&&(t.urlList=[t.urlList]);const n={info:{name:t.name},"creation date":Math.ceil((Number(t.creationDate)||Date.now())/1e3),encoding:"UTF-8"};0!==i.length&&(n.announce=i[0][0],n["announce-list"]=i);void 0!==t.comment&&(n.comment=t.comment);void 0!==t.createdBy&&(n["created by"]=t.createdBy);void 0!==t.private&&(n.info.private=Number(t.private));void 0!==t.info&&Object.assign(n.info,t.info);void 0!==t.sslCert&&(n.info["ssl-cert"]=t.sslCert);void 0!==t.urlList&&(n["url-list"]=t.urlList);const r=e.reduce(C,0),o=t.pieceLength||Math.min(p(r),t.maxPieceLength);n.info["piece length"]=o,async function(e,t,s,i,n){const r=[];let o=0,a=0;const h=e.map((e=>e.getStream)),l=i.onProgress;let c=0,d=0,p=!1;const f=u(g(h),t,{zeroPadding:!1});try{for await(const e of f)await new Promise((t=>{o+=e.length;const i=d;++d,++c{r[i]=h,--c,a+=e.length,l&&l(a,s),t(),p&&0===c&&n(null,(0,b.fk)(r.join("")),o)}))}));if(0===c)return n(null,(0,b.fk)(r.join("")),o);p=!0}catch(e){n(e)}}(e,o,r,t,((i,r,o)=>{if(i)return s(i);n.info.pieces=r,e.forEach((e=>{delete e.getStream})),t.singleFileTorrent?n.info.length=o:n.info.files=e,s(null,d.A.encode(n))}))}(i,t,s)}))};var I=n(7833),L=n(6664),O=n(1827),R=n(3208);self.Blob,self.File,self.FormData,self.Headers,self.Request,self.Response,self.AbortController,self.AbortSignal;const H=self.fetch||(()=>{throw new Error("global fetch is not available!")}),N=[255,255,26,27,28,29,30,31,255,255,255,255,255,255,255,255,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,255,255,255,255,255,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,255,255,255,255,255];const M=function(e){if(!ArrayBuffer.isView(e)&&"string"!=typeof e)throw new TypeError("base32.decode only takes Buffer or string as parameter");let t,s=0,i=0,n=0;ArrayBuffer.isView(e)||(e=(0,b.L0)(e));const r=new Uint8Array(Math.ceil(5*e.length/8));for(let o=0;o>>s,r[n]=t,n++,t=255&i<<8-s)}return r.subarray(0,n)};function U(e){return e.reduce(((e,t,s,i)=>{const n=t.split("-").map((e=>parseInt(e)));return e.concat(((e,t=e)=>Array.from({length:t-e+1},((t,s)=>s+e)))(...n))}),[])}const F=function(e){const t={},s=e.split("magnet:?")[1];let i;if((s&&s.length>=0?s.split("&"):[]).forEach((e=>{const s=e.split("=");if(2!==s.length)return;const i=s[0];let n=s[1];"dn"===i&&(n=decodeURIComponent(n).replace(/\+/g," ")),"tr"!==i&&"xs"!==i&&"as"!==i&&"ws"!==i||(n=decodeURIComponent(n)),"kt"===i&&(n=decodeURIComponent(n).split("+")),"ix"===i&&(n=Number(n)),"so"===i&&(n=U(decodeURIComponent(n).split(","))),t[i]?(Array.isArray(t[i])||(t[i]=[t[i]]),t[i].push(n)):t[i]=n})),t.xt){(Array.isArray(t.xt)?t.xt:[t.xt]).forEach((e=>{(i=e.match(/^urn:btih:(.{40})/))?t.infoHash=i[1].toLowerCase():(i=e.match(/^urn:btih:(.{32})/))?t.infoHash=(0,b.V5)(M(i[1])):(i=e.match(/^urn:btmh:1220(.{64})/))&&(t.infoHashV2=i[1].toLowerCase())}))}if(t.xs){(Array.isArray(t.xs)?t.xs:[t.xs]).forEach((e=>{(i=e.match(/^urn:btpk:(.{64})/))&&(t.publicKey=i[1].toLowerCase())}))}return t.infoHash&&(t.infoHashBuffer=(0,b.fk)(t.infoHash)),t.infoHashV2&&(t.infoHashV2Buffer=(0,b.fk)(t.infoHashV2)),t.publicKey&&(t.publicKeyBuffer=(0,b.fk)(t.publicKey)),t.dn&&(t.name=t.dn),t.kt&&(t.keywords=t.kt),t.announce=[],("string"==typeof t.tr||Array.isArray(t.tr))&&(t.announce=t.announce.concat(t.tr)),t.urlList=[],("string"==typeof t.as||Array.isArray(t.as))&&(t.urlList=t.urlList.concat(t.as)),("string"==typeof t.ws||Array.isArray(t.ws))&&(t.urlList=t.urlList.concat(t.ws)),t.peerAddresses=[],("string"==typeof t["x.pe"]||Array.isArray(t["x.pe"]))&&(t.peerAddresses=t.peerAddresses.concat(t["x.pe"])),t.announce=Array.from(new Set(t.announce)),t.urlList=Array.from(new Set(t.urlList)),t.peerAddresses=Array.from(new Set(t.peerAddresses)),t};async function j(e){if("string"==typeof e&&/^(stream-)?magnet:/.test(e)){const t=F(e);if(!t.infoHash)throw new Error("Invalid torrent identifier");return t}if("string"==typeof e&&(/^[a-f0-9]{40}$/i.test(e)||/^[a-z2-7]{32}$/i.test(e)))return F(`magnet:?xt=urn:btih:${e}`);if(ArrayBuffer.isView(e)&&20===e.length)return F(`magnet:?xt=urn:btih:${(0,b.V5)(e)}`);if(ArrayBuffer.isView(e))return await async function(e){ArrayBuffer.isView(e)&&(e=d.A.decode(e));q(e.info,"info"),q(e.info["name.utf-8"]||e.info.name,"info.name"),q(e.info["piece length"],"info['piece length']"),q(e.info.pieces,"info.pieces"),e.info.files?e.info.files.forEach((e=>{q("number"==typeof e.length,"info.files[0].length"),q(e["path.utf-8"]||e.path,"info.files[0].path")})):q("number"==typeof e.info.length,"info.length");const t={info:e.info,infoBuffer:d.A.encode(e.info),name:(0,b.dU)(e.info["name.utf-8"]||e.info.name),announce:[]};t.infoHashBuffer=await(0,b.tW)(t.infoBuffer),t.infoHash=(0,b.V5)(t.infoHashBuffer),void 0!==e.info.private&&(t.private=!!e.info.private);e["creation date"]&&(t.created=new Date(1e3*e["creation date"]));e["created by"]&&(t.createdBy=(0,b.dU)(e["created by"]));ArrayBuffer.isView(e.comment)&&(t.comment=(0,b.dU)(e.comment));Array.isArray(e["announce-list"])&&e["announce-list"].length>0?e["announce-list"].forEach((e=>{e.forEach((e=>{t.announce.push((0,b.dU)(e))}))})):e.announce&&t.announce.push((0,b.dU)(e.announce));ArrayBuffer.isView(e["url-list"])&&(e["url-list"]=e["url-list"].length>0?[e["url-list"]]:[]);t.urlList=(e["url-list"]||[]).map((e=>(0,b.dU)(e))),t.announce=Array.from(new Set(t.announce)),t.urlList=Array.from(new Set(t.urlList));const s=e.info.files||[e.info];t.files=s.map(((e,i)=>{const n=[].concat(t.name,e["path.utf-8"]||e.path||[]).map((e=>ArrayBuffer.isView(e)?(0,b.dU)(e):e));return{path:l.apply(null,[c].concat(n)).slice(1),name:n[n.length-1],length:e.length,offset:s.slice(0,i).reduce(D,0)}})),t.length=s.reduce(D,0);const i=t.files[t.files.length-1];return t.pieceLength=e.info["piece length"],t.lastPieceLength=(i.offset+i.length)%t.pieceLength||t.pieceLength,t.pieces=function(e){const t=[];for(let s=0;s{s(null,i)}));else if(n=e,"undefined"!=typeof Blob&&n instanceof Blob)try{r(new Uint8Array(await e.arrayBuffer()))}catch(e){return s(new Error(`Error converting Blob: ${e.message}`))}else if(/^https?:/.test(e))try{const s=await H(e,{headers:{"user-agent":"WebTorrent (https://webtorrent.io)"},signal:AbortSignal.timeout(3e4),...t});r(new Uint8Array(await s.arrayBuffer()))}catch(e){return s(new Error(`Error downloading torrent: ${e.message}`))}else"function"==typeof R.readFile&&"string"==typeof e?R.readFile(e,((e,t)=>{if(e)return s(new Error("Invalid torrent identifier"));r(t)})):w((()=>{s(new Error("Invalid torrent identifier"))}));var n;async function r(e){try{i=await j(e)}catch(e){return s(e)}i&&i.infoHash?s(null,i):s(new Error("Invalid torrent identifier"))}}function D(e,t){return e+t.length}function q(e,t){if(!e)throw new Error(`Torrent is missing required field: ${t}`)}const W=j,$=function(e){e=Object.assign({},e);let t=new Set;e.xt&&"string"==typeof e.xt&&t.add(e.xt),e.xt&&Array.isArray(e.xt)&&(t=new Set(e.xt)),e.infoHashBuffer&&t.add(`urn:btih:${(0,b.V5)(e.infoHashBuffer)}`),e.infoHash&&t.add(`urn:btih:${e.infoHash}`),e.infoHashV2Buffer&&t.add(e.xt=`urn:btmh:1220${(0,b.V5)(e.infoHashV2Buffer)}`),e.infoHashV2&&t.add(`urn:btmh:1220${e.infoHashV2}`);const s=Array.from(t);1===s.length&&(e.xt=s[0]),s.length>1&&(e.xt=s),e.publicKeyBuffer&&(e.xs=`urn:btpk:${(0,b.V5)(e.publicKeyBuffer)}`),e.publicKey&&(e.xs=`urn:btpk:${e.publicKey}`),e.name&&(e.dn=e.name),e.keywords&&(e.kt=e.keywords),e.announce&&(e.tr=e.announce),e.urlList&&(e.ws=e.urlList,delete e.as),e.peerAddresses&&(e["x.pe"]=e.peerAddresses);let i="magnet:?";return Object.keys(e).filter((e=>2===e.length||"x.pe"===e)).forEach(((t,s)=>{const n=Array.isArray(e[t])?e[t]:[e[t]];var r;n.forEach(((e,n)=>{(s>0||n>0)&&("kt"!==t&&"so"!==t||0===n)&&(i+="&"),"dn"===t&&(e=encodeURIComponent(e).replace(/%20/g,"+")),"tr"!==t&&"as"!==t&&"ws"!==t||(e=encodeURIComponent(e)),"xs"!==t||e.startsWith("urn:btpk:")||(e=encodeURIComponent(e)),"kt"===t&&(e=encodeURIComponent(e)),"so"!==t&&(i+="kt"===t&&n>0?`+${e}`:`${t}=${e}`)})),"so"===t&&(i+=`${t}=${r=n,r.reduce(((e,t,s,i)=>(0!==s&&t===i[s-1]+1||e.push([]),e[e.length-1].push(t),e)),[]).map((e=>e.length>1?`${e[0]}-${e[e.length-1]}`:`${e[0]}`))}`)})),i},z="undefined"!=typeof window?window:self,V=z.RTCPeerConnection||z.mozRTCPeerConnection||z.webkitRTCPeerConnection,G=z.RTCSessionDescription||z.mozRTCSessionDescription||z.webkitRTCSessionDescription,K=z.RTCIceCandidate||z.mozRTCIceCandidate||z.webkitRTCIceCandidate;z.RTCIceTransport,z.RTCDataChannel,z.RTCSctpTransport,z.RTCDtlsTransport,z.RTCCertificate,z.MediaStream,z.MediaStreamTrack,z.MediaStreamTrackEvent,z.RTCPeerConnectionIceEvent,z.RTCDataChannelEvent,z.RTCTrackEvent,z.RTCError,z.RTCErrorEvent,z.RTCRtpTransceiver,z.RTCRtpReceiver,z.RTCRtpSender;var Y=n(8179),J=n(6310);const X=I("simple-peer"),Q=65536;function Z(e){return e.replace(/a=ice-options:trickle\s\n/g,"")}class ee extends Y.Duplex{_pc;constructor(e){if(super(e=Object.assign({allowHalfOpen:!1},e)),this.__objectMode=!!e.objectMode,this._id=(0,b.V5)((0,b.po)(4)).slice(0,7),this._debug("new peer %o",e),this.channelName=e.initiator?e.channelName||(0,b.V5)((0,b.po)(20)):null,this.initiator=e.initiator||!1,this.channelConfig=e.channelConfig||ee.channelConfig,this.channelNegotiated=this.channelConfig.negotiated,this.config=Object.assign({},ee.config,e.config),this.offerOptions=e.offerOptions||{},this.answerOptions=e.answerOptions||{},this.sdpTransform=e.sdpTransform||(e=>e),this.trickle=void 0===e.trickle||e.trickle,this.allowHalfTrickle=void 0!==e.allowHalfTrickle&&e.allowHalfTrickle,this.iceCompleteTimeout=e.iceCompleteTimeout||5e3,this._destroying=!1,this._connected=!1,this.remoteAddress=void 0,this.remoteFamily=void 0,this.remotePort=void 0,this.localAddress=void 0,this.localFamily=void 0,this.localPort=void 0,!V)throw"undefined"==typeof window?J(new Error("No WebRTC support: Specify `opts.wrtc` option in this environment"),"ERR_WEBRTC_SUPPORT"):J(new Error("No WebRTC support: Not a supported browser"),"ERR_WEBRTC_SUPPORT");this._pcReady=!1,this._channelReady=!1,this._iceComplete=!1,this._iceCompleteTimer=null,this._channel=null,this._pendingCandidates=[],this._isNegotiating=!1,this._firstNegotiation=!0,this._batchedNegotiation=!1,this._queuedNegotiation=!1,this._sendersAwaitingStable=[],this._closingInterval=null,this._remoteTracks=[],this._remoteStreams=[],this._chunk=null,this._cb=null,this._interval=null;try{this._pc=new V(this.config)}catch(e){return void this.__destroy(J(e,"ERR_PC_CONSTRUCTOR"))}this._isReactNativeWebrtc="number"==typeof this._pc._peerConnectionId,this._pc.oniceconnectionstatechange=()=>{this._onIceStateChange()},this._pc.onicegatheringstatechange=()=>{this._onIceStateChange()},this._pc.onconnectionstatechange=()=>{this._onConnectionStateChange()},this._pc.onsignalingstatechange=()=>{this._onSignalingStateChange()},this._pc.onicecandidate=e=>{this._onIceCandidate(e)},"object"==typeof this._pc.peerIdentity&&this._pc.peerIdentity.catch((e=>{this.__destroy(J(e,"ERR_PC_PEER_IDENTITY"))})),this.initiator||this.channelNegotiated?this._setupData({channel:this._pc.createDataChannel(this.channelName,this.channelConfig)}):this._pc.ondatachannel=e=>{this._setupData(e)},this._debug("initial negotiation"),this._needsNegotiation(),this._onFinishBound=()=>{this._onFinish()},this.once("finish",this._onFinishBound)}get bufferSize(){return this._channel&&this._channel.bufferedAmount||0}get connected(){return this._connected&&"open"===this._channel.readyState}address(){return{port:this.localPort,family:this.localFamily,address:this.localAddress}}signal(e){if(!this._destroying){if(this.destroyed)throw J(new Error("cannot signal after peer is destroyed"),"ERR_DESTROYED");if("string"==typeof e)try{e=JSON.parse(e)}catch(t){e={}}this._debug("signal()"),e.renegotiate&&this.initiator&&(this._debug("got request to renegotiate"),this._needsNegotiation()),e.transceiverRequest&&this.initiator&&(this._debug("got request for transceiver"),this.addTransceiver(e.transceiverRequest.kind,e.transceiverRequest.init)),e.candidate&&(this._pc.remoteDescription&&this._pc.remoteDescription.type?this._addIceCandidate(e.candidate):this._pendingCandidates.push(e.candidate)),e.sdp&&this._pc.setRemoteDescription(new G(e)).then((()=>{this.destroyed||(this._pendingCandidates.forEach((e=>{this._addIceCandidate(e)})),this._pendingCandidates=[],"offer"===this._pc.remoteDescription.type&&this._createAnswer())})).catch((e=>{this.__destroy(J(e,"ERR_SET_REMOTE_DESCRIPTION"))})),e.sdp||e.candidate||e.renegotiate||e.transceiverRequest||this.__destroy(J(new Error("signal() called with invalid signal data"),"ERR_SIGNALING"))}}_addIceCandidate(e){const t=new K(e);this._pc.addIceCandidate(t).catch((e=>{var s;!t.address||t.address.endsWith(".local")?(s="Ignoring unsupported ICE candidate.",console.warn(s)):this.__destroy(J(e,"ERR_ADD_ICE_CANDIDATE"))}))}send(e){if(!this._destroying){if(this.destroyed)throw J(new Error("cannot send after peer is destroyed"),"ERR_DESTROYED");this._channel.send(e)}}_needsNegotiation(){this._debug("_needsNegotiation"),this._batchedNegotiation||(this._batchedNegotiation=!0,queueMicrotask((()=>{this._batchedNegotiation=!1,this.initiator||!this._firstNegotiation?(this._debug("starting batched negotiation"),this.negotiate()):this._debug("non-initiator initial negotiation request discarded"),this._firstNegotiation=!1})))}negotiate(){if(!this._destroying){if(this.destroyed)throw J(new Error("cannot negotiate after peer is destroyed"),"ERR_DESTROYED");this.initiator?this._isNegotiating?(this._queuedNegotiation=!0,this._debug("already negotiating, queueing")):(this._debug("start negotiation"),setTimeout((()=>{this._createOffer()}),0)):this._isNegotiating?(this._queuedNegotiation=!0,this._debug("already negotiating, queueing")):(this._debug("requesting negotiation from initiator"),this.emit("signal",{type:"renegotiate",renegotiate:!0})),this._isNegotiating=!0}}_final(e){this._readableState.ended||this.push(null),e(null)}__destroy(e){this.end(),this._destroy((()=>{}),e)}_destroy(e,t){this.destroyed||this._destroying||(this._destroying=!0,this._debug("destroying (error: %s)",t&&(t.message||t)),setTimeout((()=>{if(this._connected=!1,this._pcReady=!1,this._channelReady=!1,this._remoteTracks=null,this._remoteStreams=null,this._senderMap=null,clearInterval(this._closingInterval),this._closingInterval=null,clearInterval(this._interval),this._interval=null,this._chunk=null,this._cb=null,this._onFinishBound&&this.removeListener("finish",this._onFinishBound),this._onFinishBound=null,this._channel){try{this._channel.close()}catch(e){}this._channel.onmessage=null,this._channel.onopen=null,this._channel.onclose=null,this._channel.onerror=null}if(this._pc){try{this._pc.close()}catch(e){}this._pc.oniceconnectionstatechange=null,this._pc.onicegatheringstatechange=null,this._pc.onsignalingstatechange=null,this._pc.onicecandidate=null,this._pc.ontrack=null,this._pc.ondatachannel=null}this._pc=null,this._channel=null,t&&this.emit("error",t),e()}),0))}_setupData(e){if(!e.channel)return this.__destroy(J(new Error("Data channel event is missing `channel` property"),"ERR_DATA_CHANNEL"));this._channel=e.channel,this._channel.binaryType="arraybuffer","number"==typeof this._channel.bufferedAmountLowThreshold&&(this._channel.bufferedAmountLowThreshold=Q),this.channelName=this._channel.label,this._channel.onmessage=e=>{this._onChannelMessage(e)},this._channel.onbufferedamountlow=()=>{this._onChannelBufferedAmountLow()},this._channel.onopen=()=>{this._onChannelOpen()},this._channel.onclose=()=>{this._onChannelClose()},this._channel.onerror=e=>{const t=e.error instanceof Error?e.error:new Error(`Datachannel error: ${e.message} ${e.filename}:${e.lineno}:${e.colno}`);this.__destroy(J(t,"ERR_DATA_CHANNEL"))};let t=!1;this._closingInterval=setInterval((()=>{this._channel&&"closing"===this._channel.readyState?(t&&this._onChannelClose(),t=!0):t=!1}),5e3)}_write(e,t){if(this.destroyed)return t(J(new Error("cannot write after peer is destroyed"),"ERR_DATA_CHANNEL"));if(this._connected){try{this.send(e)}catch(e){return this.__destroy(J(e,"ERR_DATA_CHANNEL"))}this._channel.bufferedAmount>Q?(this._debug("start backpressure: bufferedAmount %d",this._channel.bufferedAmount),this._cb=t):t(null)}else this._debug("write before connect"),this._chunk=e,this._cb=t}_onFinish(){if(this.destroyed)return;const e=()=>{setTimeout((()=>this.__destroy()),1e3)};this._connected?e():this.once("connect",e)}_startIceCompleteTimeout(){this.destroyed||this._iceCompleteTimer||(this._debug("started iceComplete timeout"),this._iceCompleteTimer=setTimeout((()=>{this._iceComplete||(this._iceComplete=!0,this._debug("iceComplete timeout completed"),this.emit("iceTimeout"),this.emit("_iceComplete"))}),this.iceCompleteTimeout))}_createOffer(){this.destroyed||this._pc.createOffer(this.offerOptions).then((e=>{if(this.destroyed)return;this.trickle||this.allowHalfTrickle||(e.sdp=Z(e.sdp)),e.sdp=this.sdpTransform(e.sdp);const t=()=>{if(this.destroyed)return;const t=this._pc.localDescription||e;this._debug("signal"),this.emit("signal",{type:t.type,sdp:t.sdp})};this._pc.setLocalDescription(e).then((()=>{this._debug("createOffer success"),this.destroyed||(this.trickle||this._iceComplete?t():this.once("_iceComplete",t))})).catch((e=>{this.__destroy(J(e,"ERR_SET_LOCAL_DESCRIPTION"))}))})).catch((e=>{this.__destroy(J(e,"ERR_CREATE_OFFER"))}))}_createAnswer(){this.destroyed||this._pc.createAnswer(this.answerOptions).then((e=>{if(this.destroyed)return;this.trickle||this.allowHalfTrickle||(e.sdp=Z(e.sdp)),e.sdp=this.sdpTransform(e.sdp);const t=()=>{if(this.destroyed)return;const t=this._pc.localDescription||e;this._debug("signal"),this.emit("signal",{type:t.type,sdp:t.sdp}),this.initiator||this._requestMissingTransceivers?.()};this._pc.setLocalDescription(e).then((()=>{this.destroyed||(this.trickle||this._iceComplete?t():this.once("_iceComplete",t))})).catch((e=>{this.__destroy(J(e,"ERR_SET_LOCAL_DESCRIPTION"))}))})).catch((e=>{this.__destroy(J(e,"ERR_CREATE_ANSWER"))}))}_onConnectionStateChange(){this.destroyed||this._destroying||"failed"===this._pc.connectionState&&this.__destroy(J(new Error("Connection failed."),"ERR_CONNECTION_FAILURE"))}_onIceStateChange(){if(this.destroyed)return;const e=this._pc.iceConnectionState,t=this._pc.iceGatheringState;this._debug("iceStateChange (connection: %s) (gathering: %s)",e,t),this.emit("iceStateChange",e,t),"connected"!==e&&"completed"!==e||(this._pcReady=!0,this._maybeReady()),"failed"===e&&this.__destroy(J(new Error("Ice connection failed."),"ERR_ICE_CONNECTION_FAILURE")),"closed"===e&&this.__destroy(J(new Error("Ice connection closed."),"ERR_ICE_CONNECTION_CLOSED"))}getStats(e){const t=e=>("[object Array]"===Object.prototype.toString.call(e.values)&&e.values.forEach((t=>{Object.assign(e,t)})),e);0===this._pc.getStats.length||this._isReactNativeWebrtc?this._pc.getStats().then((s=>{const i=[];s.forEach((e=>{i.push(t(e))})),e(null,i)}),(t=>e(t))):this._pc.getStats.length>0?this._pc.getStats((s=>{if(this.destroyed)return;const i=[];s.result().forEach((e=>{const s={};e.names().forEach((t=>{s[t]=e.stat(t)})),s.id=e.id,s.type=e.type,s.timestamp=e.timestamp,i.push(t(s))})),e(null,i)}),(t=>e(t))):e(null,[])}_maybeReady(){if(this._debug("maybeReady pc %s channel %s",this._pcReady,this._channelReady),this._connected||this._connecting||!this._pcReady||!this._channelReady)return;this._connecting=!0;const e=()=>{this.destroyed||this._destroying||this.getStats(((t,s)=>{if(this.destroyed||this._destroying)return;t&&(s=[]);const i={},n={},r={};let o=!1;s.forEach((e=>{"remotecandidate"!==e.type&&"remote-candidate"!==e.type||(i[e.id]=e),"localcandidate"!==e.type&&"local-candidate"!==e.type||(n[e.id]=e),"candidatepair"!==e.type&&"candidate-pair"!==e.type||(r[e.id]=e)}));const a=e=>{o=!0;let t=n[e.localCandidateId];t&&(t.ip||t.address)?(this.localAddress=t.ip||t.address,this.localPort=Number(t.port)):t&&t.ipAddress?(this.localAddress=t.ipAddress,this.localPort=Number(t.portNumber)):"string"==typeof e.googLocalAddress&&(t=e.googLocalAddress.split(":"),this.localAddress=t[0],this.localPort=Number(t[1])),this.localAddress&&(this.localFamily=this.localAddress.includes(":")?"IPv6":"IPv4");let s=i[e.remoteCandidateId];s&&(s.ip||s.address)?(this.remoteAddress=s.ip||s.address,this.remotePort=Number(s.port)):s&&s.ipAddress?(this.remoteAddress=s.ipAddress,this.remotePort=Number(s.portNumber)):"string"==typeof e.googRemoteAddress&&(s=e.googRemoteAddress.split(":"),this.remoteAddress=s[0],this.remotePort=Number(s[1])),this.remoteAddress&&(this.remoteFamily=this.remoteAddress.includes(":")?"IPv6":"IPv4"),this._debug("connect local: %s:%s remote: %s:%s",this.localAddress,this.localPort,this.remoteAddress,this.remotePort)};if(s.forEach((e=>{"transport"===e.type&&e.selectedCandidatePairId&&a(r[e.selectedCandidatePairId]),("googCandidatePair"===e.type&&"true"===e.googActiveConnection||("candidatepair"===e.type||"candidate-pair"===e.type)&&e.selected)&&a(e)})),o||Object.keys(r).length&&!Object.keys(n).length){if(this._connecting=!1,this._connected=!0,this._chunk){try{this.send(this._chunk)}catch(t){return this.__destroy(J(t,"ERR_DATA_CHANNEL"))}this._chunk=null,this._debug('sent chunk from "write before connect"');const e=this._cb;this._cb=null,e(null)}"number"!=typeof this._channel.bufferedAmountLowThreshold&&(this._interval=setInterval((()=>this._onInterval()),150),this._interval.unref&&this._interval.unref()),this._debug("connect"),this.emit("connect")}else setTimeout(e,100)}))};e()}_onInterval(){!this._cb||!this._channel||this._channel.bufferedAmount>Q||this._onChannelBufferedAmountLow()}_onSignalingStateChange(){this.destroyed||("stable"===this._pc.signalingState&&(this._isNegotiating=!1,this._debug("flushing sender queue",this._sendersAwaitingStable),this._sendersAwaitingStable.forEach((e=>{this._pc.removeTrack(e),this._queuedNegotiation=!0})),this._sendersAwaitingStable=[],this._queuedNegotiation?(this._debug("flushing negotiation queue"),this._queuedNegotiation=!1,this._needsNegotiation()):(this._debug("negotiated"),this.emit("negotiated"))),this._debug("signalingStateChange %s",this._pc.signalingState),this.emit("signalingStateChange",this._pc.signalingState))}_onIceCandidate(e){this.destroyed||(e.candidate&&this.trickle?this.emit("signal",{type:"candidate",candidate:{candidate:e.candidate.candidate,sdpMLineIndex:e.candidate.sdpMLineIndex,sdpMid:e.candidate.sdpMid}}):e.candidate||this._iceComplete||(this._iceComplete=!0,this.emit("_iceComplete")),e.candidate&&this._startIceCompleteTimeout())}_onChannelMessage(e){if(this.destroyed)return;let t=e.data;t instanceof ArrayBuffer?t=new Uint8Array(t):!1===this.__objectMode&&(t=(0,b.L0)(t)),this.push(t)}_onChannelBufferedAmountLow(){if(this.destroyed||!this._cb)return;this._debug("ending backpressure: bufferedAmount %d",this._channel.bufferedAmount);const e=this._cb;this._cb=null,e(null)}_onChannelOpen(){this._connected||this.destroyed||(this._debug("on channel open"),this._channelReady=!0,this._maybeReady())}_onChannelClose(){this.destroyed||(this._debug("on channel close"),this.__destroy())}_debug(){const e=[].slice.call(arguments);e[0]="["+this._id+"] "+e[0],X.apply(null,e)}}ee.WEBRTC_SUPPORT=!!V,ee.config={iceServers:[{urls:["stun:stun.l.google.com:19302","stun:global.stun.twilio.com:3478"]}],sdpSemantics:"unified-plan"},ee.channelConfig={};const te=ee;var se=n(1035),ie=n(7541),ne=n(3278),re=n(8271),oe=n(6686),ae=n(7828),he=n(6889);const le=/^\[?([^\]]+)]?:(\d+)$/;let ce=new Map;function de(e){if(1e5===ce.size&&ce.clear(),!ce.has(e)){const t=le.exec(e);if(!t)throw new Error(`invalid addr: ${e}`);ce.set(e,[t[1],Number(t[2])])}return ce.get(e)}var ue=n(3033),pe=n(4497);async function*fe(e,t={}){if(e?.[Symbol.asyncIterator])return void(yield*e[Symbol.asyncIterator](t.offset));if(!e?.get)throw new Error("First argument must be an abstract-chunk-store compliant store");const s=t.chunkLength||e.chunkLength;if(!s)throw new Error("missing required `chunkLength` property");let i=t.length||e.length;if(!Number.isFinite(i))throw new Error("missing required `length` property");const n=t.offset||0,r=(t,s,i)=>new Promise(((n,r)=>{e.get(t,{offset:i,length:s},((e,t)=>{e&&r(e),n(t)}))}));let o=Math.floor(n/s);const a=n%s;if(n){const e=Math.min(i,s-a);i-=e,yield r(o++,e,a)}for(let e=i;e>0;++o,e-=s)yield r(o,Math.min(e,s))}async function me(e,t,s={}){if(!e?.put)throw new Error("First argument must be an abstract-chunk-store compliant store");const i=s.chunkLength||e.chunkLength;if(!i)throw new Error("missing required `chunkLength` property");const n=s.storeMaxOutstandingPuts||16;let r=0,o=0,a=()=>{},h=!1;for await(const l of u(t,i,{zeroPadding:s.zeroPadding||!1}))await new Promise((t=>{r++<=n&&t(),e.put(o++,l,(e=>{if(e)throw e;--r,t(),h&&0===r&&a()}))}));0!==r&&(h=new Promise((e=>{a=e})),await h)}var _e=n(4018),ge=n(3970),ye=n(3519),we=n(1551);const be={DEFAULT_ANNOUNCE_PEERS:50,MAX_ANNOUNCE_PEERS:82,parseUrl:e=>{const t=new URL(e.replace(/^udp:/,"http:"));return e.match(/^udp:/)&&Object.defineProperties(t,{href:{value:t.href.replace(/^http/,"udp")},protocol:{value:t.protocol.replace(/^http/,"udp")},origin:{value:t.origin.replace(/^http/,"udp")}}),t},...n.t(we,2)};var ve=n(826),ke=n(61),xe=n(2701);const Se=I("simple-websocket"),Ee="function"!=typeof xe?WebSocket:xe;class Ce extends Y.Duplex{constructor(e={}){if("string"==typeof e&&(e={url:e}),super(e=Object.assign({allowHalfOpen:!1},e)),this.__objectMode=!!e.objectMode,null!=e.objectMode&&delete e.objectMode,null==e.url&&null==e.socket)throw new Error("Missing required `url` or `socket` option");if(null!=e.url&&null!=e.socket)throw new Error("Must specify either `url` or `socket` option, not both");if(this._id=(0,b.V5)((0,b.po)(4)).slice(0,7),this._debug("new websocket: %o",e),this.connected=!1,this._chunk=null,this._cb=null,this._interval=null,e.socket)this.url=e.socket.url,this._ws=e.socket,this.connected=e.socket.readyState===Ee.OPEN;else{this.url=e.url;try{this._ws="function"==typeof xe?new Ee(e.url,{...e,encoding:void 0}):new Ee(e.url)}catch(e){return void w((()=>this.destroy(e)))}}this._ws.binaryType="arraybuffer",e.socket&&this.connected?w((()=>this._handleOpen())):this._ws.onopen=()=>this._handleOpen(),this._ws.onmessage=e=>this._handleMessage(e),this._ws.onclose=()=>this._handleClose(),this._ws.onerror=e=>this._handleError(e),this._handleFinishBound=()=>this._handleFinish(),this.once("finish",this._handleFinishBound)}send(e){this._ws.send(e)}_final(e){this._readableState.ended||this.push(null),e(null)}_destroy(e){if(!this.destroyed){if(this._writableState.ended||this.end(),this.connected=!1,clearInterval(this._interval),this._interval=null,this._chunk=null,this._cb=null,this._handleFinishBound&&this.removeListener("finish",this._handleFinishBound),this._handleFinishBound=null,this._ws){const e=this._ws,t=()=>{e.onclose=null};if(e.readyState===Ee.CLOSED)t();else try{e.onclose=t,e.close()}catch(e){t()}e.onopen=null,e.onmessage=null,e.onerror=()=>{}}this._ws=null,e()}}_write(e,t){if(this.destroyed)return t(new Error("cannot write after socket is destroyed"));if(this.connected){try{this.send(e)}catch(e){return this.destroy(e)}"function"!=typeof xe&&this._ws.bufferedAmount>65536?(this._debug("start backpressure: bufferedAmount %d",this._ws.bufferedAmount),this._cb=t):t(null)}else this._debug("write before connect"),this._chunk=e,this._cb=t}_handleOpen(){if(!this.connected&&!this.destroyed){if(this.connected=!0,this._chunk){try{this.send(this._chunk)}catch(e){return this.destroy(e)}this._chunk=null,this._debug('sent chunk from "write before connect"');const e=this._cb;this._cb=null,e(null)}"function"!=typeof xe&&(this._interval=setInterval((()=>this._onInterval()),150),this._interval.unref&&this._interval.unref()),this._debug("connect"),this.emit("connect")}}_handleMessage(e){if(this.destroyed)return;let t=e.data;t instanceof ArrayBuffer&&(t=new Uint8Array(t)),!1===this.__objectMode&&(t=(0,b.L0)(t)),this.push(t)}_handleClose(){this.destroyed||(this._debug("on close"),this.destroy())}_handleError(e){this.destroy(new Error(`Error connecting to ${this.url}`))}_handleFinish(){if(this.destroyed)return;const e=()=>{setTimeout((()=>this.destroy()),1e3)};this.connected?e():this.once("connect",e)}_onInterval(){if(!this._cb||!this._ws||this._ws.bufferedAmount>65536)return;this._debug("ending backpressure: bufferedAmount %d",this._ws.bufferedAmount);const e=this._cb;this._cb=null,e(null)}_debug(){const e=[].slice.call(arguments);e[0]="["+this._id+"] "+e[0],Se.apply(null,e)}}Ce.WEBSOCKET_SUPPORT=!!Ee;const Ae=class extends o{constructor(e,t){super(),this.client=e,this.announceUrl=t,this.interval=null,this.destroyed=!1}setInterval(e){null==e&&(e=this.DEFAULT_ANNOUNCE_INTERVAL),clearInterval(this.interval),e&&(this.interval=setInterval((()=>{this.announce(this.client._defaultAnnounceOpts())}),e),this.interval.unref&&this.interval.unref())}},Te=I("bittorrent-tracker:websocket-tracker"),Pe={};class Ie extends Ae{constructor(e,t){super(e,t),Te("new websocket tracker %s",t),this.peers={},this.socket=null,this.reconnecting=!1,this.retries=0,this.reconnectTimer=null,this.expectingResponse=!1,this._openSocket()}announce(e){if(this.destroyed||this.reconnecting)return;if(!this.socket.connected)return void this.socket.once("connect",(()=>{this.announce(e)}));const t=Object.assign({},e,{action:"announce",info_hash:this.client._infoHashBinary,peer_id:this.client._peerIdBinary});if(this._trackerId&&(t.trackerid=this._trackerId),"stopped"===e.event||"completed"===e.event)this._send(t);else{const s=Math.min(e.numwant,5);this._generateOffers(s,(e=>{t.numwant=s,t.offers=e,this._send(t)}))}}scrape(e){if(this.destroyed||this.reconnecting)return;if(!this.socket.connected)return void this.socket.once("connect",(()=>{this.scrape(e)}));const t={action:"scrape",info_hash:Array.isArray(e.infoHash)&&e.infoHash.length>0?e.infoHash.map((e=>(0,b.Ht)(e))):e.infoHash&&(0,b.Ht)(e.infoHash)||this.client._infoHashBinary};this._send(t)}destroy(e=Le){if(this.destroyed)return e(null);this.destroyed=!0,clearInterval(this.interval),clearTimeout(this.reconnectTimer);for(const e in this.peers){const t=this.peers[e];clearTimeout(t.trackerTimeout),t.destroy()}if(this.peers=null,this.socket&&(this.socket.removeListener("connect",this._onSocketConnectBound),this.socket.removeListener("data",this._onSocketDataBound),this.socket.removeListener("close",this._onSocketCloseBound),this.socket.removeListener("error",this._onSocketErrorBound),this.socket=null),this._onSocketConnectBound=null,this._onSocketErrorBound=null,this._onSocketDataBound=null,this._onSocketCloseBound=null,Pe[this.announceUrl]&&(Pe[this.announceUrl].consumers-=1),Pe[this.announceUrl].consumers>0)return e();let t,s=Pe[this.announceUrl];if(delete Pe[this.announceUrl],s.on("error",Le),s.once("close",e),!this.expectingResponse)return i();function i(){t&&(clearTimeout(t),t=null),s.removeListener("data",i),s.destroy(),s=null}t=setTimeout(i,be.DESTROY_TIMEOUT),s.once("data",i)}_openSocket(){if(this.destroyed=!1,this.peers||(this.peers={}),this._onSocketConnectBound=()=>{this._onSocketConnect()},this._onSocketErrorBound=e=>{this._onSocketError(e)},this._onSocketDataBound=e=>{this._onSocketData(e)},this._onSocketCloseBound=()=>{this._onSocketClose()},this.socket=Pe[this.announceUrl],this.socket)Pe[this.announceUrl].consumers+=1,this.socket.connected&&this._onSocketConnectBound();else{const e=new URL(this.announceUrl);let t;this.client._proxyOpts&&(t="wss:"===e.protocol?this.client._proxyOpts.httpsAgent:this.client._proxyOpts.httpAgent,!t&&this.client._proxyOpts.socksProxy&&(t=this.client._proxyOpts.socksProxy)),this.socket=Pe[this.announceUrl]=new Ce({url:this.announceUrl,agent:t}),this.socket.consumers=1,this.socket.once("connect",this._onSocketConnectBound)}this.socket.on("data",this._onSocketDataBound),this.socket.once("close",this._onSocketCloseBound),this.socket.once("error",this._onSocketErrorBound)}_onSocketConnect(){this.destroyed||this.reconnecting&&(this.reconnecting=!1,this.retries=0,this.announce(this.client._defaultAnnounceOpts()))}_onSocketData(e){if(!this.destroyed){this.expectingResponse=!1;try{e=JSON.parse((0,b.dU)(e))}catch(e){return void this.client.emit("warning",new Error("Invalid tracker response"))}"announce"===e.action?this._onAnnounceResponse(e):"scrape"===e.action?this._onScrapeResponse(e):this._onSocketError(new Error(`invalid action in WS response: ${e.action}`))}}_onAnnounceResponse(e){if(e.info_hash!==this.client._infoHashBinary)return void Te("ignoring websocket data from %s for %s (looking for %s: reused socket)",this.announceUrl,(0,b.HB)(e.info_hash),this.client.infoHash);if(e.peer_id&&e.peer_id===this.client._peerIdBinary)return;Te("received %s from %s for %s",JSON.stringify(e),this.announceUrl,this.client.infoHash);const t=e["failure reason"];if(t)return this.client.emit("warning",new Error(t));const s=e["warning message"];s&&this.client.emit("warning",new Error(s));const i=e.interval||e["min interval"];i&&this.setInterval(1e3*i);const n=e["tracker id"];if(n&&(this._trackerId=n),null!=e.complete){const t=Object.assign({},e,{announce:this.announceUrl,infoHash:(0,b.HB)(e.info_hash)});this.client.emit("update",t)}let r;if(e.offer&&e.peer_id&&(Te("creating peer (from remote offer)"),r=this._createPeer(),r.id=(0,b.HB)(e.peer_id),r.once("signal",(t=>{const s={action:"announce",info_hash:this.client._infoHashBinary,peer_id:this.client._peerIdBinary,to_peer_id:e.peer_id,answer:t,offer_id:e.offer_id};this._trackerId&&(s.trackerid=this._trackerId),this._send(s)})),this.client.emit("peer",r),r.signal(e.offer)),e.answer&&e.peer_id){const t=(0,b.HB)(e.offer_id);r=this.peers[t],r?(r.id=(0,b.HB)(e.peer_id),this.client.emit("peer",r),r.signal(e.answer),clearTimeout(r.trackerTimeout),r.trackerTimeout=null,delete this.peers[t]):Te(`got unexpected answer: ${JSON.stringify(e.answer)}`)}}_onScrapeResponse(e){e=e.files||{};const t=Object.keys(e);0!==t.length?t.forEach((t=>{const s=Object.assign(e[t],{announce:this.announceUrl,infoHash:(0,b.HB)(t)});this.client.emit("scrape",s)})):this.client.emit("warning",new Error("invalid scrape response"))}_onSocketClose(){this.destroyed||(this.destroy(),this._startReconnectTimer())}_onSocketError(e){this.destroyed||(this.destroy(),this.client.emit("warning",e),this._startReconnectTimer())}_startReconnectTimer(){const e=Math.floor(3e5*Math.random())+Math.min(1e4*Math.pow(2,this.retries),36e5);this.reconnecting=!0,clearTimeout(this.reconnectTimer),this.reconnectTimer=setTimeout((()=>{this.retries++,this._openSocket()}),e),this.reconnectTimer.unref&&this.reconnectTimer.unref(),Te("reconnecting socket in %s ms",e)}_send(e){if(this.destroyed)return;this.expectingResponse=!0;const t=JSON.stringify(e);Te("send %s",t),this.socket.send(t)}_generateOffers(e,t){const s=this,i=[];Te("generating %s offers",e);for(let t=0;t{i.push({offer:t,offer_id:(0,b.Ht)(e)}),r()})),t.trackerTimeout=setTimeout((()=>{Te("tracker timeout: destroying peer"),t.trackerTimeout=null,delete s.peers[e],t.destroy()}),5e4),t.trackerTimeout.unref&&t.trackerTimeout.unref()}function r(){i.length===e&&(Te("generated %s offers",e),t(i))}r()}_createPeer(e){const t=this;e=Object.assign({trickle:!1,config:t.client._rtcConfig,wrtc:t.client._wrtc},e);const s=new te(e);return s.once("error",i),s.once("connect",(function e(){s.removeListener("error",i),s.removeListener("connect",e)})),s;function i(e){t.client.emit("warning",new Error(`Connection error: ${e.message}`)),s.destroy()}}}function Le(){}Ie.prototype.DEFAULT_ANNOUNCE_INTERVAL=3e4,Ie._socketPool=Pe;const Oe=Ie;var Re=n(717);const He=I("bittorrent-tracker:client");class Ne extends o{constructor(e={}){if(super(),!e.peerId)throw new Error("Option `peerId` is required");if(!e.infoHash)throw new Error("Option `infoHash` is required");if(!e.announce)throw new Error("Option `announce` is required");if(!Re.browser&&!e.port)throw new Error("Option `port` is required");this.peerId="string"==typeof e.peerId?e.peerId:(0,b.V5)(e.peerId),this._peerIdBuffer=(0,b.fk)(this.peerId),this._peerIdBinary=(0,b.Ht)(this.peerId),this.infoHash="string"==typeof e.infoHash?e.infoHash.toLowerCase():(0,b.V5)(e.infoHash),this._infoHashBuffer=(0,b.fk)(this.infoHash),this._infoHashBinary=(0,b.Ht)(this.infoHash),He("new client %s",this.infoHash),this.destroyed=!1,this._port=e.port,this._getAnnounceOpts=e.getAnnounceOpts,this._rtcConfig=e.rtcConfig,this._userAgent=e.userAgent,this._proxyOpts=e.proxyOpts,this._wrtc="function"==typeof e.wrtc?e.wrtc():e.wrtc;let t="string"==typeof e.announce?[e.announce]:null==e.announce?[]:e.announce;t=t.map((e=>(ArrayBuffer.isView(e)&&(e=(0,b.dU)(e)),"/"===e[e.length-1]&&(e=e.substring(0,e.length-1)),e))),t=Array.from(new Set(t));const s=!1!==this._wrtc&&(!!this._wrtc||te.WEBRTC_SUPPORT),i=e=>{w((()=>{this.emit("warning",e)}))};this._trackers=t.map((e=>{let t;try{t=be.parseUrl(e)}catch(t){return i(new Error(`Invalid tracker URL: ${e}`)),null}const n=t.port;if(n<0||n>65535)return i(new Error(`Invalid tracker port: ${e}`)),null;const r=t.protocol;return"http:"!==r&&"https:"!==r||"function"!=typeof ve?"udp:"===r&&"function"==typeof ke?new ke(this,e):"ws:"!==r&&"wss:"!==r||!s||"ws:"===r&&"undefined"!=typeof window&&"https:"===window.location.protocol?(i(new Error(`Unsupported tracker protocol: ${e}`)),null):new Oe(this,e):new ve(this,e)})).filter(Boolean)}start(e){(e=this._defaultAnnounceOpts(e)).event="started",He("send `start` %o",e),this._announce(e),this._trackers.forEach((e=>{e.setInterval()}))}stop(e){(e=this._defaultAnnounceOpts(e)).event="stopped",He("send `stop` %o",e),this._announce(e)}complete(e){e||(e={}),(e=this._defaultAnnounceOpts(e)).event="completed",He("send `complete` %o",e),this._announce(e)}update(e){(e=this._defaultAnnounceOpts(e)).event&&delete e.event,He("send `update` %o",e),this._announce(e)}_announce(e){this._trackers.forEach((t=>{t.announce(e)}))}scrape(e){He("send `scrape`"),e||(e={}),this._trackers.forEach((t=>{t.scrape(e)}))}setInterval(e){He("setInterval %d",e),this._trackers.forEach((t=>{t.setInterval(e)}))}destroy(e){if(this.destroyed)return;this.destroyed=!0,He("destroy");const t=this._trackers.map((e=>t=>{e.destroy(t)}));y(t,e),this._trackers=[],this._getAnnounceOpts=null}_defaultAnnounceOpts(e={}){return null==e.numwant&&(e.numwant=be.DEFAULT_ANNOUNCE_PEERS),null==e.uploaded&&(e.uploaded=0),null==e.downloaded&&(e.downloaded=0),this._getAnnounceOpts&&(e=Object.assign({},e,this._getAnnounceOpts())),e}}Ne.scrape=(e,t)=>{if(t=ye(t),!e.infoHash)throw new Error("Option `infoHash` is required");if(!e.announce)throw new Error("Option `announce` is required");const s=Object.assign({},e,{infoHash:Array.isArray(e.infoHash)?e.infoHash[0]:e.infoHash,peerId:(0,b.L0)("01234567890123456789"),port:6881}),i=new Ne(s);i.once("error",t),i.once("warning",t);let n=Array.isArray(e.infoHash)?e.infoHash.length:1;const r={};return i.on("scrape",(e=>{if(n-=1,r[e.infoHash]=e,0===n){i.destroy();const e=Object.keys(r);1===e.length?t(null,r[e[0]]):t(null,r)}})),i.scrape({infoHash:e.infoHash}),i};const Me=Ne;n(7936);var Ue=n(2799),Fe=n(717);const je=I("torrent-discovery");class Be extends o.EventEmitter{constructor(e){if(super(),!e.peerId)throw new Error("Option `peerId` is required");if(!e.infoHash)throw new Error("Option `infoHash` is required");if(!Fe.browser&&!e.port)throw new Error("Option `port` is required");this.peerId="string"==typeof e.peerId?e.peerId:e.peerId.toString("hex"),this.infoHash="string"==typeof e.infoHash?e.infoHash.toLowerCase():e.infoHash.toString("hex"),this._port=e.port,this._userAgent=e.userAgent,this.destroyed=!1,this._announce=e.announce||[],this._intervalMs=e.intervalMs||9e5,this._trackerOpts=null,this._dhtAnnouncing=!1,this._dhtTimeout=!1,this._internalDHT=!1,this._onWarning=e=>{this.emit("warning",e)},this._onError=e=>{this.emit("error",e)},this._onDHTPeer=(e,t)=>{t.toString("hex")===this.infoHash&&this.emit("peer",`${e.host}:${e.port}`,"dht")},this._onTrackerPeer=e=>{this.emit("peer",e,"tracker")},this._onTrackerAnnounce=()=>{this.emit("trackerAnnounce")},this._onLSDPeer=(e,t)=>{this.emit("peer",e,"lsd")};const t=(e,t)=>{const s=new ge.Client(t);return s.on("warning",this._onWarning),s.on("error",this._onError),s.listen(e),this._internalDHT=!0,s};!1===e.tracker?this.tracker=null:e.tracker&&"object"==typeof e.tracker?(this._trackerOpts=Object.assign({},e.tracker),this.tracker=this._createTracker()):this.tracker=this._createTracker(),!1===e.dht||"function"!=typeof ge.Client?this.dht=null:e.dht&&"function"==typeof e.dht.addNode?this.dht=e.dht:e.dht&&"object"==typeof e.dht?this.dht=t(e.dhtPort,e.dht):this.dht=t(e.dhtPort),this.dht&&(this.dht.on("peer",this._onDHTPeer),this._dhtAnnounce()),!1===e.lsd||"function"!=typeof Ue?this.lsd=null:this.lsd=this._createLSD()}updatePort(e){e!==this._port&&(this._port=e,this.dht&&this._dhtAnnounce(),this.tracker&&(this.tracker.stop(),this.tracker.destroy((()=>{this.tracker=this._createTracker()}))))}complete(e){this.tracker&&this.tracker.complete(e)}destroy(e){if(this.destroyed)return;this.destroyed=!0,clearTimeout(this._dhtTimeout);const t=[];this.tracker&&(this.tracker.stop(),this.tracker.removeListener("warning",this._onWarning),this.tracker.removeListener("error",this._onError),this.tracker.removeListener("peer",this._onTrackerPeer),this.tracker.removeListener("update",this._onTrackerAnnounce),t.push((e=>{this.tracker.destroy(e)}))),this.dht&&this.dht.removeListener("peer",this._onDHTPeer),this._internalDHT&&(this.dht.removeListener("warning",this._onWarning),this.dht.removeListener("error",this._onError),t.push((e=>{this.dht.destroy(e)}))),this.lsd&&(this.lsd.removeListener("warning",this._onWarning),this.lsd.removeListener("error",this._onError),this.lsd.removeListener("peer",this._onLSDPeer),t.push((e=>{this.lsd.destroy(e)}))),y(t,e),this.dht=null,this.tracker=null,this.lsd=null,this._announce=null}_createTracker(){const e=Object.assign({},this._trackerOpts,{infoHash:this.infoHash,announce:this._announce,peerId:this.peerId,port:this._port,userAgent:this._userAgent}),t=new Me(e);return t.on("warning",this._onWarning),t.on("error",this._onError),t.on("peer",this._onTrackerPeer),t.on("update",this._onTrackerAnnounce),t.setInterval(this._intervalMs),t.start(),t}_dhtAnnounce(){this._dhtAnnouncing||(je("dht announce"),this._dhtAnnouncing=!0,clearTimeout(this._dhtTimeout),this.dht.announce(this.infoHash,this._port,(e=>{this._dhtAnnouncing=!1,je("dht announce complete"),e&&this.emit("warning",e),this.emit("dhtAnnounce"),this.destroyed||(this._dhtTimeout=setTimeout((()=>{this._dhtAnnounce()}),this._intervalMs+Math.floor(Math.random()*this._intervalMs/5)),this._dhtTimeout.unref&&this._dhtTimeout.unref())})))}_createLSD(){const e=Object.assign({},{infoHash:this.infoHash,peerId:this.peerId,port:this._port}),t=new Ue(e);return t.on("warning",this._onWarning),t.on("error",this._onError),t.on("peer",this._onLSDPeer),t.start(),t}}const De=Be;const qe=["seeking position failed.","InvalidStateError"],We=["A requested file or directory could not be found at the time an operation was processed.","NotFoundError"],$e=e=>[`Failed to execute 'write' on 'UnderlyingSinkBase': Invalid params passed. ${e}`,"SyntaxError"];class ze extends WritableStream{constructor(e){super(e),Object.setPrototypeOf(this,FileSystemWritableFileStream.prototype),this._closed=!1}async close(){this._closed=!0;const e=this.getWriter(),t=e.close();return e.releaseLock(),t}seek(e){return this.write({type:"seek",position:e})}truncate(e){return this.write({type:"truncate",size:e})}write(e){if(this._closed)return Promise.reject(new TypeError("Cannot write to a CLOSED writable stream"));const t=this.getWriter(),s=t.write(e);return t.releaseLock(),s}}if(Object.defineProperty(ze.prototype,Symbol.toStringTag,{value:"FileSystemWritableFileStream",writable:!1,enumerable:!1,configurable:!0}),Object.defineProperties(ze.prototype,{close:{enumerable:!0},seek:{enumerable:!0},truncate:{enumerable:!0},write:{enumerable:!0}}),!globalThis.FileSystemFileHandle||globalThis.FileSystemFileHandle.prototype.createWritable||globalThis.FileSystemWritableFileStream||(globalThis.FileSystemWritableFileStream=ze),globalThis.FileSystemFileHandle&&!globalThis.FileSystemFileHandle.prototype.createWritable){const e=new WeakMap;let t;const s=()=>{let e,t;onmessage=async s=>{const i=s.ports[0],n=s.data;switch(n.type){case"open":{const s=n.name;let i=await navigator.storage.getDirectory();for(const e of n.path)i=await i.getDirectoryHandle(e);e=await i.getFileHandle(s),t=await e.createSyncAccessHandle();break}case"write":t.write(n.data,{at:n.position}),t.flush();break;case"truncate":t.truncate(n.size);break;case"abort":case"close":t.close()}i.postMessage(0)}};globalThis.FileSystemFileHandle.prototype.createWritable=async function(i){if(!t){const e=`(${s.toString()})()`,i=new Blob([e],{type:"text/javascript"});t=URL.createObjectURL(i)}const n=new Worker(t,{type:"module"});let r=0;const o=new TextEncoder;let a=await this.getFile().then((e=>e.size));const h=e=>new Promise(((t,s)=>{const i=new MessageChannel;i.port1.onmessage=e=>{e.data instanceof Error?s(e.data):t(e.data),i.port1.close(),i.port2.close(),i.port1.onmessage=null},n.postMessage(e,[i.port2])})),l=await navigator.storage.getDirectory(),c=await e.get(this),d=await l.resolve(c);if(null===d)throw new DOMException(...We);return await h({type:"open",path:d,name:this.name}),!1===i?.keepExistingData&&(await h({type:"truncate",size:0}),a=0),new ze({async write(e){if("write"===(e=e?.constructor===Object?{...e}:{type:"write",data:e,position:r}).type){if(!("data"in e))throw await h({type:"close"}),new DOMException(...$e("write requires a data argument"));if(e.position??=r,"string"==typeof e.data)e.data=o.encode(e.data);else if(e.data instanceof ArrayBuffer)e.data=new Uint8Array(e.data);else if(e.data instanceof Uint8Array||!ArrayBuffer.isView(e.data)){if(!(e.data instanceof Uint8Array)){const t=await new Response(e.data).arrayBuffer();e.data=new Uint8Array(t)}}else e.data=new Uint8Array(e.data.buffer,e.data.byteOffset,e.data.byteLength);Number.isInteger(e.position)&&e.position>=0&&(r=e.position),r+=e.data.byteLength,a+=e.data.byteLength}else{if("seek"===e.type){if(Number.isInteger(e.position)&&e.position>=0){if(a=0))throw await h({type:"close"}),new DOMException(...$e("truncate requires a size argument"));a=e.size,r>a&&(r=a)}}await h(e)},async close(){await h({type:"close"}),n.terminate()},async abort(e){await h({type:"abort",reason:e}),n.terminate()}})};const i=FileSystemDirectoryHandle.prototype.getFileHandle;FileSystemDirectoryHandle.prototype.getFileHandle=async function(...t){const s=await i.call(this,...t);return e.set(s,this),s}}const Ve=/[<>:"/\\|?*\u0000-\u001F]/g;globalThis.navigator?.storage?.getDirectory&&navigator.storage.getDirectory().then((e=>{e.removeEntry("chunks",{recursive:!0}).catch((()=>{}))}));const Ge=(e,t)=>{};class Ke{name="";chunks=[];chunkMap=[];directoryMap={};files;rootDirPromise;storageDirPromise;chunksDirPromise;closing=!1;closed=!1;constructor(e,t={}){if(this.chunkLength=Number(e),!this.chunkLength)throw new Error("First argument must be a chunk length");if(!globalThis.navigator?.storage?.getDirectory)throw new Error("FSA API is not supported");if(this.closed=!1,this.name=t.name||crypto.randomUUID(),this.rootDirPromise=t.rootDir||navigator.storage.getDirectory(),this.storageDirPromise=(async()=>(await this.rootDirPromise).getDirectoryHandle(this.name,{create:!0}))(),this.chunksDirPromise=this.storageDirPromise,t.files&&t.rootDir){if(this.chunksDirPromise=this._getChunksDirHandle(),this.files=t.files.map(((e,t,s)=>{if(null==e.path)throw new Error("File is missing `path` property");if(null==e.length)throw new Error("File is missing `length` property");if(null==e.offset)if(0===t)e.offset=0;else{const i=s[t-1];e.offset=i.offset+i.length}null==e.handle&&(e.handle=this._createFileHandle({path:e.path})),e.blob=this._createBlobReference(e.handle);const i=e.offset,n=e.offset+e.length,r=Math.floor(i/this.chunkLength),o=Math.floor((n-1)/this.chunkLength);for(let t=r;t<=o;++t){const s=t*this.chunkLength,r=is+this.chunkLength?this.chunkLength:n-s,a=i>s?0:s-i;this.chunkMap[t]||(this.chunkMap[t]=[]),this.chunkMap[t].push({from:r,to:o,offset:a,file:e})}return e})),window.addEventListener("pagehide",(()=>this.cleanup())),this.length=this.files.reduce(((e,t)=>e+t.length),0),null!=t.length&&t.length!==this.length)throw new Error("total `files` length is not equal to explicit `length` option")}else this.length=Number(t.length)||1/0;this.length!==1/0&&(this.lastChunkLength=this.length%this.chunkLength||this.chunkLength,this.lastChunkIndex=Math.ceil(this.length/this.chunkLength)-1)}async _getChunkHandle(e){let t=this.chunks[e];if(!t){const s=await this.chunksDirPromise;this.chunks[e]=t=await s.getFileHandle(e,{create:!0})}return t}async _createFileHandle(e){const t=e.path.slice(e.path.lastIndexOf("/")+1);return(await this._getDirectoryHandle(e)).getFileHandle(t.replace(Ve,""),{create:!0})}async _createBlobReference(e){return(await e).getFile()}async _getDirectoryHandle(e){const t=e.path.lastIndexOf("/");if(-1===t||0===t)return this.storageDirPromise;const s=e.path=e.path.slice(0,t);return this.directoryMap[s]||(this.directoryMap[s]=(async()=>(await this._getDirectoryHandle(e)).getDirectoryHandle(s.slice(s.lastIndexOf("/")+1),{create:!0}))()),this.directoryMap[s]}async _getChunksDirHandle(){const e=await navigator.storage.getDirectory();return(await e.getDirectoryHandle("chunks",{create:!0})).getDirectoryHandle(this.name,{create:!0})}async put(e,t,s=Ge){try{return await this._put(e,t),s(null),null}catch(e){return queueMicrotask((()=>s(e))),e}}async getStreamForHandle(e){return(await e).createWritable({keepExistingData:!0})}async _put(e,t){if(this.closed)throw new Error("Storage is closed");const s=e===this.lastChunkIndex;if(s&&t.length!==this.lastChunkLength)throw new Error(`Last chunk length must be ${this.lastChunkLength}`);if(!s&&t.length!==this.chunkLength)throw new Error(`Chunk length must be ${this.chunkLength}`);const i=(async()=>{const s=await this._getChunkHandle(e),i=await s.createWritable({keepExistingData:!1});await i.write(t),await i.close()})();if(!this.files)return i;const n=this.chunkMap[e];if(!n)throw new Error("No files matching the request range");const r=n.map((async({file:e,offset:s,from:i,to:n})=>{e.stream||(e.stream=this.getStreamForHandle(e.handle)),await(await e.stream).write({type:"write",position:s,data:t.slice(i,n)})}));r.push(i),await Promise.all(r)}async get(e,t,s=Ge){null==t&&(t={});try{const i=await this._get(e,t);return s(null,i),i}catch(e){return s(e),e}}async _get(e,t){if("function"==typeof t)return this.get(e,void 0,t);if(this.closed)throw new Error("Storage is closed");const s=e===this.lastChunkIndex?this.lastChunkLength:this.chunkLength,i=t.offset||0,n=t.length?i+t.length:s,r=t.length||s-i;if(i<0||i<0||n>s)throw new Error("Invalid offset and/or length");if(i===n)return new Uint8Array(0);if(!this.files||this.chunks[e]){const t=await this._getChunkHandle(e);let n=await t.getFile();0===i&&r===s||(n=n.slice(i,r+i));const o=await n.arrayBuffer();if(0===o.byteLength)throw new Error(`Index ${e} does not exist`);return new Uint8Array(o)}let o=this.chunkMap[e];if(!o)throw new Error("No files matching the request range");if(t&&(o=o.filter((({from:e,to:t})=>t>i&&e{t&&(s>n&&(s=n),equeueMicrotask((()=>e(new Error(t)))))(e,"Storage is closed");this.closing=!0,this.chunkMap=void 0,this.directoryMap=void 0,this.files&&await this.cleanup(),this.closed=!0,queueMicrotask((()=>e(null)))}async cleanup(){if(this.closed||!this.files)return;const e=[];for(const t of this.files)t.stream&&(e.push(t.stream.then((e=>e.close()))),t.stream=void 0);const t=(async()=>{const e=await this.chunksDirPromise;this.chunks=[];for await(const t of e.keys())await e.removeEntry(t,{recursive:!0});this.chunksDirPromise=this._getChunksDirHandle(),await this.chunksDirPromise})();await Promise.all(e);for(const e of this.files)e.blob=this._createBlobReference(e.handle);await t}async destroy(e=Ge){this.close((async t=>{if(t)return e(t);try{const e=await this.rootDirPromise;await e.removeEntry(this.name,{recursive:!0})}catch(t){return e(t)}e(null)}))}}var Ye=n(3714),Je=n(1314);const Xe=I("lt_donthave"),Qe=()=>{class e extends o.EventEmitter{constructor(e){super(),this._peerSupports=!1,this._wire=e}onExtendedHandshake(){this._peerSupports=!0}onMessage(e){let t;try{t=new DataView(e.buffer).getUint32(0)}catch(e){return}this._wire.peerPieces.get(t)&&(Xe("got donthave %d",t),this._wire.peerPieces.set(t,!1),this.emit("donthave",t),this._failRequests(t))}donthave(e){if(!this._peerSupports)return;Xe("donthave %d",e);const t=new Uint8Array(4);new DataView(t.buffer).setUint32(0,e),this._wire.extended("lt_donthave",t)}_failRequests(e){const t=this._wire.requests;for(let s=0;s{class t extends o.EventEmitter{constructor(t){super(),this._wire=t,this._fetching=!1,this._metadataComplete=!1,this._metadataSize=null,this._remainingRejects=null,this._bitfield=new ue.A(0,{grow:1e3}),ArrayBuffer.isView(e)&&this.setMetadata(e)}onHandshake(e,t,s){this._infoHash=e}onExtendedHandshake(e){return e.m&&e.m.ut_metadata?e.metadata_size?"number"!=typeof e.metadata_size||1e7this._metadataSize&&(s=this._metadataSize);const i=this.metadata.slice(t,s);this._data(e,i,this._metadataSize)}_onData(e,t,s){t.length>rt||!this._fetching||(this.metadata.set(t,e*rt),this._bitfield.set(e),this._checkDone())}_onReject(e){this._remainingRejects>0&&this._fetching?(this._request(e),this._remainingRejects-=1):this.emit("warning",new Error('Peer sent "reject" too much'))}_requestPieces(){if(this._fetching){this.metadata=new Uint8Array(this._metadataSize);for(let e=0;e0?this._requestPieces():this.emit("warning",new Error("Peer sent invalid metadata"))}}return t.prototype.name="ut_metadata",t};var at=n(8878),ht=n(1133);const lt=I("webtorrent:file-iterator");class ct extends o{constructor(e,{start:t,end:s}){super(),this._torrent=e._torrent,this._pieceLength=e._torrent.pieceLength,this._startPiece=(t+e.offset)/this._pieceLength|0,this._endPiece=(s+e.offset)/this._pieceLength|0,this._piece=this._startPiece,this._offset=t+e.offset-this._startPiece*this._pieceLength,this._missing=s-t+1,this._criticalLength=Math.min(1048576/this._pieceLength|0,2),this._torrent._select(this._startPiece,this._endPiece,1,null,!0),this.destroyed=!1}[Symbol.asyncIterator](){return this}next(){return new Promise(((e,t)=>{if(0===this._missing||this.destroyed)return e({done:!0}),this.destroy();const s=(i,n)=>{if(!this._torrent.bitfield.get(i)){const e=t=>{(t===i||this.destroyed)&&(this._torrent.removeListener("verified",e),s(i,n))};return this._torrent.on("verified",e),this._torrent.critical(i,i+this._criticalLength)}if(this._torrent.destroyed)return t(new Error("Torrent removed"));this._torrent.store.get(i,n,((s,n)=>this.destroyed?e({done:!0}):(lt("read %s and yielding (length %s) (err %s)",i,n?.length,s?.message),s?t(s):void e({value:n,done:!1}))))},i=Math.min(this._missing,this._pieceLength-this._offset);s(this._piece++,{length:i,offset:this._offset}),this._missing-=i,this._offset=0}))}async return(){return this.destroy(),{done:!0}}async throw(e){throw e}destroy(e=()=>{},t){this.destroyed||(this.destroyed=!0,this._torrent.destroyed||this._torrent._deselect(this._startPiece,this._endPiece,!0),this.emit("return"),e(t))}}class dt extends o{constructor(e,t){super(),this._torrent=e,this._destroyed=!1,this._fileStreams=new Set,this._iterators=new Set,this.name=t.name,this.path=t.path,this.length=t.length,this.size=t.length,this.type=ht.getType(this.name)||"application/octet-stream",this.offset=t.offset,this.done=!1;const s=t.offset,i=s+t.length-1;this._startPiece=s/this._torrent.pieceLength|0,this._endPiece=i/this._torrent.pieceLength|0,0===this.length&&(this.done=!0,this.emit("done")),this._client=e.client}get downloaded(){if(this._destroyed||!this._torrent.bitfield)return 0;const{pieces:e,bitfield:t,pieceLength:s,lastPieceLength:i}=this._torrent,{_startPiece:n,_endPiece:r}=this,o=n=>{const r=n===e.length-1?i:s;return t.get(n)?r:r-e[n].missing};let a=0;for(let t=n;t<=r;t+=1){const h=o(t);if(a+=h,t===n){const e=this.offset%s;a-=Math.min(e,h)}if(t===r){const t=(r===e.length-1?i:s)-(this.offset+this.length)%s;a-=Math.min(t,h)}}return a}get progress(){return this.length?this.downloaded/this.length:0}select(e){0!==this.length&&this._torrent.select(this._startPiece,this._endPiece,e)}deselect(){0!==this.length&&this._torrent.deselect(this._startPiece,this._endPiece)}[Symbol.asyncIterator](e={}){if(0===this.length)return async function*(){}();const{start:t=0}=e??{},s=e?.end&&e.end{this._iterators.delete(i)})),i}createReadStream(e){const t=this[Symbol.asyncIterator](e),s=Y.Readable.from(t);return this._fileStreams.add(s),s.once("close",(()=>{this._fileStreams.delete(s)})),s}async arrayBuffer(e={}){const{start:t=0}=e,s=e?.end&&e.end{t=this[Symbol.asyncIterator](e)},async pull(e){const{value:s,done:i}=await t.next();i?e.close():e.enqueue(s)},cancel(){t.return()}})}get streamURL(){if(!this._client._server)throw new Error("No server created");return`${this._client._server.pathname}/${this._torrent.infoHash}/${this.path}`}streamTo(e){return e.src=this.streamURL,e}includes(e){return this._startPiece<=e&&this._endPiece>=e}_destroy(){this._destroyed=!0,this._torrent=null;for(const e of this._fileStreams)e.destroy();this._fileStreams.clear();for(const e of this._iterators)e.destroy();this._iterators.clear()}}var ut=n(5658);class pt{constructor(e){this._torrent=e,this._numPieces=e.pieces.length,this._pieces=new Array(this._numPieces),this._onWire=e=>{this.recalculate(),this._initWire(e)},this._onWireHave=e=>{this._pieces[e]+=1},this._onWireBitfield=()=>{this.recalculate()},this._torrent.wires.forEach((e=>{this._initWire(e)})),this._torrent.on("wire",this._onWire),this.recalculate()}getRarestPiece(e){let t=[],s=1/0;for(let i=0;i{this._cleanupWireEvents(e)})),this._torrent=null,this._pieces=null,this._onWire=null,this._onWireHave=null,this._onWireBitfield=null}_initWire(e){e._onClose=()=>{this._cleanupWireEvents(e);for(let t=0;t{const i=await(0,b.tW)(e,"hex");if(this.destroyed)return;this.handshake(t,i);const n=this._torrent.pieces.length,r=new ue.A(n);for(let e=0;e<=n;e++)r.set(e,!0);this.bitfield(r)})),this.once("interested",(()=>{gt("interested"),this.unchoke()})),this.on("uninterested",(()=>{gt("uninterested")})),this.on("choke",(()=>{gt("choke")})),this.on("unchoke",(()=>{gt("unchoke")})),this.on("bitfield",(()=>{gt("bitfield")})),this.lt_donthave.on("donthave",(()=>{gt("donthave")})),this.on("request",((e,t,s,i)=>{gt("request pieceIndex=%d offset=%d length=%d",e,t,s),this.httpRequest(e,t,s,((t,s)=>{if(t){this.lt_donthave.donthave(e);const t=setTimeout((()=>{this.destroyed||this.have(e)}),1e4);t.unref&&t.unref()}i(t,s)}))}))}async httpRequest(e,t,s,i){i=ye(i);const n=e*this._torrent.pieceLength+t,r=n+s-1,o=this._torrent.files;let a,h;if(o.length<=1)a=[{url:this.url,start:n,end:r}];else{const e=o.filter((e=>e.offset<=r&&e.offset+e.length>n));if(e.length<1)return i(new Error("Could not find file corresponding to web seed range request"));a=e.map((e=>{const t=e.offset+e.length-1;return{url:this.url+("/"===this.url[this.url.length-1]?"":"/")+e.path.replace(this._torrent.path,""),fileOffsetInRange:Math.max(e.offset-n,0),start:Math.max(n-e.offset,0),end:Math.min(t,r-e.offset)}}))}try{h=await Promise.all(a.map((async({start:i,end:n,url:r})=>{gt("Requesting url=%s pieceIndex=%d offset=%d length=%d start=%d end=%d",r,e,t,s,i,n);const o=await H(r,{cache:"no-store",method:"GET",headers:{"Cache-Control":"no-store","user-agent":`WebTorrent/${_t} (https://webtorrent.io)`,range:`bytes=${i}-${n}`},signal:AbortSignal.timeout(6e4)});if(!o.ok)throw new Error(`Unexpected HTTP status code ${o.status}`);const a=new Uint8Array(await o.arrayBuffer());return gt("Got data of length %d",a.length),a})))}catch(e){return i(e)}i(null,(0,b.xW)(h))}destroy(){super.destroy(),this._torrent=null}}class wt{_items=[];remove(e){for(let t=0;t=0&&0!==e.from&&i.push(n);const r={...s,from:e.to+1};r.to-r.from>=0&&i.push(r),this._items.splice(t,1,...i),t=t-1+i.length}else xt(e,s)&&(this._items.splice(t,1),t--)}}insert(e){if(e.from>e.to)throw new Error("Invalid interval");if(!e.isStreamSelection){const{notify:t}=e,s=[];for(const t of this._items)t.notify&&St(e,t)&&s.push(t.notify);s.length>0&&(e.notify=()=>{s.forEach((e=>e())),t?.()}),this.remove(e)}this._items.push(e)}sort(e=(e,t)=>e.from-t.from){this._items.sort(e)}get length(){return this._items.length}get(e){return this._items[e]}swap(e,t){const s=this._items[e];this._items[e]=this._items[t],this._items[t]=s}clear(){this._items.length=0}*[Symbol.iterator](){for(let e=0;e{this._items.splice(e,1),e--},yield t,delete t.remove}}}function bt(e,t){return e.from<=t.to&&e.from>t.from&&e.to>t.to}function vt(e,t){return e.to>=t.from&&e.to=t.from&&e.to<=t.to&&i=t.to}const St=(e,t)=>()=>bt(e,t)||vt(e,t)||kt(e,t)||xt(e,t);var Et=n(717);const Ct=I("webtorrent:torrent"),At=5e3,Tt=3*st.BLOCK_LENGTH,Pt=Et.browser?_e().length:2,It=[1e3,5e3,15e3],Lt=`WebTorrent/${_t} (https://webtorrent.io)`,Ot=globalThis.navigator?.storage?.getDirectory&&globalThis.FileSystemFileHandle?.prototype?.createWritable,Rt=!Et.browser||Ot?Ke:Ze;let Ht;try{Ht=l(oe.statSync("/tmp")&&"/tmp","webtorrent")}catch(e){Ht=l("function"==typeof he.tmpdir?he.tmpdir():"/","webtorrent")}const Nt="undefined"!=typeof window&&"function"==typeof window.requestIdleCallback&&window.requestIdleCallback;class Mt extends o{constructor(e,t,s){super(),this._debugId="unknown infohash",this.client=t,this.announce=s.announce,this.urlList=s.urlList,this.path=s.path||Ht,this.addUID=s.addUID||!1,this.rootDir=s.rootDir||null,this.skipVerify=!!s.skipVerify,this._store=s.store||Rt,this._preloadedStore=s.preloadedStore||null,this._storeCacheSlots=void 0!==s.storeCacheSlots?s.storeCacheSlots:20,this._destroyStoreOnDestroy=s.destroyStoreOnDestroy||!1,this.store=null,this.storeOpts=s.storeOpts,this.alwaysChokeSeeders=s.alwaysChokeSeeders??!0,this._getAnnounceOpts=s.getAnnounceOpts,"boolean"==typeof s.private&&(this.private=s.private),this.strategy=s.strategy||"sequential",this.maxWebConns=s.maxWebConns||4,this._rechokeNumSlots=!1===s.uploads||0===s.uploads?0:+s.uploads||10,this._rechokeOptimisticWire=null,this._rechokeOptimisticTime=0,this._rechokeIntervalId=null,this._noPeersIntervalId=null,this._noPeersIntervalTime=s.noPeersIntervalTime?1e3*s.noPeersIntervalTime:3e4,this._startAsDeselected=s.deselect||!1,this.ready=!1,this.destroyed=!1,this.paused=s.paused||!1,this.done=!1,this.metadata=null,this.files=[],this.pieces=[],this._amInterested=!1,this._selections=new wt,this._critical=[],this.wires=[],this._queue=[],this._peers={},this._peersLength=0,this.received=0,this.uploaded=0,this._downloadSpeed=se(),this._uploadSpeed=se(),this._servers=[],this._xsRequests=[],this._fileModtimes=s.fileModtimes,null!==e&&this._onTorrentId(e),this._debug("new torrent")}get timeRemaining(){return this.done?0:0===this.downloadSpeed?1/0:(this.length-this.downloaded)/this.downloadSpeed*1e3}get downloaded(){if(!this.bitfield)return 0;let e=0;for(let t=0,s=this.pieces.length;t{this.destroyed||this._onParsedTorrent(t)}))):B(e,((e,t)=>{if(!this.destroyed)return e?this._destroy(e):void this._onParsedTorrent(t)}))}_onParsedTorrent(e){if(!this.destroyed){if(this._processParsedTorrent(e),!this.infoHash)return this._destroy(new Error("Malformed torrent data: No info hash"));this._rechokeIntervalId=setInterval((()=>{this._rechoke()}),1e4),this._rechokeIntervalId.unref&&this._rechokeIntervalId.unref(),this.emit("_infoHash",this.infoHash),this.destroyed||(this.emit("infoHash",this.infoHash),this.destroyed||(this.client.listening?this._onListening():this.client.once("listening",(()=>{this._onListening()}))))}}_processParsedTorrent(e){this._debugId=(0,b.V5)(e.infoHash).substring(0,7),void 0!==this.private&&(e.private=this.private),Array.isArray(this.announce)&&(e.announce=e.announce.concat(this.announce)),this.client.tracker&&Array.isArray(this.client.tracker.announce)&&!e.private&&(e.announce=e.announce.concat(this.client.tracker.announce)),this.client.tracker&&globalThis.WEBTORRENT_ANNOUNCE&&!e.private&&(e.announce=e.announce.concat(globalThis.WEBTORRENT_ANNOUNCE)),this.urlList&&(e.urlList=e.urlList.concat(this.urlList)),e.announce=Array.from(new Set(e.announce)),e.urlList=Array.from(new Set(e.urlList)),Object.assign(this,e),this.magnetURI=$(e),this.torrentFile=function(e){const t={info:e.info};return t["announce-list"]=(e.announce||[]).map((e=>(t.announce||(t.announce=e),[e=(0,b.L0)(e)]))),t["url-list"]=e.urlList||[],void 0!==e.private&&(t.private=Number(e.private)),e.created&&(t["creation date"]=e.created.getTime()/1e3|0),e.createdBy&&(t["created by"]=e.createdBy),e.comment&&(t.comment=e.comment),d.A.encode(t)}(e)}_onListening(){this.destroyed||(this.info?this._onMetadata(this):(this.xs&&this._getMetadataFromServer(),this._startDiscovery()))}_startDiscovery(){if(this.discovery||this.destroyed)return;let e=this.client.tracker;e&&(e=Object.assign({},this.client.tracker,{getAnnounceOpts:()=>{if(this.destroyed)return;const e={uploaded:this.uploaded,downloaded:this.downloaded,left:Math.max(this.length-this.downloaded,0)};return this.client.tracker.getAnnounceOpts&&Object.assign(e,this.client.tracker.getAnnounceOpts()),this._getAnnounceOpts&&Object.assign(e,this._getAnnounceOpts()),e}})),this.peerAddresses&&this.peerAddresses.forEach((e=>this.addPeer(e,ut.default.SOURCE_MANUAL))),this.discovery=new De({infoHash:this.infoHash,announce:this.announce,peerId:this.client.peerId,dht:!this.private&&this.client.dht,tracker:e,port:this.client.torrentPort,userAgent:Lt,lsd:this.client.lsd}),this.discovery.on("error",(e=>{this._destroy(e)})),this.discovery.on("peer",((e,t)=>{this._debug("peer %s discovered via %s",e,t),this.client.seedOutgoingConnections||!this.done?this.addPeer(e,t):this._debug("ignoring peer %s: torrent is done and seedOutgoingConnections is false",e)})),this.discovery.on("trackerAnnounce",(()=>{this.emit("trackerAnnounce")})),this.discovery.on("dhtAnnounce",(()=>{this.emit("dhtAnnounce")})),this.discovery.on("warning",(e=>{this.emit("warning",e)})),this._noPeersIntervalId=setInterval((()=>{if(this.destroyed)return;const e={[ut.default.SOURCE_TRACKER]:{enabled:!!this.client.tracker,numPeers:0},[ut.default.SOURCE_DHT]:{enabled:!!this.client.dht,numPeers:0},[ut.default.SOURCE_LSD]:{enabled:!!this.client.lsd,numPeers:0},[ut.default.SOURCE_UT_PEX]:{enabled:this.client.utPex&&"function"==typeof at,numPeers:0}};for(const t of Object.values(this._peers)){const s=e[t.source];void 0!==s&&s.numPeers++}for(const t of Object.keys(e)){const s=e[t];s.enabled&&0===s.numPeers&&this.emit("noPeers",t)}}),this._noPeersIntervalTime),this._noPeersIntervalId.unref&&this._noPeersIntervalId.unref()}_getMetadataFromServer(){const e=this,t=Array.isArray(this.xs)?this.xs:[this.xs];e._xsRequestsController=new AbortController;const s=e._xsRequestsController.signal,i=t.map((t=>i=>{!async function(t,i){if(0!==t.indexOf("http://")&&0!==t.indexOf("https://"))return e.emit("warning",new Error(`skipping non-http xs param: ${t}`)),i(null);const n={method:"GET",headers:{"user-agent":Lt},signal:s};let r,o,a;try{r=await H(t,n)}catch(s){return e.emit("warning",new Error(`http error from xs param: ${t}`)),i(null)}if(e.destroyed)return i(null);if(e.metadata)return i(null);if(200!==r.status)return e.emit("warning",new Error(`non-200 status code ${r.status} from xs param: ${t}`)),i(null);try{o=new Uint8Array(await r.arrayBuffer())}catch(t){return e.emit("warning",t),i(null)}try{a=await W(o)}catch(e){}if(!a)return e.emit("warning",new Error(`got invalid torrent file from xs param: ${t}`)),i(null);if(a.infoHash!==e.infoHash)return e.emit("warning",new Error(`got torrent file with incorrect info hash from xs param: ${t}`)),i(null);e._onMetadata(a),i(null)}(t,i)}));y(i)}async _onMetadata(e){if(this.metadata||this.destroyed)return;let t;if(this._debug("got metadata"),this._xsRequestsController?.abort(),this._xsRequestsController=null,e&&e.infoHash)t=e;else try{t=await W(e)}catch(e){return this._destroy(e)}this._processParsedTorrent(t),this.metadata=this.torrentFile,this.client.enableWebSeeds&&this.urlList.forEach((e=>{this.addWebSeed(e)})),this._rarityMap=new pt(this),this.files=this.files.map((e=>new dt(this,e)));let s=this._preloadedStore;if(s||(s=new this._store(this.pieceLength,{...this.storeOpts,torrent:this,path:this.path,files:this.files,length:this.length,name:this.name+" - "+this.infoHash.slice(0,8),addUID:this.addUID,rootDir:this.rootDir,max:this._storeCacheSlots})),this._storeCacheSlots>0&&!(s instanceof Ze)&&(s=new pe(s,{max:this._storeCacheSlots})),this.store=new Ye(s),this.so&&!this._startAsDeselected?this.files.forEach(((e,t)=>{this.so.includes(t)&&this.files[t].select()})):0===this.pieces.length||this._startAsDeselected||this.select(0,this.pieces.length-1,0),this._hashes=this.pieces,this.pieces=this.pieces.map(((e,t)=>{const s=t===this.pieces.length-1?this.lastPieceLength:this.pieceLength;return new st(s)})),this._reservations=this.pieces.map((()=>[])),this.bitfield=new ue.A(this.pieces.length),this.emit("metadata"),!this.destroyed)if(this.skipVerify)this._markAllVerified(),this._onStore();else{const e=e=>{if(e)return this._destroy(e);this._debug("done verifying"),this._onStore()};this._debug("verifying existing torrent data"),this._fileModtimes&&this._store===Ke?this.getFileModtimes(((t,s)=>{if(t)return this._destroy(t);this.files.map(((e,t)=>s[t]===this._fileModtimes[t])).every((e=>e))?(this._markAllVerified(),this._onStore()):this._verifyPieces(e)})):this._verifyPieces(e)}}getFileModtimes(e){const t=[];et(this.files.map(((e,s)=>i=>{const n=this.addUID?l(this.name+" - "+this.infoHash.slice(0,8)):l(this.path,e.path);oe.stat(n,((e,n)=>{if(e&&"ENOENT"!==e.code)return i(e);t[s]=n&&n.mtime.getTime(),i(null)}))})),Pt,(s=>{this._debug("done getting file modtimes"),e(s,t)}))}_verifyPieces(e){et(this.pieces.map(((e,t)=>e=>{if(this.destroyed)return e(new Error("torrent is destroyed"));const s={};t===this.pieces.length-1&&(s.length=this.lastPieceLength),this.store.get(t,s,(async(s,i)=>{if(this.destroyed)return e(new Error("torrent is destroyed"));if(s)return w((()=>e(null)));const n=await(0,b.tW)(i,"hex");if(this.destroyed)return e(new Error("torrent is destroyed"));n===this._hashes[t]?(this._debug("piece verified %s",t),this._markVerified(t)):(this._markUnverified(t),this._debug("piece invalid %s",t)),e(null)}))})),Pt,e)}rescanFiles(e){if(this.destroyed)throw new Error("torrent is destroyed");e||(e=Ft),this._verifyPieces((t=>{if(t)return this._destroy(t),e(t);this._checkDone(),e(null)}))}_markAllVerified(){for(let e=0;e{t.done&&t.includes(e)&&(t.done=!1)}))}_hasAllPieces(){for(let e=0;ee))return!0;return!1}_onStore(){this.destroyed||(this._debug("on store"),this._startDiscovery(),this.ready=!0,this.emit("ready"),this._checkDone(),this._updateSelections(),this.wires.forEach((e=>{e.ut_metadata&&e.ut_metadata.setMetadata(this.metadata),this._onWireWithMetadata(e)})))}destroy(e,t){if("function"==typeof e)return this.destroy(null,e);this._destroy(null,e,t)}_destroy(e,t,s){if("function"==typeof t)return this._destroy(e,null,t);if(this.destroyed)return;this.destroyed=!0,this._debug("destroy"),this.client._remove(this),this._selections.clear(),clearInterval(this._rechokeIntervalId),clearInterval(this._noPeersIntervalId),this._xsRequestsController?.abort(),this._rarityMap&&this._rarityMap.destroy();for(const e in this._peers)this.removePeer(e);this.files.forEach((e=>{e instanceof dt&&e._destroy()}));const i=this._servers.map((e=>t=>{e.destroy(t)}));if(this.discovery&&i.push((e=>{this.discovery.destroy(e)})),this.store){let e=this._destroyStoreOnDestroy;t&&void 0!==t.destroyStore&&(e=t.destroyStore),i.push((t=>{e?this.store.destroy(t):this.store.close(t)}))}y(i,s),e&&(0===this.listenerCount("error")?this.client.emit("error",e):this.emit("error",e)),this.emit("close"),this.client=null,this.files=[],this.discovery=null,this.store=null,this._rarityMap=null,this._peers=null,this._servers=null,this._xsRequests=null}addPeer(e,t){if(this.destroyed)throw new Error("torrent is destroyed");if(!this.infoHash)throw new Error("addPeer() must not be called before the `infoHash` event");let s;if("string"==typeof e){let t;try{t=de(e)}catch(t){return this._debug("ignoring peer: invalid %s",e),this.emit("invalidPeer",e),!1}s=t[0]}else"string"==typeof e.remoteAddress&&(s=e.remoteAddress);if(this.client.blocked&&s&&this.client.blocked.contains(s))return this._debug("ignoring peer: blocked %s",e),"string"!=typeof e&&e.destroy(),this.emit("blockedPeer",e),!1;const i=this.client.utp&&this._isIPv4(s)?"utp":"tcp",n=!!this._addPeer(e,i,t);return n?this.emit("peer",e):this.emit("invalidPeer",e),n}_addPeer(e,t,s){if(this.destroyed)return"string"!=typeof e&&e.destroy(),null;if("string"==typeof e&&!this._validAddr(e))return this._debug("ignoring peer: invalid %s",e),null;const i=e&&e.id||e;if(this._peers[i])return this._debug("ignoring peer: duplicate (%s)",i),"string"!=typeof e&&e.destroy(),null;if(this.paused)return this._debug("ignoring peer: torrent is paused"),"string"!=typeof e&&e.destroy(),null;let n;return this._debug("add peer %s",i),n="string"==typeof e?"utp"===t?ut.default.createUTPOutgoingPeer(e,this,this.client.throttleGroups):ut.default.createTCPOutgoingPeer(e,this,this.client.throttleGroups):ut.default.createWebRTCPeer(e,this,this.client.throttleGroups),this._registerPeer(n),"string"==typeof e&&(this._queue.push(n),this._drain()),n}addWebSeed(e){if(this.destroyed)throw new Error("torrent is destroyed");let t,s;if("string"==typeof e){if(t=e,!/^https?:\/\/.+/.test(t))return this.emit("warning",new Error(`ignoring invalid web seed: ${t}`)),void this.emit("invalidPeer",t);if(this._peers[t])return this.emit("warning",new Error(`ignoring duplicate web seed: ${t}`)),void this.emit("invalidPeer",t);s=new yt(t,this)}else{if(!e||"string"!=typeof e.connId)return void this.emit("warning",new Error("addWebSeed must be passed a string or connection object with id property"));if(s=e,t=s.connId,this._peers[t])return this.emit("warning",new Error(`ignoring duplicate web seed: ${t}`)),void this.emit("invalidPeer",t)}this._debug("add web seed %s",t);const i=ut.default.createWebSeedPeer(s,t,this,this.client.throttleGroups);this._registerPeer(i),this.emit("peer",t)}_addIncomingPeer(e){return this.destroyed?e.destroy(new Error("torrent is destroyed")):this.paused?e.destroy(new Error("torrent is paused")):(this._debug("add incoming peer %s",e.id),void this._registerPeer(e))}_registerPeer(e){e.on("download",(e=>{this.destroyed||(this.received+=e,this._downloadSpeed(e),this.client._downloadSpeed(e),this.emit("download",e),this.destroyed||this.client.emit("download",e))})),e.on("upload",(e=>{this.destroyed||(this.uploaded+=e,this._uploadSpeed(e),this.client._uploadSpeed(e),this.emit("upload",e),this.destroyed||this.client.emit("upload",e))})),this._peers[e.id]=e,this._peersLength+=1}removePeer(e){const t=e?.id||e;e&&!e.id&&(e=this._peers?.[t]),e&&(e.destroy(),this.destroyed||(this._debug("removePeer %s",t),delete this._peers[t],this._peersLength-=1,this._drain()))}_select(e,t,s,i,n=!1){if(this.destroyed)throw new Error("torrent is destroyed");if(e<0||tt.priority-e.priority)),this._updateSelections()}select(e,t,s,i){this._select(e,t,s,i,!1)}_deselect(e,t,s=!1){if(this.destroyed)throw new Error("torrent is destroyed");this._debug("deselect %s-%s",e,t),this._selections.remove({from:e,to:t,isStreamSelection:s}),this._updateSelections()}deselect(e,t){this._deselect(e,t,!1)}critical(e,t){if(this.destroyed)throw new Error("torrent is destroyed");this._debug("critical %s-%s",e,t);for(let s=e;s<=t;++s)this._critical[s]=!0;this._updateSelections()}_onWire(e,t){if(this._debug("got wire %s (%s)",e._debugId,t||"Unknown"),this.wires.push(e),t){const s=de(t);e.remoteAddress=s[0],e.remotePort=s[1]}this.client.dht&&this.client.dht.listening&&e.on("port",(s=>{if(!this.destroyed&&!this.client.dht.destroyed){if(!e.remoteAddress)return this._debug("ignoring PORT from peer with no address");if(0===s||s>65536)return this._debug("ignoring invalid PORT from peer");this._debug("port: %s (from %s)",s,t),this.client.dht.addNode({host:e.remoteAddress,port:s})}})),e.on("timeout",(()=>{this._debug("wire timeout (%s)",t),e.destroy()})),"webSeed"!==e.type&&e.setTimeout(3e4,!0),e.setKeepAlive(!0),e.use(ot(this.metadata)),e.ut_metadata.on("warning",(e=>{this._debug("ut_metadata warning: %s",e.message)})),this.metadata||(e.ut_metadata.on("metadata",(e=>{this._debug("got metadata via ut_metadata"),this._onMetadata(e)})),e.ut_metadata.fetch()),this.client.utPex&&"function"==typeof at&&!this.private&&(e.use(at()),e.ut_pex.on("peer",(e=>{this.done||(this._debug("ut_pex: got peer: %s (from %s)",e,t),this.addPeer(e,ut.default.SOURCE_UT_PEX))})),e.ut_pex.on("dropped",(e=>{const s=this._peers[e];s&&!s.connected&&(this._debug("ut_pex: dropped peer: %s (from %s)",e,t),this.removePeer(e))})),e.once("close",(()=>{e.ut_pex.reset()}))),e.use(Qe()),this.emit("wire",e,t),this.ready&&w((()=>{this._onWireWithMetadata(e)}))}_onWireWithMetadata(e){let t=null;const s=()=>{this.destroyed||e.destroyed||(this._numQueued>2*(this._numConns-this.numPeers)&&e.amInterested?e.destroy():(t=setTimeout(s,At),t.unref&&t.unref()))};let i;const n=()=>{if(e.peerPieces.buffer.length===this.bitfield.buffer.length){for(i=0;i{n(),this._update(),this._updateWireInterest(e)})),e.on("have",(()=>{n(),this._update(),this._updateWireInterest(e)})),e.lt_donthave.on("donthave",(()=>{n(),this._update(),this._updateWireInterest(e)})),e.on("have-all",(()=>{e.isSeeder=!0,this.alwaysChokeSeeders&&e.choke(),this._update(),this._updateWireInterest(e)})),e.on("have-none",(()=>{e.isSeeder=!1,this._update(),this._updateWireInterest(e)})),e.on("allowed-fast",(e=>{this._update()})),e.once("interested",(()=>{e.unchoke()})),e.once("close",(()=>{clearTimeout(t)})),e.on("choke",(()=>{clearTimeout(t),t=setTimeout(s,At),t.unref&&t.unref()})),e.on("unchoke",(()=>{clearTimeout(t),this._update()})),e.on("request",((t,s,i,n)=>{if(i>131072)return e.destroy();this.pieces[t]||this.store.get(t,{offset:s,length:i},n)})),e.hasFast&&this._hasAllPieces()?e.haveAll():e.hasFast&&this._hasNoPieces()?e.haveNone():e.bitfield(this.bitfield),this._updateWireInterest(e),e.peerExtensions.dht&&this.client.dht&&this.client.dht.listening&&e.port(this.client.dht.address().port),"webSeed"!==e.type&&(t=setTimeout(s,At),t.unref&&t.unref()),e.isSeeder=!1,n()}_updateSelections(){this.ready&&!this.destroyed&&(w((()=>{this._gcSelections()})),this._updateInterest(),this._update())}_gcSelections(){for(const e of this._selections){const t=e.offset;for(;this.bitfield.get(e.from+e.offset)&&e.from+e.offsetthis._updateWireInterest(e))),e!==this._amInterested&&(this._amInterested?this.emit("interested"):this.emit("uninterested"))}_updateWireInterest(e){let t=!1;for(let s=0;sthis._updateWireWrapper()),{timeout:250}):this._updateWireWrapper()}_updateWireWrapper(){if(this.destroyed)return;const e=it(this.wires);let t;for(;t=e();)this._updateWire(t)}_updateWire(e){if(e.destroyed)return!1;const t=this,s=Ut(e,.5);if(e.requests.length>=s)return;const i=Ut(e,1);if(e.peerChoking)e.hasFast&&e.peerAllowedFastSet.length>0&&!this._hasMorePieces(e.peerAllowedFastSet.length-1)&&function(){if(e.requests.length>=i)return!1;for(const s of e.peerAllowedFastSet){if(e.peerPieces.get(s)&&!t.bitfield.get(s))for(;t._request(e,s,!1)&&e.requests.length=i.from+i.offset;--r)if(e.peerPieces.get(r)&&t._request(e,r,!1))return}}();o(!1)||o(!0)}function n(t,s,i,n){return r=>r>=t&&r<=s&&!(r in i)&&e.peerPieces.get(r)&&(!n||n(r))}function r(e){let s=e;for(let i=e;i=i)return!0;const o=function(){const s=e.downloadSpeed()||1;if(s>Tt)return()=>!0;const i=Math.max(1,e.requests.length)*st.BLOCK_LENGTH/s;let n=10,r=0;return e=>{if(!n||t.bitfield.get(e))return!0;let o=t.pieces[e].missing;for(;r0))return n--,!1}return!0}}();for(let a=0;a({wire:e,random:Math.random()}))).sort(((e,t)=>{const s=e.wire,i=t.wire;return s.downloadSpeed()!==i.downloadSpeed()?s.downloadSpeed()-i.downloadSpeed():s.uploadSpeed()!==i.uploadSpeed()?s.uploadSpeed()-i.uploadSpeed():s.amChoking!==i.amChoking?s.amChoking?-1:1:e.random-t.random})).map((e=>e.wire));this._rechokeOptimisticTime<=0?this._rechokeOptimisticWire=null:this._rechokeOptimisticTime-=1;let t=0;for(;e.length>0&&t0){const t=e.filter((e=>e.peerInterested));if(t.length>0){const e=t[(s=t.length,Math.random()*s|0)];e.unchoke(),this._rechokeOptimisticWire=e,this._rechokeOptimisticTime=2}}var s;e.filter((e=>e!==this._rechokeOptimisticWire)).forEach((e=>e.choke()))}_hotswap(e,t){const s=e.downloadSpeed();if(s=Tt||(2*a>s||a>o||(n=t,o=a))}if(!n)return!1;for(r=0;r=o)return!1;const a=i.pieces[t];let h=r?a.reserveRemaining():a.reserve();if(-1===h&&s&&i._hotswap(e,t)&&(h=r?a.reserveRemaining():a.reserve()),-1===h)return!1;let l=i._reservations[t];l||(l=i._reservations[t]=[]);let c=l.indexOf(null);-1===c&&(c=l.length),l[c]=e;const d=a.chunkOffset(h),u=r?a.chunkLengthRemaining(h):a.chunkLength(h);function p(){w((()=>{i._update()}))}return e.request(t,d,u,(async function s(n,o){if(i.destroyed)return;if(!i.ready)return i.once("ready",(()=>{s(n,o)}));if(l[c]===e&&(l[c]=null),a!==i.pieces[t])return p();if(n)return i._debug("error getting piece %s (offset: %s length: %s) from %s: %s",t,d,u,`${e.remoteAddress}:${e.remotePort}`,n.message),r?a.cancelRemaining(h):a.cancel(h),void p();if(i._debug("got piece %s (offset: %s length: %s) from %s",t,d,u,`${e.remoteAddress}:${e.remotePort}`),!a.set(h,o,e))return p();const f=a.flush(),m=await(0,b.tW)(f,"hex");i.destroyed||(m===i._hashes[t]?(i._debug("piece verified %s",t),i.store.put(t,f,(e=>{e?i._destroy(e):(i.pieces[t]=null,i._markVerified(t),i.wires.forEach((e=>{e.have(t)})),i._checkDone()&&!i.destroyed&&i.discovery.complete(),p())}))):(i.pieces[t]=new st(a.length),i.emit("warning",new Error(`Piece ${t} failed verification`)),p()))})),!0}_checkDone(){if(this.destroyed)return;this.files.forEach((e=>{if(!e.done){for(let t=e._startPiece;t<=e._endPiece;++t)if(!this.bitfield.get(t))return;e.done=!0,e.emit("done"),this._debug(`file done: ${e.name}`)}}));let e=!0;for(const t of this._selections){for(let s=t.from;s<=t.to;s++)if(!this.bitfield.get(s)){e=!1;break}if(!e)break}return!this.done&&e?(this.done=!0,this._debug(`torrent done: ${this.infoHash}`),this.emit("done")):this.done=!1,this._gcSelections(),e}async load(e,t){if(this.destroyed)throw new Error("torrent is destroyed");if(!this.ready)return this.once("ready",(()=>{this.load(e,t)}));Array.isArray(e)||(e=[e]),t||(t=Ft);try{await me(this.store,g(e),{chunkLength:this.pieceLength}),this._markAllVerified(),this._checkDone(),t(null)}catch(e){return t(e),e}}pause(){this.destroyed||(this._debug("pause"),this.paused=!0)}resume(){this.destroyed||(this._debug("resume"),this.paused=!1,this._drain())}_debug(){const e=[].slice.call(arguments);e[0]=`[${this.client?this.client._debugId:"No Client"}] [${this._debugId}] ${e[0]}`,Ct(...e)}_drain(){if(this._debug("_drain numConns %s maxConns %s",this._numConns,this.client.maxConns),"function"!=typeof ae.connect||this.destroyed||this.paused||this._numConns>=this.client.maxConns)return;this._debug("drain (%s queued, %s/%s peers)",this._numQueued,this.numPeers,this.client.maxConns);const e=this._queue.shift();if(!e)return;this._debug("%s connect attempt to %s",e.type,e.addr);const t=de(e.addr),s={host:t[0],port:t[1]};this.client.utp&&e.type===ut.default.TYPE_UTP_OUTGOING?e.conn=ft.connect(s.port,s.host):e.conn=ae.connect(s);const i=e.conn;i.once("connect",(()=>{this.destroyed||e.onConnect()})),i.once("error",(t=>{e.destroy(t)})),e.startConnectTimeout(),i.on("close",(()=>{if(this.destroyed)return;if(e.retries>=It.length){if(this.client.utp){const t=this._addPeer(e.addr,"tcp",e.source);t&&(t.retries=0)}else this._debug("conn %s closed: will not re-add (max %s attempts)",e.addr,It.length);return}const t=It[e.retries];this._debug("conn %s closed: will re-add to queue in %sms (attempt %s)",e.addr,t,e.retries+1);const s=setTimeout((()=>{if(this.destroyed)return;const t=de(e.addr)[0],s=this.client.utp&&this._isIPv4(t)?"utp":"tcp",i=this._addPeer(e.addr,s,e.source);i&&(i.retries=e.retries+1)}),t);s.unref&&s.unref()}))}_validAddr(e){let t;try{t=de(e)}catch(e){return!1}const s=t[0],i=t[1];return i>0&&i<65535&&!("127.0.0.1"===s&&i===this.client.torrentPort)}_isIPv4(e){return/^((?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$/.test(e)}}function Ut(e,t){let s=2+Math.ceil(t*e.downloadSpeed()/st.BLOCK_LENGTH);if(e.peerExtendedHandshake){const t=e.peerExtendedHandshake.reqq;"number"==typeof t&&t>0&&(s=Math.min(s,t))}return s}function Ft(){}var jt=n(4043),Bt=n(580),Dt=n(815),qt=n(2878);class Wt{constructor(e,t={}){this.client=e,t.origin||(t.origin="*"),this.opts=t,this.pendingReady=new Set}static serveIndexPage(e,t,s){const i=t.map((e=>`
  • \n \n ${Bt(e.name)}\n \n (${Bt(e.length)} bytes)\n
    • `)).join("
    ");return e.status=200,e.headers["Content-Type"]="text/html",e.body=Vt("WebTorrent",`

    WebTorrent

    \n
      ${i}
    `),e}isOriginAllowed(e){return!1!==this.opts.origin&&("*"===this.opts.origin||e.headers.origin===this.opts.origin)}static serveMethodNotAllowed(e){return e.status=405,e.headers["Content-Type"]="text/html",e.body=Vt("405 - Method Not Allowed","

    405 - Method Not Allowed

    "),e}static serve404Page(e){return e.status=404,e.headers["Content-Type"]="text/html",e.body=Vt("404 - Not Found","

    404 - Not Found

    "),e}static serveTorrentPage(e,t,s){const i=e.files.map((t=>`
  • \n \n ${Bt(t.path)}\n \n (${Bt(t.length)} bytes)\n
    • `)).join("
    ");return t.status=200,t.headers["Content-Type"]="text/html",t.body=Vt(`${Bt(e.name)} - WebTorrent`,`

    ${Bt(e.name)}

    \n
      ${i}
    `),t}static serveOptionsRequest(e,t){return t.status=204,t.headers["Access-Control-Max-Age"]="600",t.headers["Access-Control-Allow-Methods"]="GET,HEAD",e.headers["access-control-request-headers"]&&(t.headers["Access-Control-Allow-Headers"]=e.headers["access-control-request-headers"]),t}static serveFile(e,t,s){s.status=200,s.headers.Expires="0",s.headers["Cache-Control"]="no-cache, no-store, must-revalidate, max-age=0",s.headers["Accept-Ranges"]="bytes",s.headers["Content-Type"]=e.type,s.headers["transferMode.dlna.org"]="Streaming",s.headers["contentFeatures.dlna.org"]="DLNA.ORG_OP=01;DLNA.ORG_CI=0;DLNA.ORG_FLAGS=01700000000000000000000000000000","document"===t.destination?(s.headers["Content-Type"]="application/octet-stream",s.headers["Content-Disposition"]=`attachment; filename*=UTF-8''${Gt(e.name)}`,s.body="DOWNLOAD"):s.headers["Content-Disposition"]=`inline; filename*=UTF-8''${Gt(e.name)}`;let i=qt(e.length,t.headers.range||"");if(Array.isArray(i)?(s.status=206,i=i[0],s.headers["Content-Range"]=`bytes ${i.start}-${i.end}/${e.length}`,s.headers["Content-Length"]=i.end-i.start+1):(s.statusCode=200,i=null,s.headers["Content-Length"]=e.length),"GET"===t.method){const n=e[Symbol.asyncIterator](i);let r=null;e.emit("iterator",{iterator:n,req:t,file:e},(e=>{r=e}));const o=Y.Readable.from(r||n);let a=null;e.emit("stream",{stream:o,req:t,file:e},(e=>{a=Dt(o,e)})),s.body=a||o}else s.body=!1;return s}async onRequest(e,t){let s=new URL(e.url,"http://example.com").pathname;s=s.slice(s.indexOf(this.pathname)+this.pathname.length+1);const i={headers:{"X-Content-Type-Options":"nosniff","Content-Security-Policy":"base-uri 'none'; frame-ancestors 'none'; form-action 'none';"}};if(this.isOriginAllowed(e)&&(i.headers["Access-Control-Allow-Origin"]="*"===this.opts.origin?"*":e.headers.origin),"favicon.ico"===s)return t(Wt.serve404Page(i));if("OPTIONS"===e.method)return this.isOriginAllowed(e)?t(Wt.serveOptionsRequest(e,i)):t(Wt.serveMethodNotAllowed(i));const n=async()=>{this.pendingReady.delete(n);const e=await r();t(e)},r=async()=>{if(""===s)return Wt.serveIndexPage(i,this.client.torrents,this.pathname);let[t,...n]=s.split("/");n=decodeURI(n.join("/"));const r=await this.client.get(t);if(!t||!r)return Wt.serve404Page(i);if(!n)return Wt.serveTorrentPage(r,i,this.pathname);const o=r.files.find((e=>e.path.replace(/\\/g,"/")===n));return o?Wt.serveFile(o,e,i):Wt.serve404Page(i)};if("GET"===e.method||"HEAD"===e.method){if(this.client.ready){const e=await r();return t(e)}return this.pendingReady.add(n),void this.client.once("ready",n)}return t(Wt.serveMethodNotAllowed(i))}close(e=()=>{}){this.closed=!0,this.pendingReady.forEach((e=>{this.client.removeListener("ready",e)})),this.pendingReady.clear(),w(e)}destroy(e=()=>{}){this.closed?w(e):this.close(e),this.client=null}}class $t extends Wt{constructor(e,t){super(e,t),this.server=jt.createServer(),this._listen=this.server.listen,this.server.listen=this.listen.bind(this),this._close=this.server.close,this.server.close=this.close.bind(this),this.sockets=new Set,this.closed=!1,this.pathname=t?.pathname||"/webtorrent"}wrapRequest(e,t){return this.opts.hostname&&e.headers.host!==`${this.opts.hostname}:${this.server.address().port}`?e.destroy():new URL(e.url,"http://example.com").pathname.startsWith(this.pathname)?void this.onRequest(e,(({status:e,headers:s,body:i})=>{t.writeHead(e,s),i._readableState||i._writableState?Dt(i,t):t.end(i)})):e.destroy()}onConnection(e){e.setTimeout(36e6),this.sockets.add(e),e.once("close",(()=>{this.sockets.delete(e)}))}address(){return this.server.address()}listen(...e){return this.closed=!1,this.server.on("connection",this.onConnection.bind(this)),this.server.on("request",this.wrapRequest.bind(this)),this._listen.apply(this.server,e)}close(e=()=>{}){this.server.removeAllListeners("connection"),this.server.removeAllListeners("request"),this.server.removeAllListeners("listening"),super.close(),this._close.call(this.server,e)}destroy(e){this.sockets.forEach((e=>{e.destroy()})),super.destroy(e)}}class zt extends Wt{constructor(e,t){super(e,t),this.registration=t.controller,this.workerKeepAliveInterval=null,this.workerPortCount=0;const s=new URL(t.controller.scope);this.pathname=s.pathname+"webtorrent",this._address={port:s.port,family:"IPv4",address:s.hostname},this.boundHandler=this.wrapRequest.bind(this),navigator.serviceWorker.addEventListener("message",this.boundHandler),fetch(`${this.pathname}/cancel/`).then((e=>{e.body.cancel()}))}wrapRequest(e){const t=e.data;if("webtorrent"===!t?.type||!t.url)return null;const[s]=e.ports;this.onRequest(t,(({status:e,headers:t,body:i})=>{const n=i[Symbol.asyncIterator]?.(),r=()=>{s.onmessage=null,i?.destroy&&i.destroy(),this.workerPortCount--,this.workerPortCount||(clearInterval(this.workerKeepAliveInterval),this.workerKeepAliveInterval=null)};s.onmessage=async e=>{if(e.data){let e;try{e=(await n.next()).value}catch(e){}s.postMessage(e),e||r(),this.workerKeepAliveInterval||(this.workerKeepAliveInterval=setInterval((()=>fetch(`${this.pathname}/keepalive/`)),2e4))}else r()},this.workerPortCount++,s.postMessage({status:e,headers:t,body:n?"STREAM":i})}))}listen(e,t){t()}address(){return this._address}close(e){navigator.serviceWorker.removeEventListener("message",this.boundHandler),super.close(e)}destroy(e){super.destroy(e)}}function Vt(e,t){return`\n \n \n \n \n ${e}\n \n \n ${t}\n \n \n `}function Gt(e){return encodeURIComponent(e).replace(/['()]/g,escape).replace(/\*/g,"%2A").replace(/%(?:7C|60|5E)/g,unescape)}const Kt=I("webtorrent"),Yt=_t.replace(/\d*./g,(e=>("0"+e%100).slice(-2))).slice(0,4),Jt=`-WW${Yt}-`;class Xt extends o{constructor(e={}){super(),"string"==typeof e.peerId?this.peerId=e.peerId:ArrayBuffer.isView(e.peerId)?this.peerId=(0,b.V5)(e.peerId):this.peerId=(0,b.V5)((0,b.L0)(Jt+(0,b.NJ)((0,b.po)(9)))),this.peerIdBuffer=(0,b.fk)(this.peerId),"string"==typeof e.nodeId?this.nodeId=e.nodeId:ArrayBuffer.isView(e.nodeId)?this.nodeId=(0,b.V5)(e.nodeId):this.nodeId=(0,b.V5)((0,b.po)(20)),this.nodeIdBuffer=(0,b.fk)(this.nodeId),this._debugId=this.peerId.substring(0,7),this.destroyed=!1,this.listening=!1,this.torrentPort=e.torrentPort||0,this.dhtPort=e.dhtPort||0,this.tracker=void 0!==e.tracker?e.tracker:{},this.lsd=!1!==e.lsd,this.utPex=!1!==e.utPex,this.natUpnp=e.natUpnp??!0,this.natPmp=e.natPmp??!0,this.torrents=[],this.maxConns=Number(e.maxConns)||55,this.utp=Xt.UTP_SUPPORT&&!1!==e.utp,this.seedOutgoingConnections=e.seedOutgoingConnections??!0,this._downloadLimit=Math.max("number"==typeof e.downloadLimit?e.downloadLimit:-1,-1),this._uploadLimit=Math.max("number"==typeof e.uploadLimit?e.uploadLimit:-1,-1),(this.natUpnp||this.natPmp)&&"function"==typeof ne&&(this.natTraversal=new ne({enableUPNP:this.natUpnp,enablePMP:this.natPmp,upnpPermanentFallback:"permanent"===e.natUpnp})),!0===e.secure&&Promise.resolve().then(n.bind(n,5658)).then((({enableSecure:e})=>e())),this._debug("new webtorrent (peerId %s, nodeId %s, port %s)",this.peerId,this.nodeId,this.torrentPort),this.throttleGroups={down:new ie.ThrottleGroup({rate:Math.max(this._downloadLimit,0),enabled:this._downloadLimit>=0}),up:new ie.ThrottleGroup({rate:Math.max(this._uploadLimit,0),enabled:this._uploadLimit>=0})},this.tracker&&("object"!=typeof this.tracker&&(this.tracker={}),globalThis.WRTC&&!this.tracker.wrtc&&(this.tracker.wrtc=globalThis.WRTC)),"function"==typeof re?this._connPool=new re(this):w((()=>{this._onListening()})),this._downloadSpeed=se(),this._uploadSpeed=se(),!1!==e.dht&&"function"==typeof L.Client?(this.dht=new L.Client(Object.assign({},{nodeId:this.nodeId},e.dht)),this.dht.once("error",(e=>{this._destroy(e)})),this.dht.once("listening",(()=>{const e=this.dht.address();e&&(this.dhtPort=e.port,this.natTraversal&&this.natTraversal.map({publicPort:this.dhtPort,privatePort:this.dhtPort,protocol:"udp",description:"WebTorrent DHT"}).catch((e=>{Kt("error mapping DHT port via UPnP/PMP: %o",e)})))})),this.dht.setMaxListeners(0),this.dht.listen(this.dhtPort)):this.dht=!1,this.enableWebSeeds=!1!==e.webSeeds;const t=()=>{this.destroyed||(this.ready=!0,this.emit("ready"))};"function"==typeof O&&null!=e.blocklist?O(e.blocklist,{headers:{"user-agent":`WebTorrent/${_t} (https://webtorrent.io)`}},((e,s)=>{if(e)return console.error(`Failed to load blocklist: ${e.message}`);this.blocked=s,t()})):w(t)}createServer(e,t){if(this.destroyed)throw new Error("torrent is destroyed");if(this._server)throw new Error("server already created");if("undefined"!=typeof window&&"node"!==t||"browser"===t){if(!(e?.controller instanceof ServiceWorkerRegistration))throw new Error("Invalid worker registration");if("activated"!==e.controller.active.state)throw new Error("Worker isn't activated");return this._server=new zt(this,e),this._server}return this._server=new $t(this,e),this._server}get downloadSpeed(){return this._downloadSpeed()}get uploadSpeed(){return this._uploadSpeed()}get progress(){const e=this.torrents.filter((e=>1!==e.progress));return e.reduce(((e,t)=>e+t.downloaded),0)/(e.reduce(((e,t)=>e+(t.length||0)),0)||1)}get ratio(){return this.torrents.reduce(((e,t)=>e+t.uploaded),0)/(this.torrents.reduce(((e,t)=>e+t.received),0)||1)}async get(e){if(e instanceof Mt){if(this.torrents.includes(e))return e}else{const t=this.torrents;let s;try{s=await W(e)}catch(e){}if(!s)return null;if(!s.infoHash)throw new Error("Invalid torrent identifier");for(const e of t)if(e.infoHash===s.infoHash)return e}return null}add(e,t={},s=()=>{}){if(this.destroyed)throw new Error("client is destroyed");"function"==typeof t&&([t,s]=[{},t]);const i=()=>{if(!this.destroyed)for(const e of this.torrents)if(e.infoHash===r.infoHash&&e!==r)return r._destroy(new Error(`Cannot add duplicate torrent ${r.infoHash}`)),void s(e)},n=()=>{this.destroyed||(s(r),this.emit("torrent",r))};this._debug("add"),t=t?Object.assign({},t):{};const r=new Mt(e,this,t);return this.torrents.push(r),r.once("_infoHash",i),r.once("ready",n),r.once("close",(function e(){r.removeListener("_infoHash",i),r.removeListener("ready",n),r.removeListener("close",e)})),this.emit("add",r),r}seed(e,t,s){if(this.destroyed)throw new Error("client is destroyed");"function"==typeof t&&([t,s]=[{},t]),this._debug("seed"),(t=t?Object.assign({},t):{}).skipVerify=!0;const i="string"==typeof e;i&&(t.path=function(e){if(a(e),0===e.length)return".";let t=e.charCodeAt(0);const s=47===t;let i=-1,n=!0;for(let s=e.length-1;s>=1;--s)if(t=e.charCodeAt(s),47===t){if(!n){i=s;break}}else n=!1;return-1===i?s?"/":".":s&&1===i?"//":e.slice(0,i)}(e)),t.createdBy||(t.createdBy=`WebTorrent/${Yt}`);const n=e=>{this._debug("on seed"),"function"==typeof s&&s(e),e.emit("seed"),this.emit("seed",e)},r=this.add(null,t,(e=>{const s=[s=>{if(i||t.preloadedStore)return s();e.load(o,s)}];this.dht&&s.push((t=>{e.once("dhtAnnounce",t)})),y(s,(t=>{if(!this.destroyed)return t?e._destroy(t):void n(e)}))}));let o;var h;return h=e,"undefined"!=typeof FileList&&h instanceof FileList?e=Array.from(e):Array.isArray(e)||(e=[e]),y(e.map((e=>async s=>{if(!t.preloadedStore&&function(e){return"object"==typeof e&&null!=e&&"function"==typeof e.pipe}(e)){const t=[];try{for await(const s of e)t.push(s)}catch(e){return s(e)}const i=(0,b.xW)(t);i.name=e.name,s(null,i)}else s(null,e)})),((e,i)=>{if(!this.destroyed)return e?r._destroy(e):void function(e,t,s){"function"==typeof t&&([t,s]=[s,t]),S(e,t=t?Object.assign({},t):{},s)}(i,t,((e,n)=>{if(!this.destroyed){if(e)return r._destroy(e);o=n.map((e=>e.getStream)),P(i,t,(async(e,t)=>{if(this.destroyed)return;if(e)return r._destroy(e);const i=await this.get(t);i?(console.warn("A torrent with the same id is already being seeded"),r._destroy(),"function"==typeof s&&s(i)):r._onTorrentId(t)}))}}))})),r}async remove(e,t,s){if("function"==typeof t)return this.remove(e,null,t);this._debug("remove");const i=await this.get(e);if(!i)throw new Error(`No torrent with id ${e}`);this._remove(i,t,s)}_remove(e,t,s){if(!e)return;if("function"==typeof t)return this._remove(e,null,t);const i=this.torrents.indexOf(e);-1!==i&&(this.torrents.splice(i,1),e.destroy(t,s),this.dht&&this.dht._tables.remove(e.infoHash),this.emit("remove",e))}address(){return this.listening?this._connPool?this._connPool.tcpServer.address():{address:"0.0.0.0",family:"IPv4",port:0}:null}throttleDownload(e){return e=Number(e),!(isNaN(e)||!isFinite(e)||e<-1)&&(this._downloadLimit=e,this._downloadLimit<0?this.throttleGroups.down.setEnabled(!1):(this.throttleGroups.down.setEnabled(!0),void this.throttleGroups.down.setRate(this._downloadLimit)))}throttleUpload(e){return e=Number(e),!(isNaN(e)||!isFinite(e)||e<-1)&&(this._uploadLimit=e,this._uploadLimit<0?this.throttleGroups.up.setEnabled(!1):(this.throttleGroups.up.setEnabled(!0),void this.throttleGroups.up.setRate(this._uploadLimit)))}destroy(e){if(this.destroyed)throw new Error("client already destroyed");this._destroy(null,e)}_destroy(e,t){this._debug("client destroy"),this.destroyed=!0;const s=this.torrents.map((e=>t=>{e.destroy(t)}));this._connPool&&s.push((e=>{this._connPool.destroy(e)})),this.dht&&s.push((e=>{this.dht.destroy(e)})),this._server&&s.push((e=>{this._server.destroy(e)})),this.natTraversal&&s.push((e=>{this.natTraversal.destroy().then((()=>e()))})),y(s,t),e&&this.emit("error",e),this.torrents=[],this._connPool=null,this.dht=null,this.throttleGroups.down.destroy(),this.throttleGroups.up.destroy()}_onListening(){if(this._debug("listening"),this.listening=!0,this._connPool){const e=this._connPool.tcpServer.address();e&&(this.torrentPort=e.port,this.natTraversal&&this.natTraversal.map({publicPort:this.torrentPort,privatePort:this.torrentPort,protocol:this.utp?null:"tcp",description:"WebTorrent Torrent"}).catch((e=>{Kt("error mapping WebTorrent port via UPnP/PMP: %o",e)})))}this.emit("listening")}_debug(){const e=[].slice.call(arguments);e[0]=`[${this._debugId}] ${e[0]}`,Kt(...e)}async _getByHash(e){for(const t of this.torrents)if(t.infoHashHash||(t.infoHashHash=await(0,b.tW)((0,b.fk)("72657132"+t.infoHash),"hex")),e===t.infoHashHash)return t;return null}}Xt.WEBRTC_SUPPORT=te.WEBRTC_SUPPORT,Xt.UTP_SUPPORT=re.UTP_SUPPORT,Xt.VERSION=_t;var Qt=r.A;export{Qt as default}; -js/historyView.js:420: d: "M10 18a8 8 0 100-16 8 8 0 000 16zm3.78-9.72a.75.75 0 00-1.06-1.06L9 11.94l-1.72-1.72a.75.75 0 10-1.06 1.06l2.25 2.25a.75.75 0 001.06 0l3.25-3.25z", -js/historyView.js:427: d: "M10 18a8 8 0 100-16 8 8 0 000 16zm-.75-11.75a.75.75 0 011.5 0v4.5a.75.75 0 01-1.5 0v-4.5zm.75 8.5a1 1 0 100-2 1 1 0 000 2z", -js/historyView.js:1127: "watch-history-card group relative flex flex-row items-start gap-4 p-3 sm:p-4 rounded-lg transition-colors"; -js/historyView.js:1196: content.className = "flex flex-col flex-1 min-w-0 gap-1.5"; -js/historyView.js:1229: "flex-shrink-0 w-5 h-5 rounded-full overflow-hidden bg-surface-alt hover:opacity-80 transition-opacity"; -js/historyView.js:1274: moderationMount.className = "flex flex-wrap items-center gap-2 mt-0.5"; -js/feedEngine/kidsScoring.js:19: maxDurationSeconds: 5 * 60, -js/feedEngine/kidsScoring.js:187: penalty = Math.min(1, trustedCount / 3) * 0.7; -js/feedEngine/kidsScoring.js:209: const divisor = Math.min(3, preferredTags.size); -js/feedEngine/kidsScoring.js:287: let durationScore = 0.5; -js/feedEngine/kidsScoring.js:304: const divisor = Math.min(3, educationalTagSet.size); -js/feedEngine/kidsScoring.js:320: popularityWithinKids = clamp01(Math.log1p(popularityValue) / Math.log1p(popularityValue + 100)); -js/feedEngine/watchHistoryFeed.js:229: if (parts.length < 3) return address; -js/feedEngine/watchHistoryFeed.js:385: if (parts.length < 3) continue; -js/feedEngine/exploreScoring.js:7: novelty: 0.3, -js/bufferPolyfill.js:1:import { Buffer } from "https://cdn.jsdelivr.net/npm/buffer@6.0.3/+esm"; -js/gridHealthLogic.js:106: if (distanceDelta <= 0.5) { -js/state/cache.js:37:const MODERATION_SETTINGS_STORAGE_VERSION = 3; -js/adminListStore.js:387: if (!Number.isFinite(kind) || kind !== 30000) { -js/adminListStore.js:530: : 30000; -js/nostrEventSchemas.js:53:export const KIND_MUTE_LIST = 10000; -js/nostrEventSchemas.js:281: schemaVersion: 3, -js/nostrEventSchemas.js:516: kind: 30000, -js/nostrEventSchemas.js:531: kind: 30000, -js/nostrEventSchemas.js:554: "Legacy NIP-51 block list using custom d tag. Migrated to standard Mute List (kind 10000).", -js/nostrEventSchemas.js:575: kind: 30000, -js/nostrEventSchemas.js:587: kind: 30000, -js/nostrEventSchemas.js:599: kind: 30000, -js/nostrEventSchemas.js:632: kind: 5, -js/nostrEventSchemas.js:1760: kind: schema?.kind ?? 5, -js/nostrEventSchemas.js:2224: if (existingAuthorTag.length < 3) { -js/nostrEventSchemas.js:2496: if (existingParentAuthorTag.length < 3) { -js/nostrEventSchemas.js:2629: kind: schema?.kind ?? 30000, -js/nostrEventSchemas.js:2665: kind: schema?.kind ?? 10000, -js/nostrEventSchemas.js:2735: kind: 30000, -js/nostrEventSchemas.js:2758: kind: schema?.kind ?? 30000, -js/ui/loginModalController.js:1676: // view structure: h3, p, div(space-y-3) -js/ui/loginModalController.js:1677: const contentContainer = view.querySelector(".space-y-3"); -js/ui/applicationBootstrap.js:818: parts.length === 3 && parts[0] === "dm" -js/ui/subscriptionHistoryController.js:145: "card p-3 cursor-pointer hover:bg-surface-2 transition-colors border-l-4 border-transparent rounded-r-md"; -js/ui/subscriptionHistoryController.js:254: "flex items-center gap-3 p-2 rounded-md hover:bg-surface-2 border border-transparent hover:border-border/50 transition-colors"; -js/ui/torrentStatusController.js:69: ? `${(torrent.progress * 100).toFixed(2)}%` -js/ui/components/EventDetailsModal.js:43: -js/ui/components/EventDetailsModal.js:55:
    -js/ui/components/EventDetailsModal.js:65: -js/ui/components/EventDetailsModal.js:67: -js/ui/components/EventDetailsModal.js:75:
    -js/ui/components/EventDetailsModal.js:80: -js/ui/components/EventDetailsModal.js:85:
    -js/ui/components/EventDetailsModal.js:90: -js/ui/components/RevertModal.js:430: "px-3", -js/ui/components/RevertModal.js:431: "py-3", -js/ui/components/RevertModal.js:503: container.className = "flex items-start justify-between gap-3"; -js/ui/components/RevertModal.js:825: code.className = "rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/RevertModal.js:890: dl.className = "grid gap-3 sm:grid-cols-2 text-xs text-subtle"; -js/ui/components/RevertModal.js:928: headerContent.className = "flex-1 space-y-3"; -js/ui/components/RevertModal.js:988: c.className = "rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/RevertModal.js:998: c.className = "break-all rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/RevertModal.js:1009: c.className = "break-all rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/RevertModal.js:1294: code.className = `rounded bg-overlay-panel-soft px-1.5 py-0.5 text-[0.75rem] text-primary ${breakClass}`; -js/ui/components/VideoModal.js:3539: ? Math.round((likeCount / totalReactions) * 100) -js/ui/components/VideoModal.js:3586: const clamped = Math.max(0, Math.min(100, Math.round(likeRatio))); -js/ui/components/VideoModal.js:3814: const clamped = Math.max(0, Math.min(100, nextValue)); -js/ui/components/VideoModal.js:3815: this.modalProgress.max = 100; -js/ui/components/VideoModal.js:3818: const state = clamped >= 100 ? "complete" : "active"; -js/ui/components/VideoModal.js:4271: li.className = "rounded border border-border p-3 bg-overlay-panel-soft"; -js/ui/components/VideoModal.js:4358: "rounded border border-border p-3 bg-overlay-panel-soft text-xs text-warning-strong"; -js/ui/components/VideoModal.js:5337: card.className = "card flex flex-col gap-2 p-3"; -js/ui/components/VideoModal.js:5341: header.className = "flex items-start gap-3"; -js/ui/components/EmbedPlayerModal.js:65: this.status.className = "pointer-events-none absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 rounded-md bg-black/60 px-3 py-1 text-sm backdrop-blur-sm"; -js/ui/components/ShareNostrModal.js:288: "inline-flex items-center gap-2 rounded-full border border-border/70 bg-surface-alt px-3 py-1 text-xs text-text"; -js/ui/components/ShareNostrModal.js:298: "btn-ghost text-muted hover:text-text px-1 py-0.5 rounded-full"; -js/ui/components/ShareNostrModal.js:303: ''; -js/ui/components/VideoCard.js:503: classNames: ["mt-3", "text-xs", "text-status-warning-on"], -js/ui/components/VideoCard.js:889: isCompact ? "space-x-2" : "space-x-3", -js/ui/components/VideoCard.js:1025: addCircle(5); -js/ui/components/VideoCard.js:1047: "M24,13.616L24,10.384C22.349,9.797 21.306,9.632 20.781,8.365L20.781,8.364C20.254,7.093 20.881,6.23 21.628,4.657L19.343,2.372C17.782,3.114 16.91,3.747 15.636,3.219L15.635,3.219C14.366,2.693 14.2,1.643 13.616,0L10.384,0C9.802,1.635 9.635,2.692 8.365,3.219L8.364,3.219C7.093,3.747 6.232,3.121 4.657,2.372L2.372,4.657C3.117,6.225 3.747,7.091 3.219,8.364C2.692,9.635 1.635,9.802 0,10.384L0,13.616C1.632,14.196 2.692,14.365 3.219,15.635C3.749,16.917 3.105,17.801 2.372,19.342L4.657,21.628C6.219,20.885 7.091,20.253 8.364,20.781L8.365,20.781C9.635,21.307 9.801,22.36 10.384,24L13.616,24C14.198,22.364 14.366,21.31 15.643,20.778L15.644,20.778C16.906,20.254 17.764,20.879 19.342,21.629L21.627,19.343C20.883,17.78 20.252,16.91 20.779,15.637C21.306,14.366 22.367,14.197 24,13.616ZM12,16C9.791,16 8,14.209 8,12C8,9.791 9.791,8 12,8C14.209,8 16,9.791 16,12C16,14.209 14.209,16 12,16Z" -js/ui/components/VideoCard.js:1083: const icon = this.createSettingsIcon(["icon-image", "w-5", "h-5"]); -js/ui/components/VideoCard.js:1108: const icon = this.createEllipsisIcon(["icon-image", "w-5", "h-5"]); -js/ui/components/VideoCard.js:1411: d: "M10 18a8 8 0 100-16 8 8 0 000 16zm3.78-9.72a.75.75 0 00-1.06-1.06L9 11.94l-1.72-1.72a.75.75 0 10-1.06 1.06l2.25 2.25a.75.75 0 001.06 0l3.25-3.25z", -js/ui/components/VideoCard.js:1418: d: "M10 18a8 8 0 100-16 8 8 0 000 16zm-.75-11.75a.75.75 0 011.5 0v4.5a.75.75 0 01-1.5 0v-4.5zm.75 8.5a1 1 0 100-2 1 1 0 000 2z", -js/ui/components/VideoCard.js:2426: circle.setAttribute("r", "3"); -js/ui/components/VideoCard.js:2452: "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z" -js/ui/components/VideoCard.js:2480: "mt-3", -js/ui/components/VideoCard.js:2488: classNames: ["flex", "items-center", "gap-1.5"], -js/ui/components/VideoCard.js:2522: classNames: ["flex", "items-center", "gap-1.5"], -js/ui/components/revertModalRenderers.js:9: ol.className = "space-y-3"; -js/ui/components/revertModalRenderers.js:15: li.className = "rounded-md border border-overlay bg-overlay-muted p-3 space-y-3"; -js/ui/components/revertModalRenderers.js:40: dl.className = "grid gap-3 sm:grid-cols-2 text-xs text-subtle"; -js/ui/components/revertModalRenderers.js:63: c.className = "rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/revertModalRenderers.js:74: c.className = "rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/revertModalRenderers.js:91: c.className = "break-all rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/revertModalRenderers.js:102: nestedGrid.className = "grid gap-3 sm:grid-cols-3 text-xs text-subtle"; -js/ui/components/revertModalRenderers.js:156: ol.className = "space-y-3"; -js/ui/components/revertModalRenderers.js:160: li.className = "rounded-md border border-overlay bg-overlay-muted p-3 space-y-3"; -js/ui/components/revertModalRenderers.js:181: dl.className = "grid gap-3 sm:grid-cols-2 text-xs text-subtle"; -js/ui/components/revertModalRenderers.js:207: c.className = "rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/revertModalRenderers.js:241: ol.className = "space-y-3"; -js/ui/components/revertModalRenderers.js:273: li.className = "rounded-md border border-overlay bg-overlay-muted p-3 space-y-3"; -js/ui/components/revertModalRenderers.js:281: dl.className = "grid gap-3 sm:grid-cols-2 text-xs text-subtle"; -js/ui/components/revertModalRenderers.js:355: ol.className = "space-y-3"; -js/ui/components/revertModalRenderers.js:359: li.className = "rounded-md border border-overlay bg-overlay-muted p-3 space-y-2"; -js/ui/components/revertModalRenderers.js:367: dl.className = "grid gap-3 sm:grid-cols-2 text-xs text-subtle"; -js/ui/components/revertModalRenderers.js:394: c.className = "break-all rounded bg-overlay-panel-soft px-1.5 py-0.5 text-primary"; -js/ui/components/tagPillList.js:88: "M8.75 3.5a.75.75 0 0 0-1.5 0v3.75H3.5a.75.75 0 1 0 0 1.5h3.75V12.5a.75.75 0 0 0 1.5 0V8.75H12.5a.75.75 0 0 0 0-1.5H8.75z", -js/ui/components/SimilarContentCard.js:186: const pointer = Array.isArray(info.pointer) ? info.pointer.slice(0, 3) : null; -js/ui/components/SimilarContentCard.js:690: path.setAttribute("d", "M10 18a8 8 0 100-16 8 8 0 000 16zm3.78-9.72a.75.75 0 00-1.06-1.06L9 11.94l-1.72-1.72a.75.75 0 10-1.06 1.06l2.25 2.25a.75.75 0 001.06 0l3.25-3.25z"); -js/ui/components/SimilarContentCard.js:692: path.setAttribute("d", "M10 18a8 8 0 100-16 8 8 0 000 16zm-.75-11.75a.75.75 0 011.5 0v4.5a.75.75 0 01-1.5 0v-4.5zm.75 8.5a1 1 0 100-2 1 1 0 000 2z"); -js/ui/components/SimilarContentCard.js:1077: circle.setAttribute("r", "3"); -js/ui/components/SimilarContentCard.js:1103: "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z" -js/ui/components/SimilarContentCard.js:1129: "mt-1.5", -js/ui/components/SimilarContentCard.js:1137: wrapper.classList.add("flex", "items-center", "gap-1.5"); -js/ui/components/SimilarContentCard.js:1140: const icon = this.createEyeIcon(["w-3.5", "h-3.5"]); -js/ui/components/SimilarContentCard.js:1169: wrapper.classList.add("flex", "items-center", "gap-1.5"); -js/ui/components/SimilarContentCard.js:1174: const icon = this.createMessageIcon(["w-3.5", "h-3.5"]); -js/ui/components/UploadModal.js:543: // 3. Determine Keys -js/ui/components/UploadModal.js:560: // 3. Start Video Upload -js/ui/components/UploadModal.js:621: // 5. Handle Torrent Result & Upload .torrent file -js/ui/components/UploadModal.js:815: const pct = Math.round(fraction * 100); -js/ui/components/UploadModal.js:825: const pct = Math.round(fraction * 100); -js/ui/notificationController.js:92: // Optional auto-hide after 5 seconds -js/ui/similarContentController.js:56: computeCandidates({ activeVideo, maxItems = 5 } = {}) { -js/ui/similarContentController.js:119: : 5; -js/ui/zapController.js:983: const overrideFee = share.type === "platform" ? 100 : 0; -js/ui/moreMenuController.js:237: