From fef03214759cfaa5aa62579cee7a5b0dc8760cfc Mon Sep 17 00:00:00 2001 From: William Petit Date: Fri, 3 Mar 2023 16:33:24 +0100 Subject: [PATCH] fix(http,client): add js generated client to repository --- .gitignore | 1 - pkg/sdk/client/dist/client.js | 4082 +++++++++++++++++++++++++++++ pkg/sdk/client/dist/client.js.map | 7 + 3 files changed, 4089 insertions(+), 1 deletion(-) create mode 100644 pkg/sdk/client/dist/client.js create mode 100644 pkg/sdk/client/dist/client.js.map diff --git a/.gitignore b/.gitignore index 255d7fa..70d677f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ /node_modules /bin -/pkg/sdk/client/dist /.env /tools *.sqlite diff --git a/pkg/sdk/client/dist/client.js b/pkg/sdk/client/dist/client.js new file mode 100644 index 0000000..7128f80 --- /dev/null +++ b/pkg/sdk/client/dist/client.js @@ -0,0 +1,4082 @@ +var Edge = (() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + + // node_modules/sockjs-client/lib/utils/browser-crypto.js + var require_browser_crypto = __commonJS({ + "node_modules/sockjs-client/lib/utils/browser-crypto.js"(exports, module) { + "use strict"; + if (window.crypto && window.crypto.getRandomValues) { + module.exports.randomBytes = function(length) { + var bytes = new Uint8Array(length); + window.crypto.getRandomValues(bytes); + return bytes; + }; + } else { + module.exports.randomBytes = function(length) { + var bytes = new Array(length); + for (var i = 0; i < length; i++) { + bytes[i] = Math.floor(Math.random() * 256); + } + return bytes; + }; + } + } + }); + + // node_modules/sockjs-client/lib/utils/random.js + var require_random = __commonJS({ + "node_modules/sockjs-client/lib/utils/random.js"(exports, module) { + "use strict"; + var crypto = require_browser_crypto(); + var _randomStringChars = "abcdefghijklmnopqrstuvwxyz012345"; + module.exports = { + string: function(length) { + var max = _randomStringChars.length; + var bytes = crypto.randomBytes(length); + var ret = []; + for (var i = 0; i < length; i++) { + ret.push(_randomStringChars.substr(bytes[i] % max, 1)); + } + return ret.join(""); + }, + number: function(max) { + return Math.floor(Math.random() * max); + }, + numberString: function(max) { + var t = ("" + (max - 1)).length; + var p = new Array(t + 1).join("0"); + return (p + this.number(max)).slice(-t); + } + }; + } + }); + + // node_modules/sockjs-client/lib/utils/event.js + var require_event = __commonJS({ + "node_modules/sockjs-client/lib/utils/event.js"(exports, module) { + "use strict"; + var random = require_random(); + var onUnload = {}; + var afterUnload = false; + var isChromePackagedApp = window.chrome && window.chrome.app && window.chrome.app.runtime; + module.exports = { + attachEvent: function(event, listener) { + if (typeof window.addEventListener !== "undefined") { + window.addEventListener(event, listener, false); + } else if (window.document && window.attachEvent) { + window.document.attachEvent("on" + event, listener); + window.attachEvent("on" + event, listener); + } + }, + detachEvent: function(event, listener) { + if (typeof window.addEventListener !== "undefined") { + window.removeEventListener(event, listener, false); + } else if (window.document && window.detachEvent) { + window.document.detachEvent("on" + event, listener); + window.detachEvent("on" + event, listener); + } + }, + unloadAdd: function(listener) { + if (isChromePackagedApp) { + return null; + } + var ref = random.string(8); + onUnload[ref] = listener; + if (afterUnload) { + setTimeout(this.triggerUnloadCallbacks, 0); + } + return ref; + }, + unloadDel: function(ref) { + if (ref in onUnload) { + delete onUnload[ref]; + } + }, + triggerUnloadCallbacks: function() { + for (var ref in onUnload) { + onUnload[ref](); + delete onUnload[ref]; + } + } + }; + var unloadTriggered = function() { + if (afterUnload) { + return; + } + afterUnload = true; + module.exports.triggerUnloadCallbacks(); + }; + if (!isChromePackagedApp) { + module.exports.attachEvent("unload", unloadTriggered); + } + } + }); + + // node_modules/requires-port/index.js + var require_requires_port = __commonJS({ + "node_modules/requires-port/index.js"(exports, module) { + "use strict"; + module.exports = function required(port, protocol) { + protocol = protocol.split(":")[0]; + port = +port; + if (!port) + return false; + switch (protocol) { + case "http": + case "ws": + return port !== 80; + case "https": + case "wss": + return port !== 443; + case "ftp": + return port !== 21; + case "gopher": + return port !== 70; + case "file": + return false; + } + return port !== 0; + }; + } + }); + + // node_modules/querystringify/index.js + var require_querystringify = __commonJS({ + "node_modules/querystringify/index.js"(exports) { + "use strict"; + var has = Object.prototype.hasOwnProperty; + var undef; + function decode(input) { + try { + return decodeURIComponent(input.replace(/\+/g, " ")); + } catch (e) { + return null; + } + } + function encode(input) { + try { + return encodeURIComponent(input); + } catch (e) { + return null; + } + } + function querystring(query) { + var parser = /([^=?#&]+)=?([^&]*)/g, result = {}, part; + while (part = parser.exec(query)) { + var key = decode(part[1]), value = decode(part[2]); + if (key === null || value === null || key in result) + continue; + result[key] = value; + } + return result; + } + function querystringify(obj, prefix) { + prefix = prefix || ""; + var pairs = [], value, key; + if ("string" !== typeof prefix) + prefix = "?"; + for (key in obj) { + if (has.call(obj, key)) { + value = obj[key]; + if (!value && (value === null || value === undef || isNaN(value))) { + value = ""; + } + key = encode(key); + value = encode(value); + if (key === null || value === null) + continue; + pairs.push(key + "=" + value); + } + } + return pairs.length ? prefix + pairs.join("&") : ""; + } + exports.stringify = querystringify; + exports.parse = querystring; + } + }); + + // node_modules/url-parse/index.js + var require_url_parse = __commonJS({ + "node_modules/url-parse/index.js"(exports, module) { + "use strict"; + var required = require_requires_port(); + var qs = require_querystringify(); + var controlOrWhitespace = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/; + var CRHTLF = /[\n\r\t]/g; + var slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//; + var port = /:\d+$/; + var protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i; + var windowsDriveLetter = /^[a-zA-Z]:/; + function trimLeft(str) { + return (str ? str : "").toString().replace(controlOrWhitespace, ""); + } + var rules = [ + ["#", "hash"], + // Extract from the back. + ["?", "query"], + // Extract from the back. + function sanitize(address, url) { + return isSpecial(url.protocol) ? address.replace(/\\/g, "/") : address; + }, + ["/", "pathname"], + // Extract from the back. + ["@", "auth", 1], + // Extract from the front. + [NaN, "host", void 0, 1, 1], + // Set left over value. + [/:(\d*)$/, "port", void 0, 1], + // RegExp the back. + [NaN, "hostname", void 0, 1, 1] + // Set left over. + ]; + var ignore = { hash: 1, query: 1 }; + function lolcation(loc) { + var globalVar; + if (typeof window !== "undefined") + globalVar = window; + else if (typeof window !== "undefined") + globalVar = window; + else if (typeof self !== "undefined") + globalVar = self; + else + globalVar = {}; + var location = globalVar.location || {}; + loc = loc || location; + var finaldestination = {}, type = typeof loc, key; + if ("blob:" === loc.protocol) { + finaldestination = new Url(unescape(loc.pathname), {}); + } else if ("string" === type) { + finaldestination = new Url(loc, {}); + for (key in ignore) + delete finaldestination[key]; + } else if ("object" === type) { + for (key in loc) { + if (key in ignore) + continue; + finaldestination[key] = loc[key]; + } + if (finaldestination.slashes === void 0) { + finaldestination.slashes = slashes.test(loc.href); + } + } + return finaldestination; + } + function isSpecial(scheme) { + return scheme === "file:" || scheme === "ftp:" || scheme === "http:" || scheme === "https:" || scheme === "ws:" || scheme === "wss:"; + } + function extractProtocol(address, location) { + address = trimLeft(address); + address = address.replace(CRHTLF, ""); + location = location || {}; + var match = protocolre.exec(address); + var protocol = match[1] ? match[1].toLowerCase() : ""; + var forwardSlashes = !!match[2]; + var otherSlashes = !!match[3]; + var slashesCount = 0; + var rest; + if (forwardSlashes) { + if (otherSlashes) { + rest = match[2] + match[3] + match[4]; + slashesCount = match[2].length + match[3].length; + } else { + rest = match[2] + match[4]; + slashesCount = match[2].length; + } + } else { + if (otherSlashes) { + rest = match[3] + match[4]; + slashesCount = match[3].length; + } else { + rest = match[4]; + } + } + if (protocol === "file:") { + if (slashesCount >= 2) { + rest = rest.slice(2); + } + } else if (isSpecial(protocol)) { + rest = match[4]; + } else if (protocol) { + if (forwardSlashes) { + rest = rest.slice(2); + } + } else if (slashesCount >= 2 && isSpecial(location.protocol)) { + rest = match[4]; + } + return { + protocol, + slashes: forwardSlashes || isSpecial(protocol), + slashesCount, + rest + }; + } + function resolve(relative, base) { + if (relative === "") + return base; + var path = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i = path.length, last = path[i - 1], unshift = false, up = 0; + while (i--) { + if (path[i] === ".") { + path.splice(i, 1); + } else if (path[i] === "..") { + path.splice(i, 1); + up++; + } else if (up) { + if (i === 0) + unshift = true; + path.splice(i, 1); + up--; + } + } + if (unshift) + path.unshift(""); + if (last === "." || last === "..") + path.push(""); + return path.join("/"); + } + function Url(address, location, parser) { + address = trimLeft(address); + address = address.replace(CRHTLF, ""); + if (!(this instanceof Url)) { + return new Url(address, location, parser); + } + var relative, extracted, parse, instruction, index, key, instructions = rules.slice(), type = typeof location, url = this, i = 0; + if ("object" !== type && "string" !== type) { + parser = location; + location = null; + } + if (parser && "function" !== typeof parser) + parser = qs.parse; + location = lolcation(location); + extracted = extractProtocol(address || "", location); + relative = !extracted.protocol && !extracted.slashes; + url.slashes = extracted.slashes || relative && location.slashes; + url.protocol = extracted.protocol || location.protocol || ""; + address = extracted.rest; + if (extracted.protocol === "file:" && (extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) || !extracted.slashes && (extracted.protocol || extracted.slashesCount < 2 || !isSpecial(url.protocol))) { + instructions[3] = [/(.*)/, "pathname"]; + } + for (; i < instructions.length; i++) { + instruction = instructions[i]; + if (typeof instruction === "function") { + address = instruction(address, url); + continue; + } + parse = instruction[0]; + key = instruction[1]; + if (parse !== parse) { + url[key] = address; + } else if ("string" === typeof parse) { + index = parse === "@" ? address.lastIndexOf(parse) : address.indexOf(parse); + if (~index) { + if ("number" === typeof instruction[2]) { + url[key] = address.slice(0, index); + address = address.slice(index + instruction[2]); + } else { + url[key] = address.slice(index); + address = address.slice(0, index); + } + } + } else if (index = parse.exec(address)) { + url[key] = index[1]; + address = address.slice(0, index.index); + } + url[key] = url[key] || (relative && instruction[3] ? location[key] || "" : ""); + if (instruction[4]) + url[key] = url[key].toLowerCase(); + } + if (parser) + url.query = parser(url.query); + if (relative && location.slashes && url.pathname.charAt(0) !== "/" && (url.pathname !== "" || location.pathname !== "")) { + url.pathname = resolve(url.pathname, location.pathname); + } + if (url.pathname.charAt(0) !== "/" && isSpecial(url.protocol)) { + url.pathname = "/" + url.pathname; + } + if (!required(url.port, url.protocol)) { + url.host = url.hostname; + url.port = ""; + } + url.username = url.password = ""; + if (url.auth) { + index = url.auth.indexOf(":"); + if (~index) { + url.username = url.auth.slice(0, index); + url.username = encodeURIComponent(decodeURIComponent(url.username)); + url.password = url.auth.slice(index + 1); + url.password = encodeURIComponent(decodeURIComponent(url.password)); + } else { + url.username = encodeURIComponent(decodeURIComponent(url.auth)); + } + url.auth = url.password ? url.username + ":" + url.password : url.username; + } + url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null"; + url.href = url.toString(); + } + function set(part, value, fn) { + var url = this; + switch (part) { + case "query": + if ("string" === typeof value && value.length) { + value = (fn || qs.parse)(value); + } + url[part] = value; + break; + case "port": + url[part] = value; + if (!required(value, url.protocol)) { + url.host = url.hostname; + url[part] = ""; + } else if (value) { + url.host = url.hostname + ":" + value; + } + break; + case "hostname": + url[part] = value; + if (url.port) + value += ":" + url.port; + url.host = value; + break; + case "host": + url[part] = value; + if (port.test(value)) { + value = value.split(":"); + url.port = value.pop(); + url.hostname = value.join(":"); + } else { + url.hostname = value; + url.port = ""; + } + break; + case "protocol": + url.protocol = value.toLowerCase(); + url.slashes = !fn; + break; + case "pathname": + case "hash": + if (value) { + var char = part === "pathname" ? "/" : "#"; + url[part] = value.charAt(0) !== char ? char + value : value; + } else { + url[part] = value; + } + break; + case "username": + case "password": + url[part] = encodeURIComponent(value); + break; + case "auth": + var index = value.indexOf(":"); + if (~index) { + url.username = value.slice(0, index); + url.username = encodeURIComponent(decodeURIComponent(url.username)); + url.password = value.slice(index + 1); + url.password = encodeURIComponent(decodeURIComponent(url.password)); + } else { + url.username = encodeURIComponent(decodeURIComponent(value)); + } + } + for (var i = 0; i < rules.length; i++) { + var ins = rules[i]; + if (ins[4]) + url[ins[1]] = url[ins[1]].toLowerCase(); + } + url.auth = url.password ? url.username + ":" + url.password : url.username; + url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null"; + url.href = url.toString(); + return url; + } + function toString(stringify) { + if (!stringify || "function" !== typeof stringify) + stringify = qs.stringify; + var query, url = this, host = url.host, protocol = url.protocol; + if (protocol && protocol.charAt(protocol.length - 1) !== ":") + protocol += ":"; + var result = protocol + (url.protocol && url.slashes || isSpecial(url.protocol) ? "//" : ""); + if (url.username) { + result += url.username; + if (url.password) + result += ":" + url.password; + result += "@"; + } else if (url.password) { + result += ":" + url.password; + result += "@"; + } else if (url.protocol !== "file:" && isSpecial(url.protocol) && !host && url.pathname !== "/") { + result += "@"; + } + if (host[host.length - 1] === ":" || port.test(url.hostname) && !url.port) { + host += ":"; + } + result += host + url.pathname; + query = "object" === typeof url.query ? stringify(url.query) : url.query; + if (query) + result += "?" !== query.charAt(0) ? "?" + query : query; + if (url.hash) + result += url.hash; + return result; + } + Url.prototype = { set, toString }; + Url.extractProtocol = extractProtocol; + Url.location = lolcation; + Url.trimLeft = trimLeft; + Url.qs = qs; + module.exports = Url; + } + }); + + // node_modules/ms/index.js + var require_ms = __commonJS({ + "node_modules/ms/index.js"(exports, module) { + var s = 1e3; + var m = s * 60; + var h = m * 60; + var d = h * 24; + var w = d * 7; + var y = d * 365.25; + module.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === "string" && val.length > 0) { + return parse(val); + } else if (type === "number" && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + "val is not a non-empty string or a valid number. val=" + JSON.stringify(val) + ); + }; + function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + 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( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || "ms").toLowerCase(); + switch (type) { + case "years": + case "year": + case "yrs": + case "yr": + case "y": + return n * y; + case "weeks": + case "week": + case "w": + return n * w; + case "days": + case "day": + case "d": + return n * d; + case "hours": + case "hour": + case "hrs": + case "hr": + case "h": + return n * h; + case "minutes": + case "minute": + case "mins": + case "min": + case "m": + return n * m; + case "seconds": + case "second": + case "secs": + case "sec": + case "s": + return n * s; + case "milliseconds": + case "millisecond": + case "msecs": + case "msec": + case "ms": + return n; + default: + return void 0; + } + } + function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + "d"; + } + if (msAbs >= h) { + return Math.round(ms / h) + "h"; + } + if (msAbs >= m) { + return Math.round(ms / m) + "m"; + } + if (msAbs >= s) { + return Math.round(ms / s) + "s"; + } + return ms + "ms"; + } + function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, "day"); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, "hour"); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, "minute"); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, "second"); + } + return ms + " ms"; + } + function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); + } + } + }); + + // node_modules/debug/src/common.js + var require_common = __commonJS({ + "node_modules/debug/src/common.js"(exports, module) { + "use strict"; + function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = require_ms(); + Object.keys(env).forEach(function(key) { + createDebug[key] = env[key]; + }); + createDebug.instances = []; + createDebug.names = []; + createDebug.skips = []; + createDebug.formatters = {}; + function selectColor(namespace) { + var hash = 0; + for (var i = 0; i < namespace.length; i++) { + hash = (hash << 5) - hash + namespace.charCodeAt(i); + hash |= 0; + } + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + function createDebug(namespace) { + var prevTime; + function debug() { + if (!debug.enabled) { + return; + } + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + var self2 = debug; + var curr = Number(/* @__PURE__ */ new Date()); + var ms = curr - (prevTime || curr); + self2.diff = ms; + self2.prev = prevTime; + self2.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== "string") { + args.unshift("%O"); + } + var index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) { + if (match === "%%") { + return match; + } + index++; + var formatter = createDebug.formatters[format]; + if (typeof formatter === "function") { + var val = args[index]; + match = formatter.call(self2, val); + args.splice(index, 1); + index--; + } + return match; + }); + createDebug.formatArgs.call(self2, args); + var logFn = self2.log || createDebug.log; + logFn.apply(self2, args); + } + debug.namespace = namespace; + debug.enabled = createDebug.enabled(namespace); + debug.useColors = createDebug.useColors(); + debug.color = selectColor(namespace); + debug.destroy = destroy; + debug.extend = extend; + if (typeof createDebug.init === "function") { + createDebug.init(debug); + } + createDebug.instances.push(debug); + return debug; + } + function destroy() { + var index = createDebug.instances.indexOf(this); + if (index !== -1) { + createDebug.instances.splice(index, 1); + return true; + } + return false; + } + function extend(namespace, delimiter) { + return createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace); + } + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.names = []; + createDebug.skips = []; + var i; + var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/); + var len = split.length; + for (i = 0; i < len; i++) { + if (!split[i]) { + continue; + } + namespaces = split[i].replace(/\*/g, ".*?"); + if (namespaces[0] === "-") { + createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$")); + } else { + createDebug.names.push(new RegExp("^" + namespaces + "$")); + } + } + for (i = 0; i < createDebug.instances.length; i++) { + var instance = createDebug.instances[i]; + instance.enabled = createDebug.enabled(instance.namespace); + } + } + function disable() { + createDebug.enable(""); + } + function enabled(name) { + if (name[name.length - 1] === "*") { + return true; + } + var i; + var len; + for (i = 0, len = createDebug.skips.length; i < len; i++) { + if (createDebug.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = createDebug.names.length; i < len; i++) { + if (createDebug.names[i].test(name)) { + return true; + } + } + return false; + } + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + createDebug.enable(createDebug.load()); + return createDebug; + } + module.exports = setup; + } + }); + + // node_modules/debug/src/browser.js + var require_browser = __commonJS({ + "node_modules/debug/src/browser.js"(exports, module) { + "use strict"; + function _typeof(obj) { + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function _typeof2(obj2) { + return typeof obj2; + }; + } else { + _typeof = function _typeof2(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + exports.log = log; + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load; + exports.useColors = useColors; + exports.storage = localstorage(); + exports.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"]; + function useColors() { + if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) { + return true; + } + if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773 + typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); + } + function formatArgs(args) { + args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff); + if (!this.useColors) { + return; + } + var c = "color: " + this.color; + args.splice(1, 0, c, "color: inherit"); + var index = 0; + var lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, function(match) { + if (match === "%%") { + return; + } + index++; + if (match === "%c") { + lastC = index; + } + }); + args.splice(lastC, 0, c); + } + function log() { + var _console; + return (typeof console === "undefined" ? "undefined" : _typeof(console)) === "object" && console.log && (_console = console).log.apply(_console, arguments); + } + function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem("debug", namespaces); + } else { + exports.storage.removeItem("debug"); + } + } catch (error) { + } + } + function load() { + var r; + try { + r = exports.storage.getItem("debug"); + } catch (error) { + } + if (!r && typeof process !== "undefined" && "env" in process) { + r = process.env.DEBUG; + } + return r; + } + function localstorage() { + try { + return localStorage; + } catch (error) { + } + } + module.exports = require_common()(exports); + var formatters = module.exports.formatters; + formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (error) { + return "[UnexpectedJSONParseError]: " + error.message; + } + }; + } + }); + + // node_modules/sockjs-client/lib/utils/url.js + var require_url = __commonJS({ + "node_modules/sockjs-client/lib/utils/url.js"(exports, module) { + "use strict"; + var URL = require_url_parse(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:utils:url"); + } + module.exports = { + getOrigin: function(url) { + if (!url) { + return null; + } + var p = new URL(url); + if (p.protocol === "file:") { + return null; + } + var port = p.port; + if (!port) { + port = p.protocol === "https:" ? "443" : "80"; + } + return p.protocol + "//" + p.hostname + ":" + port; + }, + isOriginEqual: function(a, b) { + var res = this.getOrigin(a) === this.getOrigin(b); + debug("same", a, b, res); + return res; + }, + isSchemeEqual: function(a, b) { + return a.split(":")[0] === b.split(":")[0]; + }, + addPath: function(url, path) { + var qs = url.split("?"); + return qs[0] + path + (qs[1] ? "?" + qs[1] : ""); + }, + addQuery: function(url, q) { + return url + (url.indexOf("?") === -1 ? "?" + q : "&" + q); + }, + isLoopbackAddr: function(addr) { + return /^127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) || /^\[::1\]$/.test(addr); + } + }; + } + }); + + // node_modules/inherits/inherits_browser.js + var require_inherits_browser = __commonJS({ + "node_modules/inherits/inherits_browser.js"(exports, module) { + if (typeof Object.create === "function") { + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + } + }; + } else { + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + }; + } + } + }); + + // node_modules/sockjs-client/lib/event/eventtarget.js + var require_eventtarget = __commonJS({ + "node_modules/sockjs-client/lib/event/eventtarget.js"(exports, module) { + "use strict"; + function EventTarget2() { + this._listeners = {}; + } + EventTarget2.prototype.addEventListener = function(eventType, listener) { + if (!(eventType in this._listeners)) { + this._listeners[eventType] = []; + } + var arr = this._listeners[eventType]; + if (arr.indexOf(listener) === -1) { + arr = arr.concat([listener]); + } + this._listeners[eventType] = arr; + }; + EventTarget2.prototype.removeEventListener = function(eventType, listener) { + var arr = this._listeners[eventType]; + if (!arr) { + return; + } + var idx = arr.indexOf(listener); + if (idx !== -1) { + if (arr.length > 1) { + this._listeners[eventType] = arr.slice(0, idx).concat(arr.slice(idx + 1)); + } else { + delete this._listeners[eventType]; + } + return; + } + }; + EventTarget2.prototype.dispatchEvent = function() { + var event = arguments[0]; + var t = event.type; + var args = arguments.length === 1 ? [event] : Array.apply(null, arguments); + if (this["on" + t]) { + this["on" + t].apply(this, args); + } + if (t in this._listeners) { + var listeners = this._listeners[t]; + for (var i = 0; i < listeners.length; i++) { + listeners[i].apply(this, args); + } + } + }; + module.exports = EventTarget2; + } + }); + + // node_modules/sockjs-client/lib/event/emitter.js + var require_emitter = __commonJS({ + "node_modules/sockjs-client/lib/event/emitter.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var EventTarget2 = require_eventtarget(); + function EventEmitter() { + EventTarget2.call(this); + } + inherits(EventEmitter, EventTarget2); + EventEmitter.prototype.removeAllListeners = function(type) { + if (type) { + delete this._listeners[type]; + } else { + this._listeners = {}; + } + }; + EventEmitter.prototype.once = function(type, listener) { + var self2 = this, fired = false; + function g() { + self2.removeListener(type, g); + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + this.on(type, g); + }; + EventEmitter.prototype.emit = function() { + var type = arguments[0]; + var listeners = this._listeners[type]; + if (!listeners) { + return; + } + var l = arguments.length; + var args = new Array(l - 1); + for (var ai = 1; ai < l; ai++) { + args[ai - 1] = arguments[ai]; + } + for (var i = 0; i < listeners.length; i++) { + listeners[i].apply(this, args); + } + }; + EventEmitter.prototype.on = EventEmitter.prototype.addListener = EventTarget2.prototype.addEventListener; + EventEmitter.prototype.removeListener = EventTarget2.prototype.removeEventListener; + module.exports.EventEmitter = EventEmitter; + } + }); + + // node_modules/sockjs-client/lib/transport/browser/websocket.js + var require_websocket = __commonJS({ + "node_modules/sockjs-client/lib/transport/browser/websocket.js"(exports, module) { + "use strict"; + var Driver = window.WebSocket || window.MozWebSocket; + if (Driver) { + module.exports = function WebSocketBrowserDriver(url) { + return new Driver(url); + }; + } else { + module.exports = void 0; + } + } + }); + + // node_modules/sockjs-client/lib/transport/websocket.js + var require_websocket2 = __commonJS({ + "node_modules/sockjs-client/lib/transport/websocket.js"(exports, module) { + "use strict"; + var utils = require_event(); + var urlUtils = require_url(); + var inherits = require_inherits_browser(); + var EventEmitter = require_emitter().EventEmitter; + var WebsocketDriver = require_websocket(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:websocket"); + } + function WebSocketTransport(transUrl, ignore, options) { + if (!WebSocketTransport.enabled()) { + throw new Error("Transport created when disabled"); + } + EventEmitter.call(this); + debug("constructor", transUrl); + var self2 = this; + var url = urlUtils.addPath(transUrl, "/websocket"); + if (url.slice(0, 5) === "https") { + url = "wss" + url.slice(5); + } else { + url = "ws" + url.slice(4); + } + this.url = url; + this.ws = new WebsocketDriver(this.url, [], options); + this.ws.onmessage = function(e) { + debug("message event", e.data); + self2.emit("message", e.data); + }; + this.unloadRef = utils.unloadAdd(function() { + debug("unload"); + self2.ws.close(); + }); + this.ws.onclose = function(e) { + debug("close event", e.code, e.reason); + self2.emit("close", e.code, e.reason); + self2._cleanup(); + }; + this.ws.onerror = function(e) { + debug("error event", e); + self2.emit("close", 1006, "WebSocket connection broken"); + self2._cleanup(); + }; + } + inherits(WebSocketTransport, EventEmitter); + WebSocketTransport.prototype.send = function(data) { + var msg = "[" + data + "]"; + debug("send", msg); + this.ws.send(msg); + }; + WebSocketTransport.prototype.close = function() { + debug("close"); + var ws = this.ws; + this._cleanup(); + if (ws) { + ws.close(); + } + }; + WebSocketTransport.prototype._cleanup = function() { + debug("_cleanup"); + var ws = this.ws; + if (ws) { + ws.onmessage = ws.onclose = ws.onerror = null; + } + utils.unloadDel(this.unloadRef); + this.unloadRef = this.ws = null; + this.removeAllListeners(); + }; + WebSocketTransport.enabled = function() { + debug("enabled"); + return !!WebsocketDriver; + }; + WebSocketTransport.transportName = "websocket"; + WebSocketTransport.roundTrips = 2; + module.exports = WebSocketTransport; + } + }); + + // node_modules/sockjs-client/lib/transport/lib/buffered-sender.js + var require_buffered_sender = __commonJS({ + "node_modules/sockjs-client/lib/transport/lib/buffered-sender.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var EventEmitter = require_emitter().EventEmitter; + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:buffered-sender"); + } + function BufferedSender(url, sender) { + debug(url); + EventEmitter.call(this); + this.sendBuffer = []; + this.sender = sender; + this.url = url; + } + inherits(BufferedSender, EventEmitter); + BufferedSender.prototype.send = function(message) { + debug("send", message); + this.sendBuffer.push(message); + if (!this.sendStop) { + this.sendSchedule(); + } + }; + BufferedSender.prototype.sendScheduleWait = function() { + debug("sendScheduleWait"); + var self2 = this; + var tref; + this.sendStop = function() { + debug("sendStop"); + self2.sendStop = null; + clearTimeout(tref); + }; + tref = setTimeout(function() { + debug("timeout"); + self2.sendStop = null; + self2.sendSchedule(); + }, 25); + }; + BufferedSender.prototype.sendSchedule = function() { + debug("sendSchedule", this.sendBuffer.length); + var self2 = this; + if (this.sendBuffer.length > 0) { + var payload = "[" + this.sendBuffer.join(",") + "]"; + this.sendStop = this.sender(this.url, payload, function(err) { + self2.sendStop = null; + if (err) { + debug("error", err); + self2.emit("close", err.code || 1006, "Sending error: " + err); + self2.close(); + } else { + self2.sendScheduleWait(); + } + }); + this.sendBuffer = []; + } + }; + BufferedSender.prototype._cleanup = function() { + debug("_cleanup"); + this.removeAllListeners(); + }; + BufferedSender.prototype.close = function() { + debug("close"); + this._cleanup(); + if (this.sendStop) { + this.sendStop(); + this.sendStop = null; + } + }; + module.exports = BufferedSender; + } + }); + + // node_modules/sockjs-client/lib/transport/lib/polling.js + var require_polling = __commonJS({ + "node_modules/sockjs-client/lib/transport/lib/polling.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var EventEmitter = require_emitter().EventEmitter; + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:polling"); + } + function Polling(Receiver, receiveUrl, AjaxObject) { + debug(receiveUrl); + EventEmitter.call(this); + this.Receiver = Receiver; + this.receiveUrl = receiveUrl; + this.AjaxObject = AjaxObject; + this._scheduleReceiver(); + } + inherits(Polling, EventEmitter); + Polling.prototype._scheduleReceiver = function() { + debug("_scheduleReceiver"); + var self2 = this; + var poll = this.poll = new this.Receiver(this.receiveUrl, this.AjaxObject); + poll.on("message", function(msg) { + debug("message", msg); + self2.emit("message", msg); + }); + poll.once("close", function(code, reason) { + debug("close", code, reason, self2.pollIsClosing); + self2.poll = poll = null; + if (!self2.pollIsClosing) { + if (reason === "network") { + self2._scheduleReceiver(); + } else { + self2.emit("close", code || 1006, reason); + self2.removeAllListeners(); + } + } + }); + }; + Polling.prototype.abort = function() { + debug("abort"); + this.removeAllListeners(); + this.pollIsClosing = true; + if (this.poll) { + this.poll.abort(); + } + }; + module.exports = Polling; + } + }); + + // node_modules/sockjs-client/lib/transport/lib/sender-receiver.js + var require_sender_receiver = __commonJS({ + "node_modules/sockjs-client/lib/transport/lib/sender-receiver.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var urlUtils = require_url(); + var BufferedSender = require_buffered_sender(); + var Polling = require_polling(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:sender-receiver"); + } + function SenderReceiver(transUrl, urlSuffix, senderFunc, Receiver, AjaxObject) { + var pollUrl = urlUtils.addPath(transUrl, urlSuffix); + debug(pollUrl); + var self2 = this; + BufferedSender.call(this, transUrl, senderFunc); + this.poll = new Polling(Receiver, pollUrl, AjaxObject); + this.poll.on("message", function(msg) { + debug("poll message", msg); + self2.emit("message", msg); + }); + this.poll.once("close", function(code, reason) { + debug("poll close", code, reason); + self2.poll = null; + self2.emit("close", code, reason); + self2.close(); + }); + } + inherits(SenderReceiver, BufferedSender); + SenderReceiver.prototype.close = function() { + BufferedSender.prototype.close.call(this); + debug("close"); + this.removeAllListeners(); + if (this.poll) { + this.poll.abort(); + this.poll = null; + } + }; + module.exports = SenderReceiver; + } + }); + + // node_modules/sockjs-client/lib/transport/lib/ajax-based.js + var require_ajax_based = __commonJS({ + "node_modules/sockjs-client/lib/transport/lib/ajax-based.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var urlUtils = require_url(); + var SenderReceiver = require_sender_receiver(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:ajax-based"); + } + function createAjaxSender(AjaxObject) { + return function(url, payload, callback) { + debug("create ajax sender", url, payload); + var opt = {}; + if (typeof payload === "string") { + opt.headers = { "Content-type": "text/plain" }; + } + var ajaxUrl = urlUtils.addPath(url, "/xhr_send"); + var xo = new AjaxObject("POST", ajaxUrl, payload, opt); + xo.once("finish", function(status) { + debug("finish", status); + xo = null; + if (status !== 200 && status !== 204) { + return callback(new Error("http status " + status)); + } + callback(); + }); + return function() { + debug("abort"); + xo.close(); + xo = null; + var err = new Error("Aborted"); + err.code = 1e3; + callback(err); + }; + }; + } + function AjaxBasedTransport(transUrl, urlSuffix, Receiver, AjaxObject) { + SenderReceiver.call(this, transUrl, urlSuffix, createAjaxSender(AjaxObject), Receiver, AjaxObject); + } + inherits(AjaxBasedTransport, SenderReceiver); + module.exports = AjaxBasedTransport; + } + }); + + // node_modules/sockjs-client/lib/transport/receiver/xhr.js + var require_xhr = __commonJS({ + "node_modules/sockjs-client/lib/transport/receiver/xhr.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var EventEmitter = require_emitter().EventEmitter; + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:receiver:xhr"); + } + function XhrReceiver(url, AjaxObject) { + debug(url); + EventEmitter.call(this); + var self2 = this; + this.bufferPosition = 0; + this.xo = new AjaxObject("POST", url, null); + this.xo.on("chunk", this._chunkHandler.bind(this)); + this.xo.once("finish", function(status, text) { + debug("finish", status, text); + self2._chunkHandler(status, text); + self2.xo = null; + var reason = status === 200 ? "network" : "permanent"; + debug("close", reason); + self2.emit("close", null, reason); + self2._cleanup(); + }); + } + inherits(XhrReceiver, EventEmitter); + XhrReceiver.prototype._chunkHandler = function(status, text) { + debug("_chunkHandler", status); + if (status !== 200 || !text) { + return; + } + for (var idx = -1; ; this.bufferPosition += idx + 1) { + var buf = text.slice(this.bufferPosition); + idx = buf.indexOf("\n"); + if (idx === -1) { + break; + } + var msg = buf.slice(0, idx); + if (msg) { + debug("message", msg); + this.emit("message", msg); + } + } + }; + XhrReceiver.prototype._cleanup = function() { + debug("_cleanup"); + this.removeAllListeners(); + }; + XhrReceiver.prototype.abort = function() { + debug("abort"); + if (this.xo) { + this.xo.close(); + debug("close"); + this.emit("close", null, "user"); + this.xo = null; + } + this._cleanup(); + }; + module.exports = XhrReceiver; + } + }); + + // node_modules/sockjs-client/lib/transport/browser/abstract-xhr.js + var require_abstract_xhr = __commonJS({ + "node_modules/sockjs-client/lib/transport/browser/abstract-xhr.js"(exports, module) { + "use strict"; + var EventEmitter = require_emitter().EventEmitter; + var inherits = require_inherits_browser(); + var utils = require_event(); + var urlUtils = require_url(); + var XHR = window.XMLHttpRequest; + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:browser:xhr"); + } + function AbstractXHRObject(method, url, payload, opts) { + debug(method, url); + var self2 = this; + EventEmitter.call(this); + setTimeout(function() { + self2._start(method, url, payload, opts); + }, 0); + } + inherits(AbstractXHRObject, EventEmitter); + AbstractXHRObject.prototype._start = function(method, url, payload, opts) { + var self2 = this; + try { + this.xhr = new XHR(); + } catch (x) { + } + if (!this.xhr) { + debug("no xhr"); + this.emit("finish", 0, "no xhr support"); + this._cleanup(); + return; + } + url = urlUtils.addQuery(url, "t=" + +/* @__PURE__ */ new Date()); + this.unloadRef = utils.unloadAdd(function() { + debug("unload cleanup"); + self2._cleanup(true); + }); + try { + this.xhr.open(method, url, true); + if (this.timeout && "timeout" in this.xhr) { + this.xhr.timeout = this.timeout; + this.xhr.ontimeout = function() { + debug("xhr timeout"); + self2.emit("finish", 0, ""); + self2._cleanup(false); + }; + } + } catch (e) { + debug("exception", e); + this.emit("finish", 0, ""); + this._cleanup(false); + return; + } + if ((!opts || !opts.noCredentials) && AbstractXHRObject.supportsCORS) { + debug("withCredentials"); + this.xhr.withCredentials = true; + } + if (opts && opts.headers) { + for (var key in opts.headers) { + this.xhr.setRequestHeader(key, opts.headers[key]); + } + } + this.xhr.onreadystatechange = function() { + if (self2.xhr) { + var x = self2.xhr; + var text, status; + debug("readyState", x.readyState); + switch (x.readyState) { + case 3: + try { + status = x.status; + text = x.responseText; + } catch (e) { + } + debug("status", status); + if (status === 1223) { + status = 204; + } + if (status === 200 && text && text.length > 0) { + debug("chunk"); + self2.emit("chunk", status, text); + } + break; + case 4: + status = x.status; + debug("status", status); + if (status === 1223) { + status = 204; + } + if (status === 12005 || status === 12029) { + status = 0; + } + debug("finish", status, x.responseText); + self2.emit("finish", status, x.responseText); + self2._cleanup(false); + break; + } + } + }; + try { + self2.xhr.send(payload); + } catch (e) { + self2.emit("finish", 0, ""); + self2._cleanup(false); + } + }; + AbstractXHRObject.prototype._cleanup = function(abort) { + debug("cleanup"); + if (!this.xhr) { + return; + } + this.removeAllListeners(); + utils.unloadDel(this.unloadRef); + this.xhr.onreadystatechange = function() { + }; + if (this.xhr.ontimeout) { + this.xhr.ontimeout = null; + } + if (abort) { + try { + this.xhr.abort(); + } catch (x) { + } + } + this.unloadRef = this.xhr = null; + }; + AbstractXHRObject.prototype.close = function() { + debug("close"); + this._cleanup(true); + }; + AbstractXHRObject.enabled = !!XHR; + var axo = ["Active"].concat("Object").join("X"); + if (!AbstractXHRObject.enabled && axo in window) { + debug("overriding xmlhttprequest"); + XHR = function() { + try { + return new window[axo]("Microsoft.XMLHTTP"); + } catch (e) { + return null; + } + }; + AbstractXHRObject.enabled = !!new XHR(); + } + var cors = false; + try { + cors = "withCredentials" in new XHR(); + } catch (ignored) { + } + AbstractXHRObject.supportsCORS = cors; + module.exports = AbstractXHRObject; + } + }); + + // node_modules/sockjs-client/lib/transport/sender/xhr-cors.js + var require_xhr_cors = __commonJS({ + "node_modules/sockjs-client/lib/transport/sender/xhr-cors.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var XhrDriver = require_abstract_xhr(); + function XHRCorsObject(method, url, payload, opts) { + XhrDriver.call(this, method, url, payload, opts); + } + inherits(XHRCorsObject, XhrDriver); + XHRCorsObject.enabled = XhrDriver.enabled && XhrDriver.supportsCORS; + module.exports = XHRCorsObject; + } + }); + + // node_modules/sockjs-client/lib/transport/sender/xhr-local.js + var require_xhr_local = __commonJS({ + "node_modules/sockjs-client/lib/transport/sender/xhr-local.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var XhrDriver = require_abstract_xhr(); + function XHRLocalObject(method, url, payload) { + XhrDriver.call(this, method, url, payload, { + noCredentials: true + }); + } + inherits(XHRLocalObject, XhrDriver); + XHRLocalObject.enabled = XhrDriver.enabled; + module.exports = XHRLocalObject; + } + }); + + // node_modules/sockjs-client/lib/utils/browser.js + var require_browser2 = __commonJS({ + "node_modules/sockjs-client/lib/utils/browser.js"(exports, module) { + "use strict"; + module.exports = { + isOpera: function() { + return window.navigator && /opera/i.test(window.navigator.userAgent); + }, + isKonqueror: function() { + return window.navigator && /konqueror/i.test(window.navigator.userAgent); + }, + hasDomain: function() { + if (!window.document) { + return true; + } + try { + return !!window.document.domain; + } catch (e) { + return false; + } + } + }; + } + }); + + // node_modules/sockjs-client/lib/transport/xhr-streaming.js + var require_xhr_streaming = __commonJS({ + "node_modules/sockjs-client/lib/transport/xhr-streaming.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var AjaxBasedTransport = require_ajax_based(); + var XhrReceiver = require_xhr(); + var XHRCorsObject = require_xhr_cors(); + var XHRLocalObject = require_xhr_local(); + var browser = require_browser2(); + function XhrStreamingTransport(transUrl) { + if (!XHRLocalObject.enabled && !XHRCorsObject.enabled) { + throw new Error("Transport created when disabled"); + } + AjaxBasedTransport.call(this, transUrl, "/xhr_streaming", XhrReceiver, XHRCorsObject); + } + inherits(XhrStreamingTransport, AjaxBasedTransport); + XhrStreamingTransport.enabled = function(info) { + if (info.nullOrigin) { + return false; + } + if (browser.isOpera()) { + return false; + } + return XHRCorsObject.enabled; + }; + XhrStreamingTransport.transportName = "xhr-streaming"; + XhrStreamingTransport.roundTrips = 2; + XhrStreamingTransport.needBody = !!window.document; + module.exports = XhrStreamingTransport; + } + }); + + // node_modules/sockjs-client/lib/transport/sender/xdr.js + var require_xdr = __commonJS({ + "node_modules/sockjs-client/lib/transport/sender/xdr.js"(exports, module) { + "use strict"; + var EventEmitter = require_emitter().EventEmitter; + var inherits = require_inherits_browser(); + var eventUtils = require_event(); + var browser = require_browser2(); + var urlUtils = require_url(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:sender:xdr"); + } + function XDRObject(method, url, payload) { + debug(method, url); + var self2 = this; + EventEmitter.call(this); + setTimeout(function() { + self2._start(method, url, payload); + }, 0); + } + inherits(XDRObject, EventEmitter); + XDRObject.prototype._start = function(method, url, payload) { + debug("_start"); + var self2 = this; + var xdr = new window.XDomainRequest(); + url = urlUtils.addQuery(url, "t=" + +/* @__PURE__ */ new Date()); + xdr.onerror = function() { + debug("onerror"); + self2._error(); + }; + xdr.ontimeout = function() { + debug("ontimeout"); + self2._error(); + }; + xdr.onprogress = function() { + debug("progress", xdr.responseText); + self2.emit("chunk", 200, xdr.responseText); + }; + xdr.onload = function() { + debug("load"); + self2.emit("finish", 200, xdr.responseText); + self2._cleanup(false); + }; + this.xdr = xdr; + this.unloadRef = eventUtils.unloadAdd(function() { + self2._cleanup(true); + }); + try { + this.xdr.open(method, url); + if (this.timeout) { + this.xdr.timeout = this.timeout; + } + this.xdr.send(payload); + } catch (x) { + this._error(); + } + }; + XDRObject.prototype._error = function() { + this.emit("finish", 0, ""); + this._cleanup(false); + }; + XDRObject.prototype._cleanup = function(abort) { + debug("cleanup", abort); + if (!this.xdr) { + return; + } + this.removeAllListeners(); + eventUtils.unloadDel(this.unloadRef); + this.xdr.ontimeout = this.xdr.onerror = this.xdr.onprogress = this.xdr.onload = null; + if (abort) { + try { + this.xdr.abort(); + } catch (x) { + } + } + this.unloadRef = this.xdr = null; + }; + XDRObject.prototype.close = function() { + debug("close"); + this._cleanup(true); + }; + XDRObject.enabled = !!(window.XDomainRequest && browser.hasDomain()); + module.exports = XDRObject; + } + }); + + // node_modules/sockjs-client/lib/transport/xdr-streaming.js + var require_xdr_streaming = __commonJS({ + "node_modules/sockjs-client/lib/transport/xdr-streaming.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var AjaxBasedTransport = require_ajax_based(); + var XhrReceiver = require_xhr(); + var XDRObject = require_xdr(); + function XdrStreamingTransport(transUrl) { + if (!XDRObject.enabled) { + throw new Error("Transport created when disabled"); + } + AjaxBasedTransport.call(this, transUrl, "/xhr_streaming", XhrReceiver, XDRObject); + } + inherits(XdrStreamingTransport, AjaxBasedTransport); + XdrStreamingTransport.enabled = function(info) { + if (info.cookie_needed || info.nullOrigin) { + return false; + } + return XDRObject.enabled && info.sameScheme; + }; + XdrStreamingTransport.transportName = "xdr-streaming"; + XdrStreamingTransport.roundTrips = 2; + module.exports = XdrStreamingTransport; + } + }); + + // node_modules/sockjs-client/lib/transport/browser/eventsource.js + var require_eventsource = __commonJS({ + "node_modules/sockjs-client/lib/transport/browser/eventsource.js"(exports, module) { + module.exports = window.EventSource; + } + }); + + // node_modules/sockjs-client/lib/transport/receiver/eventsource.js + var require_eventsource2 = __commonJS({ + "node_modules/sockjs-client/lib/transport/receiver/eventsource.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var EventEmitter = require_emitter().EventEmitter; + var EventSourceDriver = require_eventsource(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:receiver:eventsource"); + } + function EventSourceReceiver(url) { + debug(url); + EventEmitter.call(this); + var self2 = this; + var es = this.es = new EventSourceDriver(url); + es.onmessage = function(e) { + debug("message", e.data); + self2.emit("message", decodeURI(e.data)); + }; + es.onerror = function(e) { + debug("error", es.readyState, e); + var reason = es.readyState !== 2 ? "network" : "permanent"; + self2._cleanup(); + self2._close(reason); + }; + } + inherits(EventSourceReceiver, EventEmitter); + EventSourceReceiver.prototype.abort = function() { + debug("abort"); + this._cleanup(); + this._close("user"); + }; + EventSourceReceiver.prototype._cleanup = function() { + debug("cleanup"); + var es = this.es; + if (es) { + es.onmessage = es.onerror = null; + es.close(); + this.es = null; + } + }; + EventSourceReceiver.prototype._close = function(reason) { + debug("close", reason); + var self2 = this; + setTimeout(function() { + self2.emit("close", null, reason); + self2.removeAllListeners(); + }, 200); + }; + module.exports = EventSourceReceiver; + } + }); + + // node_modules/sockjs-client/lib/transport/eventsource.js + var require_eventsource3 = __commonJS({ + "node_modules/sockjs-client/lib/transport/eventsource.js"(exports, module) { + "use strict"; + var inherits = require_inherits_browser(); + var AjaxBasedTransport = require_ajax_based(); + var EventSourceReceiver = require_eventsource2(); + var XHRCorsObject = require_xhr_cors(); + var EventSourceDriver = require_eventsource(); + function EventSourceTransport(transUrl) { + if (!EventSourceTransport.enabled()) { + throw new Error("Transport created when disabled"); + } + AjaxBasedTransport.call(this, transUrl, "/eventsource", EventSourceReceiver, XHRCorsObject); + } + inherits(EventSourceTransport, AjaxBasedTransport); + EventSourceTransport.enabled = function() { + return !!EventSourceDriver; + }; + EventSourceTransport.transportName = "eventsource"; + EventSourceTransport.roundTrips = 2; + module.exports = EventSourceTransport; + } + }); + + // node_modules/sockjs-client/lib/version.js + var require_version = __commonJS({ + "node_modules/sockjs-client/lib/version.js"(exports, module) { + module.exports = "1.6.1"; + } + }); + + // node_modules/sockjs-client/lib/utils/iframe.js + var require_iframe = __commonJS({ + "node_modules/sockjs-client/lib/utils/iframe.js"(exports, module) { + "use strict"; + var eventUtils = require_event(); + var browser = require_browser2(); + var debug = function() { + }; + if (true) { + debug = require_browser()("sockjs-client:utils:iframe"); + } + module.exports = { + WPrefix: "_jp", + currentWindowId: null, + polluteGlobalNamespace: function() { + if (!(module.exports.WPrefix in window)) { + window[module.exports.WPrefix] = {}; + } + }, + postMessage: function(type, data) { + if (window.parent !== window) { + window.parent.postMessage(JSON.stringify({ + windowId: module.exports.currentWindowId, + type, + data: data || "" + }), "*"); + } else { + debug("Cannot postMessage, no parent window.", type, data); + } + }, + createIframe: function(iframeUrl, errorCallback) { + var iframe = window.document.createElement("iframe"); + var tref, unloadRef; + var unattach = function() { + debug("unattach"); + clearTimeout(tref); + try { + iframe.onload = null; + } catch (x) { + } + iframe.onerror = null; + }; + var cleanup = function() { + debug("cleanup"); + if (iframe) { + unattach(); + setTimeout(function() { + if (iframe) { + iframe.parentNode.removeChild(iframe); + } + iframe = null; + }, 0); + eventUtils.unloadDel(unloadRef); + } + }; + var onerror = function(err) { + debug("onerror", err); + if (iframe) { + cleanup(); + errorCallback(err); + } + }; + var post = function(msg, origin) { + debug("post", msg, origin); + setTimeout(function() { + try { + if (iframe && iframe.contentWindow) { + iframe.contentWindow.postMessage(msg, origin); + } + } catch (x) { + } + }, 0); + }; + iframe.src = iframeUrl; + iframe.style.display = "none"; + iframe.style.position = "absolute"; + iframe.onerror = function() { + onerror("onerror"); + }; + iframe.onload = function() { + debug("onload"); + clearTimeout(tref); + tref = setTimeout(function() { + onerror("onload timeout"); + }, 2e3); + }; + window.document.body.appendChild(iframe); + tref = setTimeout(function() { + onerror("timeout"); + }, 15e3); + unloadRef = eventUtils.unloadAdd(cleanup); + return { + post, + cleanup, + loaded: unattach + }; + }, + createHtmlfile: function(iframeUrl, errorCallback) { + var axo = ["Active"].concat("Object").join("X"); + var doc = new window[axo]("htmlfile"); + var tref, unloadRef; + var iframe; + var unattach = function() { + clearTimeout(tref); + iframe.onerror = null; + }; + var cleanup = function() { + if (doc) { + unattach(); + eventUtils.unloadDel(unloadRef); + iframe.parentNode.removeChild(iframe); + iframe = doc = null; + CollectGarbage(); + } + }; + var onerror = function(r) { + debug("onerror", r); + if (doc) { + cleanup(); + errorCallback(r); + } + }; + var post = function(msg, origin) { + try { + setTimeout(function() { + if (iframe && iframe.contentWindow) { + iframe.contentWindow.postMessage(msg, origin); + } + }, 0); + } catch (x) { + } + }; + doc.open(); + doc.write('