From 89b837d75b40a7bd2ddafde837473c212db8b313 Mon Sep 17 00:00:00 2001 From: GitHub Action Date: Tue, 7 Apr 2026 20:08:00 +0000 Subject: [PATCH] build --- .gitignore | 1 - lib/index.js | 70335 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70335 insertions(+), 1 deletion(-) create mode 100644 lib/index.js diff --git a/.gitignore b/.gitignore index 261a2da..9b3dd5c 100644 --- a/.gitignore +++ b/.gitignore @@ -331,4 +331,3 @@ node_modules coverage # Transpiled JS -lib/ diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 0000000..7103f3d --- /dev/null +++ b/lib/index.js @@ -0,0 +1,70335 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { + get: (a, b) => (typeof require !== "undefined" ? require : a)[b] +}) : x)(function(x) { + if (typeof require !== "undefined") return require.apply(this, arguments); + throw Error('Dynamic require of "' + x + '" is not supported'); +}); +var __commonJS = (cb, mod2) => function __require2() { + return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports; +}; +var __copyProps = (to, from2, except, desc) => { + if (from2 && typeof from2 === "object" || typeof from2 === "function") { + for (let key of __getOwnPropNames(from2)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __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 || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, + mod2 +)); + +// node_modules/tunnel/lib/tunnel.js +var require_tunnel = __commonJS({ + "node_modules/tunnel/lib/tunnel.js"(exports) { + "use strict"; + var net2 = __require("net"); + var tls = __require("tls"); + var http2 = __require("http"); + var https2 = __require("https"); + var events2 = __require("events"); + var assert = __require("assert"); + var util2 = __require("util"); + exports.httpOverHttp = httpOverHttp2; + exports.httpsOverHttp = httpsOverHttp2; + exports.httpOverHttps = httpOverHttps2; + exports.httpsOverHttps = httpsOverHttps2; + function httpOverHttp2(options) { + var agent = new TunnelingAgent(options); + agent.request = http2.request; + return agent; + } + function httpsOverHttp2(options) { + var agent = new TunnelingAgent(options); + agent.request = http2.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function httpOverHttps2(options) { + var agent = new TunnelingAgent(options); + agent.request = https2.request; + return agent; + } + function httpsOverHttps2(options) { + var agent = new TunnelingAgent(options); + agent.request = https2.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http2.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + self.on("free", function onFree(socket, host, port, localAddress) { + var options2 = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options2.host && pending.port === options2.port) { + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); + } + util2.inherits(TunnelingAgent, events2.EventEmitter); + TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({ request: req }, self.options, toOptions(host, port, localAddress)); + if (self.sockets.length >= this.maxSockets) { + self.requests.push(options); + return; + } + self.createSocket(options, function(socket) { + socket.on("free", onFree); + socket.on("close", onCloseOrRemove); + socket.on("agentRemove", onCloseOrRemove); + req.onSocket(socket); + function onFree() { + self.emit("free", socket, options); + } + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener("free", onFree); + socket.removeListener("close", onCloseOrRemove); + socket.removeListener("agentRemove", onCloseOrRemove); + } + }); + }; + TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: "CONNECT", + path: options.host + ":" + options.port, + agent: false, + headers: { + host: options.host + ":" + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); + } + debug2("making CONNECT request"); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; + connectReq.once("response", onResponse); + connectReq.once("upgrade", onUpgrade); + connectReq.once("connect", onConnect); + connectReq.once("error", onError); + connectReq.end(); + function onResponse(res) { + res.upgrade = true; + } + function onUpgrade(res, socket, head) { + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + if (res.statusCode !== 200) { + debug2( + "tunneling socket could not be established, statusCode=%d", + res.statusCode + ); + socket.destroy(); + var error2 = new Error("tunneling socket could not be established, statusCode=" + res.statusCode); + error2.code = "ECONNRESET"; + options.request.emit("error", error2); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug2("got illegal response body from proxy"); + socket.destroy(); + var error2 = new Error("got illegal response body from proxy"); + error2.code = "ECONNRESET"; + options.request.emit("error", error2); + self.removeSocket(placeholder); + return; + } + debug2("tunneling connection has established"); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + function onError(cause) { + connectReq.removeAllListeners(); + debug2( + "tunneling socket could not be established, cause=%s\n", + cause.message, + cause.stack + ); + var error2 = new Error("tunneling socket could not be established, cause=" + cause.message); + error2.code = "ECONNRESET"; + options.request.emit("error", error2); + self.removeSocket(placeholder); + } + }; + TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket); + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + var pending = this.requests.shift(); + if (pending) { + this.createSocket(pending, function(socket2) { + pending.request.onSocket(socket2); + }); + } + }; + function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader("host"); + var tlsOptions = mergeOptions({}, self.options, { + socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host + }); + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); + } + function toOptions(host, port, localAddress) { + if (typeof host === "string") { + return { + host, + port, + localAddress + }; + } + return host; + } + function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === "object") { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== void 0) { + target[k] = overrides[k]; + } + } + } + } + return target; + } + var debug2; + if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug2 = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === "string") { + args[0] = "TUNNEL: " + args[0]; + } else { + args.unshift("TUNNEL:"); + } + console.error.apply(console, args); + }; + } else { + debug2 = function() { + }; + } + exports.debug = debug2; + } +}); + +// node_modules/tunnel/index.js +var require_tunnel2 = __commonJS({ + "node_modules/tunnel/index.js"(exports, module) { + module.exports = require_tunnel(); + } +}); + +// node_modules/undici/lib/core/symbols.js +var require_symbols = __commonJS({ + "node_modules/undici/lib/core/symbols.js"(exports, module) { + module.exports = { + kClose: /* @__PURE__ */ Symbol("close"), + kDestroy: /* @__PURE__ */ Symbol("destroy"), + kDispatch: /* @__PURE__ */ Symbol("dispatch"), + kUrl: /* @__PURE__ */ Symbol("url"), + kWriting: /* @__PURE__ */ Symbol("writing"), + kResuming: /* @__PURE__ */ Symbol("resuming"), + kQueue: /* @__PURE__ */ Symbol("queue"), + kConnect: /* @__PURE__ */ Symbol("connect"), + kConnecting: /* @__PURE__ */ Symbol("connecting"), + kKeepAliveDefaultTimeout: /* @__PURE__ */ Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: /* @__PURE__ */ Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: /* @__PURE__ */ Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: /* @__PURE__ */ Symbol("keep alive timeout"), + kKeepAlive: /* @__PURE__ */ Symbol("keep alive"), + kHeadersTimeout: /* @__PURE__ */ Symbol("headers timeout"), + kBodyTimeout: /* @__PURE__ */ Symbol("body timeout"), + kServerName: /* @__PURE__ */ Symbol("server name"), + kLocalAddress: /* @__PURE__ */ Symbol("local address"), + kHost: /* @__PURE__ */ Symbol("host"), + kNoRef: /* @__PURE__ */ Symbol("no ref"), + kBodyUsed: /* @__PURE__ */ Symbol("used"), + kBody: /* @__PURE__ */ Symbol("abstracted request body"), + kRunning: /* @__PURE__ */ Symbol("running"), + kBlocking: /* @__PURE__ */ Symbol("blocking"), + kPending: /* @__PURE__ */ Symbol("pending"), + kSize: /* @__PURE__ */ Symbol("size"), + kBusy: /* @__PURE__ */ Symbol("busy"), + kQueued: /* @__PURE__ */ Symbol("queued"), + kFree: /* @__PURE__ */ Symbol("free"), + kConnected: /* @__PURE__ */ Symbol("connected"), + kClosed: /* @__PURE__ */ Symbol("closed"), + kNeedDrain: /* @__PURE__ */ Symbol("need drain"), + kReset: /* @__PURE__ */ Symbol("reset"), + kDestroyed: /* @__PURE__ */ Symbol.for("nodejs.stream.destroyed"), + kResume: /* @__PURE__ */ Symbol("resume"), + kOnError: /* @__PURE__ */ Symbol("on error"), + kMaxHeadersSize: /* @__PURE__ */ Symbol("max headers size"), + kRunningIdx: /* @__PURE__ */ Symbol("running index"), + kPendingIdx: /* @__PURE__ */ Symbol("pending index"), + kError: /* @__PURE__ */ Symbol("error"), + kClients: /* @__PURE__ */ Symbol("clients"), + kClient: /* @__PURE__ */ Symbol("client"), + kParser: /* @__PURE__ */ Symbol("parser"), + kOnDestroyed: /* @__PURE__ */ Symbol("destroy callbacks"), + kPipelining: /* @__PURE__ */ Symbol("pipelining"), + kSocket: /* @__PURE__ */ Symbol("socket"), + kHostHeader: /* @__PURE__ */ Symbol("host header"), + kConnector: /* @__PURE__ */ Symbol("connector"), + kStrictContentLength: /* @__PURE__ */ Symbol("strict content length"), + kMaxRedirections: /* @__PURE__ */ Symbol("maxRedirections"), + kMaxRequests: /* @__PURE__ */ Symbol("maxRequestsPerClient"), + kProxy: /* @__PURE__ */ Symbol("proxy agent options"), + kCounter: /* @__PURE__ */ Symbol("socket request counter"), + kInterceptors: /* @__PURE__ */ Symbol("dispatch interceptors"), + kMaxResponseSize: /* @__PURE__ */ Symbol("max response size"), + kHTTP2Session: /* @__PURE__ */ Symbol("http2Session"), + kHTTP2SessionState: /* @__PURE__ */ Symbol("http2Session state"), + kRetryHandlerDefaultRetry: /* @__PURE__ */ Symbol("retry agent default retry"), + kConstruct: /* @__PURE__ */ Symbol("constructable"), + kListeners: /* @__PURE__ */ Symbol("listeners"), + kHTTPContext: /* @__PURE__ */ Symbol("http context"), + kMaxConcurrentStreams: /* @__PURE__ */ Symbol("max concurrent streams"), + kNoProxyAgent: /* @__PURE__ */ Symbol("no proxy agent"), + kHttpProxyAgent: /* @__PURE__ */ Symbol("http proxy agent"), + kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent") + }; + } +}); + +// node_modules/undici/lib/core/errors.js +var require_errors = __commonJS({ + "node_modules/undici/lib/core/errors.js"(exports, module) { + "use strict"; + var kUndiciError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR"); + var UndiciError = class extends Error { + constructor(message) { + super(message); + this.name = "UndiciError"; + this.code = "UND_ERR"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kUndiciError] === true; + } + [kUndiciError] = true; + }; + var kConnectTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT"); + var ConnectTimeoutError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ConnectTimeoutError"; + this.message = message || "Connect Timeout Error"; + this.code = "UND_ERR_CONNECT_TIMEOUT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kConnectTimeoutError] === true; + } + [kConnectTimeoutError] = true; + }; + var kHeadersTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT"); + var HeadersTimeoutError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "HeadersTimeoutError"; + this.message = message || "Headers Timeout Error"; + this.code = "UND_ERR_HEADERS_TIMEOUT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kHeadersTimeoutError] === true; + } + [kHeadersTimeoutError] = true; + }; + var kHeadersOverflowError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW"); + var HeadersOverflowError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "HeadersOverflowError"; + this.message = message || "Headers Overflow Error"; + this.code = "UND_ERR_HEADERS_OVERFLOW"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kHeadersOverflowError] === true; + } + [kHeadersOverflowError] = true; + }; + var kBodyTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT"); + var BodyTimeoutError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "BodyTimeoutError"; + this.message = message || "Body Timeout Error"; + this.code = "UND_ERR_BODY_TIMEOUT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kBodyTimeoutError] === true; + } + [kBodyTimeoutError] = true; + }; + var kResponseStatusCodeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE"); + var ResponseStatusCodeError = class extends UndiciError { + constructor(message, statusCode, headers2, body) { + super(message); + this.name = "ResponseStatusCodeError"; + this.message = message || "Response Status Code Error"; + this.code = "UND_ERR_RESPONSE_STATUS_CODE"; + this.body = body; + this.status = statusCode; + this.statusCode = statusCode; + this.headers = headers2; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseStatusCodeError] === true; + } + [kResponseStatusCodeError] = true; + }; + var kInvalidArgumentError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_ARG"); + var InvalidArgumentError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "InvalidArgumentError"; + this.message = message || "Invalid Argument Error"; + this.code = "UND_ERR_INVALID_ARG"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kInvalidArgumentError] === true; + } + [kInvalidArgumentError] = true; + }; + var kInvalidReturnValueError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE"); + var InvalidReturnValueError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "InvalidReturnValueError"; + this.message = message || "Invalid Return Value Error"; + this.code = "UND_ERR_INVALID_RETURN_VALUE"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kInvalidReturnValueError] === true; + } + [kInvalidReturnValueError] = true; + }; + var kAbortError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORT"); + var AbortError2 = class extends UndiciError { + constructor(message) { + super(message); + this.name = "AbortError"; + this.message = message || "The operation was aborted"; + this.code = "UND_ERR_ABORT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kAbortError] === true; + } + [kAbortError] = true; + }; + var kRequestAbortedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORTED"); + var RequestAbortedError = class extends AbortError2 { + constructor(message) { + super(message); + this.name = "AbortError"; + this.message = message || "Request aborted"; + this.code = "UND_ERR_ABORTED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kRequestAbortedError] === true; + } + [kRequestAbortedError] = true; + }; + var kInformationalError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INFO"); + var InformationalError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "InformationalError"; + this.message = message || "Request information"; + this.code = "UND_ERR_INFO"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kInformationalError] === true; + } + [kInformationalError] = true; + }; + var kRequestContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"); + var RequestContentLengthMismatchError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "RequestContentLengthMismatchError"; + this.message = message || "Request body length does not match content-length header"; + this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kRequestContentLengthMismatchError] === true; + } + [kRequestContentLengthMismatchError] = true; + }; + var kResponseContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH"); + var ResponseContentLengthMismatchError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ResponseContentLengthMismatchError"; + this.message = message || "Response body length does not match content-length header"; + this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseContentLengthMismatchError] === true; + } + [kResponseContentLengthMismatchError] = true; + }; + var kClientDestroyedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_DESTROYED"); + var ClientDestroyedError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ClientDestroyedError"; + this.message = message || "The client is destroyed"; + this.code = "UND_ERR_DESTROYED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kClientDestroyedError] === true; + } + [kClientDestroyedError] = true; + }; + var kClientClosedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CLOSED"); + var ClientClosedError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ClientClosedError"; + this.message = message || "The client is closed"; + this.code = "UND_ERR_CLOSED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kClientClosedError] === true; + } + [kClientClosedError] = true; + }; + var kSocketError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_SOCKET"); + var SocketError = class extends UndiciError { + constructor(message, socket) { + super(message); + this.name = "SocketError"; + this.message = message || "Socket error"; + this.code = "UND_ERR_SOCKET"; + this.socket = socket; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kSocketError] === true; + } + [kSocketError] = true; + }; + var kNotSupportedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED"); + var NotSupportedError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "NotSupportedError"; + this.message = message || "Not supported error"; + this.code = "UND_ERR_NOT_SUPPORTED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kNotSupportedError] === true; + } + [kNotSupportedError] = true; + }; + var kBalancedPoolMissingUpstreamError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM"); + var BalancedPoolMissingUpstreamError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "MissingUpstreamError"; + this.message = message || "No upstream has been added to the BalancedPool"; + this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kBalancedPoolMissingUpstreamError] === true; + } + [kBalancedPoolMissingUpstreamError] = true; + }; + var kHTTPParserError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HTTP_PARSER"); + var HTTPParserError = class extends Error { + constructor(message, code, data) { + super(message); + this.name = "HTTPParserError"; + this.code = code ? `HPE_${code}` : void 0; + this.data = data ? data.toString() : void 0; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kHTTPParserError] === true; + } + [kHTTPParserError] = true; + }; + var kResponseExceededMaxSizeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE"); + var ResponseExceededMaxSizeError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ResponseExceededMaxSizeError"; + this.message = message || "Response content exceeded max size"; + this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseExceededMaxSizeError] === true; + } + [kResponseExceededMaxSizeError] = true; + }; + var kRequestRetryError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_RETRY"); + var RequestRetryError = class extends UndiciError { + constructor(message, code, { headers: headers2, data }) { + super(message); + this.name = "RequestRetryError"; + this.message = message || "Request retry error"; + this.code = "UND_ERR_REQ_RETRY"; + this.statusCode = code; + this.data = data; + this.headers = headers2; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kRequestRetryError] === true; + } + [kRequestRetryError] = true; + }; + var kResponseError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE"); + var ResponseError = class extends UndiciError { + constructor(message, code, { headers: headers2, data }) { + super(message); + this.name = "ResponseError"; + this.message = message || "Response error"; + this.code = "UND_ERR_RESPONSE"; + this.statusCode = code; + this.data = data; + this.headers = headers2; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseError] === true; + } + [kResponseError] = true; + }; + var kSecureProxyConnectionError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_PRX_TLS"); + var SecureProxyConnectionError = class extends UndiciError { + constructor(cause, message, options) { + super(message, { cause, ...options ?? {} }); + this.name = "SecureProxyConnectionError"; + this.message = message || "Secure Proxy Connection failed"; + this.code = "UND_ERR_PRX_TLS"; + this.cause = cause; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kSecureProxyConnectionError] === true; + } + [kSecureProxyConnectionError] = true; + }; + var kMessageSizeExceededError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"); + var MessageSizeExceededError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "MessageSizeExceededError"; + this.message = message || "Max decompressed message size exceeded"; + this.code = "UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kMessageSizeExceededError] === true; + } + get [kMessageSizeExceededError]() { + return true; + } + }; + module.exports = { + AbortError: AbortError2, + HTTPParserError, + UndiciError, + HeadersTimeoutError, + HeadersOverflowError, + BodyTimeoutError, + RequestContentLengthMismatchError, + ConnectTimeoutError, + ResponseStatusCodeError, + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError, + ClientDestroyedError, + ClientClosedError, + InformationalError, + SocketError, + NotSupportedError, + ResponseContentLengthMismatchError, + BalancedPoolMissingUpstreamError, + ResponseExceededMaxSizeError, + RequestRetryError, + ResponseError, + SecureProxyConnectionError, + MessageSizeExceededError + }; + } +}); + +// node_modules/undici/lib/core/constants.js +var require_constants = __commonJS({ + "node_modules/undici/lib/core/constants.js"(exports, module) { + "use strict"; + var headerNameLowerCasedRecord = {}; + var wellknownHeaderNames = [ + "Accept", + "Accept-Encoding", + "Accept-Language", + "Accept-Ranges", + "Access-Control-Allow-Credentials", + "Access-Control-Allow-Headers", + "Access-Control-Allow-Methods", + "Access-Control-Allow-Origin", + "Access-Control-Expose-Headers", + "Access-Control-Max-Age", + "Access-Control-Request-Headers", + "Access-Control-Request-Method", + "Age", + "Allow", + "Alt-Svc", + "Alt-Used", + "Authorization", + "Cache-Control", + "Clear-Site-Data", + "Connection", + "Content-Disposition", + "Content-Encoding", + "Content-Language", + "Content-Length", + "Content-Location", + "Content-Range", + "Content-Security-Policy", + "Content-Security-Policy-Report-Only", + "Content-Type", + "Cookie", + "Cross-Origin-Embedder-Policy", + "Cross-Origin-Opener-Policy", + "Cross-Origin-Resource-Policy", + "Date", + "Device-Memory", + "Downlink", + "ECT", + "ETag", + "Expect", + "Expect-CT", + "Expires", + "Forwarded", + "From", + "Host", + "If-Match", + "If-Modified-Since", + "If-None-Match", + "If-Range", + "If-Unmodified-Since", + "Keep-Alive", + "Last-Modified", + "Link", + "Location", + "Max-Forwards", + "Origin", + "Permissions-Policy", + "Pragma", + "Proxy-Authenticate", + "Proxy-Authorization", + "RTT", + "Range", + "Referer", + "Referrer-Policy", + "Refresh", + "Retry-After", + "Sec-WebSocket-Accept", + "Sec-WebSocket-Extensions", + "Sec-WebSocket-Key", + "Sec-WebSocket-Protocol", + "Sec-WebSocket-Version", + "Server", + "Server-Timing", + "Service-Worker-Allowed", + "Service-Worker-Navigation-Preload", + "Set-Cookie", + "SourceMap", + "Strict-Transport-Security", + "Supports-Loading-Mode", + "TE", + "Timing-Allow-Origin", + "Trailer", + "Transfer-Encoding", + "Upgrade", + "Upgrade-Insecure-Requests", + "User-Agent", + "Vary", + "Via", + "WWW-Authenticate", + "X-Content-Type-Options", + "X-DNS-Prefetch-Control", + "X-Frame-Options", + "X-Permitted-Cross-Domain-Policies", + "X-Powered-By", + "X-Requested-With", + "X-XSS-Protection" + ]; + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i]; + const lowerCasedKey = key.toLowerCase(); + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; + } + Object.setPrototypeOf(headerNameLowerCasedRecord, null); + module.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord + }; + } +}); + +// node_modules/undici/lib/core/tree.js +var require_tree = __commonJS({ + "node_modules/undici/lib/core/tree.js"(exports, module) { + "use strict"; + var { + wellknownHeaderNames, + headerNameLowerCasedRecord + } = require_constants(); + var TstNode = class _TstNode { + /** @type {any} */ + value = null; + /** @type {null | TstNode} */ + left = null; + /** @type {null | TstNode} */ + middle = null; + /** @type {null | TstNode} */ + right = null; + /** @type {number} */ + code; + /** + * @param {string} key + * @param {any} value + * @param {number} index + */ + constructor(key, value, index2) { + if (index2 === void 0 || index2 >= key.length) { + throw new TypeError("Unreachable"); + } + const code = this.code = key.charCodeAt(index2); + if (code > 127) { + throw new TypeError("key must be ascii string"); + } + if (key.length !== ++index2) { + this.middle = new _TstNode(key, value, index2); + } else { + this.value = value; + } + } + /** + * @param {string} key + * @param {any} value + */ + add(key, value) { + const length = key.length; + if (length === 0) { + throw new TypeError("Unreachable"); + } + let index2 = 0; + let node = this; + while (true) { + const code = key.charCodeAt(index2); + if (code > 127) { + throw new TypeError("key must be ascii string"); + } + if (node.code === code) { + if (length === ++index2) { + node.value = value; + break; + } else if (node.middle !== null) { + node = node.middle; + } else { + node.middle = new _TstNode(key, value, index2); + break; + } + } else if (node.code < code) { + if (node.left !== null) { + node = node.left; + } else { + node.left = new _TstNode(key, value, index2); + break; + } + } else if (node.right !== null) { + node = node.right; + } else { + node.right = new _TstNode(key, value, index2); + break; + } + } + } + /** + * @param {Uint8Array} key + * @return {TstNode | null} + */ + search(key) { + const keylength = key.length; + let index2 = 0; + let node = this; + while (node !== null && index2 < keylength) { + let code = key[index2]; + if (code <= 90 && code >= 65) { + code |= 32; + } + while (node !== null) { + if (code === node.code) { + if (keylength === ++index2) { + return node; + } + node = node.middle; + break; + } + node = node.code < code ? node.left : node.right; + } + } + return null; + } + }; + var TernarySearchTree = class { + /** @type {TstNode | null} */ + node = null; + /** + * @param {string} key + * @param {any} value + * */ + insert(key, value) { + if (this.node === null) { + this.node = new TstNode(key, value, 0); + } else { + this.node.add(key, value); + } + } + /** + * @param {Uint8Array} key + * @return {any} + */ + lookup(key) { + return this.node?.search(key)?.value ?? null; + } + }; + var tree = new TernarySearchTree(); + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]; + tree.insert(key, key); + } + module.exports = { + TernarySearchTree, + tree + }; + } +}); + +// node_modules/undici/lib/core/util.js +var require_util = __commonJS({ + "node_modules/undici/lib/core/util.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols(); + var { IncomingMessage } = __require("node:http"); + var stream = __require("node:stream"); + var net2 = __require("node:net"); + var { Blob: Blob2 } = __require("node:buffer"); + var nodeUtil = __require("node:util"); + var { stringify: stringify2 } = __require("node:querystring"); + var { EventEmitter: EE } = __require("node:events"); + var { InvalidArgumentError } = require_errors(); + var { headerNameLowerCasedRecord } = require_constants(); + var { tree } = require_tree(); + var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + function wrapRequestBody(body) { + if (isStream(body)) { + if (bodyLength(body) === 0) { + body.on("data", function() { + assert(false); + }); + } + if (typeof body.readableDidRead !== "boolean") { + body[kBodyUsed] = false; + EE.prototype.on.call(body, "data", function() { + this[kBodyUsed] = true; + }); + } + return body; + } else if (body && typeof body.pipeTo === "function") { + return new BodyAsyncIterable(body); + } else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) { + return new BodyAsyncIterable(body); + } else { + return body; + } + } + function nop() { + } + function isStream(obj) { + return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; + } + function isBlobLike(object) { + if (object === null) { + return false; + } else if (object instanceof Blob2) { + return true; + } else if (typeof object !== "object") { + return false; + } else { + const sTag = object[Symbol.toStringTag]; + return (sTag === "Blob" || sTag === "File") && ("stream" in object && typeof object.stream === "function" || "arrayBuffer" in object && typeof object.arrayBuffer === "function"); + } + } + function buildURL(url, queryParams) { + if (url.includes("?") || url.includes("#")) { + throw new Error('Query params cannot be passed when url already contains "?" or "#".'); + } + const stringified = stringify2(queryParams); + if (stringified) { + url += "?" + stringified; + } + return url; + } + function isValidPort(port) { + const value = parseInt(port, 10); + return value === Number(port) && value >= 0 && value <= 65535; + } + function isHttpOrHttpsPrefixed(value) { + return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":"); + } + function parseURL(url) { + if (typeof url === "string") { + url = new URL(url); + if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + return url; + } + if (!url || typeof url !== "object") { + throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object."); + } + if (!(url instanceof URL)) { + if (url.port != null && url.port !== "" && isValidPort(url.port) === false) { + throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer."); + } + if (url.path != null && typeof url.path !== "string") { + throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined."); + } + if (url.pathname != null && typeof url.pathname !== "string") { + throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined."); + } + if (url.hostname != null && typeof url.hostname !== "string") { + throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined."); + } + if (url.origin != null && typeof url.origin !== "string") { + throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined."); + } + if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; + let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`; + let path7 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + if (origin[origin.length - 1] === "/") { + origin = origin.slice(0, origin.length - 1); + } + if (path7 && path7[0] !== "/") { + path7 = `/${path7}`; + } + return new URL(`${origin}${path7}`); + } + if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + return url; + } + function parseOrigin(url) { + url = parseURL(url); + if (url.pathname !== "/" || url.search || url.hash) { + throw new InvalidArgumentError("invalid url"); + } + return url; + } + function getHostname(host) { + if (host[0] === "[") { + const idx2 = host.indexOf("]"); + assert(idx2 !== -1); + return host.substring(1, idx2); + } + const idx = host.indexOf(":"); + if (idx === -1) return host; + return host.substring(0, idx); + } + function getServerName(host) { + if (!host) { + return null; + } + assert(typeof host === "string"); + const servername = getHostname(host); + if (net2.isIP(servername)) { + return ""; + } + return servername; + } + function deepClone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isAsyncIterable(obj) { + return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); + } + function isIterable(obj) { + return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); + } + function bodyLength(body) { + if (body == null) { + return 0; + } else if (isStream(body)) { + const state = body._readableState; + return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; + } else if (isBlobLike(body)) { + return body.size != null ? body.size : null; + } else if (isBuffer(body)) { + return body.byteLength; + } + return null; + } + function isDestroyed(body) { + return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body)); + } + function destroy(stream2, err) { + if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { + return; + } + if (typeof stream2.destroy === "function") { + if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) { + stream2.socket = null; + } + stream2.destroy(err); + } else if (err) { + queueMicrotask(() => { + stream2.emit("error", err); + }); + } + if (stream2.destroyed !== true) { + stream2[kDestroyed] = true; + } + } + var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; + function parseKeepAliveTimeout(val) { + const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); + return m ? parseInt(m[1], 10) * 1e3 : null; + } + function headerNameToString(value) { + return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase(); + } + function bufferToLowerCasedHeaderName(value) { + return tree.lookup(value) ?? value.toString("latin1").toLowerCase(); + } + function parseHeaders(headers2, obj) { + if (obj === void 0) obj = {}; + for (let i = 0; i < headers2.length; i += 2) { + const key = headerNameToString(headers2[i]); + let val = obj[key]; + if (val) { + if (typeof val === "string") { + val = [val]; + obj[key] = val; + } + val.push(headers2[i + 1].toString("utf8")); + } else { + const headersValue = headers2[i + 1]; + if (typeof headersValue === "string") { + obj[key] = headersValue; + } else { + obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8"); + } + } + } + if ("content-length" in obj && "content-disposition" in obj) { + obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); + } + return obj; + } + function parseRawHeaders(headers2) { + const len = headers2.length; + const ret = new Array(len); + let hasContentLength = false; + let contentDispositionIdx = -1; + let key; + let val; + let kLen = 0; + for (let n = 0; n < headers2.length; n += 2) { + key = headers2[n]; + val = headers2[n + 1]; + typeof key !== "string" && (key = key.toString()); + typeof val !== "string" && (val = val.toString("utf8")); + kLen = key.length; + if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) { + hasContentLength = true; + } else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) { + contentDispositionIdx = n + 1; + } + ret[n] = key; + ret[n + 1] = val; + } + if (hasContentLength && contentDispositionIdx !== -1) { + ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); + } + return ret; + } + function isBuffer(buffer) { + return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); + } + function validateHandler(handler, method, upgrade) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + if (typeof handler.onConnect !== "function") { + throw new InvalidArgumentError("invalid onConnect method"); + } + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) { + throw new InvalidArgumentError("invalid onBodySent method"); + } + if (upgrade || method === "CONNECT") { + if (typeof handler.onUpgrade !== "function") { + throw new InvalidArgumentError("invalid onUpgrade method"); + } + } else { + if (typeof handler.onHeaders !== "function") { + throw new InvalidArgumentError("invalid onHeaders method"); + } + if (typeof handler.onData !== "function") { + throw new InvalidArgumentError("invalid onData method"); + } + if (typeof handler.onComplete !== "function") { + throw new InvalidArgumentError("invalid onComplete method"); + } + } + } + function isDisturbed(body) { + return !!(body && (stream.isDisturbed(body) || body[kBodyUsed])); + } + function isErrored(body) { + return !!(body && stream.isErrored(body)); + } + function isReadable(body) { + return !!(body && stream.isReadable(body)); + } + function getSocketInfo(socket) { + return { + localAddress: socket.localAddress, + localPort: socket.localPort, + remoteAddress: socket.remoteAddress, + remotePort: socket.remotePort, + remoteFamily: socket.remoteFamily, + timeout: socket.timeout, + bytesWritten: socket.bytesWritten, + bytesRead: socket.bytesRead + }; + } + function ReadableStreamFrom(iterable) { + let iterator; + return new ReadableStream( + { + async start() { + iterator = iterable[Symbol.asyncIterator](); + }, + async pull(controller) { + const { done, value } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + controller.byobRequest?.respond(0); + }); + } else { + const buf2 = Buffer.isBuffer(value) ? value : Buffer.from(value); + if (buf2.byteLength) { + controller.enqueue(new Uint8Array(buf2)); + } + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: "bytes" + } + ); + } + function isFormDataLike(object) { + return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; + } + function addAbortListener(signal3, listener) { + if ("addEventListener" in signal3) { + signal3.addEventListener("abort", listener, { once: true }); + return () => signal3.removeEventListener("abort", listener); + } + signal3.addListener("abort", listener); + return () => signal3.removeListener("abort", listener); + } + var hasToWellFormed = typeof String.prototype.toWellFormed === "function"; + var hasIsWellFormed = typeof String.prototype.isWellFormed === "function"; + function toUSVString(val) { + return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val); + } + function isUSVString(val) { + return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`; + } + function isTokenCharCode(c) { + switch (c) { + case 34: + case 40: + case 41: + case 44: + case 47: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 91: + case 92: + case 93: + case 123: + case 125: + return false; + default: + return c >= 33 && c <= 126; + } + } + function isValidHTTPToken(characters) { + if (characters.length === 0) { + return false; + } + for (let i = 0; i < characters.length; ++i) { + if (!isTokenCharCode(characters.charCodeAt(i))) { + return false; + } + } + return true; + } + var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; + function isValidHeaderValue(characters) { + return !headerCharRegex.test(characters); + } + function parseRangeHeader(range) { + if (range == null || range === "") return { start: 0, end: null, size: null }; + const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; + return m ? { + start: parseInt(m[1]), + end: m[2] ? parseInt(m[2]) : null, + size: m[3] ? parseInt(m[3]) : null + } : null; + } + function addListener(obj, name, listener) { + const listeners = obj[kListeners] ??= []; + listeners.push([name, listener]); + obj.on(name, listener); + return obj; + } + function removeAllListeners(obj) { + for (const [name, listener] of obj[kListeners] ?? []) { + obj.removeListener(name, listener); + } + obj[kListeners] = null; + } + function errorRequest(client, request, err) { + try { + request.onError(err); + assert(request.aborted); + } catch (err2) { + client.emit("error", err2); + } + } + var kEnumerableProperty = /* @__PURE__ */ Object.create(null); + kEnumerableProperty.enumerable = true; + var normalizedMethodRecordsBase = { + delete: "DELETE", + DELETE: "DELETE", + get: "GET", + GET: "GET", + head: "HEAD", + HEAD: "HEAD", + options: "OPTIONS", + OPTIONS: "OPTIONS", + post: "POST", + POST: "POST", + put: "PUT", + PUT: "PUT" + }; + var normalizedMethodRecords = { + ...normalizedMethodRecordsBase, + patch: "patch", + PATCH: "PATCH" + }; + Object.setPrototypeOf(normalizedMethodRecordsBase, null); + Object.setPrototypeOf(normalizedMethodRecords, null); + module.exports = { + kEnumerableProperty, + nop, + isDisturbed, + isErrored, + isReadable, + toUSVString, + isUSVString, + isBlobLike, + parseOrigin, + parseURL, + getServerName, + isStream, + isIterable, + isAsyncIterable, + isDestroyed, + headerNameToString, + bufferToLowerCasedHeaderName, + addListener, + removeAllListeners, + errorRequest, + parseRawHeaders, + parseHeaders, + parseKeepAliveTimeout, + destroy, + bodyLength, + deepClone, + ReadableStreamFrom, + isBuffer, + validateHandler, + getSocketInfo, + isFormDataLike, + buildURL, + addAbortListener, + isValidHTTPToken, + isValidHeaderValue, + isTokenCharCode, + parseRangeHeader, + normalizedMethodRecordsBase, + normalizedMethodRecords, + isValidPort, + isHttpOrHttpsPrefixed, + nodeMajor, + nodeMinor, + safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"], + wrapRequestBody + }; + } +}); + +// node_modules/undici/lib/core/diagnostics.js +var require_diagnostics = __commonJS({ + "node_modules/undici/lib/core/diagnostics.js"(exports, module) { + "use strict"; + var diagnosticsChannel = __require("node:diagnostics_channel"); + var util2 = __require("node:util"); + var undiciDebugLog = util2.debuglog("undici"); + var fetchDebuglog = util2.debuglog("fetch"); + var websocketDebuglog = util2.debuglog("websocket"); + var isClientSet = false; + var channels = { + // Client + beforeConnect: diagnosticsChannel.channel("undici:client:beforeConnect"), + connected: diagnosticsChannel.channel("undici:client:connected"), + connectError: diagnosticsChannel.channel("undici:client:connectError"), + sendHeaders: diagnosticsChannel.channel("undici:client:sendHeaders"), + // Request + create: diagnosticsChannel.channel("undici:request:create"), + bodySent: diagnosticsChannel.channel("undici:request:bodySent"), + headers: diagnosticsChannel.channel("undici:request:headers"), + trailers: diagnosticsChannel.channel("undici:request:trailers"), + error: diagnosticsChannel.channel("undici:request:error"), + // WebSocket + open: diagnosticsChannel.channel("undici:websocket:open"), + close: diagnosticsChannel.channel("undici:websocket:close"), + socketError: diagnosticsChannel.channel("undici:websocket:socket_error"), + ping: diagnosticsChannel.channel("undici:websocket:ping"), + pong: diagnosticsChannel.channel("undici:websocket:pong") + }; + if (undiciDebugLog.enabled || fetchDebuglog.enabled) { + const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog; + diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => { + const { + connectParams: { version, protocol, port, host } + } = evt; + debuglog( + "connecting to %s using %s%s", + `${host}${port ? `:${port}` : ""}`, + protocol, + version + ); + }); + diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => { + const { + connectParams: { version, protocol, port, host } + } = evt; + debuglog( + "connected to %s using %s%s", + `${host}${port ? `:${port}` : ""}`, + protocol, + version + ); + }); + diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => { + const { + connectParams: { version, protocol, port, host }, + error: error2 + } = evt; + debuglog( + "connection to %s using %s%s errored - %s", + `${host}${port ? `:${port}` : ""}`, + protocol, + version, + error2.message + ); + }); + diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => { + const { + request: { method, path: path7, origin } + } = evt; + debuglog("sending request to %s %s/%s", method, origin, path7); + }); + diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => { + const { + request: { method, path: path7, origin }, + response: { statusCode } + } = evt; + debuglog( + "received response to %s %s/%s - HTTP %d", + method, + origin, + path7, + statusCode + ); + }); + diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => { + const { + request: { method, path: path7, origin } + } = evt; + debuglog("trailers received from %s %s/%s", method, origin, path7); + }); + diagnosticsChannel.channel("undici:request:error").subscribe((evt) => { + const { + request: { method, path: path7, origin }, + error: error2 + } = evt; + debuglog( + "request to %s %s/%s errored - %s", + method, + origin, + path7, + error2.message + ); + }); + isClientSet = true; + } + if (websocketDebuglog.enabled) { + if (!isClientSet) { + const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog; + diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => { + const { + connectParams: { version, protocol, port, host } + } = evt; + debuglog( + "connecting to %s%s using %s%s", + host, + port ? `:${port}` : "", + protocol, + version + ); + }); + diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => { + const { + connectParams: { version, protocol, port, host } + } = evt; + debuglog( + "connected to %s%s using %s%s", + host, + port ? `:${port}` : "", + protocol, + version + ); + }); + diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => { + const { + connectParams: { version, protocol, port, host }, + error: error2 + } = evt; + debuglog( + "connection to %s%s using %s%s errored - %s", + host, + port ? `:${port}` : "", + protocol, + version, + error2.message + ); + }); + diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => { + const { + request: { method, path: path7, origin } + } = evt; + debuglog("sending request to %s %s/%s", method, origin, path7); + }); + } + diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => { + const { + address: { address, port } + } = evt; + websocketDebuglog("connection opened %s%s", address, port ? `:${port}` : ""); + }); + diagnosticsChannel.channel("undici:websocket:close").subscribe((evt) => { + const { websocket, code, reason } = evt; + websocketDebuglog( + "closed connection to %s - %s %s", + websocket.url, + code, + reason + ); + }); + diagnosticsChannel.channel("undici:websocket:socket_error").subscribe((err) => { + websocketDebuglog("connection errored - %s", err.message); + }); + diagnosticsChannel.channel("undici:websocket:ping").subscribe((evt) => { + websocketDebuglog("ping received"); + }); + diagnosticsChannel.channel("undici:websocket:pong").subscribe((evt) => { + websocketDebuglog("pong received"); + }); + } + module.exports = { + channels + }; + } +}); + +// node_modules/undici/lib/core/request.js +var require_request = __commonJS({ + "node_modules/undici/lib/core/request.js"(exports, module) { + "use strict"; + var { + InvalidArgumentError, + NotSupportedError + } = require_errors(); + var assert = __require("node:assert"); + var { + isValidHTTPToken, + isValidHeaderValue, + isStream, + destroy, + isBuffer, + isFormDataLike, + isIterable, + isBlobLike, + buildURL, + validateHandler, + getServerName, + normalizedMethodRecords + } = require_util(); + var { channels } = require_diagnostics(); + var { headerNameLowerCasedRecord } = require_constants(); + var invalidPathRegex = /[^\u0021-\u00ff]/; + var kHandler = /* @__PURE__ */ Symbol("handler"); + var Request2 = class { + constructor(origin, { + path: path7, + method, + body, + headers: headers2, + query, + idempotent, + blocking, + upgrade, + headersTimeout, + bodyTimeout, + reset, + throwOnError, + expectContinue, + servername + }, handler) { + if (typeof path7 !== "string") { + throw new InvalidArgumentError("path must be a string"); + } else if (path7[0] !== "/" && !(path7.startsWith("http://") || path7.startsWith("https://")) && method !== "CONNECT") { + throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); + } else if (invalidPathRegex.test(path7)) { + throw new InvalidArgumentError("invalid request path"); + } + if (typeof method !== "string") { + throw new InvalidArgumentError("method must be a string"); + } else if (normalizedMethodRecords[method] === void 0 && !isValidHTTPToken(method)) { + throw new InvalidArgumentError("invalid request method"); + } + if (upgrade && typeof upgrade !== "string") { + throw new InvalidArgumentError("upgrade must be a string"); + } + if (upgrade && !isValidHeaderValue(upgrade)) { + throw new InvalidArgumentError("invalid upgrade header"); + } + if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("invalid headersTimeout"); + } + if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("invalid bodyTimeout"); + } + if (reset != null && typeof reset !== "boolean") { + throw new InvalidArgumentError("invalid reset"); + } + if (expectContinue != null && typeof expectContinue !== "boolean") { + throw new InvalidArgumentError("invalid expectContinue"); + } + this.headersTimeout = headersTimeout; + this.bodyTimeout = bodyTimeout; + this.throwOnError = throwOnError === true; + this.method = method; + this.abort = null; + if (body == null) { + this.body = null; + } else if (isStream(body)) { + this.body = body; + const rState = this.body._readableState; + if (!rState || !rState.autoDestroy) { + this.endHandler = function autoDestroy() { + destroy(this); + }; + this.body.on("end", this.endHandler); + } + this.errorHandler = (err) => { + if (this.abort) { + this.abort(err); + } else { + this.error = err; + } + }; + this.body.on("error", this.errorHandler); + } else if (isBuffer(body)) { + this.body = body.byteLength ? body : null; + } else if (ArrayBuffer.isView(body)) { + this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; + } else if (body instanceof ArrayBuffer) { + this.body = body.byteLength ? Buffer.from(body) : null; + } else if (typeof body === "string") { + this.body = body.length ? Buffer.from(body) : null; + } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) { + this.body = body; + } else { + throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); + } + this.completed = false; + this.aborted = false; + this.upgrade = upgrade || null; + this.path = query ? buildURL(path7, query) : path7; + this.origin = origin; + this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; + this.blocking = blocking == null ? false : blocking; + this.reset = reset == null ? null : reset; + this.host = null; + this.contentLength = null; + this.contentType = null; + this.headers = []; + this.expectContinue = expectContinue != null ? expectContinue : false; + if (Array.isArray(headers2)) { + if (headers2.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers2.length; i += 2) { + processHeader(this, headers2[i], headers2[i + 1]); + } + } else if (headers2 && typeof headers2 === "object") { + if (headers2[Symbol.iterator]) { + for (const header of headers2) { + if (!Array.isArray(header) || header.length !== 2) { + throw new InvalidArgumentError("headers must be in key-value pair format"); + } + processHeader(this, header[0], header[1]); + } + } else { + const keys = Object.keys(headers2); + for (let i = 0; i < keys.length; ++i) { + processHeader(this, keys[i], headers2[keys[i]]); + } + } + } else if (headers2 != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + validateHandler(handler, method, upgrade); + this.servername = servername || getServerName(this.host); + this[kHandler] = handler; + if (channels.create.hasSubscribers) { + channels.create.publish({ request: this }); + } + } + onBodySent(chunk) { + if (this[kHandler].onBodySent) { + try { + return this[kHandler].onBodySent(chunk); + } catch (err) { + this.abort(err); + } + } + } + onRequestSent() { + if (channels.bodySent.hasSubscribers) { + channels.bodySent.publish({ request: this }); + } + if (this[kHandler].onRequestSent) { + try { + return this[kHandler].onRequestSent(); + } catch (err) { + this.abort(err); + } + } + } + onConnect(abort) { + assert(!this.aborted); + assert(!this.completed); + if (this.error) { + abort(this.error); + } else { + this.abort = abort; + return this[kHandler].onConnect(abort); + } + } + onResponseStarted() { + return this[kHandler].onResponseStarted?.(); + } + onHeaders(statusCode, headers2, resume, statusText) { + assert(!this.aborted); + assert(!this.completed); + if (channels.headers.hasSubscribers) { + channels.headers.publish({ request: this, response: { statusCode, headers: headers2, statusText } }); + } + try { + return this[kHandler].onHeaders(statusCode, headers2, resume, statusText); + } catch (err) { + this.abort(err); + } + } + onData(chunk) { + assert(!this.aborted); + assert(!this.completed); + try { + return this[kHandler].onData(chunk); + } catch (err) { + this.abort(err); + return false; + } + } + onUpgrade(statusCode, headers2, socket) { + assert(!this.aborted); + assert(!this.completed); + return this[kHandler].onUpgrade(statusCode, headers2, socket); + } + onComplete(trailers) { + this.onFinally(); + assert(!this.aborted); + this.completed = true; + if (channels.trailers.hasSubscribers) { + channels.trailers.publish({ request: this, trailers }); + } + try { + return this[kHandler].onComplete(trailers); + } catch (err) { + this.onError(err); + } + } + onError(error2) { + this.onFinally(); + if (channels.error.hasSubscribers) { + channels.error.publish({ request: this, error: error2 }); + } + if (this.aborted) { + return; + } + this.aborted = true; + return this[kHandler].onError(error2); + } + onFinally() { + if (this.errorHandler) { + this.body.off("error", this.errorHandler); + this.errorHandler = null; + } + if (this.endHandler) { + this.body.off("end", this.endHandler); + this.endHandler = null; + } + } + addHeader(key, value) { + processHeader(this, key, value); + return this; + } + }; + function processHeader(request, key, val) { + if (val && (typeof val === "object" && !Array.isArray(val))) { + throw new InvalidArgumentError(`invalid ${key} header`); + } else if (val === void 0) { + return; + } + let headerName = headerNameLowerCasedRecord[key]; + if (headerName === void 0) { + headerName = key.toLowerCase(); + if (headerNameLowerCasedRecord[headerName] === void 0 && !isValidHTTPToken(headerName)) { + throw new InvalidArgumentError("invalid header key"); + } + } + if (Array.isArray(val)) { + const arr = []; + for (let i = 0; i < val.length; i++) { + if (typeof val[i] === "string") { + if (!isValidHeaderValue(val[i])) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + arr.push(val[i]); + } else if (val[i] === null) { + arr.push(""); + } else if (typeof val[i] === "object") { + throw new InvalidArgumentError(`invalid ${key} header`); + } else { + arr.push(`${val[i]}`); + } + } + val = arr; + } else if (typeof val === "string") { + if (!isValidHeaderValue(val)) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + } else if (val === null) { + val = ""; + } else { + val = `${val}`; + } + if (headerName === "host") { + if (request.host !== null) { + throw new InvalidArgumentError("duplicate host header"); + } + if (typeof val !== "string") { + throw new InvalidArgumentError("invalid host header"); + } + request.host = val; + } else if (headerName === "content-length") { + if (request.contentLength !== null) { + throw new InvalidArgumentError("duplicate content-length header"); + } + request.contentLength = parseInt(val, 10); + if (!Number.isFinite(request.contentLength)) { + throw new InvalidArgumentError("invalid content-length header"); + } + } else if (request.contentType === null && headerName === "content-type") { + request.contentType = val; + request.headers.push(key, val); + } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") { + throw new InvalidArgumentError(`invalid ${headerName} header`); + } else if (headerName === "connection") { + const value = typeof val === "string" ? val.toLowerCase() : null; + if (value !== "close" && value !== "keep-alive") { + throw new InvalidArgumentError("invalid connection header"); + } + if (value === "close") { + request.reset = true; + } + } else if (headerName === "expect") { + throw new NotSupportedError("expect header not supported"); + } else { + request.headers.push(key, val); + } + } + module.exports = Request2; + } +}); + +// node_modules/undici/lib/dispatcher/dispatcher.js +var require_dispatcher = __commonJS({ + "node_modules/undici/lib/dispatcher/dispatcher.js"(exports, module) { + "use strict"; + var EventEmitter2 = __require("node:events"); + var Dispatcher = class extends EventEmitter2 { + dispatch() { + throw new Error("not implemented"); + } + close() { + throw new Error("not implemented"); + } + destroy() { + throw new Error("not implemented"); + } + compose(...args) { + const interceptors = Array.isArray(args[0]) ? args[0] : args; + let dispatch = this.dispatch.bind(this); + for (const interceptor of interceptors) { + if (interceptor == null) { + continue; + } + if (typeof interceptor !== "function") { + throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`); + } + dispatch = interceptor(dispatch); + if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) { + throw new TypeError("invalid interceptor"); + } + } + return new ComposedDispatcher(this, dispatch); + } + }; + var ComposedDispatcher = class extends Dispatcher { + #dispatcher = null; + #dispatch = null; + constructor(dispatcher, dispatch) { + super(); + this.#dispatcher = dispatcher; + this.#dispatch = dispatch; + } + dispatch(...args) { + this.#dispatch(...args); + } + close(...args) { + return this.#dispatcher.close(...args); + } + destroy(...args) { + return this.#dispatcher.destroy(...args); + } + }; + module.exports = Dispatcher; + } +}); + +// node_modules/undici/lib/dispatcher/dispatcher-base.js +var require_dispatcher_base = __commonJS({ + "node_modules/undici/lib/dispatcher/dispatcher-base.js"(exports, module) { + "use strict"; + var Dispatcher = require_dispatcher(); + var { + ClientDestroyedError, + ClientClosedError, + InvalidArgumentError + } = require_errors(); + var { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = require_symbols(); + var kOnDestroyed = /* @__PURE__ */ Symbol("onDestroyed"); + var kOnClosed = /* @__PURE__ */ Symbol("onClosed"); + var kInterceptedDispatch = /* @__PURE__ */ Symbol("Intercepted Dispatch"); + var DispatcherBase = class extends Dispatcher { + constructor() { + super(); + this[kDestroyed] = false; + this[kOnDestroyed] = null; + this[kClosed] = false; + this[kOnClosed] = []; + } + get destroyed() { + return this[kDestroyed]; + } + get closed() { + return this[kClosed]; + } + get interceptors() { + return this[kInterceptors]; + } + set interceptors(newInterceptors) { + if (newInterceptors) { + for (let i = newInterceptors.length - 1; i >= 0; i--) { + const interceptor = this[kInterceptors][i]; + if (typeof interceptor !== "function") { + throw new InvalidArgumentError("interceptor must be an function"); + } + } + } + this[kInterceptors] = newInterceptors; + } + close(callback) { + if (callback === void 0) { + return new Promise((resolve2, reject) => { + this.close((err, data) => { + return err ? reject(err) : resolve2(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + queueMicrotask(() => callback(new ClientDestroyedError(), null)); + return; + } + if (this[kClosed]) { + if (this[kOnClosed]) { + this[kOnClosed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + this[kClosed] = true; + this[kOnClosed].push(callback); + const onClosed = () => { + const callbacks = this[kOnClosed]; + this[kOnClosed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kClose]().then(() => this.destroy()).then(() => { + queueMicrotask(onClosed); + }); + } + destroy(err, callback) { + if (typeof err === "function") { + callback = err; + err = null; + } + if (callback === void 0) { + return new Promise((resolve2, reject) => { + this.destroy(err, (err2, data) => { + return err2 ? ( + /* istanbul ignore next: should never error */ + reject(err2) + ) : resolve2(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + if (this[kOnDestroyed]) { + this[kOnDestroyed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + if (!err) { + err = new ClientDestroyedError(); + } + this[kDestroyed] = true; + this[kOnDestroyed] = this[kOnDestroyed] || []; + this[kOnDestroyed].push(callback); + const onDestroyed = () => { + const callbacks = this[kOnDestroyed]; + this[kOnDestroyed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kDestroy](err).then(() => { + queueMicrotask(onDestroyed); + }); + } + [kInterceptedDispatch](opts, handler) { + if (!this[kInterceptors] || this[kInterceptors].length === 0) { + this[kInterceptedDispatch] = this[kDispatch]; + return this[kDispatch](opts, handler); + } + let dispatch = this[kDispatch].bind(this); + for (let i = this[kInterceptors].length - 1; i >= 0; i--) { + dispatch = this[kInterceptors][i](dispatch); + } + this[kInterceptedDispatch] = dispatch; + return dispatch(opts, handler); + } + dispatch(opts, handler) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + try { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object."); + } + if (this[kDestroyed] || this[kOnDestroyed]) { + throw new ClientDestroyedError(); + } + if (this[kClosed]) { + throw new ClientClosedError(); + } + return this[kInterceptedDispatch](opts, handler); + } catch (err) { + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + handler.onError(err); + return false; + } + } + }; + module.exports = DispatcherBase; + } +}); + +// node_modules/undici/lib/util/timers.js +var require_timers = __commonJS({ + "node_modules/undici/lib/util/timers.js"(exports, module) { + "use strict"; + var fastNow = 0; + var RESOLUTION_MS = 1e3; + var TICK_MS = (RESOLUTION_MS >> 1) - 1; + var fastNowTimeout; + var kFastTimer = /* @__PURE__ */ Symbol("kFastTimer"); + var fastTimers = []; + var NOT_IN_LIST = -2; + var TO_BE_CLEARED = -1; + var PENDING = 0; + var ACTIVE = 1; + function onTick() { + fastNow += TICK_MS; + let idx = 0; + let len = fastTimers.length; + while (idx < len) { + const timer = fastTimers[idx]; + if (timer._state === PENDING) { + timer._idleStart = fastNow - TICK_MS; + timer._state = ACTIVE; + } else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout) { + timer._state = TO_BE_CLEARED; + timer._idleStart = -1; + timer._onTimeout(timer._timerArg); + } + if (timer._state === TO_BE_CLEARED) { + timer._state = NOT_IN_LIST; + if (--len !== 0) { + fastTimers[idx] = fastTimers[len]; + } + } else { + ++idx; + } + } + fastTimers.length = len; + if (fastTimers.length !== 0) { + refreshTimeout(); + } + } + function refreshTimeout() { + if (fastNowTimeout) { + fastNowTimeout.refresh(); + } else { + clearTimeout(fastNowTimeout); + fastNowTimeout = setTimeout(onTick, TICK_MS); + if (fastNowTimeout.unref) { + fastNowTimeout.unref(); + } + } + } + var FastTimer = class { + [kFastTimer] = true; + /** + * The state of the timer, which can be one of the following: + * - NOT_IN_LIST (-2) + * - TO_BE_CLEARED (-1) + * - PENDING (0) + * - ACTIVE (1) + * + * @type {-2|-1|0|1} + * @private + */ + _state = NOT_IN_LIST; + /** + * The number of milliseconds to wait before calling the callback. + * + * @type {number} + * @private + */ + _idleTimeout = -1; + /** + * The time in milliseconds when the timer was started. This value is used to + * calculate when the timer should expire. + * + * @type {number} + * @default -1 + * @private + */ + _idleStart = -1; + /** + * The function to be executed when the timer expires. + * @type {Function} + * @private + */ + _onTimeout; + /** + * The argument to be passed to the callback when the timer expires. + * + * @type {*} + * @private + */ + _timerArg; + /** + * @constructor + * @param {Function} callback A function to be executed after the timer + * expires. + * @param {number} delay The time, in milliseconds that the timer should wait + * before the specified function or code is executed. + * @param {*} arg + */ + constructor(callback, delay, arg) { + this._onTimeout = callback; + this._idleTimeout = delay; + this._timerArg = arg; + this.refresh(); + } + /** + * Sets the timer's start time to the current time, and reschedules the timer + * to call its callback at the previously specified duration adjusted to the + * current time. + * Using this on a timer that has already called its callback will reactivate + * the timer. + * + * @returns {void} + */ + refresh() { + if (this._state === NOT_IN_LIST) { + fastTimers.push(this); + } + if (!fastNowTimeout || fastTimers.length === 1) { + refreshTimeout(); + } + this._state = PENDING; + } + /** + * The `clear` method cancels the timer, preventing it from executing. + * + * @returns {void} + * @private + */ + clear() { + this._state = TO_BE_CLEARED; + this._idleStart = -1; + } + }; + module.exports = { + /** + * The setTimeout() method sets a timer which executes a function once the + * timer expires. + * @param {Function} callback A function to be executed after the timer + * expires. + * @param {number} delay The time, in milliseconds that the timer should + * wait before the specified function or code is executed. + * @param {*} [arg] An optional argument to be passed to the callback function + * when the timer expires. + * @returns {NodeJS.Timeout|FastTimer} + */ + setTimeout(callback, delay, arg) { + return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg); + }, + /** + * The clearTimeout method cancels an instantiated Timer previously created + * by calling setTimeout. + * + * @param {NodeJS.Timeout|FastTimer} timeout + */ + clearTimeout(timeout) { + if (timeout[kFastTimer]) { + timeout.clear(); + } else { + clearTimeout(timeout); + } + }, + /** + * The setFastTimeout() method sets a fastTimer which executes a function once + * the timer expires. + * @param {Function} callback A function to be executed after the timer + * expires. + * @param {number} delay The time, in milliseconds that the timer should + * wait before the specified function or code is executed. + * @param {*} [arg] An optional argument to be passed to the callback function + * when the timer expires. + * @returns {FastTimer} + */ + setFastTimeout(callback, delay, arg) { + return new FastTimer(callback, delay, arg); + }, + /** + * The clearTimeout method cancels an instantiated FastTimer previously + * created by calling setFastTimeout. + * + * @param {FastTimer} timeout + */ + clearFastTimeout(timeout) { + timeout.clear(); + }, + /** + * The now method returns the value of the internal fast timer clock. + * + * @returns {number} + */ + now() { + return fastNow; + }, + /** + * Trigger the onTick function to process the fastTimers array. + * Exported for testing purposes only. + * Marking as deprecated to discourage any use outside of testing. + * @deprecated + * @param {number} [delay=0] The delay in milliseconds to add to the now value. + */ + tick(delay = 0) { + fastNow += delay - RESOLUTION_MS + 1; + onTick(); + onTick(); + }, + /** + * Reset FastTimers. + * Exported for testing purposes only. + * Marking as deprecated to discourage any use outside of testing. + * @deprecated + */ + reset() { + fastNow = 0; + fastTimers.length = 0; + clearTimeout(fastNowTimeout); + fastNowTimeout = null; + }, + /** + * Exporting for testing purposes only. + * Marking as deprecated to discourage any use outside of testing. + * @deprecated + */ + kFastTimer + }; + } +}); + +// node_modules/undici/lib/core/connect.js +var require_connect = __commonJS({ + "node_modules/undici/lib/core/connect.js"(exports, module) { + "use strict"; + var net2 = __require("node:net"); + var assert = __require("node:assert"); + var util2 = require_util(); + var { InvalidArgumentError, ConnectTimeoutError } = require_errors(); + var timers = require_timers(); + function noop() { + } + var tls; + var SessionCache; + if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) { + SessionCache = class WeakSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) { + return; + } + const ref = this._sessionCache.get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this._sessionCache.delete(key); + } + }); + } + get(sessionKey) { + const ref = this._sessionCache.get(sessionKey); + return ref ? ref.deref() : null; + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + this._sessionCache.set(sessionKey, new WeakRef(session)); + this._sessionRegistry.register(session, sessionKey); + } + }; + } else { + SessionCache = class SimpleSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + } + get(sessionKey) { + return this._sessionCache.get(sessionKey); + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + if (this._sessionCache.size >= this._maxCachedSessions) { + const { value: oldestKey } = this._sessionCache.keys().next(); + this._sessionCache.delete(oldestKey); + } + this._sessionCache.set(sessionKey, session); + } + }; + } + function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { + throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero"); + } + const options = { path: socketPath, ...opts }; + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); + timeout = timeout == null ? 1e4 : timeout; + allowH2 = allowH2 != null ? allowH2 : false; + return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket; + if (protocol === "https:") { + if (!tls) { + tls = __require("node:tls"); + } + servername = servername || options.servername || util2.getServerName(host) || null; + const sessionKey = servername || hostname; + assert(sessionKey); + const session = customSession || sessionCache.get(sessionKey) || null; + port = port || 443; + socket = tls.connect({ + highWaterMark: 16384, + // TLS in node can't have bigger HWM anyway... + ...options, + servername, + session, + localAddress, + // TODO(HTTP/2): Add support for h2c + ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], + socket: httpSocket, + // upgrade socket connection + port, + host: hostname + }); + socket.on("session", function(session2) { + sessionCache.set(sessionKey, session2); + }); + } else { + assert(!httpSocket, "httpSocket can only be sent on TLS update"); + port = port || 80; + socket = net2.connect({ + highWaterMark: 64 * 1024, + // Same as nodejs fs streams. + ...options, + localAddress, + port, + host: hostname + }); + } + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; + socket.setKeepAlive(true, keepAliveInitialDelay); + } + const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port }); + socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { + queueMicrotask(clearConnectTimeout); + if (callback) { + const cb = callback; + callback = null; + cb(null, this); + } + }).on("error", function(err) { + queueMicrotask(clearConnectTimeout); + if (callback) { + const cb = callback; + callback = null; + cb(err); + } + }); + return socket; + }; + } + var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => { + if (!opts.timeout) { + return noop; + } + let s1 = null; + let s2 = null; + const fastTimer = timers.setFastTimeout(() => { + s1 = setImmediate(() => { + s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts)); + }); + }, opts.timeout); + return () => { + timers.clearFastTimeout(fastTimer); + clearImmediate(s1); + clearImmediate(s2); + }; + } : (socketWeakRef, opts) => { + if (!opts.timeout) { + return noop; + } + let s1 = null; + const fastTimer = timers.setFastTimeout(() => { + s1 = setImmediate(() => { + onConnectTimeout(socketWeakRef.deref(), opts); + }); + }, opts.timeout); + return () => { + timers.clearFastTimeout(fastTimer); + clearImmediate(s1); + }; + }; + function onConnectTimeout(socket, opts) { + if (socket == null) { + return; + } + let message = "Connect Timeout Error"; + if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) { + message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`; + } else { + message += ` (attempted address: ${opts.hostname}:${opts.port},`; + } + message += ` timeout: ${opts.timeout}ms)`; + util2.destroy(socket, new ConnectTimeoutError(message)); + } + module.exports = buildConnector; + } +}); + +// node_modules/undici/lib/llhttp/utils.js +var require_utils = __commonJS({ + "node_modules/undici/lib/llhttp/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.enumToMap = void 0; + function enumToMap(obj) { + const res = {}; + Object.keys(obj).forEach((key) => { + const value = obj[key]; + if (typeof value === "number") { + res[key] = value; + } + }); + return res; + } + exports.enumToMap = enumToMap; + } +}); + +// node_modules/undici/lib/llhttp/constants.js +var require_constants2 = __commonJS({ + "node_modules/undici/lib/llhttp/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0; + var utils_1 = require_utils(); + var ERROR2; + (function(ERROR3) { + ERROR3[ERROR3["OK"] = 0] = "OK"; + ERROR3[ERROR3["INTERNAL"] = 1] = "INTERNAL"; + ERROR3[ERROR3["STRICT"] = 2] = "STRICT"; + ERROR3[ERROR3["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR3[ERROR3["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR3[ERROR3["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR3[ERROR3["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR3[ERROR3["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR3[ERROR3["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR3[ERROR3["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR3[ERROR3["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR3[ERROR3["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR3[ERROR3["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR3[ERROR3["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR3[ERROR3["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR3[ERROR3["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR3[ERROR3["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR3[ERROR3["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR3[ERROR3["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR3[ERROR3["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR3[ERROR3["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR3[ERROR3["PAUSED"] = 21] = "PAUSED"; + ERROR3[ERROR3["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR3[ERROR3["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR3[ERROR3["USER"] = 24] = "USER"; + })(ERROR2 = exports.ERROR || (exports.ERROR = {})); + var TYPE; + (function(TYPE2) { + TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; + TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST"; + TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE"; + })(TYPE = exports.TYPE || (exports.TYPE = {})); + var FLAGS; + (function(FLAGS2) { + FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; + FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; + FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; + FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED"; + FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE"; + FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; + FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY"; + FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING"; + FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; + })(FLAGS = exports.FLAGS || (exports.FLAGS = {})); + var LENIENT_FLAGS; + (function(LENIENT_FLAGS2) { + LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS"; + LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; + LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; + })(LENIENT_FLAGS = exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {})); + var METHODS; + (function(METHODS2) { + METHODS2[METHODS2["DELETE"] = 0] = "DELETE"; + METHODS2[METHODS2["GET"] = 1] = "GET"; + METHODS2[METHODS2["HEAD"] = 2] = "HEAD"; + METHODS2[METHODS2["POST"] = 3] = "POST"; + METHODS2[METHODS2["PUT"] = 4] = "PUT"; + METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT"; + METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS"; + METHODS2[METHODS2["TRACE"] = 7] = "TRACE"; + METHODS2[METHODS2["COPY"] = 8] = "COPY"; + METHODS2[METHODS2["LOCK"] = 9] = "LOCK"; + METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL"; + METHODS2[METHODS2["MOVE"] = 11] = "MOVE"; + METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND"; + METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH"; + METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH"; + METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK"; + METHODS2[METHODS2["BIND"] = 16] = "BIND"; + METHODS2[METHODS2["REBIND"] = 17] = "REBIND"; + METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND"; + METHODS2[METHODS2["ACL"] = 19] = "ACL"; + METHODS2[METHODS2["REPORT"] = 20] = "REPORT"; + METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY"; + METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT"; + METHODS2[METHODS2["MERGE"] = 23] = "MERGE"; + METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH"; + METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY"; + METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE"; + METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; + METHODS2[METHODS2["PATCH"] = 28] = "PATCH"; + METHODS2[METHODS2["PURGE"] = 29] = "PURGE"; + METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR"; + METHODS2[METHODS2["LINK"] = 31] = "LINK"; + METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK"; + METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE"; + METHODS2[METHODS2["PRI"] = 34] = "PRI"; + METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE"; + METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE"; + METHODS2[METHODS2["SETUP"] = 37] = "SETUP"; + METHODS2[METHODS2["PLAY"] = 38] = "PLAY"; + METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE"; + METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN"; + METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER"; + METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER"; + METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT"; + METHODS2[METHODS2["RECORD"] = 44] = "RECORD"; + METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH"; + })(METHODS = exports.METHODS || (exports.METHODS = {})); + exports.METHODS_HTTP = [ + METHODS.DELETE, + METHODS.GET, + METHODS.HEAD, + METHODS.POST, + METHODS.PUT, + METHODS.CONNECT, + METHODS.OPTIONS, + METHODS.TRACE, + METHODS.COPY, + METHODS.LOCK, + METHODS.MKCOL, + METHODS.MOVE, + METHODS.PROPFIND, + METHODS.PROPPATCH, + METHODS.SEARCH, + METHODS.UNLOCK, + METHODS.BIND, + METHODS.REBIND, + METHODS.UNBIND, + METHODS.ACL, + METHODS.REPORT, + METHODS.MKACTIVITY, + METHODS.CHECKOUT, + METHODS.MERGE, + METHODS["M-SEARCH"], + METHODS.NOTIFY, + METHODS.SUBSCRIBE, + METHODS.UNSUBSCRIBE, + METHODS.PATCH, + METHODS.PURGE, + METHODS.MKCALENDAR, + METHODS.LINK, + METHODS.UNLINK, + METHODS.PRI, + // TODO(indutny): should we allow it with HTTP? + METHODS.SOURCE + ]; + exports.METHODS_ICE = [ + METHODS.SOURCE + ]; + exports.METHODS_RTSP = [ + METHODS.OPTIONS, + METHODS.DESCRIBE, + METHODS.ANNOUNCE, + METHODS.SETUP, + METHODS.PLAY, + METHODS.PAUSE, + METHODS.TEARDOWN, + METHODS.GET_PARAMETER, + METHODS.SET_PARAMETER, + METHODS.REDIRECT, + METHODS.RECORD, + METHODS.FLUSH, + // For AirPlay + METHODS.GET, + METHODS.POST + ]; + exports.METHOD_MAP = utils_1.enumToMap(METHODS); + exports.H_METHOD_MAP = {}; + Object.keys(exports.METHOD_MAP).forEach((key) => { + if (/^H/.test(key)) { + exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key]; + } + }); + var FINISH; + (function(FINISH2) { + FINISH2[FINISH2["SAFE"] = 0] = "SAFE"; + FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; + FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE"; + })(FINISH = exports.FINISH || (exports.FINISH = {})); + exports.ALPHA = []; + for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { + exports.ALPHA.push(String.fromCharCode(i)); + exports.ALPHA.push(String.fromCharCode(i + 32)); + } + exports.NUM_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9 + }; + exports.HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15 + }; + exports.NUM = [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9" + ]; + exports.ALPHANUM = exports.ALPHA.concat(exports.NUM); + exports.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"]; + exports.USERINFO_CHARS = exports.ALPHANUM.concat(exports.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]); + exports.STRICT_URL_CHAR = [ + "!", + '"', + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + ":", + ";", + "<", + "=", + ">", + "@", + "[", + "\\", + "]", + "^", + "_", + "`", + "{", + "|", + "}", + "~" + ].concat(exports.ALPHANUM); + exports.URL_CHAR = exports.STRICT_URL_CHAR.concat([" ", "\f"]); + for (let i = 128; i <= 255; i++) { + exports.URL_CHAR.push(i); + } + exports.HEX = exports.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]); + exports.STRICT_TOKEN = [ + "!", + "#", + "$", + "%", + "&", + "'", + "*", + "+", + "-", + ".", + "^", + "_", + "`", + "|", + "~" + ].concat(exports.ALPHANUM); + exports.TOKEN = exports.STRICT_TOKEN.concat([" "]); + exports.HEADER_CHARS = [" "]; + for (let i = 32; i <= 255; i++) { + if (i !== 127) { + exports.HEADER_CHARS.push(i); + } + } + exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44); + exports.MAJOR = exports.NUM_MAP; + exports.MINOR = exports.MAJOR; + var HEADER_STATE; + (function(HEADER_STATE2) { + HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL"; + HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION"; + HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; + HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; + })(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {})); + exports.SPECIAL_HEADERS = { + "connection": HEADER_STATE.CONNECTION, + "content-length": HEADER_STATE.CONTENT_LENGTH, + "proxy-connection": HEADER_STATE.CONNECTION, + "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, + "upgrade": HEADER_STATE.UPGRADE + }; + } +}); + +// node_modules/undici/lib/llhttp/llhttp-wasm.js +var require_llhttp_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports, module) { + "use strict"; + var { Buffer: Buffer2 } = __require("node:buffer"); + module.exports = Buffer2.from("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", "base64"); + } +}); + +// node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +var require_llhttp_simd_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports, module) { + "use strict"; + var { Buffer: Buffer2 } = __require("node:buffer"); + module.exports = Buffer2.from("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", "base64"); + } +}); + +// node_modules/undici/lib/web/fetch/constants.js +var require_constants3 = __commonJS({ + "node_modules/undici/lib/web/fetch/constants.js"(exports, module) { + "use strict"; + var corsSafeListedMethods = ( + /** @type {const} */ + ["GET", "HEAD", "POST"] + ); + var corsSafeListedMethodsSet = new Set(corsSafeListedMethods); + var nullBodyStatus = ( + /** @type {const} */ + [101, 204, 205, 304] + ); + var redirectStatus = ( + /** @type {const} */ + [301, 302, 303, 307, 308] + ); + var redirectStatusSet = new Set(redirectStatus); + var badPorts = ( + /** @type {const} */ + [ + "1", + "7", + "9", + "11", + "13", + "15", + "17", + "19", + "20", + "21", + "22", + "23", + "25", + "37", + "42", + "43", + "53", + "69", + "77", + "79", + "87", + "95", + "101", + "102", + "103", + "104", + "109", + "110", + "111", + "113", + "115", + "117", + "119", + "123", + "135", + "137", + "139", + "143", + "161", + "179", + "389", + "427", + "465", + "512", + "513", + "514", + "515", + "526", + "530", + "531", + "532", + "540", + "548", + "554", + "556", + "563", + "587", + "601", + "636", + "989", + "990", + "993", + "995", + "1719", + "1720", + "1723", + "2049", + "3659", + "4045", + "4190", + "5060", + "5061", + "6000", + "6566", + "6665", + "6666", + "6667", + "6668", + "6669", + "6679", + "6697", + "10080" + ] + ); + var badPortsSet = new Set(badPorts); + var referrerPolicy = ( + /** @type {const} */ + [ + "", + "no-referrer", + "no-referrer-when-downgrade", + "same-origin", + "origin", + "strict-origin", + "origin-when-cross-origin", + "strict-origin-when-cross-origin", + "unsafe-url" + ] + ); + var referrerPolicySet = new Set(referrerPolicy); + var requestRedirect = ( + /** @type {const} */ + ["follow", "manual", "error"] + ); + var safeMethods = ( + /** @type {const} */ + ["GET", "HEAD", "OPTIONS", "TRACE"] + ); + var safeMethodsSet = new Set(safeMethods); + var requestMode = ( + /** @type {const} */ + ["navigate", "same-origin", "no-cors", "cors"] + ); + var requestCredentials = ( + /** @type {const} */ + ["omit", "same-origin", "include"] + ); + var requestCache = ( + /** @type {const} */ + [ + "default", + "no-store", + "reload", + "no-cache", + "force-cache", + "only-if-cached" + ] + ); + var requestBodyHeader = ( + /** @type {const} */ + [ + "content-encoding", + "content-language", + "content-location", + "content-type", + // See https://github.com/nodejs/undici/issues/2021 + // 'Content-Length' is a forbidden header name, which is typically + // removed in the Headers implementation. However, undici doesn't + // filter out headers, so we add it here. + "content-length" + ] + ); + var requestDuplex = ( + /** @type {const} */ + [ + "half" + ] + ); + var forbiddenMethods = ( + /** @type {const} */ + ["CONNECT", "TRACE", "TRACK"] + ); + var forbiddenMethodsSet = new Set(forbiddenMethods); + var subresource = ( + /** @type {const} */ + [ + "audio", + "audioworklet", + "font", + "image", + "manifest", + "paintworklet", + "script", + "style", + "track", + "video", + "xslt", + "" + ] + ); + var subresourceSet = new Set(subresource); + module.exports = { + subresource, + forbiddenMethods, + requestBodyHeader, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + redirectStatus, + corsSafeListedMethods, + nullBodyStatus, + safeMethods, + badPorts, + requestDuplex, + subresourceSet, + badPortsSet, + redirectStatusSet, + corsSafeListedMethodsSet, + safeMethodsSet, + forbiddenMethodsSet, + referrerPolicySet + }; + } +}); + +// node_modules/undici/lib/web/fetch/global.js +var require_global = __commonJS({ + "node_modules/undici/lib/web/fetch/global.js"(exports, module) { + "use strict"; + var globalOrigin = /* @__PURE__ */ Symbol.for("undici.globalOrigin.1"); + function getGlobalOrigin() { + return globalThis[globalOrigin]; + } + function setGlobalOrigin(newOrigin) { + if (newOrigin === void 0) { + Object.defineProperty(globalThis, globalOrigin, { + value: void 0, + writable: true, + enumerable: false, + configurable: false + }); + return; + } + const parsedURL = new URL(newOrigin); + if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") { + throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); + } + Object.defineProperty(globalThis, globalOrigin, { + value: parsedURL, + writable: true, + enumerable: false, + configurable: false + }); + } + module.exports = { + getGlobalOrigin, + setGlobalOrigin + }; + } +}); + +// node_modules/undici/lib/web/fetch/data-url.js +var require_data_url = __commonJS({ + "node_modules/undici/lib/web/fetch/data-url.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var encoder2 = new TextEncoder(); + var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/; + var HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/; + var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g; + var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/; + function dataURLProcessor(dataURL) { + assert(dataURL.protocol === "data:"); + let input = URLSerializer(dataURL, true); + input = input.slice(5); + const position = { position: 0 }; + let mimeType = collectASequenceOfCodePointsFast( + ",", + input, + position + ); + const mimeTypeLength = mimeType.length; + mimeType = removeASCIIWhitespace(mimeType, true, true); + if (position.position >= input.length) { + return "failure"; + } + position.position++; + const encodedBody = input.slice(mimeTypeLength + 1); + let body = stringPercentDecode(encodedBody); + if (/;(\u0020){0,}base64$/i.test(mimeType)) { + const stringBody = isomorphicDecode(body); + body = forgivingBase64(stringBody); + if (body === "failure") { + return "failure"; + } + mimeType = mimeType.slice(0, -6); + mimeType = mimeType.replace(/(\u0020)+$/, ""); + mimeType = mimeType.slice(0, -1); + } + if (mimeType.startsWith(";")) { + mimeType = "text/plain" + mimeType; + } + let mimeTypeRecord = parseMIMEType(mimeType); + if (mimeTypeRecord === "failure") { + mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); + } + return { mimeType: mimeTypeRecord, body }; + } + function URLSerializer(url, excludeFragment = false) { + if (!excludeFragment) { + return url.href; + } + const href = url.href; + const hashLength = url.hash.length; + const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength); + if (!hashLength && href.endsWith("#")) { + return serialized.slice(0, -1); + } + return serialized; + } + function collectASequenceOfCodePoints(condition, input, position) { + let result = ""; + while (position.position < input.length && condition(input[position.position])) { + result += input[position.position]; + position.position++; + } + return result; + } + function collectASequenceOfCodePointsFast(char, input, position) { + const idx = input.indexOf(char, position.position); + const start = position.position; + if (idx === -1) { + position.position = input.length; + return input.slice(start); + } + position.position = idx; + return input.slice(start, position.position); + } + function stringPercentDecode(input) { + const bytes = encoder2.encode(input); + return percentDecode(bytes); + } + function isHexCharByte(byte) { + return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102; + } + function hexByteToNumber(byte) { + return ( + // 0-9 + byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55 + ); + } + function percentDecode(input) { + const length = input.length; + const output = new Uint8Array(length); + let j = 0; + for (let i = 0; i < length; ++i) { + const byte = input[i]; + if (byte !== 37) { + output[j++] = byte; + } else if (byte === 37 && !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))) { + output[j++] = 37; + } else { + output[j++] = hexByteToNumber(input[i + 1]) << 4 | hexByteToNumber(input[i + 2]); + i += 2; + } + } + return length === j ? output : output.subarray(0, j); + } + function parseMIMEType(input) { + input = removeHTTPWhitespace(input, true, true); + const position = { position: 0 }; + const type2 = collectASequenceOfCodePointsFast( + "/", + input, + position + ); + if (type2.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type2)) { + return "failure"; + } + if (position.position > input.length) { + return "failure"; + } + position.position++; + let subtype = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + subtype = removeHTTPWhitespace(subtype, false, true); + if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { + return "failure"; + } + const typeLowercase = type2.toLowerCase(); + const subtypeLowercase = subtype.toLowerCase(); + const mimeType = { + type: typeLowercase, + subtype: subtypeLowercase, + /** @type {Map} */ + parameters: /* @__PURE__ */ new Map(), + // https://mimesniff.spec.whatwg.org/#mime-type-essence + essence: `${typeLowercase}/${subtypeLowercase}` + }; + while (position.position < input.length) { + position.position++; + collectASequenceOfCodePoints( + // https://fetch.spec.whatwg.org/#http-whitespace + (char) => HTTP_WHITESPACE_REGEX.test(char), + input, + position + ); + let parameterName = collectASequenceOfCodePoints( + (char) => char !== ";" && char !== "=", + input, + position + ); + parameterName = parameterName.toLowerCase(); + if (position.position < input.length) { + if (input[position.position] === ";") { + continue; + } + position.position++; + } + if (position.position > input.length) { + break; + } + let parameterValue = null; + if (input[position.position] === '"') { + parameterValue = collectAnHTTPQuotedString(input, position, true); + collectASequenceOfCodePointsFast( + ";", + input, + position + ); + } else { + parameterValue = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + parameterValue = removeHTTPWhitespace(parameterValue, false, true); + if (parameterValue.length === 0) { + continue; + } + } + if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) { + mimeType.parameters.set(parameterName, parameterValue); + } + } + return mimeType; + } + function forgivingBase64(data) { + data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, ""); + let dataLength = data.length; + if (dataLength % 4 === 0) { + if (data.charCodeAt(dataLength - 1) === 61) { + --dataLength; + if (data.charCodeAt(dataLength - 1) === 61) { + --dataLength; + } + } + } + if (dataLength % 4 === 1) { + return "failure"; + } + if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) { + return "failure"; + } + const buffer = Buffer.from(data, "base64"); + return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength); + } + function collectAnHTTPQuotedString(input, position, extractValue) { + const positionStart = position.position; + let value = ""; + assert(input[position.position] === '"'); + position.position++; + while (true) { + value += collectASequenceOfCodePoints( + (char) => char !== '"' && char !== "\\", + input, + position + ); + if (position.position >= input.length) { + break; + } + const quoteOrBackslash = input[position.position]; + position.position++; + if (quoteOrBackslash === "\\") { + if (position.position >= input.length) { + value += "\\"; + break; + } + value += input[position.position]; + position.position++; + } else { + assert(quoteOrBackslash === '"'); + break; + } + } + if (extractValue) { + return value; + } + return input.slice(positionStart, position.position); + } + function serializeAMimeType(mimeType) { + assert(mimeType !== "failure"); + const { parameters, essence } = mimeType; + let serialization = essence; + for (let [name, value] of parameters.entries()) { + serialization += ";"; + serialization += name; + serialization += "="; + if (!HTTP_TOKEN_CODEPOINTS.test(value)) { + value = value.replace(/(\\|")/g, "\\$1"); + value = '"' + value; + value += '"'; + } + serialization += value; + } + return serialization; + } + function isHTTPWhiteSpace(char) { + return char === 13 || char === 10 || char === 9 || char === 32; + } + function removeHTTPWhitespace(str2, leading = true, trailing = true) { + return removeChars(str2, leading, trailing, isHTTPWhiteSpace); + } + function isASCIIWhitespace(char) { + return char === 13 || char === 10 || char === 9 || char === 12 || char === 32; + } + function removeASCIIWhitespace(str2, leading = true, trailing = true) { + return removeChars(str2, leading, trailing, isASCIIWhitespace); + } + function removeChars(str2, leading, trailing, predicate) { + let lead = 0; + let trail = str2.length - 1; + if (leading) { + while (lead < str2.length && predicate(str2.charCodeAt(lead))) lead++; + } + if (trailing) { + while (trail > 0 && predicate(str2.charCodeAt(trail))) trail--; + } + return lead === 0 && trail === str2.length - 1 ? str2 : str2.slice(lead, trail + 1); + } + function isomorphicDecode(input) { + const length = input.length; + if ((2 << 15) - 1 > length) { + return String.fromCharCode.apply(null, input); + } + let result = ""; + let i = 0; + let addition = (2 << 15) - 1; + while (i < length) { + if (i + addition > length) { + addition = length - i; + } + result += String.fromCharCode.apply(null, input.subarray(i, i += addition)); + } + return result; + } + function minimizeSupportedMimeType(mimeType) { + switch (mimeType.essence) { + case "application/ecmascript": + case "application/javascript": + case "application/x-ecmascript": + case "application/x-javascript": + case "text/ecmascript": + case "text/javascript": + case "text/javascript1.0": + case "text/javascript1.1": + case "text/javascript1.2": + case "text/javascript1.3": + case "text/javascript1.4": + case "text/javascript1.5": + case "text/jscript": + case "text/livescript": + case "text/x-ecmascript": + case "text/x-javascript": + return "text/javascript"; + case "application/json": + case "text/json": + return "application/json"; + case "image/svg+xml": + return "image/svg+xml"; + case "text/xml": + case "application/xml": + return "application/xml"; + } + if (mimeType.subtype.endsWith("+json")) { + return "application/json"; + } + if (mimeType.subtype.endsWith("+xml")) { + return "application/xml"; + } + return ""; + } + module.exports = { + dataURLProcessor, + URLSerializer, + collectASequenceOfCodePoints, + collectASequenceOfCodePointsFast, + stringPercentDecode, + parseMIMEType, + collectAnHTTPQuotedString, + serializeAMimeType, + removeChars, + removeHTTPWhitespace, + minimizeSupportedMimeType, + HTTP_TOKEN_CODEPOINTS, + isomorphicDecode + }; + } +}); + +// node_modules/undici/lib/web/fetch/webidl.js +var require_webidl = __commonJS({ + "node_modules/undici/lib/web/fetch/webidl.js"(exports, module) { + "use strict"; + var { types: types2, inspect } = __require("node:util"); + var { markAsUncloneable } = __require("node:worker_threads"); + var { toUSVString } = require_util(); + var webidl = {}; + webidl.converters = {}; + webidl.util = {}; + webidl.errors = {}; + webidl.errors.exception = function(message) { + return new TypeError(`${message.header}: ${message.message}`); + }; + webidl.errors.conversionFailed = function(context) { + const plural = context.types.length === 1 ? "" : " one of"; + const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`; + return webidl.errors.exception({ + header: context.prefix, + message + }); + }; + webidl.errors.invalidArgument = function(context) { + return webidl.errors.exception({ + header: context.prefix, + message: `"${context.value}" is an invalid ${context.type}.` + }); + }; + webidl.brandCheck = function(V, I, opts) { + if (opts?.strict !== false) { + if (!(V instanceof I)) { + const err = new TypeError("Illegal invocation"); + err.code = "ERR_INVALID_THIS"; + throw err; + } + } else { + if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) { + const err = new TypeError("Illegal invocation"); + err.code = "ERR_INVALID_THIS"; + throw err; + } + } + }; + webidl.argumentLengthCheck = function({ length }, min, ctx) { + if (length < min) { + throw webidl.errors.exception({ + message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, + header: ctx + }); + } + }; + webidl.illegalConstructor = function() { + throw webidl.errors.exception({ + header: "TypeError", + message: "Illegal constructor" + }); + }; + webidl.util.Type = function(V) { + switch (typeof V) { + case "undefined": + return "Undefined"; + case "boolean": + return "Boolean"; + case "string": + return "String"; + case "symbol": + return "Symbol"; + case "number": + return "Number"; + case "bigint": + return "BigInt"; + case "function": + case "object": { + if (V === null) { + return "Null"; + } + return "Object"; + } + } + }; + webidl.util.markAsUncloneable = markAsUncloneable || (() => { + }); + webidl.util.ConvertToInt = function(V, bitLength, signedness, opts) { + let upperBound; + let lowerBound; + if (bitLength === 64) { + upperBound = Math.pow(2, 53) - 1; + if (signedness === "unsigned") { + lowerBound = 0; + } else { + lowerBound = Math.pow(-2, 53) + 1; + } + } else if (signedness === "unsigned") { + lowerBound = 0; + upperBound = Math.pow(2, bitLength) - 1; + } else { + lowerBound = Math.pow(-2, bitLength) - 1; + upperBound = Math.pow(2, bitLength - 1) - 1; + } + let x = Number(V); + if (x === 0) { + x = 0; + } + if (opts?.enforceRange === true) { + if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Could not convert ${webidl.util.Stringify(V)} to an integer.` + }); + } + x = webidl.util.IntegerPart(x); + if (x < lowerBound || x > upperBound) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` + }); + } + return x; + } + if (!Number.isNaN(x) && opts?.clamp === true) { + x = Math.min(Math.max(x, lowerBound), upperBound); + if (Math.floor(x) % 2 === 0) { + x = Math.floor(x); + } else { + x = Math.ceil(x); + } + return x; + } + if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + return 0; + } + x = webidl.util.IntegerPart(x); + x = x % Math.pow(2, bitLength); + if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { + return x - Math.pow(2, bitLength); + } + return x; + }; + webidl.util.IntegerPart = function(n) { + const r = Math.floor(Math.abs(n)); + if (n < 0) { + return -1 * r; + } + return r; + }; + webidl.util.Stringify = function(V) { + const type2 = webidl.util.Type(V); + switch (type2) { + case "Symbol": + return `Symbol(${V.description})`; + case "Object": + return inspect(V); + case "String": + return `"${V}"`; + default: + return `${V}`; + } + }; + webidl.sequenceConverter = function(converter) { + return (V, prefix, argument, Iterable) => { + if (webidl.util.Type(V) !== "Object") { + throw webidl.errors.exception({ + header: prefix, + message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.` + }); + } + const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.(); + const seq2 = []; + let index2 = 0; + if (method === void 0 || typeof method.next !== "function") { + throw webidl.errors.exception({ + header: prefix, + message: `${argument} is not iterable.` + }); + } + while (true) { + const { done, value } = method.next(); + if (done) { + break; + } + seq2.push(converter(value, prefix, `${argument}[${index2++}]`)); + } + return seq2; + }; + }; + webidl.recordConverter = function(keyConverter, valueConverter) { + return (O, prefix, argument) => { + if (webidl.util.Type(O) !== "Object") { + throw webidl.errors.exception({ + header: prefix, + message: `${argument} ("${webidl.util.Type(O)}") is not an Object.` + }); + } + const result = {}; + if (!types2.isProxy(O)) { + const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)]; + for (const key of keys2) { + const typedKey = keyConverter(key, prefix, argument); + const typedValue = valueConverter(O[key], prefix, argument); + result[typedKey] = typedValue; + } + return result; + } + const keys = Reflect.ownKeys(O); + for (const key of keys) { + const desc = Reflect.getOwnPropertyDescriptor(O, key); + if (desc?.enumerable) { + const typedKey = keyConverter(key, prefix, argument); + const typedValue = valueConverter(O[key], prefix, argument); + result[typedKey] = typedValue; + } + } + return result; + }; + }; + webidl.interfaceConverter = function(i) { + return (V, prefix, argument, opts) => { + if (opts?.strict !== false && !(V instanceof i)) { + throw webidl.errors.exception({ + header: prefix, + message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.` + }); + } + return V; + }; + }; + webidl.dictionaryConverter = function(converters) { + return (dictionary, prefix, argument) => { + const type2 = webidl.util.Type(dictionary); + const dict = {}; + if (type2 === "Null" || type2 === "Undefined") { + return dict; + } else if (type2 !== "Object") { + throw webidl.errors.exception({ + header: prefix, + message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` + }); + } + for (const options of converters) { + const { key, defaultValue, required, converter } = options; + if (required === true) { + if (!Object.hasOwn(dictionary, key)) { + throw webidl.errors.exception({ + header: prefix, + message: `Missing required key "${key}".` + }); + } + } + let value = dictionary[key]; + const hasDefault = Object.hasOwn(options, "defaultValue"); + if (hasDefault && value !== null) { + value ??= defaultValue(); + } + if (required || hasDefault || value !== void 0) { + value = converter(value, prefix, `${argument}.${key}`); + if (options.allowedValues && !options.allowedValues.includes(value)) { + throw webidl.errors.exception({ + header: prefix, + message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` + }); + } + dict[key] = value; + } + } + return dict; + }; + }; + webidl.nullableConverter = function(converter) { + return (V, prefix, argument) => { + if (V === null) { + return V; + } + return converter(V, prefix, argument); + }; + }; + webidl.converters.DOMString = function(V, prefix, argument, opts) { + if (V === null && opts?.legacyNullToEmptyString) { + return ""; + } + if (typeof V === "symbol") { + throw webidl.errors.exception({ + header: prefix, + message: `${argument} is a symbol, which cannot be converted to a DOMString.` + }); + } + return String(V); + }; + webidl.converters.ByteString = function(V, prefix, argument) { + const x = webidl.converters.DOMString(V, prefix, argument); + for (let index2 = 0; index2 < x.length; index2++) { + if (x.charCodeAt(index2) > 255) { + throw new TypeError( + `Cannot convert argument to a ByteString because the character at index ${index2} has a value of ${x.charCodeAt(index2)} which is greater than 255.` + ); + } + } + return x; + }; + webidl.converters.USVString = toUSVString; + webidl.converters.boolean = function(V) { + const x = Boolean(V); + return x; + }; + webidl.converters.any = function(V) { + return V; + }; + webidl.converters["long long"] = function(V, prefix, argument) { + const x = webidl.util.ConvertToInt(V, 64, "signed", void 0, prefix, argument); + return x; + }; + webidl.converters["unsigned long long"] = function(V, prefix, argument) { + const x = webidl.util.ConvertToInt(V, 64, "unsigned", void 0, prefix, argument); + return x; + }; + webidl.converters["unsigned long"] = function(V, prefix, argument) { + const x = webidl.util.ConvertToInt(V, 32, "unsigned", void 0, prefix, argument); + return x; + }; + webidl.converters["unsigned short"] = function(V, prefix, argument, opts) { + const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts, prefix, argument); + return x; + }; + webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) { + if (webidl.util.Type(V) !== "Object" || !types2.isAnyArrayBuffer(V)) { + throw webidl.errors.conversionFailed({ + prefix, + argument: `${argument} ("${webidl.util.Stringify(V)}")`, + types: ["ArrayBuffer"] + }); + } + if (opts?.allowShared === false && types2.isSharedArrayBuffer(V)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + if (V.resizable || V.growable) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "Received a resizable ArrayBuffer." + }); + } + return V; + }; + webidl.converters.TypedArray = function(V, T, prefix, name, opts) { + if (webidl.util.Type(V) !== "Object" || !types2.isTypedArray(V) || V.constructor.name !== T.name) { + throw webidl.errors.conversionFailed({ + prefix, + argument: `${name} ("${webidl.util.Stringify(V)}")`, + types: [T.name] + }); + } + if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + if (V.buffer.resizable || V.buffer.growable) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "Received a resizable ArrayBuffer." + }); + } + return V; + }; + webidl.converters.DataView = function(V, prefix, name, opts) { + if (webidl.util.Type(V) !== "Object" || !types2.isDataView(V)) { + throw webidl.errors.exception({ + header: prefix, + message: `${name} is not a DataView.` + }); + } + if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + if (V.buffer.resizable || V.buffer.growable) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "Received a resizable ArrayBuffer." + }); + } + return V; + }; + webidl.converters.BufferSource = function(V, prefix, name, opts) { + if (types2.isAnyArrayBuffer(V)) { + return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false }); + } + if (types2.isTypedArray(V)) { + return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false }); + } + if (types2.isDataView(V)) { + return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false }); + } + throw webidl.errors.conversionFailed({ + prefix, + argument: `${name} ("${webidl.util.Stringify(V)}")`, + types: ["BufferSource"] + }); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.ByteString + ); + webidl.converters["sequence>"] = webidl.sequenceConverter( + webidl.converters["sequence"] + ); + webidl.converters["record"] = webidl.recordConverter( + webidl.converters.ByteString, + webidl.converters.ByteString + ); + module.exports = { + webidl + }; + } +}); + +// node_modules/undici/lib/web/fetch/util.js +var require_util2 = __commonJS({ + "node_modules/undici/lib/web/fetch/util.js"(exports, module) { + "use strict"; + var { Transform } = __require("node:stream"); + var zlib = __require("node:zlib"); + var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants3(); + var { getGlobalOrigin } = require_global(); + var { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url(); + var { performance: performance2 } = __require("node:perf_hooks"); + var { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util(); + var assert = __require("node:assert"); + var { isUint8Array } = __require("node:util/types"); + var { webidl } = require_webidl(); + var supportedHashes = []; + var crypto3; + try { + crypto3 = __require("node:crypto"); + const possibleRelevantHashes = ["sha256", "sha384", "sha512"]; + supportedHashes = crypto3.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); + } catch { + } + function responseURL(response) { + const urlList = response.urlList; + const length = urlList.length; + return length === 0 ? null : urlList[length - 1].toString(); + } + function responseLocationURL(response, requestFragment) { + if (!redirectStatusSet.has(response.status)) { + return null; + } + let location = response.headersList.get("location", true); + if (location !== null && isValidHeaderValue(location)) { + if (!isValidEncodedURL(location)) { + location = normalizeBinaryStringToUtf8(location); + } + location = new URL(location, responseURL(response)); + } + if (location && !location.hash) { + location.hash = requestFragment; + } + return location; + } + function isValidEncodedURL(url) { + for (let i = 0; i < url.length; ++i) { + const code = url.charCodeAt(i); + if (code > 126 || // Non-US-ASCII + DEL + code < 32) { + return false; + } + } + return true; + } + function normalizeBinaryStringToUtf8(value) { + return Buffer.from(value, "binary").toString("utf8"); + } + function requestCurrentURL(request) { + return request.urlList[request.urlList.length - 1]; + } + function requestBadPort(request) { + const url = requestCurrentURL(request); + if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { + return "blocked"; + } + return "allowed"; + } + function isErrorLike(object) { + return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"); + } + function isValidReasonPhrase(statusText) { + for (let i = 0; i < statusText.length; ++i) { + const c = statusText.charCodeAt(i); + if (!(c === 9 || // HTAB + c >= 32 && c <= 126 || // SP / VCHAR + c >= 128 && c <= 255)) { + return false; + } + } + return true; + } + var isValidHeaderName = isValidHTTPToken; + function isValidHeaderValue(potentialValue) { + return (potentialValue[0] === " " || potentialValue[0] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue.includes("\n") || potentialValue.includes("\r") || potentialValue.includes("\0")) === false; + } + function setRequestReferrerPolicyOnRedirect(request, actualResponse) { + const { headersList } = actualResponse; + const policyHeader = (headersList.get("referrer-policy", true) ?? "").split(","); + let policy = ""; + if (policyHeader.length > 0) { + for (let i = policyHeader.length; i !== 0; i--) { + const token = policyHeader[i - 1].trim(); + if (referrerPolicyTokens.has(token)) { + policy = token; + break; + } + } + } + if (policy !== "") { + request.referrerPolicy = policy; + } + } + function crossOriginResourcePolicyCheck() { + return "allowed"; + } + function corsCheck() { + return "success"; + } + function TAOCheck() { + return "success"; + } + function appendFetchMetadata(httpRequest) { + let header = null; + header = httpRequest.mode; + httpRequest.headersList.set("sec-fetch-mode", header, true); + } + function appendRequestOriginHeader(request) { + let serializedOrigin = request.origin; + if (serializedOrigin === "client" || serializedOrigin === void 0) { + return; + } + if (request.responseTainting === "cors" || request.mode === "websocket") { + request.headersList.append("origin", serializedOrigin, true); + } else if (request.method !== "GET" && request.method !== "HEAD") { + switch (request.referrerPolicy) { + case "no-referrer": + serializedOrigin = null; + break; + case "no-referrer-when-downgrade": + case "strict-origin": + case "strict-origin-when-cross-origin": + if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + case "same-origin": + if (!sameOrigin(request, requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + default: + } + request.headersList.append("origin", serializedOrigin, true); + } + } + function coarsenTime(timestamp2, crossOriginIsolatedCapability) { + return timestamp2; + } + function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) { + if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) { + return { + domainLookupStartTime: defaultStartTime, + domainLookupEndTime: defaultStartTime, + connectionStartTime: defaultStartTime, + connectionEndTime: defaultStartTime, + secureConnectionStartTime: defaultStartTime, + ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol + }; + } + return { + domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability), + domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability), + connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability), + connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability), + secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability), + ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol + }; + } + function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { + return coarsenTime(performance2.now(), crossOriginIsolatedCapability); + } + function createOpaqueTimingInfo(timingInfo) { + return { + startTime: timingInfo.startTime ?? 0, + redirectStartTime: 0, + redirectEndTime: 0, + postRedirectStartTime: timingInfo.startTime ?? 0, + finalServiceWorkerStartTime: 0, + finalNetworkResponseStartTime: 0, + finalNetworkRequestStartTime: 0, + endTime: 0, + encodedBodySize: 0, + decodedBodySize: 0, + finalConnectionTimingInfo: null + }; + } + function makePolicyContainer() { + return { + referrerPolicy: "strict-origin-when-cross-origin" + }; + } + function clonePolicyContainer(policyContainer) { + return { + referrerPolicy: policyContainer.referrerPolicy + }; + } + function determineRequestsReferrer(request) { + const policy = request.referrerPolicy; + assert(policy); + let referrerSource = null; + if (request.referrer === "client") { + const globalOrigin = getGlobalOrigin(); + if (!globalOrigin || globalOrigin.origin === "null") { + return "no-referrer"; + } + referrerSource = new URL(globalOrigin); + } else if (request.referrer instanceof URL) { + referrerSource = request.referrer; + } + let referrerURL = stripURLForReferrer(referrerSource); + const referrerOrigin = stripURLForReferrer(referrerSource, true); + if (referrerURL.toString().length > 4096) { + referrerURL = referrerOrigin; + } + const areSameOrigin = sameOrigin(request, referrerURL); + const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url); + switch (policy) { + case "origin": + return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); + case "unsafe-url": + return referrerURL; + case "same-origin": + return areSameOrigin ? referrerOrigin : "no-referrer"; + case "origin-when-cross-origin": + return areSameOrigin ? referrerURL : referrerOrigin; + case "strict-origin-when-cross-origin": { + const currentURL = requestCurrentURL(request); + if (sameOrigin(referrerURL, currentURL)) { + return referrerURL; + } + if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { + return "no-referrer"; + } + return referrerOrigin; + } + case "strict-origin": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + case "no-referrer-when-downgrade": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + default: + return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; + } + } + function stripURLForReferrer(url, originOnly) { + assert(url instanceof URL); + url = new URL(url); + if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { + return "no-referrer"; + } + url.username = ""; + url.password = ""; + url.hash = ""; + if (originOnly) { + url.pathname = ""; + url.search = ""; + } + return url; + } + function isURLPotentiallyTrustworthy(url) { + if (!(url instanceof URL)) { + return false; + } + if (url.href === "about:blank" || url.href === "about:srcdoc") { + return true; + } + if (url.protocol === "data:") return true; + if (url.protocol === "file:") return true; + return isOriginPotentiallyTrustworthy(url.origin); + function isOriginPotentiallyTrustworthy(origin) { + if (origin == null || origin === "null") return false; + const originAsURL = new URL(origin); + if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") { + return true; + } + if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) { + return true; + } + return false; + } + } + function bytesMatch(bytes, metadataList) { + if (crypto3 === void 0) { + return true; + } + const parsedMetadata = parseMetadata(metadataList); + if (parsedMetadata === "no metadata") { + return true; + } + if (parsedMetadata.length === 0) { + return true; + } + const strongest = getStrongestMetadata(parsedMetadata); + const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest); + for (const item of metadata) { + const algorithm = item.algo; + const expectedValue = item.hash; + let actualValue = crypto3.createHash(algorithm).update(bytes).digest("base64"); + if (actualValue[actualValue.length - 1] === "=") { + if (actualValue[actualValue.length - 2] === "=") { + actualValue = actualValue.slice(0, -2); + } else { + actualValue = actualValue.slice(0, -1); + } + } + if (compareBase64Mixed(actualValue, expectedValue)) { + return true; + } + } + return false; + } + var parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; + function parseMetadata(metadata) { + const result = []; + let empty = true; + for (const token of metadata.split(" ")) { + empty = false; + const parsedToken = parseHashWithOptions.exec(token); + if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) { + continue; + } + const algorithm = parsedToken.groups.algo.toLowerCase(); + if (supportedHashes.includes(algorithm)) { + result.push(parsedToken.groups); + } + } + if (empty === true) { + return "no metadata"; + } + return result; + } + function getStrongestMetadata(metadataList) { + let algorithm = metadataList[0].algo; + if (algorithm[3] === "5") { + return algorithm; + } + for (let i = 1; i < metadataList.length; ++i) { + const metadata = metadataList[i]; + if (metadata.algo[3] === "5") { + algorithm = "sha512"; + break; + } else if (algorithm[3] === "3") { + continue; + } else if (metadata.algo[3] === "3") { + algorithm = "sha384"; + } + } + return algorithm; + } + function filterMetadataListByAlgorithm(metadataList, algorithm) { + if (metadataList.length === 1) { + return metadataList; + } + let pos = 0; + for (let i = 0; i < metadataList.length; ++i) { + if (metadataList[i].algo === algorithm) { + metadataList[pos++] = metadataList[i]; + } + } + metadataList.length = pos; + return metadataList; + } + function compareBase64Mixed(actualValue, expectedValue) { + if (actualValue.length !== expectedValue.length) { + return false; + } + for (let i = 0; i < actualValue.length; ++i) { + if (actualValue[i] !== expectedValue[i]) { + if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") { + continue; + } + return false; + } + } + return true; + } + function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) { + } + function sameOrigin(A, B) { + if (A.origin === B.origin && A.origin === "null") { + return true; + } + if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { + return true; + } + return false; + } + function createDeferredPromise() { + let res; + let rej; + const promise = new Promise((resolve2, reject) => { + res = resolve2; + rej = reject; + }); + return { promise, resolve: res, reject: rej }; + } + function isAborted(fetchParams) { + return fetchParams.controller.state === "aborted"; + } + function isCancelled(fetchParams) { + return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; + } + function normalizeMethod(method) { + return normalizedMethodRecordsBase[method.toLowerCase()] ?? method; + } + function serializeJavascriptValueToJSONString(value) { + const result = JSON.stringify(value); + if (result === void 0) { + throw new TypeError("Value is not JSON serializable"); + } + assert(typeof result === "string"); + return result; + } + var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); + function createIterator(name, kInternalIterator, keyIndex = 0, valueIndex = 1) { + class FastIterableIterator { + /** @type {any} */ + #target; + /** @type {'key' | 'value' | 'key+value'} */ + #kind; + /** @type {number} */ + #index; + /** + * @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object + * @param {unknown} target + * @param {'key' | 'value' | 'key+value'} kind + */ + constructor(target, kind) { + this.#target = target; + this.#kind = kind; + this.#index = 0; + } + next() { + if (typeof this !== "object" || this === null || !(#target in this)) { + throw new TypeError( + `'next' called on an object that does not implement interface ${name} Iterator.` + ); + } + const index2 = this.#index; + const values = this.#target[kInternalIterator]; + const len = values.length; + if (index2 >= len) { + return { + value: void 0, + done: true + }; + } + const { [keyIndex]: key, [valueIndex]: value } = values[index2]; + this.#index = index2 + 1; + let result; + switch (this.#kind) { + case "key": + result = key; + break; + case "value": + result = value; + break; + case "key+value": + result = [key, value]; + break; + } + return { + value: result, + done: false + }; + } + } + delete FastIterableIterator.prototype.constructor; + Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype); + Object.defineProperties(FastIterableIterator.prototype, { + [Symbol.toStringTag]: { + writable: false, + enumerable: false, + configurable: true, + value: `${name} Iterator` + }, + next: { writable: true, enumerable: true, configurable: true } + }); + return function(target, kind) { + return new FastIterableIterator(target, kind); + }; + } + function iteratorMixin(name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) { + const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex); + const properties = { + keys: { + writable: true, + enumerable: true, + configurable: true, + value: function keys() { + webidl.brandCheck(this, object); + return makeIterator(this, "key"); + } + }, + values: { + writable: true, + enumerable: true, + configurable: true, + value: function values() { + webidl.brandCheck(this, object); + return makeIterator(this, "value"); + } + }, + entries: { + writable: true, + enumerable: true, + configurable: true, + value: function entries() { + webidl.brandCheck(this, object); + return makeIterator(this, "key+value"); + } + }, + forEach: { + writable: true, + enumerable: true, + configurable: true, + value: function forEach(callbackfn, thisArg = globalThis) { + webidl.brandCheck(this, object); + webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`); + if (typeof callbackfn !== "function") { + throw new TypeError( + `Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.` + ); + } + for (const { 0: key, 1: value } of makeIterator(this, "key+value")) { + callbackfn.call(thisArg, value, key, this); + } + } + } + }; + return Object.defineProperties(object.prototype, { + ...properties, + [Symbol.iterator]: { + writable: true, + enumerable: false, + configurable: true, + value: properties.entries.value + } + }); + } + async function fullyReadBody(body, processBody, processBodyError) { + const successSteps = processBody; + const errorSteps = processBodyError; + let reader; + try { + reader = body.stream.getReader(); + } catch (e2) { + errorSteps(e2); + return; + } + try { + successSteps(await readAllBytes(reader)); + } catch (e2) { + errorSteps(e2); + } + } + function isReadableStreamLike(stream) { + return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; + } + function readableStreamClose(controller) { + try { + controller.close(); + controller.byobRequest?.respond(0); + } catch (err) { + if (!err.message.includes("Controller is already closed") && !err.message.includes("ReadableStream is already closed")) { + throw err; + } + } + } + var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/; + function isomorphicEncode(input) { + assert(!invalidIsomorphicEncodeValueRegex.test(input)); + return input; + } + async function readAllBytes(reader) { + const bytes = []; + let byteLength = 0; + while (true) { + const { done, value: chunk } = await reader.read(); + if (done) { + return Buffer.concat(bytes, byteLength); + } + if (!isUint8Array(chunk)) { + throw new TypeError("Received non-Uint8Array chunk"); + } + bytes.push(chunk); + byteLength += chunk.length; + } + } + function urlIsLocal(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "about:" || protocol === "blob:" || protocol === "data:"; + } + function urlHasHttpsScheme(url) { + return typeof url === "string" && url[5] === ":" && url[0] === "h" && url[1] === "t" && url[2] === "t" && url[3] === "p" && url[4] === "s" || url.protocol === "https:"; + } + function urlIsHttpHttpsScheme(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "http:" || protocol === "https:"; + } + function simpleRangeHeaderValue(value, allowWhitespace) { + const data = value; + if (!data.startsWith("bytes")) { + return "failure"; + } + const position = { position: 5 }; + if (allowWhitespace) { + collectASequenceOfCodePoints( + (char) => char === " " || char === " ", + data, + position + ); + } + if (data.charCodeAt(position.position) !== 61) { + return "failure"; + } + position.position++; + if (allowWhitespace) { + collectASequenceOfCodePoints( + (char) => char === " " || char === " ", + data, + position + ); + } + const rangeStart = collectASequenceOfCodePoints( + (char) => { + const code = char.charCodeAt(0); + return code >= 48 && code <= 57; + }, + data, + position + ); + const rangeStartValue = rangeStart.length ? Number(rangeStart) : null; + if (allowWhitespace) { + collectASequenceOfCodePoints( + (char) => char === " " || char === " ", + data, + position + ); + } + if (data.charCodeAt(position.position) !== 45) { + return "failure"; + } + position.position++; + if (allowWhitespace) { + collectASequenceOfCodePoints( + (char) => char === " " || char === " ", + data, + position + ); + } + const rangeEnd = collectASequenceOfCodePoints( + (char) => { + const code = char.charCodeAt(0); + return code >= 48 && code <= 57; + }, + data, + position + ); + const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null; + if (position.position < data.length) { + return "failure"; + } + if (rangeEndValue === null && rangeStartValue === null) { + return "failure"; + } + if (rangeStartValue > rangeEndValue) { + return "failure"; + } + return { rangeStartValue, rangeEndValue }; + } + function buildContentRange(rangeStart, rangeEnd, fullLength) { + let contentRange = "bytes "; + contentRange += isomorphicEncode(`${rangeStart}`); + contentRange += "-"; + contentRange += isomorphicEncode(`${rangeEnd}`); + contentRange += "/"; + contentRange += isomorphicEncode(`${fullLength}`); + return contentRange; + } + var InflateStream = class extends Transform { + #zlibOptions; + /** @param {zlib.ZlibOptions} [zlibOptions] */ + constructor(zlibOptions) { + super(); + this.#zlibOptions = zlibOptions; + } + _transform(chunk, encoding, callback) { + if (!this._inflateStream) { + if (chunk.length === 0) { + callback(); + return; + } + this._inflateStream = (chunk[0] & 15) === 8 ? zlib.createInflate(this.#zlibOptions) : zlib.createInflateRaw(this.#zlibOptions); + this._inflateStream.on("data", this.push.bind(this)); + this._inflateStream.on("end", () => this.push(null)); + this._inflateStream.on("error", (err) => this.destroy(err)); + } + this._inflateStream.write(chunk, encoding, callback); + } + _final(callback) { + if (this._inflateStream) { + this._inflateStream.end(); + this._inflateStream = null; + } + callback(); + } + }; + function createInflate(zlibOptions) { + return new InflateStream(zlibOptions); + } + function extractMimeType(headers2) { + let charset = null; + let essence = null; + let mimeType = null; + const values = getDecodeSplit("content-type", headers2); + if (values === null) { + return "failure"; + } + for (const value of values) { + const temporaryMimeType = parseMIMEType(value); + if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*") { + continue; + } + mimeType = temporaryMimeType; + if (mimeType.essence !== essence) { + charset = null; + if (mimeType.parameters.has("charset")) { + charset = mimeType.parameters.get("charset"); + } + essence = mimeType.essence; + } else if (!mimeType.parameters.has("charset") && charset !== null) { + mimeType.parameters.set("charset", charset); + } + } + if (mimeType == null) { + return "failure"; + } + return mimeType; + } + function gettingDecodingSplitting(value) { + const input = value; + const position = { position: 0 }; + const values = []; + let temporaryValue = ""; + while (position.position < input.length) { + temporaryValue += collectASequenceOfCodePoints( + (char) => char !== '"' && char !== ",", + input, + position + ); + if (position.position < input.length) { + if (input.charCodeAt(position.position) === 34) { + temporaryValue += collectAnHTTPQuotedString( + input, + position + ); + if (position.position < input.length) { + continue; + } + } else { + assert(input.charCodeAt(position.position) === 44); + position.position++; + } + } + temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32); + values.push(temporaryValue); + temporaryValue = ""; + } + return values; + } + function getDecodeSplit(name, list) { + const value = list.get(name, true); + if (value === null) { + return null; + } + return gettingDecodingSplitting(value); + } + var textDecoder = new TextDecoder(); + function utf8DecodeBytes(buffer) { + if (buffer.length === 0) { + return ""; + } + if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) { + buffer = buffer.subarray(3); + } + const output = textDecoder.decode(buffer); + return output; + } + var EnvironmentSettingsObjectBase = class { + get baseUrl() { + return getGlobalOrigin(); + } + get origin() { + return this.baseUrl?.origin; + } + policyContainer = makePolicyContainer(); + }; + var EnvironmentSettingsObject = class { + settingsObject = new EnvironmentSettingsObjectBase(); + }; + var environmentSettingsObject = new EnvironmentSettingsObject(); + module.exports = { + isAborted, + isCancelled, + isValidEncodedURL, + createDeferredPromise, + ReadableStreamFrom, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + clampAndCoarsenConnectionTimingInfo, + coarsenedSharedCurrentTime, + determineRequestsReferrer, + makePolicyContainer, + clonePolicyContainer, + appendFetchMetadata, + appendRequestOriginHeader, + TAOCheck, + corsCheck, + crossOriginResourcePolicyCheck, + createOpaqueTimingInfo, + setRequestReferrerPolicyOnRedirect, + isValidHTTPToken, + requestBadPort, + requestCurrentURL, + responseURL, + responseLocationURL, + isBlobLike, + isURLPotentiallyTrustworthy, + isValidReasonPhrase, + sameOrigin, + normalizeMethod, + serializeJavascriptValueToJSONString, + iteratorMixin, + createIterator, + isValidHeaderName, + isValidHeaderValue, + isErrorLike, + fullyReadBody, + bytesMatch, + isReadableStreamLike, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlHasHttpsScheme, + urlIsHttpHttpsScheme, + readAllBytes, + simpleRangeHeaderValue, + buildContentRange, + parseMetadata, + createInflate, + extractMimeType, + getDecodeSplit, + utf8DecodeBytes, + environmentSettingsObject + }; + } +}); + +// node_modules/undici/lib/web/fetch/symbols.js +var require_symbols2 = __commonJS({ + "node_modules/undici/lib/web/fetch/symbols.js"(exports, module) { + "use strict"; + module.exports = { + kUrl: /* @__PURE__ */ Symbol("url"), + kHeaders: /* @__PURE__ */ Symbol("headers"), + kSignal: /* @__PURE__ */ Symbol("signal"), + kState: /* @__PURE__ */ Symbol("state"), + kDispatcher: /* @__PURE__ */ Symbol("dispatcher") + }; + } +}); + +// node_modules/undici/lib/web/fetch/file.js +var require_file = __commonJS({ + "node_modules/undici/lib/web/fetch/file.js"(exports, module) { + "use strict"; + var { Blob: Blob2, File } = __require("node:buffer"); + var { kState } = require_symbols2(); + var { webidl } = require_webidl(); + var FileLike = class _FileLike { + constructor(blobLike, fileName, options = {}) { + const n = fileName; + const t = options.type; + const d = options.lastModified ?? Date.now(); + this[kState] = { + blobLike, + name: n, + type: t, + lastModified: d + }; + } + stream(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.stream(...args); + } + arrayBuffer(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.arrayBuffer(...args); + } + slice(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.slice(...args); + } + text(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.text(...args); + } + get size() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.size; + } + get type() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.type; + } + get name() { + webidl.brandCheck(this, _FileLike); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _FileLike); + return this[kState].lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + }; + webidl.converters.Blob = webidl.interfaceConverter(Blob2); + function isFileLike(object) { + return object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; + } + module.exports = { FileLike, isFileLike }; + } +}); + +// node_modules/undici/lib/web/fetch/formdata.js +var require_formdata = __commonJS({ + "node_modules/undici/lib/web/fetch/formdata.js"(exports, module) { + "use strict"; + var { isBlobLike, iteratorMixin } = require_util2(); + var { kState } = require_symbols2(); + var { kEnumerableProperty } = require_util(); + var { FileLike, isFileLike } = require_file(); + var { webidl } = require_webidl(); + var { File: NativeFile } = __require("node:buffer"); + var nodeUtil = __require("node:util"); + var File = globalThis.File ?? NativeFile; + var FormData = class _FormData { + constructor(form) { + webidl.util.markAsUncloneable(this); + if (form !== void 0) { + throw webidl.errors.conversionFailed({ + prefix: "FormData constructor", + argument: "Argument 1", + types: ["undefined"] + }); + } + this[kState] = []; + } + append(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + const prefix = "FormData.append"; + webidl.argumentLengthCheck(arguments, 2, prefix); + if (arguments.length === 3 && !isBlobLike(value)) { + throw new TypeError( + "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name, prefix, "name"); + value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "value", { strict: false }) : webidl.converters.USVString(value, prefix, "value"); + filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "filename") : void 0; + const entry = makeEntry(name, value, filename); + this[kState].push(entry); + } + delete(name) { + webidl.brandCheck(this, _FormData); + const prefix = "FormData.delete"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + this[kState] = this[kState].filter((entry) => entry.name !== name); + } + get(name) { + webidl.brandCheck(this, _FormData); + const prefix = "FormData.get"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx === -1) { + return null; + } + return this[kState][idx].value; + } + getAll(name) { + webidl.brandCheck(this, _FormData); + const prefix = "FormData.getAll"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + } + has(name) { + webidl.brandCheck(this, _FormData); + const prefix = "FormData.has"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + return this[kState].findIndex((entry) => entry.name === name) !== -1; + } + set(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + const prefix = "FormData.set"; + webidl.argumentLengthCheck(arguments, 2, prefix); + if (arguments.length === 3 && !isBlobLike(value)) { + throw new TypeError( + "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name, prefix, "name"); + value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "name", { strict: false }) : webidl.converters.USVString(value, prefix, "name"); + filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "name") : void 0; + const entry = makeEntry(name, value, filename); + const idx = this[kState].findIndex((entry2) => entry2.name === name); + if (idx !== -1) { + this[kState] = [ + ...this[kState].slice(0, idx), + entry, + ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) + ]; + } else { + this[kState].push(entry); + } + } + [nodeUtil.inspect.custom](depth, options) { + const state = this[kState].reduce((a, b) => { + if (a[b.name]) { + if (Array.isArray(a[b.name])) { + a[b.name].push(b.value); + } else { + a[b.name] = [a[b.name], b.value]; + } + } else { + a[b.name] = b.value; + } + return a; + }, { __proto__: null }); + options.depth ??= depth; + options.colors ??= true; + const output = nodeUtil.formatWithOptions(options, state); + return `FormData ${output.slice(output.indexOf("]") + 2)}`; + } + }; + iteratorMixin("FormData", FormData, kState, "name", "value"); + Object.defineProperties(FormData.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + getAll: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FormData", + configurable: true + } + }); + function makeEntry(name, value, filename) { + if (typeof value === "string") { + } else { + if (!isFileLike(value)) { + value = value instanceof Blob ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); + } + if (filename !== void 0) { + const options = { + type: value.type, + lastModified: value.lastModified + }; + value = value instanceof NativeFile ? new File([value], filename, options) : new FileLike(value, filename, options); + } + } + return { name, value }; + } + module.exports = { FormData, makeEntry }; + } +}); + +// node_modules/undici/lib/web/fetch/formdata-parser.js +var require_formdata_parser = __commonJS({ + "node_modules/undici/lib/web/fetch/formdata-parser.js"(exports, module) { + "use strict"; + var { isUSVString, bufferToLowerCasedHeaderName } = require_util(); + var { utf8DecodeBytes } = require_util2(); + var { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url(); + var { isFileLike } = require_file(); + var { makeEntry } = require_formdata(); + var assert = __require("node:assert"); + var { File: NodeFile } = __require("node:buffer"); + var File = globalThis.File ?? NodeFile; + var formDataNameBuffer = Buffer.from('form-data; name="'); + var filenameBuffer = Buffer.from("; filename"); + var dd = Buffer.from("--"); + var ddcrlf = Buffer.from("--\r\n"); + function isAsciiString(chars) { + for (let i = 0; i < chars.length; ++i) { + if ((chars.charCodeAt(i) & ~127) !== 0) { + return false; + } + } + return true; + } + function validateBoundary(boundary) { + const length = boundary.length; + if (length < 27 || length > 70) { + return false; + } + for (let i = 0; i < length; ++i) { + const cp = boundary.charCodeAt(i); + if (!(cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 39 || cp === 45 || cp === 95)) { + return false; + } + } + return true; + } + function multipartFormDataParser(input, mimeType) { + assert(mimeType !== "failure" && mimeType.essence === "multipart/form-data"); + const boundaryString = mimeType.parameters.get("boundary"); + if (boundaryString === void 0) { + return "failure"; + } + const boundary = Buffer.from(`--${boundaryString}`, "utf8"); + const entryList = []; + const position = { position: 0 }; + while (input[position.position] === 13 && input[position.position + 1] === 10) { + position.position += 2; + } + let trailing = input.length; + while (input[trailing - 1] === 10 && input[trailing - 2] === 13) { + trailing -= 2; + } + if (trailing !== input.length) { + input = input.subarray(0, trailing); + } + while (true) { + if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) { + position.position += boundary.length; + } else { + return "failure"; + } + if (position.position === input.length - 2 && bufferStartsWith(input, dd, position) || position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position)) { + return entryList; + } + if (input[position.position] !== 13 || input[position.position + 1] !== 10) { + return "failure"; + } + position.position += 2; + const result = parseMultipartFormDataHeaders(input, position); + if (result === "failure") { + return "failure"; + } + let { name, filename, contentType, encoding } = result; + position.position += 2; + let body; + { + const boundaryIndex = input.indexOf(boundary.subarray(2), position.position); + if (boundaryIndex === -1) { + return "failure"; + } + body = input.subarray(position.position, boundaryIndex - 4); + position.position += body.length; + if (encoding === "base64") { + body = Buffer.from(body.toString(), "base64"); + } + } + if (input[position.position] !== 13 || input[position.position + 1] !== 10) { + return "failure"; + } else { + position.position += 2; + } + let value; + if (filename !== null) { + contentType ??= "text/plain"; + if (!isAsciiString(contentType)) { + contentType = ""; + } + value = new File([body], filename, { type: contentType }); + } else { + value = utf8DecodeBytes(Buffer.from(body)); + } + assert(isUSVString(name)); + assert(typeof value === "string" && isUSVString(value) || isFileLike(value)); + entryList.push(makeEntry(name, value, filename)); + } + } + function parseMultipartFormDataHeaders(input, position) { + let name = null; + let filename = null; + let contentType = null; + let encoding = null; + while (true) { + if (input[position.position] === 13 && input[position.position + 1] === 10) { + if (name === null) { + return "failure"; + } + return { name, filename, contentType, encoding }; + } + let headerName = collectASequenceOfBytes( + (char) => char !== 10 && char !== 13 && char !== 58, + input, + position + ); + headerName = removeChars(headerName, true, true, (char) => char === 9 || char === 32); + if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) { + return "failure"; + } + if (input[position.position] !== 58) { + return "failure"; + } + position.position++; + collectASequenceOfBytes( + (char) => char === 32 || char === 9, + input, + position + ); + switch (bufferToLowerCasedHeaderName(headerName)) { + case "content-disposition": { + name = filename = null; + if (!bufferStartsWith(input, formDataNameBuffer, position)) { + return "failure"; + } + position.position += 17; + name = parseMultipartFormDataName(input, position); + if (name === null) { + return "failure"; + } + if (bufferStartsWith(input, filenameBuffer, position)) { + let check = position.position + filenameBuffer.length; + if (input[check] === 42) { + position.position += 1; + check += 1; + } + if (input[check] !== 61 || input[check + 1] !== 34) { + return "failure"; + } + position.position += 12; + filename = parseMultipartFormDataName(input, position); + if (filename === null) { + return "failure"; + } + } + break; + } + case "content-type": { + let headerValue = collectASequenceOfBytes( + (char) => char !== 10 && char !== 13, + input, + position + ); + headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32); + contentType = isomorphicDecode(headerValue); + break; + } + case "content-transfer-encoding": { + let headerValue = collectASequenceOfBytes( + (char) => char !== 10 && char !== 13, + input, + position + ); + headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32); + encoding = isomorphicDecode(headerValue); + break; + } + default: { + collectASequenceOfBytes( + (char) => char !== 10 && char !== 13, + input, + position + ); + } + } + if (input[position.position] !== 13 && input[position.position + 1] !== 10) { + return "failure"; + } else { + position.position += 2; + } + } + } + function parseMultipartFormDataName(input, position) { + assert(input[position.position - 1] === 34); + let name = collectASequenceOfBytes( + (char) => char !== 10 && char !== 13 && char !== 34, + input, + position + ); + if (input[position.position] !== 34) { + return null; + } else { + position.position++; + } + name = new TextDecoder().decode(name).replace(/%0A/ig, "\n").replace(/%0D/ig, "\r").replace(/%22/g, '"'); + return name; + } + function collectASequenceOfBytes(condition, input, position) { + let start = position.position; + while (start < input.length && condition(input[start])) { + ++start; + } + return input.subarray(position.position, position.position = start); + } + function removeChars(buf2, leading, trailing, predicate) { + let lead = 0; + let trail = buf2.length - 1; + if (leading) { + while (lead < buf2.length && predicate(buf2[lead])) lead++; + } + if (trailing) { + while (trail > 0 && predicate(buf2[trail])) trail--; + } + return lead === 0 && trail === buf2.length - 1 ? buf2 : buf2.subarray(lead, trail + 1); + } + function bufferStartsWith(buffer, start, position) { + if (buffer.length < start.length) { + return false; + } + for (let i = 0; i < start.length; i++) { + if (start[i] !== buffer[position.position + i]) { + return false; + } + } + return true; + } + module.exports = { + multipartFormDataParser, + validateBoundary + }; + } +}); + +// node_modules/undici/lib/web/fetch/body.js +var require_body = __commonJS({ + "node_modules/undici/lib/web/fetch/body.js"(exports, module) { + "use strict"; + var util2 = require_util(); + var { + ReadableStreamFrom, + isBlobLike, + isReadableStreamLike, + readableStreamClose, + createDeferredPromise, + fullyReadBody, + extractMimeType, + utf8DecodeBytes + } = require_util2(); + var { FormData } = require_formdata(); + var { kState } = require_symbols2(); + var { webidl } = require_webidl(); + var { Blob: Blob2 } = __require("node:buffer"); + var assert = __require("node:assert"); + var { isErrored, isDisturbed } = __require("node:stream"); + var { isArrayBuffer } = __require("node:util/types"); + var { serializeAMimeType } = require_data_url(); + var { multipartFormDataParser } = require_formdata_parser(); + var random; + try { + const crypto3 = __require("node:crypto"); + random = (max) => crypto3.randomInt(0, max); + } catch { + random = (max) => Math.floor(Math.random(max)); + } + var textEncoder = new TextEncoder(); + function noop() { + } + var hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0; + var streamRegistry; + if (hasFinalizationRegistry) { + streamRegistry = new FinalizationRegistry((weakRef) => { + const stream = weakRef.deref(); + if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) { + stream.cancel("Response object has been garbage collected").catch(noop); + } + }); + } + function extractBody(object, keepalive = false) { + let stream = null; + if (object instanceof ReadableStream) { + stream = object; + } else if (isBlobLike(object)) { + stream = object.stream(); + } else { + stream = new ReadableStream({ + async pull(controller) { + const buffer = typeof source === "string" ? textEncoder.encode(source) : source; + if (buffer.byteLength) { + controller.enqueue(buffer); + } + queueMicrotask(() => readableStreamClose(controller)); + }, + start() { + }, + type: "bytes" + }); + } + assert(isReadableStreamLike(stream)); + let action = null; + let source = null; + let length = null; + let type2 = null; + if (typeof object === "string") { + source = object; + type2 = "text/plain;charset=UTF-8"; + } else if (object instanceof URLSearchParams) { + source = object.toString(); + type2 = "application/x-www-form-urlencoded;charset=UTF-8"; + } else if (isArrayBuffer(object)) { + source = new Uint8Array(object.slice()); + } else if (ArrayBuffer.isView(object)) { + source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); + } else if (util2.isFormDataLike(object)) { + const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; + const prefix = `--${boundary}\r +Content-Disposition: form-data`; + const escape = (str2) => str2.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); + const blobParts = []; + const rn = new Uint8Array([13, 10]); + length = 0; + let hasUnknownSizeValue = false; + for (const [name, value] of object) { + if (typeof value === "string") { + const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r +\r +${normalizeLinefeeds(value)}\r +`); + blobParts.push(chunk2); + length += chunk2.byteLength; + } else { + const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r +Content-Type: ${value.type || "application/octet-stream"}\r +\r +`); + blobParts.push(chunk2, value, rn); + if (typeof value.size === "number") { + length += chunk2.byteLength + value.size + rn.byteLength; + } else { + hasUnknownSizeValue = true; + } + } + } + const chunk = textEncoder.encode(`--${boundary}--\r +`); + blobParts.push(chunk); + length += chunk.byteLength; + if (hasUnknownSizeValue) { + length = null; + } + source = object; + action = async function* () { + for (const part of blobParts) { + if (part.stream) { + yield* part.stream(); + } else { + yield part; + } + } + }; + type2 = `multipart/form-data; boundary=${boundary}`; + } else if (isBlobLike(object)) { + source = object; + length = object.size; + if (object.type) { + type2 = object.type; + } + } else if (typeof object[Symbol.asyncIterator] === "function") { + if (keepalive) { + throw new TypeError("keepalive"); + } + if (util2.isDisturbed(object) || object.locked) { + throw new TypeError( + "Response body object should not be disturbed or locked" + ); + } + stream = object instanceof ReadableStream ? object : ReadableStreamFrom(object); + } + if (typeof source === "string" || util2.isBuffer(source)) { + length = Buffer.byteLength(source); + } + if (action != null) { + let iterator; + stream = new ReadableStream({ + async start() { + iterator = action(object)[Symbol.asyncIterator](); + }, + async pull(controller) { + const { value, done } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + controller.byobRequest?.respond(0); + }); + } else { + if (!isErrored(stream)) { + const buffer = new Uint8Array(value); + if (buffer.byteLength) { + controller.enqueue(buffer); + } + } + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: "bytes" + }); + } + const body = { stream, source, length }; + return [body, type2]; + } + function safelyExtractBody(object, keepalive = false) { + if (object instanceof ReadableStream) { + assert(!util2.isDisturbed(object), "The body has already been consumed."); + assert(!object.locked, "The stream is locked."); + } + return extractBody(object, keepalive); + } + function cloneBody(instance, body) { + const [out1, out2] = body.stream.tee(); + body.stream = out1; + return { + stream: out2, + length: body.length, + source: body.source + }; + } + function throwIfAborted(state) { + if (state.aborted) { + throw new DOMException("The operation was aborted.", "AbortError"); + } + } + function bodyMixinMethods(instance) { + const methods = { + blob() { + return consumeBody(this, (bytes) => { + let mimeType = bodyMimeType(this); + if (mimeType === null) { + mimeType = ""; + } else if (mimeType) { + mimeType = serializeAMimeType(mimeType); + } + return new Blob2([bytes], { type: mimeType }); + }, instance); + }, + arrayBuffer() { + return consumeBody(this, (bytes) => { + return new Uint8Array(bytes).buffer; + }, instance); + }, + text() { + return consumeBody(this, utf8DecodeBytes, instance); + }, + json() { + return consumeBody(this, parseJSONFromBytes, instance); + }, + formData() { + return consumeBody(this, (value) => { + const mimeType = bodyMimeType(this); + if (mimeType !== null) { + switch (mimeType.essence) { + case "multipart/form-data": { + const parsed = multipartFormDataParser(value, mimeType); + if (parsed === "failure") { + throw new TypeError("Failed to parse body as FormData."); + } + const fd = new FormData(); + fd[kState] = parsed; + return fd; + } + case "application/x-www-form-urlencoded": { + const entries = new URLSearchParams(value.toString()); + const fd = new FormData(); + for (const [name, value2] of entries) { + fd.append(name, value2); + } + return fd; + } + } + } + throw new TypeError( + 'Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".' + ); + }, instance); + }, + bytes() { + return consumeBody(this, (bytes) => { + return new Uint8Array(bytes); + }, instance); + } + }; + return methods; + } + function mixinBody(prototype) { + Object.assign(prototype.prototype, bodyMixinMethods(prototype)); + } + async function consumeBody(object, convertBytesToJSValue, instance) { + webidl.brandCheck(object, instance); + if (bodyUnusable(object)) { + throw new TypeError("Body is unusable: Body has already been read"); + } + throwIfAborted(object[kState]); + const promise = createDeferredPromise(); + const errorSteps = (error2) => promise.reject(error2); + const successSteps = (data) => { + try { + promise.resolve(convertBytesToJSValue(data)); + } catch (e2) { + errorSteps(e2); + } + }; + if (object[kState].body == null) { + successSteps(Buffer.allocUnsafe(0)); + return promise.promise; + } + await fullyReadBody(object[kState].body, successSteps, errorSteps); + return promise.promise; + } + function bodyUnusable(object) { + const body = object[kState].body; + return body != null && (body.stream.locked || util2.isDisturbed(body.stream)); + } + function parseJSONFromBytes(bytes) { + return JSON.parse(utf8DecodeBytes(bytes)); + } + function bodyMimeType(requestOrResponse) { + const headers2 = requestOrResponse[kState].headersList; + const mimeType = extractMimeType(headers2); + if (mimeType === "failure") { + return null; + } + return mimeType; + } + module.exports = { + extractBody, + safelyExtractBody, + cloneBody, + mixinBody, + streamRegistry, + hasFinalizationRegistry, + bodyUnusable + }; + } +}); + +// node_modules/undici/lib/dispatcher/client-h1.js +var require_client_h1 = __commonJS({ + "node_modules/undici/lib/dispatcher/client-h1.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var util2 = require_util(); + var { channels } = require_diagnostics(); + var timers = require_timers(); + var { + RequestContentLengthMismatchError, + ResponseContentLengthMismatchError, + RequestAbortedError, + HeadersTimeoutError, + HeadersOverflowError, + SocketError, + InformationalError, + BodyTimeoutError, + HTTPParserError, + ResponseExceededMaxSizeError + } = require_errors(); + var { + kUrl, + kReset, + kClient, + kParser, + kBlocking, + kRunning, + kPending, + kSize, + kWriting, + kQueue, + kNoRef, + kKeepAliveDefaultTimeout, + kHostHeader, + kPendingIdx, + kRunningIdx, + kError, + kPipelining, + kSocket, + kKeepAliveTimeoutValue, + kMaxHeadersSize, + kKeepAliveMaxTimeout, + kKeepAliveTimeoutThreshold, + kHeadersTimeout, + kBodyTimeout, + kStrictContentLength, + kMaxRequests, + kCounter, + kMaxResponseSize, + kOnError, + kResume, + kHTTPContext + } = require_symbols(); + var constants3 = require_constants2(); + var EMPTY_BUF = Buffer.alloc(0); + var FastBuffer = Buffer[Symbol.species]; + var addListener = util2.addListener; + var removeAllListeners = util2.removeAllListeners; + var extractBody; + async function lazyllhttp() { + const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; + let mod2; + try { + mod2 = await WebAssembly.compile(require_llhttp_simd_wasm()); + } catch (e2) { + mod2 = await WebAssembly.compile(llhttpWasmData || require_llhttp_wasm()); + } + return await WebAssembly.instantiate(mod2, { + env: { + /* eslint-disable camelcase */ + wasm_on_url: (p, at, len) => { + return 0; + }, + wasm_on_status: (p, at, len) => { + assert(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_begin: (p) => { + assert(currentParser.ptr === p); + return currentParser.onMessageBegin() || 0; + }, + wasm_on_header_field: (p, at, len) => { + assert(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_header_value: (p, at, len) => { + assert(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { + assert(currentParser.ptr === p); + return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; + }, + wasm_on_body: (p, at, len) => { + assert(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_complete: (p) => { + assert(currentParser.ptr === p); + return currentParser.onMessageComplete() || 0; + } + /* eslint-enable camelcase */ + } + }); + } + var llhttpInstance = null; + var llhttpPromise = lazyllhttp(); + llhttpPromise.catch(); + var currentParser = null; + var currentBufferRef = null; + var currentBufferSize = 0; + var currentBufferPtr = null; + var USE_NATIVE_TIMER = 0; + var USE_FAST_TIMER = 1; + var TIMEOUT_HEADERS = 2 | USE_FAST_TIMER; + var TIMEOUT_BODY = 4 | USE_FAST_TIMER; + var TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER; + var Parser = class { + constructor(client, socket, { exports: exports2 }) { + assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + this.llhttp = exports2; + this.ptr = this.llhttp.llhttp_alloc(constants3.TYPE.RESPONSE); + this.client = client; + this.socket = socket; + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.statusCode = null; + this.statusText = ""; + this.upgrade = false; + this.headers = []; + this.headersSize = 0; + this.headersMaxSize = client[kMaxHeadersSize]; + this.shouldKeepAlive = false; + this.paused = false; + this.resume = this.resume.bind(this); + this.bytesRead = 0; + this.keepAlive = ""; + this.contentLength = ""; + this.connection = ""; + this.maxResponseSize = client[kMaxResponseSize]; + } + setTimeout(delay, type2) { + if (delay !== this.timeoutValue || type2 & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) { + if (this.timeout) { + timers.clearTimeout(this.timeout); + this.timeout = null; + } + if (delay) { + if (type2 & USE_FAST_TIMER) { + this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this)); + } else { + this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this)); + this.timeout.unref(); + } + } + this.timeoutValue = delay; + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + this.timeoutType = type2; + } + resume() { + if (this.socket.destroyed || !this.paused) { + return; + } + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_resume(this.ptr); + assert(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + this.paused = false; + this.execute(this.socket.read() || EMPTY_BUF); + this.readMore(); + } + readMore() { + while (!this.paused && this.ptr) { + const chunk = this.socket.read(); + if (chunk === null) { + break; + } + this.execute(chunk); + } + } + execute(data) { + assert(this.ptr != null); + assert(currentParser == null); + assert(!this.paused); + const { socket, llhttp } = this; + if (data.length > currentBufferSize) { + if (currentBufferPtr) { + llhttp.free(currentBufferPtr); + } + currentBufferSize = Math.ceil(data.length / 4096) * 4096; + currentBufferPtr = llhttp.malloc(currentBufferSize); + } + new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); + try { + let ret; + try { + currentBufferRef = data; + currentParser = this; + ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); + } catch (err) { + throw err; + } finally { + currentParser = null; + currentBufferRef = null; + } + const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; + if (ret === constants3.ERROR.PAUSED_UPGRADE) { + this.onUpgrade(data.slice(offset)); + } else if (ret === constants3.ERROR.PAUSED) { + this.paused = true; + socket.unshift(data.slice(offset)); + } else if (ret !== constants3.ERROR.OK) { + const ptr = llhttp.llhttp_get_error_reason(this.ptr); + let message = ""; + if (ptr) { + const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); + message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; + } + throw new HTTPParserError(message, constants3.ERROR[ret], data.slice(offset)); + } + } catch (err) { + util2.destroy(socket, err); + } + } + destroy() { + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_free(this.ptr); + this.ptr = null; + this.timeout && timers.clearTimeout(this.timeout); + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.paused = false; + } + onStatus(buf2) { + this.statusText = buf2.toString(); + } + onMessageBegin() { + const { socket, client } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + request.onResponseStarted(); + } + onHeaderField(buf2) { + const len = this.headers.length; + if ((len & 1) === 0) { + this.headers.push(buf2); + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf2]); + } + this.trackHeader(buf2.length); + } + onHeaderValue(buf2) { + let len = this.headers.length; + if ((len & 1) === 1) { + this.headers.push(buf2); + len += 1; + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf2]); + } + const key = this.headers[len - 2]; + if (key.length === 10) { + const headerName = util2.bufferToLowerCasedHeaderName(key); + if (headerName === "keep-alive") { + this.keepAlive += buf2.toString(); + } else if (headerName === "connection") { + this.connection += buf2.toString(); + } + } else if (key.length === 14 && util2.bufferToLowerCasedHeaderName(key) === "content-length") { + this.contentLength += buf2.toString(); + } + this.trackHeader(buf2.length); + } + trackHeader(len) { + this.headersSize += len; + if (this.headersSize >= this.headersMaxSize) { + util2.destroy(this.socket, new HeadersOverflowError()); + } + } + onUpgrade(head) { + const { upgrade, client, socket, headers: headers2, statusCode } = this; + assert(upgrade); + assert(client[kSocket] === socket); + assert(!socket.destroyed); + assert(!this.paused); + assert((headers2.length & 1) === 0); + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(request.upgrade || request.method === "CONNECT"); + this.statusCode = null; + this.statusText = ""; + this.shouldKeepAlive = null; + this.headers = []; + this.headersSize = 0; + socket.unshift(head); + socket[kParser].destroy(); + socket[kParser] = null; + socket[kClient] = null; + socket[kError] = null; + removeAllListeners(socket); + client[kSocket] = null; + client[kHTTPContext] = null; + client[kQueue][client[kRunningIdx]++] = null; + client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); + try { + request.onUpgrade(statusCode, headers2, socket); + } catch (err) { + util2.destroy(socket, err); + } + client[kResume](); + } + onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { + const { client, socket, headers: headers2, statusText } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + assert(!this.upgrade); + assert(this.statusCode < 200); + if (statusCode === 100) { + util2.destroy(socket, new SocketError("bad response", util2.getSocketInfo(socket))); + return -1; + } + if (upgrade && !request.upgrade) { + util2.destroy(socket, new SocketError("bad upgrade", util2.getSocketInfo(socket))); + return -1; + } + assert(this.timeoutType === TIMEOUT_HEADERS); + this.statusCode = statusCode; + this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. + request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + if (this.statusCode >= 200) { + const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; + this.setTimeout(bodyTimeout, TIMEOUT_BODY); + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + if (request.method === "CONNECT") { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + if (upgrade) { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + assert((this.headers.length & 1) === 0); + this.headers = []; + this.headersSize = 0; + if (this.shouldKeepAlive && client[kPipelining]) { + const keepAliveTimeout = this.keepAlive ? util2.parseKeepAliveTimeout(this.keepAlive) : null; + if (keepAliveTimeout != null) { + const timeout = Math.min( + keepAliveTimeout - client[kKeepAliveTimeoutThreshold], + client[kKeepAliveMaxTimeout] + ); + if (timeout <= 0) { + socket[kReset] = true; + } else { + client[kKeepAliveTimeoutValue] = timeout; + } + } else { + client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]; + } + } else { + socket[kReset] = true; + } + const pause = request.onHeaders(statusCode, headers2, this.resume, statusText) === false; + if (request.aborted) { + return -1; + } + if (request.method === "HEAD") { + return 1; + } + if (statusCode < 200) { + return 1; + } + if (socket[kBlocking]) { + socket[kBlocking] = false; + client[kResume](); + } + return pause ? constants3.ERROR.PAUSED : 0; + } + onBody(buf2) { + const { client, socket, statusCode, maxResponseSize } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + assert(statusCode >= 200); + if (maxResponseSize > -1 && this.bytesRead + buf2.length > maxResponseSize) { + util2.destroy(socket, new ResponseExceededMaxSizeError()); + return -1; + } + this.bytesRead += buf2.length; + if (request.onData(buf2) === false) { + return constants3.ERROR.PAUSED; + } + } + onMessageComplete() { + const { client, socket, statusCode, upgrade, headers: headers2, contentLength, bytesRead, shouldKeepAlive } = this; + if (socket.destroyed && (!statusCode || shouldKeepAlive)) { + return -1; + } + if (upgrade) { + return; + } + assert(statusCode >= 100); + assert((this.headers.length & 1) === 0); + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + this.statusCode = null; + this.statusText = ""; + this.bytesRead = 0; + this.contentLength = ""; + this.keepAlive = ""; + this.connection = ""; + this.headers = []; + this.headersSize = 0; + if (statusCode < 200) { + return; + } + if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + util2.destroy(socket, new ResponseContentLengthMismatchError()); + return -1; + } + request.onComplete(headers2); + client[kQueue][client[kRunningIdx]++] = null; + if (socket[kWriting]) { + assert(client[kRunning] === 0); + util2.destroy(socket, new InformationalError("reset")); + return constants3.ERROR.PAUSED; + } else if (!shouldKeepAlive) { + util2.destroy(socket, new InformationalError("reset")); + return constants3.ERROR.PAUSED; + } else if (socket[kReset] && client[kRunning] === 0) { + util2.destroy(socket, new InformationalError("reset")); + return constants3.ERROR.PAUSED; + } else if (client[kPipelining] == null || client[kPipelining] === 1) { + setImmediate(() => client[kResume]()); + } else { + client[kResume](); + } + } + }; + function onParserTimeout(parser) { + const { socket, timeoutType, client, paused } = parser.deref(); + if (timeoutType === TIMEOUT_HEADERS) { + if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { + assert(!paused, "cannot be paused while waiting for headers"); + util2.destroy(socket, new HeadersTimeoutError()); + } + } else if (timeoutType === TIMEOUT_BODY) { + if (!paused) { + util2.destroy(socket, new BodyTimeoutError()); + } + } else if (timeoutType === TIMEOUT_KEEP_ALIVE) { + assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + util2.destroy(socket, new InformationalError("socket idle timeout")); + } + } + async function connectH1(client, socket) { + client[kSocket] = socket; + if (!llhttpInstance) { + llhttpInstance = await llhttpPromise; + llhttpPromise = null; + } + socket[kNoRef] = false; + socket[kWriting] = false; + socket[kReset] = false; + socket[kBlocking] = false; + socket[kParser] = new Parser(client, socket, llhttpInstance); + addListener(socket, "error", function(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + const parser = this[kParser]; + if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + this[kError] = err; + this[kClient][kOnError](err); + }); + addListener(socket, "readable", function() { + const parser = this[kParser]; + if (parser) { + parser.readMore(); + } + }); + addListener(socket, "end", function() { + const parser = this[kParser]; + if (parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + util2.destroy(this, new SocketError("other side closed", util2.getSocketInfo(this))); + }); + addListener(socket, "close", function() { + const client2 = this[kClient]; + const parser = this[kParser]; + if (parser) { + if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + } + this[kParser].destroy(); + this[kParser] = null; + } + const err = this[kError] || new SocketError("closed", util2.getSocketInfo(this)); + client2[kSocket] = null; + client2[kHTTPContext] = null; + if (client2.destroyed) { + assert(client2[kPending] === 0); + const requests = client2[kQueue].splice(client2[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util2.errorRequest(client2, request, err); + } + } else if (client2[kRunning] > 0 && err.code !== "UND_ERR_INFO") { + const request = client2[kQueue][client2[kRunningIdx]]; + client2[kQueue][client2[kRunningIdx]++] = null; + util2.errorRequest(client2, request, err); + } + client2[kPendingIdx] = client2[kRunningIdx]; + assert(client2[kRunning] === 0); + client2.emit("disconnect", client2[kUrl], [client2], err); + client2[kResume](); + }); + let closed = false; + socket.on("close", () => { + closed = true; + }); + return { + version: "h1", + defaultPipelining: 1, + write(...args) { + return writeH1(client, ...args); + }, + resume() { + resumeH1(client); + }, + destroy(err, callback) { + if (closed) { + queueMicrotask(callback); + } else { + socket.destroy(err).on("close", callback); + } + }, + get destroyed() { + return socket.destroyed; + }, + busy(request) { + if (socket[kWriting] || socket[kReset] || socket[kBlocking]) { + return true; + } + if (request) { + if (client[kRunning] > 0 && !request.idempotent) { + return true; + } + if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) { + return true; + } + if (client[kRunning] > 0 && util2.bodyLength(request.body) !== 0 && (util2.isStream(request.body) || util2.isAsyncIterable(request.body) || util2.isFormDataLike(request.body))) { + return true; + } + } + return false; + } + }; + } + function resumeH1(client) { + const socket = client[kSocket]; + if (socket && !socket.destroyed) { + if (client[kSize] === 0) { + if (!socket[kNoRef] && socket.unref) { + socket.unref(); + socket[kNoRef] = true; + } + } else if (socket[kNoRef] && socket.ref) { + socket.ref(); + socket[kNoRef] = false; + } + if (client[kSize] === 0) { + if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) { + socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE); + } + } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { + if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { + const request = client[kQueue][client[kRunningIdx]]; + const headersTimeout = request.headersTimeout != null ? request.headersTimeout : client[kHeadersTimeout]; + socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS); + } + } + } + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function writeH1(client, request) { + const { method, path: path7, host, upgrade, blocking, reset } = request; + let { body, headers: headers2, contentLength } = request; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH"; + if (util2.isFormDataLike(body)) { + if (!extractBody) { + extractBody = require_body().extractBody; + } + const [bodyStream, contentType] = extractBody(body); + if (request.contentType == null) { + headers2.push("content-type", contentType); + } + body = bodyStream.stream; + contentLength = bodyStream.length; + } else if (util2.isBlobLike(body) && request.contentType == null && body.type) { + headers2.push("content-type", body.type); + } + if (body && typeof body.read === "function") { + body.read(0); + } + const bodyLength = util2.bodyLength(body); + contentLength = bodyLength ?? contentLength; + if (contentLength === null) { + contentLength = request.contentLength; + } + if (contentLength === 0 && !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + util2.errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + const socket = client[kSocket]; + const abort = (err) => { + if (request.aborted || request.completed) { + return; + } + util2.errorRequest(client, request, err || new RequestAbortedError()); + util2.destroy(body); + util2.destroy(socket, new InformationalError("aborted")); + }; + try { + request.onConnect(abort); + } catch (err) { + util2.errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + if (method === "HEAD") { + socket[kReset] = true; + } + if (upgrade || method === "CONNECT") { + socket[kReset] = true; + } + if (reset != null) { + socket[kReset] = reset; + } + if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + socket[kReset] = true; + } + if (blocking) { + socket[kBlocking] = true; + } + let header = `${method} ${path7} HTTP/1.1\r +`; + if (typeof host === "string") { + header += `host: ${host}\r +`; + } else { + header += client[kHostHeader]; + } + if (upgrade) { + header += `connection: upgrade\r +upgrade: ${upgrade}\r +`; + } else if (client[kPipelining] && !socket[kReset]) { + header += "connection: keep-alive\r\n"; + } else { + header += "connection: close\r\n"; + } + if (Array.isArray(headers2)) { + for (let n = 0; n < headers2.length; n += 2) { + const key = headers2[n + 0]; + const val = headers2[n + 1]; + if (Array.isArray(val)) { + for (let i = 0; i < val.length; i++) { + header += `${key}: ${val[i]}\r +`; + } + } else { + header += `${key}: ${val}\r +`; + } + } + } + if (channels.sendHeaders.hasSubscribers) { + channels.sendHeaders.publish({ request, headers: header, socket }); + } + if (!body || bodyLength === 0) { + writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload); + } else if (util2.isBuffer(body)) { + writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload); + } else if (util2.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload); + } else { + writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload); + } + } else if (util2.isStream(body)) { + writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload); + } else if (util2.isIterable(body)) { + writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload); + } else { + assert(false); + } + return true; + } + function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) { + assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + let finished = false; + const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header }); + const onData = function(chunk) { + if (finished) { + return; + } + try { + if (!writer.write(chunk) && this.pause) { + this.pause(); + } + } catch (err) { + util2.destroy(this, err); + } + }; + const onDrain = function() { + if (finished) { + return; + } + if (body.resume) { + body.resume(); + } + }; + const onClose = function() { + queueMicrotask(() => { + body.removeListener("error", onFinished); + }); + if (!finished) { + const err = new RequestAbortedError(); + queueMicrotask(() => onFinished(err)); + } + }; + const onFinished = function(err) { + if (finished) { + return; + } + finished = true; + assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + socket.off("drain", onDrain).off("error", onFinished); + body.removeListener("data", onData).removeListener("end", onFinished).removeListener("close", onClose); + if (!err) { + try { + writer.end(); + } catch (er) { + err = er; + } + } + writer.destroy(err); + if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) { + util2.destroy(body, err); + } else { + util2.destroy(body); + } + }; + body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onClose); + if (body.resume) { + body.resume(); + } + socket.on("drain", onDrain).on("error", onFinished); + if (body.errorEmitted ?? body.errored) { + setImmediate(() => onFinished(body.errored)); + } else if (body.endEmitted ?? body.readableEnded) { + setImmediate(() => onFinished(null)); + } + if (body.closeEmitted ?? body.closed) { + setImmediate(onClose); + } + } + function writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload) { + try { + if (!body) { + if (contentLength === 0) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + assert(contentLength === null, "no body must not have content length"); + socket.write(`${header}\r +`, "latin1"); + } + } else if (util2.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(body); + socket.uncork(); + request.onBodySent(body); + if (!expectsPayload && request.reset !== false) { + socket[kReset] = true; + } + } + request.onRequestSent(); + client[kResume](); + } catch (err) { + abort(err); + } + } + async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) { + assert(contentLength === body.size, "blob body must have content length"); + try { + if (contentLength != null && contentLength !== body.size) { + throw new RequestContentLengthMismatchError(); + } + const buffer = Buffer.from(await body.arrayBuffer()); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(buffer); + socket.uncork(); + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload && request.reset !== false) { + socket[kReset] = true; + } + client[kResume](); + } catch (err) { + abort(err); + } + } + async function writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload) { + assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve2, reject) => { + assert(callback === null); + if (socket[kError]) { + reject(socket[kError]); + } else { + callback = resolve2; + } + }); + socket.on("close", onDrain).on("drain", onDrain); + const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header }); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + if (!writer.write(chunk)) { + await waitForDrain(); + } + } + writer.end(); + } catch (err) { + writer.destroy(err); + } finally { + socket.off("close", onDrain).off("drain", onDrain); + } + } + var AsyncWriter = class { + constructor({ abort, socket, request, contentLength, client, expectsPayload, header }) { + this.socket = socket; + this.request = request; + this.contentLength = contentLength; + this.client = client; + this.bytesWritten = 0; + this.expectsPayload = expectsPayload; + this.header = header; + this.abort = abort; + socket[kWriting] = true; + } + write(chunk) { + const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return false; + } + const len = Buffer.byteLength(chunk); + if (!len) { + return true; + } + if (contentLength !== null && bytesWritten + len > contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + socket.cork(); + if (bytesWritten === 0) { + if (!expectsPayload && request.reset !== false) { + socket[kReset] = true; + } + if (contentLength === null) { + socket.write(`${header}transfer-encoding: chunked\r +`, "latin1"); + } else { + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + } + } + if (contentLength === null) { + socket.write(`\r +${len.toString(16)}\r +`, "latin1"); + } + this.bytesWritten += len; + const ret = socket.write(chunk); + socket.uncork(); + request.onBodySent(chunk); + if (!ret) { + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + } + return ret; + } + end() { + const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this; + request.onRequestSent(); + socket[kWriting] = false; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return; + } + if (bytesWritten === 0) { + if (expectsPayload) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + socket.write(`${header}\r +`, "latin1"); + } + } else if (contentLength === null) { + socket.write("\r\n0\r\n\r\n", "latin1"); + } + if (contentLength !== null && bytesWritten !== contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } else { + process.emitWarning(new RequestContentLengthMismatchError()); + } + } + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + client[kResume](); + } + destroy(err) { + const { socket, client, abort } = this; + socket[kWriting] = false; + if (err) { + assert(client[kRunning] <= 1, "pipeline should only contain this request"); + abort(err); + } + } + }; + module.exports = connectH1; + } +}); + +// node_modules/undici/lib/dispatcher/client-h2.js +var require_client_h2 = __commonJS({ + "node_modules/undici/lib/dispatcher/client-h2.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { pipeline } = __require("node:stream"); + var util2 = require_util(); + var { + RequestContentLengthMismatchError, + RequestAbortedError, + SocketError, + InformationalError + } = require_errors(); + var { + kUrl, + kReset, + kClient, + kRunning, + kPending, + kQueue, + kPendingIdx, + kRunningIdx, + kError, + kSocket, + kStrictContentLength, + kOnError, + kMaxConcurrentStreams, + kHTTP2Session, + kResume, + kSize, + kHTTPContext + } = require_symbols(); + var kOpenStreams = /* @__PURE__ */ Symbol("open streams"); + var extractBody; + var h2ExperimentalWarned = false; + var http2; + try { + http2 = __require("node:http2"); + } catch { + http2 = { constants: {} }; + } + var { + constants: { + HTTP2_HEADER_AUTHORITY, + HTTP2_HEADER_METHOD, + HTTP2_HEADER_PATH, + HTTP2_HEADER_SCHEME, + HTTP2_HEADER_CONTENT_LENGTH, + HTTP2_HEADER_EXPECT, + HTTP2_HEADER_STATUS + } + } = http2; + function parseH2Headers(headers2) { + const result = []; + for (const [name, value] of Object.entries(headers2)) { + if (Array.isArray(value)) { + for (const subvalue of value) { + result.push(Buffer.from(name), Buffer.from(subvalue)); + } + } else { + result.push(Buffer.from(name), Buffer.from(value)); + } + } + return result; + } + async function connectH2(client, socket) { + client[kSocket] = socket; + if (!h2ExperimentalWarned) { + h2ExperimentalWarned = true; + process.emitWarning("H2 support is experimental, expect them to change at any time.", { + code: "UNDICI-H2" + }); + } + const session = http2.connect(client[kUrl], { + createConnection: () => socket, + peerMaxConcurrentStreams: client[kMaxConcurrentStreams] + }); + session[kOpenStreams] = 0; + session[kClient] = client; + session[kSocket] = socket; + util2.addListener(session, "error", onHttp2SessionError); + util2.addListener(session, "frameError", onHttp2FrameError); + util2.addListener(session, "end", onHttp2SessionEnd); + util2.addListener(session, "goaway", onHTTP2GoAway); + util2.addListener(session, "close", function() { + const { [kClient]: client2 } = this; + const { [kSocket]: socket2 } = client2; + const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util2.getSocketInfo(socket2)); + client2[kHTTP2Session] = null; + if (client2.destroyed) { + assert(client2[kPending] === 0); + const requests = client2[kQueue].splice(client2[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util2.errorRequest(client2, request, err); + } + } + }); + session.unref(); + client[kHTTP2Session] = session; + socket[kHTTP2Session] = session; + util2.addListener(socket, "error", function(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kError] = err; + this[kClient][kOnError](err); + }); + util2.addListener(socket, "end", function() { + util2.destroy(this, new SocketError("other side closed", util2.getSocketInfo(this))); + }); + util2.addListener(socket, "close", function() { + const err = this[kError] || new SocketError("closed", util2.getSocketInfo(this)); + client[kSocket] = null; + if (this[kHTTP2Session] != null) { + this[kHTTP2Session].destroy(err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + client[kResume](); + }); + let closed = false; + socket.on("close", () => { + closed = true; + }); + return { + version: "h2", + defaultPipelining: Infinity, + write(...args) { + return writeH2(client, ...args); + }, + resume() { + resumeH2(client); + }, + destroy(err, callback) { + if (closed) { + queueMicrotask(callback); + } else { + socket.destroy(err).on("close", callback); + } + }, + get destroyed() { + return socket.destroyed; + }, + busy() { + return false; + } + }; + } + function resumeH2(client) { + const socket = client[kSocket]; + if (socket?.destroyed === false) { + if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) { + socket.unref(); + client[kHTTP2Session].unref(); + } else { + socket.ref(); + client[kHTTP2Session].ref(); + } + } + } + function onHttp2SessionError(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kSocket][kError] = err; + this[kClient][kOnError](err); + } + function onHttp2FrameError(type2, code, id) { + if (id === 0) { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type2}, code ${code}`); + this[kSocket][kError] = err; + this[kClient][kOnError](err); + } + } + function onHttp2SessionEnd() { + const err = new SocketError("other side closed", util2.getSocketInfo(this[kSocket])); + this.destroy(err); + util2.destroy(this[kSocket], err); + } + function onHTTP2GoAway(code) { + const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util2.getSocketInfo(this)); + const client = this[kClient]; + client[kSocket] = null; + client[kHTTPContext] = null; + if (this[kHTTP2Session] != null) { + this[kHTTP2Session].destroy(err); + this[kHTTP2Session] = null; + } + util2.destroy(this[kSocket], err); + if (client[kRunningIdx] < client[kQueue].length) { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + util2.errorRequest(client, request, err); + client[kPendingIdx] = client[kRunningIdx]; + } + assert(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + client[kResume](); + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function writeH2(client, request) { + const session = client[kHTTP2Session]; + const { method, path: path7, host, upgrade, expectContinue, signal: signal3, headers: reqHeaders } = request; + let { body } = request; + if (upgrade) { + util2.errorRequest(client, request, new Error("Upgrade not supported for H2")); + return false; + } + const headers2 = {}; + for (let n = 0; n < reqHeaders.length; n += 2) { + const key = reqHeaders[n + 0]; + const val = reqHeaders[n + 1]; + if (Array.isArray(val)) { + for (let i = 0; i < val.length; i++) { + if (headers2[key]) { + headers2[key] += `,${val[i]}`; + } else { + headers2[key] = val[i]; + } + } + } else { + headers2[key] = val; + } + } + let stream; + const { hostname, port } = client[kUrl]; + headers2[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`; + headers2[HTTP2_HEADER_METHOD] = method; + const abort = (err) => { + if (request.aborted || request.completed) { + return; + } + err = err || new RequestAbortedError(); + util2.errorRequest(client, request, err); + if (stream != null) { + util2.destroy(stream, err); + } + util2.destroy(body, err); + client[kQueue][client[kRunningIdx]++] = null; + client[kResume](); + }; + try { + request.onConnect(abort); + } catch (err) { + util2.errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + if (method === "CONNECT") { + session.ref(); + stream = session.request(headers2, { endStream: false, signal: signal3 }); + if (stream.id && !stream.pending) { + request.onUpgrade(null, null, stream); + ++session[kOpenStreams]; + client[kQueue][client[kRunningIdx]++] = null; + } else { + stream.once("ready", () => { + request.onUpgrade(null, null, stream); + ++session[kOpenStreams]; + client[kQueue][client[kRunningIdx]++] = null; + }); + } + stream.once("close", () => { + session[kOpenStreams] -= 1; + if (session[kOpenStreams] === 0) session.unref(); + }); + return true; + } + headers2[HTTP2_HEADER_PATH] = path7; + headers2[HTTP2_HEADER_SCHEME] = "https"; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + let contentLength = util2.bodyLength(body); + if (util2.isFormDataLike(body)) { + extractBody ??= require_body().extractBody; + const [bodyStream, contentType] = extractBody(body); + headers2["content-type"] = contentType; + body = bodyStream.stream; + contentLength = bodyStream.length; + } + if (contentLength == null) { + contentLength = request.contentLength; + } + if (contentLength === 0 || !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + util2.errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + if (contentLength != null) { + assert(body, "no body must not have content length"); + headers2[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; + } + session.ref(); + const shouldEndStream = method === "GET" || method === "HEAD" || body === null; + if (expectContinue) { + headers2[HTTP2_HEADER_EXPECT] = "100-continue"; + stream = session.request(headers2, { endStream: shouldEndStream, signal: signal3 }); + stream.once("continue", writeBodyH2); + } else { + stream = session.request(headers2, { + endStream: shouldEndStream, + signal: signal3 + }); + writeBodyH2(); + } + ++session[kOpenStreams]; + stream.once("response", (headers3) => { + const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers3; + request.onResponseStarted(); + if (request.aborted) { + const err = new RequestAbortedError(); + util2.errorRequest(client, request, err); + util2.destroy(stream, err); + return; + } + if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) { + stream.pause(); + } + stream.on("data", (chunk) => { + if (request.onData(chunk) === false) { + stream.pause(); + } + }); + }); + stream.once("end", () => { + if (stream.state?.state == null || stream.state.state < 6) { + request.onComplete([]); + } + if (session[kOpenStreams] === 0) { + session.unref(); + } + abort(new InformationalError("HTTP/2: stream half-closed (remote)")); + client[kQueue][client[kRunningIdx]++] = null; + client[kPendingIdx] = client[kRunningIdx]; + client[kResume](); + }); + stream.once("close", () => { + session[kOpenStreams] -= 1; + if (session[kOpenStreams] === 0) { + session.unref(); + } + }); + stream.once("error", function(err) { + abort(err); + }); + stream.once("frameError", (type2, code) => { + abort(new InformationalError(`HTTP/2: "frameError" received - type ${type2}, code ${code}`)); + }); + return true; + function writeBodyH2() { + if (!body || contentLength === 0) { + writeBuffer( + abort, + stream, + null, + client, + request, + client[kSocket], + contentLength, + expectsPayload + ); + } else if (util2.isBuffer(body)) { + writeBuffer( + abort, + stream, + body, + client, + request, + client[kSocket], + contentLength, + expectsPayload + ); + } else if (util2.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable( + abort, + stream, + body.stream(), + client, + request, + client[kSocket], + contentLength, + expectsPayload + ); + } else { + writeBlob( + abort, + stream, + body, + client, + request, + client[kSocket], + contentLength, + expectsPayload + ); + } + } else if (util2.isStream(body)) { + writeStream( + abort, + client[kSocket], + expectsPayload, + stream, + body, + client, + request, + contentLength + ); + } else if (util2.isIterable(body)) { + writeIterable( + abort, + stream, + body, + client, + request, + client[kSocket], + contentLength, + expectsPayload + ); + } else { + assert(false); + } + } + } + function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { + try { + if (body != null && util2.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + h2stream.cork(); + h2stream.write(body); + h2stream.uncork(); + h2stream.end(); + request.onBodySent(body); + } + if (!expectsPayload) { + socket[kReset] = true; + } + request.onRequestSent(); + client[kResume](); + } catch (error2) { + abort(error2); + } + } + function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) { + assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + const pipe = pipeline( + body, + h2stream, + (err) => { + if (err) { + util2.destroy(pipe, err); + abort(err); + } else { + util2.removeAllListeners(pipe); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + client[kResume](); + } + } + ); + util2.addListener(pipe, "data", onPipeData); + function onPipeData(chunk) { + request.onBodySent(chunk); + } + } + async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { + assert(contentLength === body.size, "blob body must have content length"); + try { + if (contentLength != null && contentLength !== body.size) { + throw new RequestContentLengthMismatchError(); + } + const buffer = Buffer.from(await body.arrayBuffer()); + h2stream.cork(); + h2stream.write(buffer); + h2stream.uncork(); + h2stream.end(); + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + client[kResume](); + } catch (err) { + abort(err); + } + } + async function writeIterable(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { + assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve2, reject) => { + assert(callback === null); + if (socket[kError]) { + reject(socket[kError]); + } else { + callback = resolve2; + } + }); + h2stream.on("close", onDrain).on("drain", onDrain); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + const res = h2stream.write(chunk); + request.onBodySent(chunk); + if (!res) { + await waitForDrain(); + } + } + h2stream.end(); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + client[kResume](); + } catch (err) { + abort(err); + } finally { + h2stream.off("close", onDrain).off("drain", onDrain); + } + } + module.exports = connectH2; + } +}); + +// node_modules/undici/lib/handler/redirect-handler.js +var require_redirect_handler = __commonJS({ + "node_modules/undici/lib/handler/redirect-handler.js"(exports, module) { + "use strict"; + var util2 = require_util(); + var { kBodyUsed } = require_symbols(); + var assert = __require("node:assert"); + var { InvalidArgumentError } = require_errors(); + var EE = __require("node:events"); + var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; + var kBody = /* @__PURE__ */ Symbol("body"); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + var RedirectHandler = class { + constructor(dispatch, maxRedirections, opts, handler) { + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + util2.validateHandler(handler, opts.method, opts.upgrade); + this.dispatch = dispatch; + this.location = null; + this.abort = null; + this.opts = { ...opts, maxRedirections: 0 }; + this.maxRedirections = maxRedirections; + this.handler = handler; + this.history = []; + this.redirectionLimitReached = false; + if (util2.isStream(this.opts.body)) { + if (util2.bodyLength(this.opts.body) === 0) { + this.opts.body.on("data", function() { + assert(false); + }); + } + if (typeof this.opts.body.readableDidRead !== "boolean") { + this.opts.body[kBodyUsed] = false; + EE.prototype.on.call(this.opts.body, "data", function() { + this[kBodyUsed] = true; + }); + } + } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util2.isIterable(this.opts.body)) { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } + } + onConnect(abort) { + this.abort = abort; + this.handler.onConnect(abort, { history: this.history }); + } + onUpgrade(statusCode, headers2, socket) { + this.handler.onUpgrade(statusCode, headers2, socket); + } + onError(error2) { + this.handler.onError(error2); + } + onHeaders(statusCode, headers2, resume, statusText) { + this.location = this.history.length >= this.maxRedirections || util2.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers2); + if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) { + if (this.request) { + this.request.abort(new Error("max redirects")); + } + this.redirectionLimitReached = true; + this.abort(new Error("max redirects")); + return; + } + if (this.opts.origin) { + this.history.push(new URL(this.opts.path, this.opts.origin)); + } + if (!this.location) { + return this.handler.onHeaders(statusCode, headers2, resume, statusText); + } + const { origin, pathname, search } = util2.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); + const path7 = search ? `${pathname}${search}` : pathname; + this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); + this.opts.path = path7; + this.opts.origin = origin; + this.opts.maxRedirections = 0; + this.opts.query = null; + if (statusCode === 303 && this.opts.method !== "HEAD") { + this.opts.method = "GET"; + this.opts.body = null; + } + } + onData(chunk) { + if (this.location) { + } else { + return this.handler.onData(chunk); + } + } + onComplete(trailers) { + if (this.location) { + this.location = null; + this.abort = null; + this.dispatch(this.opts, this); + } else { + this.handler.onComplete(trailers); + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) { + this.handler.onBodySent(chunk); + } + } + }; + function parseLocation(statusCode, headers2) { + if (redirectableStatusCodes.indexOf(statusCode) === -1) { + return null; + } + for (let i = 0; i < headers2.length; i += 2) { + if (headers2[i].length === 8 && util2.headerNameToString(headers2[i]) === "location") { + return headers2[i + 1]; + } + } + } + function shouldRemoveHeader(header, removeContent, unknownOrigin) { + if (header.length === 4) { + return util2.headerNameToString(header) === "host"; + } + if (removeContent && util2.headerNameToString(header).startsWith("content-")) { + return true; + } + if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { + const name = util2.headerNameToString(header); + return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + } + return false; + } + function cleanRequestHeaders(headers2, removeContent, unknownOrigin) { + const ret = []; + if (Array.isArray(headers2)) { + for (let i = 0; i < headers2.length; i += 2) { + if (!shouldRemoveHeader(headers2[i], removeContent, unknownOrigin)) { + ret.push(headers2[i], headers2[i + 1]); + } + } + } else if (headers2 && typeof headers2 === "object") { + for (const key of Object.keys(headers2)) { + if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { + ret.push(key, headers2[key]); + } + } + } else { + assert(headers2 == null, "headers must be an object or an array"); + } + return ret; + } + module.exports = RedirectHandler; + } +}); + +// node_modules/undici/lib/interceptor/redirect-interceptor.js +var require_redirect_interceptor = __commonJS({ + "node_modules/undici/lib/interceptor/redirect-interceptor.js"(exports, module) { + "use strict"; + var RedirectHandler = require_redirect_handler(); + function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { maxRedirections = defaultMaxRedirections } = opts; + if (!maxRedirections) { + return dispatch(opts, handler); + } + const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler); + opts = { ...opts, maxRedirections: 0 }; + return dispatch(opts, redirectHandler); + }; + }; + } + module.exports = createRedirectInterceptor; + } +}); + +// node_modules/undici/lib/dispatcher/client.js +var require_client = __commonJS({ + "node_modules/undici/lib/dispatcher/client.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var net2 = __require("node:net"); + var http2 = __require("node:http"); + var util2 = require_util(); + var { channels } = require_diagnostics(); + var Request2 = require_request(); + var DispatcherBase = require_dispatcher_base(); + var { + InvalidArgumentError, + InformationalError, + ClientDestroyedError + } = require_errors(); + var buildConnector = require_connect(); + var { + kUrl, + kServerName, + kClient, + kBusy, + kConnect, + kResuming, + kRunning, + kPending, + kSize, + kQueue, + kConnected, + kConnecting, + kNeedDrain, + kKeepAliveDefaultTimeout, + kHostHeader, + kPendingIdx, + kRunningIdx, + kError, + kPipelining, + kKeepAliveTimeoutValue, + kMaxHeadersSize, + kKeepAliveMaxTimeout, + kKeepAliveTimeoutThreshold, + kHeadersTimeout, + kBodyTimeout, + kStrictContentLength, + kConnector, + kMaxRedirections, + kMaxRequests, + kCounter, + kClose, + kDestroy, + kDispatch, + kInterceptors, + kLocalAddress, + kMaxResponseSize, + kOnError, + kHTTPContext, + kMaxConcurrentStreams, + kResume + } = require_symbols(); + var connectH1 = require_client_h1(); + var connectH2 = require_client_h2(); + var deprecatedInterceptorWarned = false; + var kClosedResolve = /* @__PURE__ */ Symbol("kClosedResolve"); + var noop = () => { + }; + function getPipelining(client) { + return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1; + } + var Client = class extends DispatcherBase { + /** + * + * @param {string|URL} url + * @param {import('../../types/client.js').Client.Options} options + */ + constructor(url, { + interceptors, + maxHeaderSize, + headersTimeout, + socketTimeout, + requestTimeout, + connectTimeout, + bodyTimeout, + idleTimeout, + keepAlive, + keepAliveTimeout, + maxKeepAliveTimeout, + keepAliveMaxTimeout, + keepAliveTimeoutThreshold, + socketPath, + pipelining, + tls, + strictContentLength, + maxCachedSessions, + maxRedirections, + connect: connect2, + maxRequestsPerClient, + localAddress, + maxResponseSize, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + // h2 + maxConcurrentStreams, + allowH2 + } = {}) { + super(); + if (keepAlive !== void 0) { + throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); + } + if (socketTimeout !== void 0) { + throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); + } + if (requestTimeout !== void 0) { + throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); + } + if (idleTimeout !== void 0) { + throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead"); + } + if (maxKeepAliveTimeout !== void 0) { + throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); + } + if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { + throw new InvalidArgumentError("invalid maxHeaderSize"); + } + if (socketPath != null && typeof socketPath !== "string") { + throw new InvalidArgumentError("invalid socketPath"); + } + if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { + throw new InvalidArgumentError("invalid connectTimeout"); + } + if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveTimeout"); + } + if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveMaxTimeout"); + } + if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { + throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold"); + } + if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("headersTimeout must be a positive integer or zero"); + } + if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero"); + } + if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { + throw new InvalidArgumentError("maxRequestsPerClient must be a positive number"); + } + if (localAddress != null && (typeof localAddress !== "string" || net2.isIP(localAddress) === 0)) { + throw new InvalidArgumentError("localAddress must be valid string IP address"); + } + if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { + throw new InvalidArgumentError("maxResponseSize must be a positive number"); + } + if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) { + throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number"); + } + if (allowH2 != null && typeof allowH2 !== "boolean") { + throw new InvalidArgumentError("allowH2 must be a valid boolean value"); + } + if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) { + throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0"); + } + if (typeof connect2 !== "function") { + connect2 = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect2 + }); + } + if (interceptors?.Client && Array.isArray(interceptors.Client)) { + this[kInterceptors] = interceptors.Client; + if (!deprecatedInterceptorWarned) { + deprecatedInterceptorWarned = true; + process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.", { + code: "UNDICI-CLIENT-INTERCEPTOR-DEPRECATED" + }); + } + } else { + this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })]; + } + this[kUrl] = util2.parseOrigin(url); + this[kConnector] = connect2; + this[kPipelining] = pipelining != null ? pipelining : 1; + this[kMaxHeadersSize] = maxHeaderSize || http2.maxHeaderSize; + this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; + this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; + this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold; + this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; + this[kServerName] = null; + this[kLocalAddress] = localAddress != null ? localAddress : null; + this[kResuming] = 0; + this[kNeedDrain] = 0; + this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r +`; + this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; + this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; + this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; + this[kMaxRedirections] = maxRedirections; + this[kMaxRequests] = maxRequestsPerClient; + this[kClosedResolve] = null; + this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; + this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100; + this[kHTTPContext] = null; + this[kQueue] = []; + this[kRunningIdx] = 0; + this[kPendingIdx] = 0; + this[kResume] = (sync) => resume(this, sync); + this[kOnError] = (err) => onError(this, err); + } + get pipelining() { + return this[kPipelining]; + } + set pipelining(value) { + this[kPipelining] = value; + this[kResume](true); + } + get [kPending]() { + return this[kQueue].length - this[kPendingIdx]; + } + get [kRunning]() { + return this[kPendingIdx] - this[kRunningIdx]; + } + get [kSize]() { + return this[kQueue].length - this[kRunningIdx]; + } + get [kConnected]() { + return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed; + } + get [kBusy]() { + return Boolean( + this[kHTTPContext]?.busy(null) || this[kSize] >= (getPipelining(this) || 1) || this[kPending] > 0 + ); + } + /* istanbul ignore: only used for test */ + [kConnect](cb) { + connect(this); + this.once("connect", cb); + } + [kDispatch](opts, handler) { + const origin = opts.origin || this[kUrl].origin; + const request = new Request2(origin, opts, handler); + this[kQueue].push(request); + if (this[kResuming]) { + } else if (util2.bodyLength(request.body) == null && util2.isIterable(request.body)) { + this[kResuming] = 1; + queueMicrotask(() => resume(this)); + } else { + this[kResume](true); + } + if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { + this[kNeedDrain] = 2; + } + return this[kNeedDrain] < 2; + } + async [kClose]() { + return new Promise((resolve2) => { + if (this[kSize]) { + this[kClosedResolve] = resolve2; + } else { + resolve2(null); + } + }); + } + async [kDestroy](err) { + return new Promise((resolve2) => { + const requests = this[kQueue].splice(this[kPendingIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util2.errorRequest(this, request, err); + } + const callback = () => { + if (this[kClosedResolve]) { + this[kClosedResolve](); + this[kClosedResolve] = null; + } + resolve2(null); + }; + if (this[kHTTPContext]) { + this[kHTTPContext].destroy(err, callback); + this[kHTTPContext] = null; + } else { + queueMicrotask(callback); + } + this[kResume](); + }); + } + }; + var createRedirectInterceptor = require_redirect_interceptor(); + function onError(client, err) { + if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { + assert(client[kPendingIdx] === client[kRunningIdx]); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util2.errorRequest(client, request, err); + } + assert(client[kSize] === 0); + } + } + async function connect(client) { + assert(!client[kConnecting]); + assert(!client[kHTTPContext]); + let { host, hostname, protocol, port } = client[kUrl]; + if (hostname[0] === "[") { + const idx = hostname.indexOf("]"); + assert(idx !== -1); + const ip = hostname.substring(1, idx); + assert(net2.isIP(ip)); + hostname = ip; + } + client[kConnecting] = true; + if (channels.beforeConnect.hasSubscribers) { + channels.beforeConnect.publish({ + connectParams: { + host, + hostname, + protocol, + port, + version: client[kHTTPContext]?.version, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector] + }); + } + try { + const socket = await new Promise((resolve2, reject) => { + client[kConnector]({ + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, (err, socket2) => { + if (err) { + reject(err); + } else { + resolve2(socket2); + } + }); + }); + if (client.destroyed) { + util2.destroy(socket.on("error", noop), new ClientDestroyedError()); + return; + } + assert(socket); + try { + client[kHTTPContext] = socket.alpnProtocol === "h2" ? await connectH2(client, socket) : await connectH1(client, socket); + } catch (err) { + socket.destroy().on("error", noop); + throw err; + } + client[kConnecting] = false; + socket[kCounter] = 0; + socket[kMaxRequests] = client[kMaxRequests]; + socket[kClient] = client; + socket[kError] = null; + if (channels.connected.hasSubscribers) { + channels.connected.publish({ + connectParams: { + host, + hostname, + protocol, + port, + version: client[kHTTPContext]?.version, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + socket + }); + } + client.emit("connect", client[kUrl], [client]); + } catch (err) { + if (client.destroyed) { + return; + } + client[kConnecting] = false; + if (channels.connectError.hasSubscribers) { + channels.connectError.publish({ + connectParams: { + host, + hostname, + protocol, + port, + version: client[kHTTPContext]?.version, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + error: err + }); + } + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + assert(client[kRunning] === 0); + while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { + const request = client[kQueue][client[kPendingIdx]++]; + util2.errorRequest(client, request, err); + } + } else { + onError(client, err); + } + client.emit("connectionError", client[kUrl], [client], err); + } + client[kResume](); + } + function emitDrain(client) { + client[kNeedDrain] = 0; + client.emit("drain", client[kUrl], [client]); + } + function resume(client, sync) { + if (client[kResuming] === 2) { + return; + } + client[kResuming] = 2; + _resume(client, sync); + client[kResuming] = 0; + if (client[kRunningIdx] > 256) { + client[kQueue].splice(0, client[kRunningIdx]); + client[kPendingIdx] -= client[kRunningIdx]; + client[kRunningIdx] = 0; + } + } + function _resume(client, sync) { + while (true) { + if (client.destroyed) { + assert(client[kPending] === 0); + return; + } + if (client[kClosedResolve] && !client[kSize]) { + client[kClosedResolve](); + client[kClosedResolve] = null; + return; + } + if (client[kHTTPContext]) { + client[kHTTPContext].resume(); + } + if (client[kBusy]) { + client[kNeedDrain] = 2; + } else if (client[kNeedDrain] === 2) { + if (sync) { + client[kNeedDrain] = 1; + queueMicrotask(() => emitDrain(client)); + } else { + emitDrain(client); + } + continue; + } + if (client[kPending] === 0) { + return; + } + if (client[kRunning] >= (getPipelining(client) || 1)) { + return; + } + const request = client[kQueue][client[kPendingIdx]]; + if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) { + if (client[kRunning] > 0) { + return; + } + client[kServerName] = request.servername; + client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => { + client[kHTTPContext] = null; + resume(client); + }); + } + if (client[kConnecting]) { + return; + } + if (!client[kHTTPContext]) { + connect(client); + return; + } + if (client[kHTTPContext].destroyed) { + return; + } + if (client[kHTTPContext].busy(request)) { + return; + } + if (!request.aborted && client[kHTTPContext].write(request)) { + client[kPendingIdx]++; + } else { + client[kQueue].splice(client[kPendingIdx], 1); + } + } + } + module.exports = Client; + } +}); + +// node_modules/undici/lib/dispatcher/fixed-queue.js +var require_fixed_queue = __commonJS({ + "node_modules/undici/lib/dispatcher/fixed-queue.js"(exports, module) { + "use strict"; + var kSize = 2048; + var kMask = kSize - 1; + var FixedCircularBuffer = class { + constructor() { + this.bottom = 0; + this.top = 0; + this.list = new Array(kSize); + this.next = null; + } + isEmpty() { + return this.top === this.bottom; + } + isFull() { + return (this.top + 1 & kMask) === this.bottom; + } + push(data) { + this.list[this.top] = data; + this.top = this.top + 1 & kMask; + } + shift() { + const nextItem = this.list[this.bottom]; + if (nextItem === void 0) + return null; + this.list[this.bottom] = void 0; + this.bottom = this.bottom + 1 & kMask; + return nextItem; + } + }; + module.exports = class FixedQueue { + constructor() { + this.head = this.tail = new FixedCircularBuffer(); + } + isEmpty() { + return this.head.isEmpty(); + } + push(data) { + if (this.head.isFull()) { + this.head = this.head.next = new FixedCircularBuffer(); + } + this.head.push(data); + } + shift() { + const tail = this.tail; + const next = tail.shift(); + if (tail.isEmpty() && tail.next !== null) { + this.tail = tail.next; + } + return next; + } + }; + } +}); + +// node_modules/undici/lib/dispatcher/pool-stats.js +var require_pool_stats = __commonJS({ + "node_modules/undici/lib/dispatcher/pool-stats.js"(exports, module) { + var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(); + var kPool = /* @__PURE__ */ Symbol("pool"); + var PoolStats = class { + constructor(pool) { + this[kPool] = pool; + } + get connected() { + return this[kPool][kConnected]; + } + get free() { + return this[kPool][kFree]; + } + get pending() { + return this[kPool][kPending]; + } + get queued() { + return this[kPool][kQueued]; + } + get running() { + return this[kPool][kRunning]; + } + get size() { + return this[kPool][kSize]; + } + }; + module.exports = PoolStats; + } +}); + +// node_modules/undici/lib/dispatcher/pool-base.js +var require_pool_base = __commonJS({ + "node_modules/undici/lib/dispatcher/pool-base.js"(exports, module) { + "use strict"; + var DispatcherBase = require_dispatcher_base(); + var FixedQueue = require_fixed_queue(); + var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(); + var PoolStats = require_pool_stats(); + var kClients = /* @__PURE__ */ Symbol("clients"); + var kNeedDrain = /* @__PURE__ */ Symbol("needDrain"); + var kQueue = /* @__PURE__ */ Symbol("queue"); + var kClosedResolve = /* @__PURE__ */ Symbol("closed resolve"); + var kOnDrain = /* @__PURE__ */ Symbol("onDrain"); + var kOnConnect = /* @__PURE__ */ Symbol("onConnect"); + var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect"); + var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError"); + var kGetDispatcher = /* @__PURE__ */ Symbol("get dispatcher"); + var kAddClient = /* @__PURE__ */ Symbol("add client"); + var kRemoveClient = /* @__PURE__ */ Symbol("remove client"); + var kStats = /* @__PURE__ */ Symbol("stats"); + var PoolBase = class extends DispatcherBase { + constructor() { + super(); + this[kQueue] = new FixedQueue(); + this[kClients] = []; + this[kQueued] = 0; + const pool = this; + this[kOnDrain] = function onDrain(origin, targets) { + const queue = pool[kQueue]; + let needDrain = false; + while (!needDrain) { + const item = queue.shift(); + if (!item) { + break; + } + pool[kQueued]--; + needDrain = !this.dispatch(item.opts, item.handler); + } + this[kNeedDrain] = needDrain; + if (!this[kNeedDrain] && pool[kNeedDrain]) { + pool[kNeedDrain] = false; + pool.emit("drain", origin, [pool, ...targets]); + } + if (pool[kClosedResolve] && queue.isEmpty()) { + Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]); + } + }; + this[kOnConnect] = (origin, targets) => { + pool.emit("connect", origin, [pool, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + pool.emit("disconnect", origin, [pool, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + pool.emit("connectionError", origin, [pool, ...targets], err); + }; + this[kStats] = new PoolStats(this); + } + get [kBusy]() { + return this[kNeedDrain]; + } + get [kConnected]() { + return this[kClients].filter((client) => client[kConnected]).length; + } + get [kFree]() { + return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length; + } + get [kPending]() { + let ret = this[kQueued]; + for (const { [kPending]: pending } of this[kClients]) { + ret += pending; + } + return ret; + } + get [kRunning]() { + let ret = 0; + for (const { [kRunning]: running } of this[kClients]) { + ret += running; + } + return ret; + } + get [kSize]() { + let ret = this[kQueued]; + for (const { [kSize]: size } of this[kClients]) { + ret += size; + } + return ret; + } + get stats() { + return this[kStats]; + } + async [kClose]() { + if (this[kQueue].isEmpty()) { + await Promise.all(this[kClients].map((c) => c.close())); + } else { + await new Promise((resolve2) => { + this[kClosedResolve] = resolve2; + }); + } + } + async [kDestroy](err) { + while (true) { + const item = this[kQueue].shift(); + if (!item) { + break; + } + item.handler.onError(err); + } + await Promise.all(this[kClients].map((c) => c.destroy(err))); + } + [kDispatch](opts, handler) { + const dispatcher = this[kGetDispatcher](); + if (!dispatcher) { + this[kNeedDrain] = true; + this[kQueue].push({ opts, handler }); + this[kQueued]++; + } else if (!dispatcher.dispatch(opts, handler)) { + dispatcher[kNeedDrain] = true; + this[kNeedDrain] = !this[kGetDispatcher](); + } + return !this[kNeedDrain]; + } + [kAddClient](client) { + client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].push(client); + if (this[kNeedDrain]) { + queueMicrotask(() => { + if (this[kNeedDrain]) { + this[kOnDrain](client[kUrl], [this, client]); + } + }); + } + return this; + } + [kRemoveClient](client) { + client.close(() => { + const idx = this[kClients].indexOf(client); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + }); + this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); + } + }; + module.exports = { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + }; + } +}); + +// node_modules/undici/lib/dispatcher/pool.js +var require_pool = __commonJS({ + "node_modules/undici/lib/dispatcher/pool.js"(exports, module) { + "use strict"; + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kGetDispatcher + } = require_pool_base(); + var Client = require_client(); + var { + InvalidArgumentError + } = require_errors(); + var util2 = require_util(); + var { kUrl, kInterceptors } = require_symbols(); + var buildConnector = require_connect(); + var kOptions = /* @__PURE__ */ Symbol("options"); + var kConnections = /* @__PURE__ */ Symbol("connections"); + var kFactory = /* @__PURE__ */ Symbol("factory"); + function defaultFactory(origin, opts) { + return new Client(origin, opts); + } + var Pool = class extends PoolBase { + constructor(origin, { + connections, + factory = defaultFactory, + connect, + connectTimeout, + tls, + maxCachedSessions, + socketPath, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + allowH2, + ...options + } = {}) { + super(); + if (connections != null && (!Number.isFinite(connections) || connections < 0)) { + throw new InvalidArgumentError("invalid connections"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (typeof connect !== "function") { + connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect + }); + } + this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; + this[kConnections] = connections || null; + this[kUrl] = util2.parseOrigin(origin); + this[kOptions] = { ...util2.deepClone(options), connect, allowH2 }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kFactory] = factory; + this.on("connectionError", (origin2, targets, error2) => { + for (const target of targets) { + const idx = this[kClients].indexOf(target); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + } + }); + } + [kGetDispatcher]() { + for (const client of this[kClients]) { + if (!client[kNeedDrain]) { + return client; + } + } + if (!this[kConnections] || this[kClients].length < this[kConnections]) { + const dispatcher = this[kFactory](this[kUrl], this[kOptions]); + this[kAddClient](dispatcher); + return dispatcher; + } + } + }; + module.exports = Pool; + } +}); + +// node_modules/undici/lib/dispatcher/balanced-pool.js +var require_balanced_pool = __commonJS({ + "node_modules/undici/lib/dispatcher/balanced-pool.js"(exports, module) { + "use strict"; + var { + BalancedPoolMissingUpstreamError, + InvalidArgumentError + } = require_errors(); + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + } = require_pool_base(); + var Pool = require_pool(); + var { kUrl, kInterceptors } = require_symbols(); + var { parseOrigin } = require_util(); + var kFactory = /* @__PURE__ */ Symbol("factory"); + var kOptions = /* @__PURE__ */ Symbol("options"); + var kGreatestCommonDivisor = /* @__PURE__ */ Symbol("kGreatestCommonDivisor"); + var kCurrentWeight = /* @__PURE__ */ Symbol("kCurrentWeight"); + var kIndex = /* @__PURE__ */ Symbol("kIndex"); + var kWeight = /* @__PURE__ */ Symbol("kWeight"); + var kMaxWeightPerServer = /* @__PURE__ */ Symbol("kMaxWeightPerServer"); + var kErrorPenalty = /* @__PURE__ */ Symbol("kErrorPenalty"); + function getGreatestCommonDivisor(a, b) { + if (a === 0) return b; + while (b !== 0) { + const t = b; + b = a % b; + a = t; + } + return a; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var BalancedPool = class extends PoolBase { + constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) { + super(); + this[kOptions] = opts; + this[kIndex] = -1; + this[kCurrentWeight] = 0; + this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100; + this[kErrorPenalty] = this[kOptions].errorPenalty || 15; + if (!Array.isArray(upstreams)) { + upstreams = [upstreams]; + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + this[kInterceptors] = opts.interceptors?.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : []; + this[kFactory] = factory; + for (const upstream of upstreams) { + this.addUpstream(upstream); + } + this._updateBalancedPoolStats(); + } + addUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) { + return this; + } + const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])); + this[kAddClient](pool); + pool.on("connect", () => { + pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]); + }); + pool.on("connectionError", () => { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + }); + pool.on("disconnect", (...args) => { + const err = args[2]; + if (err && err.code === "UND_ERR_SOCKET") { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + } + }); + for (const client of this[kClients]) { + client[kWeight] = this[kMaxWeightPerServer]; + } + this._updateBalancedPoolStats(); + return this; + } + _updateBalancedPoolStats() { + let result = 0; + for (let i = 0; i < this[kClients].length; i++) { + result = getGreatestCommonDivisor(this[kClients][i][kWeight], result); + } + this[kGreatestCommonDivisor] = result; + } + removeUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true); + if (pool) { + this[kRemoveClient](pool); + } + return this; + } + get upstreams() { + return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin); + } + [kGetDispatcher]() { + if (this[kClients].length === 0) { + throw new BalancedPoolMissingUpstreamError(); + } + const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true); + if (!dispatcher) { + return; + } + const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true); + if (allClientsBusy) { + return; + } + let counter = 0; + let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]); + while (counter++ < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length; + const pool = this[kClients][this[kIndex]]; + if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { + maxWeightIndex = this[kIndex]; + } + if (this[kIndex] === 0) { + this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]; + if (this[kCurrentWeight] <= 0) { + this[kCurrentWeight] = this[kMaxWeightPerServer]; + } + } + if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) { + return pool; + } + } + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]; + this[kIndex] = maxWeightIndex; + return this[kClients][maxWeightIndex]; + } + }; + module.exports = BalancedPool; + } +}); + +// node_modules/undici/lib/dispatcher/agent.js +var require_agent = __commonJS({ + "node_modules/undici/lib/dispatcher/agent.js"(exports, module) { + "use strict"; + var { InvalidArgumentError } = require_errors(); + var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); + var DispatcherBase = require_dispatcher_base(); + var Pool = require_pool(); + var Client = require_client(); + var util2 = require_util(); + var createRedirectInterceptor = require_redirect_interceptor(); + var kOnConnect = /* @__PURE__ */ Symbol("onConnect"); + var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect"); + var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError"); + var kMaxRedirections = /* @__PURE__ */ Symbol("maxRedirections"); + var kOnDrain = /* @__PURE__ */ Symbol("onDrain"); + var kFactory = /* @__PURE__ */ Symbol("factory"); + var kOptions = /* @__PURE__ */ Symbol("options"); + function defaultFactory(origin, opts) { + return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); + } + var Agent = class extends DispatcherBase { + constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + super(); + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (connect && typeof connect !== "function") { + connect = { ...connect }; + } + this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })]; + this[kOptions] = { ...util2.deepClone(options), connect }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kMaxRedirections] = maxRedirections; + this[kFactory] = factory; + this[kClients] = /* @__PURE__ */ new Map(); + this[kOnDrain] = (origin, targets) => { + this.emit("drain", origin, [this, ...targets]); + }; + this[kOnConnect] = (origin, targets) => { + this.emit("connect", origin, [this, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + this.emit("disconnect", origin, [this, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + this.emit("connectionError", origin, [this, ...targets], err); + }; + } + get [kRunning]() { + let ret = 0; + for (const client of this[kClients].values()) { + ret += client[kRunning]; + } + return ret; + } + [kDispatch](opts, handler) { + let key; + if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) { + key = String(opts.origin); + } else { + throw new InvalidArgumentError("opts.origin must be a non-empty string or URL."); + } + let dispatcher = this[kClients].get(key); + if (!dispatcher) { + dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].set(key, dispatcher); + } + return dispatcher.dispatch(opts, handler); + } + async [kClose]() { + const closePromises = []; + for (const client of this[kClients].values()) { + closePromises.push(client.close()); + } + this[kClients].clear(); + await Promise.all(closePromises); + } + async [kDestroy](err) { + const destroyPromises = []; + for (const client of this[kClients].values()) { + destroyPromises.push(client.destroy(err)); + } + this[kClients].clear(); + await Promise.all(destroyPromises); + } + }; + module.exports = Agent; + } +}); + +// node_modules/undici/lib/dispatcher/proxy-agent.js +var require_proxy_agent = __commonJS({ + "node_modules/undici/lib/dispatcher/proxy-agent.js"(exports, module) { + "use strict"; + var { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); + var { URL: URL3 } = __require("node:url"); + var Agent = require_agent(); + var Pool = require_pool(); + var DispatcherBase = require_dispatcher_base(); + var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors(); + var buildConnector = require_connect(); + var Client = require_client(); + var kAgent = /* @__PURE__ */ Symbol("proxy agent"); + var kClient = /* @__PURE__ */ Symbol("proxy client"); + var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers"); + var kRequestTls = /* @__PURE__ */ Symbol("request tls settings"); + var kProxyTls = /* @__PURE__ */ Symbol("proxy tls settings"); + var kConnectEndpoint = /* @__PURE__ */ Symbol("connect endpoint function"); + var kTunnelProxy = /* @__PURE__ */ Symbol("tunnel proxy"); + function defaultProtocolPort(protocol) { + return protocol === "https:" ? 443 : 80; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var noop = () => { + }; + function defaultAgentFactory(origin, opts) { + if (opts.connections === 1) { + return new Client(origin, opts); + } + return new Pool(origin, opts); + } + var Http1ProxyWrapper = class extends DispatcherBase { + #client; + constructor(proxyUrl, { headers: headers2 = {}, connect, factory }) { + super(); + if (!proxyUrl) { + throw new InvalidArgumentError("Proxy URL is mandatory"); + } + this[kProxyHeaders] = headers2; + if (factory) { + this.#client = factory(proxyUrl, { connect }); + } else { + this.#client = new Client(proxyUrl, { connect }); + } + } + [kDispatch](opts, handler) { + const onHeaders = handler.onHeaders; + handler.onHeaders = function(statusCode, data, resume) { + if (statusCode === 407) { + if (typeof handler.onError === "function") { + handler.onError(new InvalidArgumentError("Proxy Authentication Required (407)")); + } + return; + } + if (onHeaders) onHeaders.call(this, statusCode, data, resume); + }; + const { + origin, + path: path7 = "/", + headers: headers2 = {} + } = opts; + opts.path = origin + path7; + if (!("host" in headers2) && !("Host" in headers2)) { + const { host } = new URL3(origin); + headers2.host = host; + } + opts.headers = { ...this[kProxyHeaders], ...headers2 }; + return this.#client[kDispatch](opts, handler); + } + async [kClose]() { + return this.#client.close(); + } + async [kDestroy](err) { + return this.#client.destroy(err); + } + }; + var ProxyAgent2 = class extends DispatcherBase { + constructor(opts) { + super(); + if (!opts || typeof opts === "object" && !(opts instanceof URL3) && !opts.uri) { + throw new InvalidArgumentError("Proxy uri is mandatory"); + } + const { clientFactory = defaultFactory } = opts; + if (typeof clientFactory !== "function") { + throw new InvalidArgumentError("Proxy opts.clientFactory must be a function."); + } + const { proxyTunnel = true } = opts; + const url = this.#getUrl(opts); + const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url; + this[kProxy] = { uri: href, protocol }; + this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : []; + this[kRequestTls] = opts.requestTls; + this[kProxyTls] = opts.proxyTls; + this[kProxyHeaders] = opts.headers || {}; + this[kTunnelProxy] = proxyTunnel; + if (opts.auth && opts.token) { + throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token"); + } else if (opts.auth) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`; + } else if (opts.token) { + this[kProxyHeaders]["proxy-authorization"] = opts.token; + } else if (username && password) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + } + const connect = buildConnector({ ...opts.proxyTls }); + this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }); + const agentFactory = opts.factory || defaultAgentFactory; + const factory = (origin2, options) => { + const { protocol: protocol2 } = new URL3(origin2); + if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") { + return new Http1ProxyWrapper(this[kProxy].uri, { + headers: this[kProxyHeaders], + connect, + factory: agentFactory + }); + } + return agentFactory(origin2, options); + }; + this[kClient] = clientFactory(url, { connect }); + this[kAgent] = new Agent({ + ...opts, + factory, + connect: async (opts2, callback) => { + let requestedPath = opts2.host; + if (!opts2.port) { + requestedPath += `:${defaultProtocolPort(opts2.protocol)}`; + } + try { + const { socket, statusCode } = await this[kClient].connect({ + origin, + port, + path: requestedPath, + signal: opts2.signal, + headers: { + ...this[kProxyHeaders], + host: opts2.host + }, + servername: this[kProxyTls]?.servername || proxyHostname + }); + if (statusCode !== 200) { + socket.on("error", noop).destroy(); + callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)); + } + if (opts2.protocol !== "https:") { + callback(null, socket); + return; + } + let servername; + if (this[kRequestTls]) { + servername = this[kRequestTls].servername; + } else { + servername = opts2.servername; + } + this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback); + } catch (err) { + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + callback(new SecureProxyConnectionError(err)); + } else { + callback(err); + } + } + } + }); + } + dispatch(opts, handler) { + const headers2 = buildHeaders(opts.headers); + throwIfProxyAuthIsSent(headers2); + if (headers2 && !("host" in headers2) && !("Host" in headers2)) { + const { host } = new URL3(opts.origin); + headers2.host = host; + } + return this[kAgent].dispatch( + { + ...opts, + headers: headers2 + }, + handler + ); + } + /** + * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts + * @returns {URL} + */ + #getUrl(opts) { + if (typeof opts === "string") { + return new URL3(opts); + } else if (opts instanceof URL3) { + return opts; + } else { + return new URL3(opts.uri); + } + } + async [kClose]() { + await this[kAgent].close(); + await this[kClient].close(); + } + async [kDestroy]() { + await this[kAgent].destroy(); + await this[kClient].destroy(); + } + }; + function buildHeaders(headers2) { + if (Array.isArray(headers2)) { + const headersPair = {}; + for (let i = 0; i < headers2.length; i += 2) { + headersPair[headers2[i]] = headers2[i + 1]; + } + return headersPair; + } + return headers2; + } + function throwIfProxyAuthIsSent(headers2) { + const existProxyAuth = headers2 && Object.keys(headers2).find((key) => key.toLowerCase() === "proxy-authorization"); + if (existProxyAuth) { + throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor"); + } + } + module.exports = ProxyAgent2; + } +}); + +// node_modules/undici/lib/dispatcher/env-http-proxy-agent.js +var require_env_http_proxy_agent = __commonJS({ + "node_modules/undici/lib/dispatcher/env-http-proxy-agent.js"(exports, module) { + "use strict"; + var DispatcherBase = require_dispatcher_base(); + var { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = require_symbols(); + var ProxyAgent2 = require_proxy_agent(); + var Agent = require_agent(); + var DEFAULT_PORTS = { + "http:": 80, + "https:": 443 + }; + var experimentalWarned = false; + var EnvHttpProxyAgent = class extends DispatcherBase { + #noProxyValue = null; + #noProxyEntries = null; + #opts = null; + constructor(opts = {}) { + super(); + this.#opts = opts; + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("EnvHttpProxyAgent is experimental, expect them to change at any time.", { + code: "UNDICI-EHPA" + }); + } + const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts; + this[kNoProxyAgent] = new Agent(agentOpts); + const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY; + if (HTTP_PROXY) { + this[kHttpProxyAgent] = new ProxyAgent2({ ...agentOpts, uri: HTTP_PROXY }); + } else { + this[kHttpProxyAgent] = this[kNoProxyAgent]; + } + const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY; + if (HTTPS_PROXY) { + this[kHttpsProxyAgent] = new ProxyAgent2({ ...agentOpts, uri: HTTPS_PROXY }); + } else { + this[kHttpsProxyAgent] = this[kHttpProxyAgent]; + } + this.#parseNoProxy(); + } + [kDispatch](opts, handler) { + const url = new URL(opts.origin); + const agent = this.#getProxyAgentForUrl(url); + return agent.dispatch(opts, handler); + } + async [kClose]() { + await this[kNoProxyAgent].close(); + if (!this[kHttpProxyAgent][kClosed]) { + await this[kHttpProxyAgent].close(); + } + if (!this[kHttpsProxyAgent][kClosed]) { + await this[kHttpsProxyAgent].close(); + } + } + async [kDestroy](err) { + await this[kNoProxyAgent].destroy(err); + if (!this[kHttpProxyAgent][kDestroyed]) { + await this[kHttpProxyAgent].destroy(err); + } + if (!this[kHttpsProxyAgent][kDestroyed]) { + await this[kHttpsProxyAgent].destroy(err); + } + } + #getProxyAgentForUrl(url) { + let { protocol, host: hostname, port } = url; + hostname = hostname.replace(/:\d*$/, "").toLowerCase(); + port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0; + if (!this.#shouldProxy(hostname, port)) { + return this[kNoProxyAgent]; + } + if (protocol === "https:") { + return this[kHttpsProxyAgent]; + } + return this[kHttpProxyAgent]; + } + #shouldProxy(hostname, port) { + if (this.#noProxyChanged) { + this.#parseNoProxy(); + } + if (this.#noProxyEntries.length === 0) { + return true; + } + if (this.#noProxyValue === "*") { + return false; + } + for (let i = 0; i < this.#noProxyEntries.length; i++) { + const entry = this.#noProxyEntries[i]; + if (entry.port && entry.port !== port) { + continue; + } + if (!/^[.*]/.test(entry.hostname)) { + if (hostname === entry.hostname) { + return false; + } + } else { + if (hostname.endsWith(entry.hostname.replace(/^\*/, ""))) { + return false; + } + } + } + return true; + } + #parseNoProxy() { + const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv; + const noProxySplit = noProxyValue.split(/[,\s]/); + const noProxyEntries = []; + for (let i = 0; i < noProxySplit.length; i++) { + const entry = noProxySplit[i]; + if (!entry) { + continue; + } + const parsed = entry.match(/^(.+):(\d+)$/); + noProxyEntries.push({ + hostname: (parsed ? parsed[1] : entry).toLowerCase(), + port: parsed ? Number.parseInt(parsed[2], 10) : 0 + }); + } + this.#noProxyValue = noProxyValue; + this.#noProxyEntries = noProxyEntries; + } + get #noProxyChanged() { + if (this.#opts.noProxy !== void 0) { + return false; + } + return this.#noProxyValue !== this.#noProxyEnv; + } + get #noProxyEnv() { + return process.env.no_proxy ?? process.env.NO_PROXY ?? ""; + } + }; + module.exports = EnvHttpProxyAgent; + } +}); + +// node_modules/undici/lib/handler/retry-handler.js +var require_retry_handler = __commonJS({ + "node_modules/undici/lib/handler/retry-handler.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { kRetryHandlerDefaultRetry } = require_symbols(); + var { RequestRetryError } = require_errors(); + var { + isDisturbed, + parseHeaders, + parseRangeHeader, + wrapRequestBody + } = require_util(); + function calculateRetryAfterHeader(retryAfter) { + const current = Date.now(); + return new Date(retryAfter).getTime() - current; + } + var RetryHandler = class _RetryHandler { + constructor(opts, handlers) { + const { retryOptions, ...dispatchOpts } = opts; + const { + // Retry scoped + retry: retryFn, + maxRetries, + maxTimeout, + minTimeout, + timeoutFactor, + // Response scoped + methods, + errorCodes, + retryAfter, + statusCodes + } = retryOptions ?? {}; + this.dispatch = handlers.dispatch; + this.handler = handlers.handler; + this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) }; + this.abort = null; + this.aborted = false; + this.retryOpts = { + retry: retryFn ?? _RetryHandler[kRetryHandlerDefaultRetry], + retryAfter: retryAfter ?? true, + maxTimeout: maxTimeout ?? 30 * 1e3, + // 30s, + minTimeout: minTimeout ?? 500, + // .5s + timeoutFactor: timeoutFactor ?? 2, + maxRetries: maxRetries ?? 5, + // What errors we should retry + methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"], + // Indicates which errors to retry + statusCodes: statusCodes ?? [500, 502, 503, 504, 429], + // List of errors to retry + errorCodes: errorCodes ?? [ + "ECONNRESET", + "ECONNREFUSED", + "ENOTFOUND", + "ENETDOWN", + "ENETUNREACH", + "EHOSTDOWN", + "EHOSTUNREACH", + "EPIPE", + "UND_ERR_SOCKET" + ] + }; + this.retryCount = 0; + this.retryCountCheckpoint = 0; + this.start = 0; + this.end = null; + this.etag = null; + this.resume = null; + this.handler.onConnect((reason) => { + this.aborted = true; + if (this.abort) { + this.abort(reason); + } else { + this.reason = reason; + } + }); + } + onRequestSent() { + if (this.handler.onRequestSent) { + this.handler.onRequestSent(); + } + } + onUpgrade(statusCode, headers2, socket) { + if (this.handler.onUpgrade) { + this.handler.onUpgrade(statusCode, headers2, socket); + } + } + onConnect(abort) { + if (this.aborted) { + abort(this.reason); + } else { + this.abort = abort; + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) return this.handler.onBodySent(chunk); + } + static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) { + const { statusCode, code, headers: headers2 } = err; + const { method, retryOptions } = opts; + const { + maxRetries, + minTimeout, + maxTimeout, + timeoutFactor, + statusCodes, + errorCodes, + methods + } = retryOptions; + const { counter } = state; + if (code && code !== "UND_ERR_REQ_RETRY" && !errorCodes.includes(code)) { + cb(err); + return; + } + if (Array.isArray(methods) && !methods.includes(method)) { + cb(err); + return; + } + if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) { + cb(err); + return; + } + if (counter > maxRetries) { + cb(err); + return; + } + let retryAfterHeader = headers2?.["retry-after"]; + if (retryAfterHeader) { + retryAfterHeader = Number(retryAfterHeader); + retryAfterHeader = Number.isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3; + } + const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout); + setTimeout(() => cb(null), retryTimeout); + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers2 = parseHeaders(rawHeaders); + this.retryCount += 1; + if (statusCode >= 300) { + if (this.retryOpts.statusCodes.includes(statusCode) === false) { + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } else { + this.abort( + new RequestRetryError("Request failed", statusCode, { + headers: headers2, + data: { + count: this.retryCount + } + }) + ); + return false; + } + } + if (this.resume != null) { + this.resume = null; + if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) { + this.abort( + new RequestRetryError("server does not support the range header and the payload was partially consumed", statusCode, { + headers: headers2, + data: { count: this.retryCount } + }) + ); + return false; + } + const contentRange = parseRangeHeader(headers2["content-range"]); + if (!contentRange) { + this.abort( + new RequestRetryError("Content-Range mismatch", statusCode, { + headers: headers2, + data: { count: this.retryCount } + }) + ); + return false; + } + if (this.etag != null && this.etag !== headers2.etag) { + this.abort( + new RequestRetryError("ETag mismatch", statusCode, { + headers: headers2, + data: { count: this.retryCount } + }) + ); + return false; + } + const { start, size, end = size - 1 } = contentRange; + assert(this.start === start, "content-range mismatch"); + assert(this.end == null || this.end === end, "content-range mismatch"); + this.resume = resume; + return true; + } + if (this.end == null) { + if (statusCode === 206) { + const range = parseRangeHeader(headers2["content-range"]); + if (range == null) { + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const { start, size, end = size - 1 } = range; + assert( + start != null && Number.isFinite(start), + "content-range mismatch" + ); + assert(end != null && Number.isFinite(end), "invalid content-length"); + this.start = start; + this.end = end; + } + if (this.end == null) { + const contentLength = headers2["content-length"]; + this.end = contentLength != null ? Number(contentLength) - 1 : null; + } + assert(Number.isFinite(this.start)); + assert( + this.end == null || Number.isFinite(this.end), + "invalid content-length" + ); + this.resume = resume; + this.etag = headers2.etag != null ? headers2.etag : null; + if (this.etag != null && this.etag.startsWith("W/")) { + this.etag = null; + } + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const err = new RequestRetryError("Request failed", statusCode, { + headers: headers2, + data: { count: this.retryCount } + }); + this.abort(err); + return false; + } + onData(chunk) { + this.start += chunk.length; + return this.handler.onData(chunk); + } + onComplete(rawTrailers) { + this.retryCount = 0; + return this.handler.onComplete(rawTrailers); + } + onError(err) { + if (this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err); + } + if (this.retryCount - this.retryCountCheckpoint > 0) { + this.retryCount = this.retryCountCheckpoint + (this.retryCount - this.retryCountCheckpoint); + } else { + this.retryCount += 1; + } + this.retryOpts.retry( + err, + { + state: { counter: this.retryCount }, + opts: { retryOptions: this.retryOpts, ...this.opts } + }, + onRetry.bind(this) + ); + function onRetry(err2) { + if (err2 != null || this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err2); + } + if (this.start !== 0) { + const headers2 = { range: `bytes=${this.start}-${this.end ?? ""}` }; + if (this.etag != null) { + headers2["if-match"] = this.etag; + } + this.opts = { + ...this.opts, + headers: { + ...this.opts.headers, + ...headers2 + } + }; + } + try { + this.retryCountCheckpoint = this.retryCount; + this.dispatch(this.opts, this); + } catch (err3) { + this.handler.onError(err3); + } + } + } + }; + module.exports = RetryHandler; + } +}); + +// node_modules/undici/lib/dispatcher/retry-agent.js +var require_retry_agent = __commonJS({ + "node_modules/undici/lib/dispatcher/retry-agent.js"(exports, module) { + "use strict"; + var Dispatcher = require_dispatcher(); + var RetryHandler = require_retry_handler(); + var RetryAgent = class extends Dispatcher { + #agent = null; + #options = null; + constructor(agent, options = {}) { + super(options); + this.#agent = agent; + this.#options = options; + } + dispatch(opts, handler) { + const retry2 = new RetryHandler({ + ...opts, + retryOptions: this.#options + }, { + dispatch: this.#agent.dispatch.bind(this.#agent), + handler + }); + return this.#agent.dispatch(opts, retry2); + } + close() { + return this.#agent.close(); + } + destroy() { + return this.#agent.destroy(); + } + }; + module.exports = RetryAgent; + } +}); + +// node_modules/undici/lib/api/readable.js +var require_readable = __commonJS({ + "node_modules/undici/lib/api/readable.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { Readable } = __require("node:stream"); + var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError: AbortError2 } = require_errors(); + var util2 = require_util(); + var { ReadableStreamFrom } = require_util(); + var kConsume = /* @__PURE__ */ Symbol("kConsume"); + var kReading = /* @__PURE__ */ Symbol("kReading"); + var kBody = /* @__PURE__ */ Symbol("kBody"); + var kAbort = /* @__PURE__ */ Symbol("kAbort"); + var kContentType = /* @__PURE__ */ Symbol("kContentType"); + var kContentLength = /* @__PURE__ */ Symbol("kContentLength"); + var noop = () => { + }; + var BodyReadable = class extends Readable { + constructor({ + resume, + abort, + contentType = "", + contentLength, + highWaterMark = 64 * 1024 + // Same as nodejs fs streams. + }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark + }); + this._readableState.dataEmitted = false; + this[kAbort] = abort; + this[kConsume] = null; + this[kBody] = null; + this[kContentType] = contentType; + this[kContentLength] = contentLength; + this[kReading] = false; + } + destroy(err) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (err) { + this[kAbort](); + } + return super.destroy(err); + } + _destroy(err, callback) { + if (!this[kReading]) { + setImmediate(() => { + callback(err); + }); + } else { + callback(err); + } + } + on(ev, ...args) { + if (ev === "data" || ev === "readable") { + this[kReading] = true; + } + return super.on(ev, ...args); + } + addListener(ev, ...args) { + return this.on(ev, ...args); + } + off(ev, ...args) { + const ret = super.off(ev, ...args); + if (ev === "data" || ev === "readable") { + this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0; + } + return ret; + } + removeListener(ev, ...args) { + return this.off(ev, ...args); + } + push(chunk) { + if (this[kConsume] && chunk !== null) { + consumePush(this[kConsume], chunk); + return this[kReading] ? super.push(chunk) : true; + } + return super.push(chunk); + } + // https://fetch.spec.whatwg.org/#dom-body-text + async text() { + return consume(this, "text"); + } + // https://fetch.spec.whatwg.org/#dom-body-json + async json() { + return consume(this, "json"); + } + // https://fetch.spec.whatwg.org/#dom-body-blob + async blob() { + return consume(this, "blob"); + } + // https://fetch.spec.whatwg.org/#dom-body-bytes + async bytes() { + return consume(this, "bytes"); + } + // https://fetch.spec.whatwg.org/#dom-body-arraybuffer + async arrayBuffer() { + return consume(this, "arrayBuffer"); + } + // https://fetch.spec.whatwg.org/#dom-body-formdata + async formData() { + throw new NotSupportedError(); + } + // https://fetch.spec.whatwg.org/#dom-body-bodyused + get bodyUsed() { + return util2.isDisturbed(this); + } + // https://fetch.spec.whatwg.org/#dom-body-body + get body() { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom(this); + if (this[kConsume]) { + this[kBody].getReader(); + assert(this[kBody].locked); + } + } + return this[kBody]; + } + async dump(opts) { + let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024; + const signal3 = opts?.signal; + if (signal3 != null && (typeof signal3 !== "object" || !("aborted" in signal3))) { + throw new InvalidArgumentError("signal must be an AbortSignal"); + } + signal3?.throwIfAborted(); + if (this._readableState.closeEmitted) { + return null; + } + return await new Promise((resolve2, reject) => { + if (this[kContentLength] > limit) { + this.destroy(new AbortError2()); + } + const onAbort = () => { + this.destroy(signal3.reason ?? new AbortError2()); + }; + signal3?.addEventListener("abort", onAbort); + this.on("close", function() { + signal3?.removeEventListener("abort", onAbort); + if (signal3?.aborted) { + reject(signal3.reason ?? new AbortError2()); + } else { + resolve2(null); + } + }).on("error", noop).on("data", function(chunk) { + limit -= chunk.length; + if (limit <= 0) { + this.destroy(); + } + }).resume(); + }); + } + }; + function isLocked(self) { + return self[kBody] && self[kBody].locked === true || self[kConsume]; + } + function isUnusable(self) { + return util2.isDisturbed(self) || isLocked(self); + } + async function consume(stream, type2) { + assert(!stream[kConsume]); + return new Promise((resolve2, reject) => { + if (isUnusable(stream)) { + const rState = stream._readableState; + if (rState.destroyed && rState.closeEmitted === false) { + stream.on("error", (err) => { + reject(err); + }).on("close", () => { + reject(new TypeError("unusable")); + }); + } else { + reject(rState.errored ?? new TypeError("unusable")); + } + } else { + queueMicrotask(() => { + stream[kConsume] = { + type: type2, + stream, + resolve: resolve2, + reject, + length: 0, + body: [] + }; + stream.on("error", function(err) { + consumeFinish(this[kConsume], err); + }).on("close", function() { + if (this[kConsume].body !== null) { + consumeFinish(this[kConsume], new RequestAbortedError()); + } + }); + consumeStart(stream[kConsume]); + }); + } + }); + } + function consumeStart(consume2) { + if (consume2.body === null) { + return; + } + const { _readableState: state } = consume2.stream; + if (state.bufferIndex) { + const start = state.bufferIndex; + const end = state.buffer.length; + for (let n = start; n < end; n++) { + consumePush(consume2, state.buffer[n]); + } + } else { + for (const chunk of state.buffer) { + consumePush(consume2, chunk); + } + } + if (state.endEmitted) { + consumeEnd(this[kConsume]); + } else { + consume2.stream.on("end", function() { + consumeEnd(this[kConsume]); + }); + } + consume2.stream.resume(); + while (consume2.stream.read() != null) { + } + } + function chunksDecode(chunks, length) { + if (chunks.length === 0 || length === 0) { + return ""; + } + const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length); + const bufferLength = buffer.length; + const start = bufferLength > 2 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191 ? 3 : 0; + return buffer.utf8Slice(start, bufferLength); + } + function chunksConcat(chunks, length) { + if (chunks.length === 0 || length === 0) { + return new Uint8Array(0); + } + if (chunks.length === 1) { + return new Uint8Array(chunks[0]); + } + const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer); + let offset = 0; + for (let i = 0; i < chunks.length; ++i) { + const chunk = chunks[i]; + buffer.set(chunk, offset); + offset += chunk.length; + } + return buffer; + } + function consumeEnd(consume2) { + const { type: type2, body, resolve: resolve2, stream, length } = consume2; + try { + if (type2 === "text") { + resolve2(chunksDecode(body, length)); + } else if (type2 === "json") { + resolve2(JSON.parse(chunksDecode(body, length))); + } else if (type2 === "arrayBuffer") { + resolve2(chunksConcat(body, length).buffer); + } else if (type2 === "blob") { + resolve2(new Blob(body, { type: stream[kContentType] })); + } else if (type2 === "bytes") { + resolve2(chunksConcat(body, length)); + } + consumeFinish(consume2); + } catch (err) { + stream.destroy(err); + } + } + function consumePush(consume2, chunk) { + consume2.length += chunk.length; + consume2.body.push(chunk); + } + function consumeFinish(consume2, err) { + if (consume2.body === null) { + return; + } + if (err) { + consume2.reject(err); + } else { + consume2.resolve(); + } + consume2.type = null; + consume2.stream = null; + consume2.resolve = null; + consume2.reject = null; + consume2.length = 0; + consume2.body = null; + } + module.exports = { Readable: BodyReadable, chunksDecode }; + } +}); + +// node_modules/undici/lib/api/util.js +var require_util3 = __commonJS({ + "node_modules/undici/lib/api/util.js"(exports, module) { + var assert = __require("node:assert"); + var { + ResponseStatusCodeError + } = require_errors(); + var { chunksDecode } = require_readable(); + var CHUNK_LIMIT = 128 * 1024; + async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers: headers2 }) { + assert(body); + let chunks = []; + let length = 0; + try { + for await (const chunk of body) { + chunks.push(chunk); + length += chunk.length; + if (length > CHUNK_LIMIT) { + chunks = []; + length = 0; + break; + } + } + } catch { + chunks = []; + length = 0; + } + const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`; + if (statusCode === 204 || !contentType || !length) { + queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers2))); + return; + } + const stackTraceLimit = Error.stackTraceLimit; + Error.stackTraceLimit = 0; + let payload; + try { + if (isContentTypeApplicationJson(contentType)) { + payload = JSON.parse(chunksDecode(chunks, length)); + } else if (isContentTypeText(contentType)) { + payload = chunksDecode(chunks, length); + } + } catch { + } finally { + Error.stackTraceLimit = stackTraceLimit; + } + queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers2, payload))); + } + var isContentTypeApplicationJson = (contentType) => { + return contentType.length > 15 && contentType[11] === "/" && contentType[0] === "a" && contentType[1] === "p" && contentType[2] === "p" && contentType[3] === "l" && contentType[4] === "i" && contentType[5] === "c" && contentType[6] === "a" && contentType[7] === "t" && contentType[8] === "i" && contentType[9] === "o" && contentType[10] === "n" && contentType[12] === "j" && contentType[13] === "s" && contentType[14] === "o" && contentType[15] === "n"; + }; + var isContentTypeText = (contentType) => { + return contentType.length > 4 && contentType[4] === "/" && contentType[0] === "t" && contentType[1] === "e" && contentType[2] === "x" && contentType[3] === "t"; + }; + module.exports = { + getResolveErrorBodyCallback, + isContentTypeApplicationJson, + isContentTypeText + }; + } +}); + +// node_modules/undici/lib/api/api-request.js +var require_api_request = __commonJS({ + "node_modules/undici/lib/api/api-request.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { Readable } = require_readable(); + var { InvalidArgumentError, RequestAbortedError } = require_errors(); + var util2 = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = __require("node:async_hooks"); + var RequestHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal: signal3, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) { + throw new InvalidArgumentError("invalid highWaterMark"); + } + if (signal3 && typeof signal3.on !== "function" && typeof signal3.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_REQUEST"); + } catch (err) { + if (util2.isStream(body)) { + util2.destroy(body.on("error", util2.nop), err); + } + throw err; + } + this.method = method; + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.res = null; + this.abort = null; + this.body = body; + this.trailers = {}; + this.context = null; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError; + this.highWaterMark = highWaterMark; + this.signal = signal3; + this.reason = null; + this.removeAbortListener = null; + if (util2.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + if (this.signal) { + if (this.signal.aborted) { + this.reason = this.signal.reason ?? new RequestAbortedError(); + } else { + this.removeAbortListener = util2.addAbortListener(this.signal, () => { + this.reason = this.signal.reason ?? new RequestAbortedError(); + if (this.res) { + util2.destroy(this.res.on("error", util2.nop), this.reason); + } else if (this.abort) { + this.abort(this.reason); + } + if (this.removeAbortListener) { + this.res?.off("close", this.removeAbortListener); + this.removeAbortListener(); + this.removeAbortListener = null; + } + }); + } + } + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert(this.callback); + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this; + const headers2 = responseHeaders === "raw" ? util2.parseRawHeaders(rawHeaders) : util2.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers: headers2 }); + } + return; + } + const parsedHeaders = responseHeaders === "raw" ? util2.parseHeaders(rawHeaders) : headers2; + const contentType = parsedHeaders["content-type"]; + const contentLength = parsedHeaders["content-length"]; + const res = new Readable({ + resume, + abort, + contentType, + contentLength: this.method !== "HEAD" && contentLength ? Number(contentLength) : null, + highWaterMark + }); + if (this.removeAbortListener) { + res.on("close", this.removeAbortListener); + } + this.callback = null; + this.res = res; + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) { + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body: res, contentType, statusCode, statusMessage, headers: headers2 } + ); + } else { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers: headers2, + trailers: this.trailers, + opaque, + body: res, + context + }); + } + } + } + onData(chunk) { + return this.res.push(chunk); + } + onComplete(trailers) { + util2.parseHeaders(trailers, this.trailers); + this.res.push(null); + } + onError(err) { + const { res, callback, body, opaque } = this; + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (res) { + this.res = null; + queueMicrotask(() => { + util2.destroy(res, err); + }); + } + if (body) { + this.body = null; + util2.destroy(body, err); + } + if (this.removeAbortListener) { + res?.off("close", this.removeAbortListener); + this.removeAbortListener(); + this.removeAbortListener = null; + } + } + }; + function request(opts, callback) { + if (callback === void 0) { + return new Promise((resolve2, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve2(data); + }); + }); + } + try { + this.dispatch(opts, new RequestHandler(opts, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = request; + module.exports.RequestHandler = RequestHandler; + } +}); + +// node_modules/undici/lib/api/abort-signal.js +var require_abort_signal = __commonJS({ + "node_modules/undici/lib/api/abort-signal.js"(exports, module) { + var { addAbortListener } = require_util(); + var { RequestAbortedError } = require_errors(); + var kListener = /* @__PURE__ */ Symbol("kListener"); + var kSignal = /* @__PURE__ */ Symbol("kSignal"); + function abort(self) { + if (self.abort) { + self.abort(self[kSignal]?.reason); + } else { + self.reason = self[kSignal]?.reason ?? new RequestAbortedError(); + } + removeSignal(self); + } + function addSignal(self, signal3) { + self.reason = null; + self[kSignal] = null; + self[kListener] = null; + if (!signal3) { + return; + } + if (signal3.aborted) { + abort(self); + return; + } + self[kSignal] = signal3; + self[kListener] = () => { + abort(self); + }; + addAbortListener(self[kSignal], self[kListener]); + } + function removeSignal(self) { + if (!self[kSignal]) { + return; + } + if ("removeEventListener" in self[kSignal]) { + self[kSignal].removeEventListener("abort", self[kListener]); + } else { + self[kSignal].removeListener("abort", self[kListener]); + } + self[kSignal] = null; + self[kListener] = null; + } + module.exports = { + addSignal, + removeSignal + }; + } +}); + +// node_modules/undici/lib/api/api-stream.js +var require_api_stream = __commonJS({ + "node_modules/undici/lib/api/api-stream.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { finished, PassThrough } = __require("node:stream"); + var { InvalidArgumentError, InvalidReturnValueError } = require_errors(); + var util2 = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = __require("node:async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var StreamHandler = class extends AsyncResource { + constructor(opts, factory, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal: signal3, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("invalid factory"); + } + if (signal3 && typeof signal3.on !== "function" && typeof signal3.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_STREAM"); + } catch (err) { + if (util2.isStream(body)) { + util2.destroy(body.on("error", util2.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.factory = factory; + this.callback = callback; + this.res = null; + this.abort = null; + this.context = null; + this.trailers = null; + this.body = body; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError || false; + if (util2.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal3); + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert(this.callback); + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context, callback, responseHeaders } = this; + const headers2 = responseHeaders === "raw" ? util2.parseRawHeaders(rawHeaders) : util2.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers: headers2 }); + } + return; + } + this.factory = null; + let res; + if (this.throwOnError && statusCode >= 400) { + const parsedHeaders = responseHeaders === "raw" ? util2.parseHeaders(rawHeaders) : headers2; + const contentType = parsedHeaders["content-type"]; + res = new PassThrough(); + this.callback = null; + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body: res, contentType, statusCode, statusMessage, headers: headers2 } + ); + } else { + if (factory === null) { + return; + } + res = this.runInAsyncScope(factory, null, { + statusCode, + headers: headers2, + opaque, + context + }); + if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") { + throw new InvalidReturnValueError("expected Writable"); + } + finished(res, { readable: false }, (err) => { + const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this; + this.res = null; + if (err || !res2.readable) { + util2.destroy(res2, err); + } + this.callback = null; + this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers }); + if (err) { + abort(); + } + }); + } + res.on("drain", resume); + this.res = res; + const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState?.needDrain; + return needDrain !== true; + } + onData(chunk) { + const { res } = this; + return res ? res.write(chunk) : true; + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + if (!res) { + return; + } + this.trailers = util2.parseHeaders(trailers); + res.end(); + } + onError(err) { + const { res, callback, opaque, body } = this; + removeSignal(this); + this.factory = null; + if (res) { + this.res = null; + util2.destroy(res, err); + } else if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (body) { + this.body = null; + util2.destroy(body, err); + } + } + }; + function stream(opts, factory, callback) { + if (callback === void 0) { + return new Promise((resolve2, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve2(data); + }); + }); + } + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = stream; + } +}); + +// node_modules/undici/lib/api/api-pipeline.js +var require_api_pipeline = __commonJS({ + "node_modules/undici/lib/api/api-pipeline.js"(exports, module) { + "use strict"; + var { + Readable, + Duplex, + PassThrough + } = __require("node:stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util2 = require_util(); + var { AsyncResource } = __require("node:async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = __require("node:assert"); + var kResume = /* @__PURE__ */ Symbol("resume"); + var PipelineRequest = class extends Readable { + constructor() { + super({ autoDestroy: true }); + this[kResume] = null; + } + _read() { + const { [kResume]: resume } = this; + if (resume) { + this[kResume] = null; + resume(); + } + } + _destroy(err, callback) { + this._read(); + callback(err); + } + }; + var PipelineResponse = class extends Readable { + constructor(resume) { + super({ autoDestroy: true }); + this[kResume] = resume; + } + _read() { + this[kResume](); + } + _destroy(err, callback) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + callback(err); + } + }; + var PipelineHandler = class extends AsyncResource { + constructor(opts, handler) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof handler !== "function") { + throw new InvalidArgumentError("invalid handler"); + } + const { signal: signal3, method, opaque, onInfo, responseHeaders } = opts; + if (signal3 && typeof signal3.on !== "function" && typeof signal3.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_PIPELINE"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.handler = handler; + this.abort = null; + this.context = null; + this.onInfo = onInfo || null; + this.req = new PipelineRequest().on("error", util2.nop); + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this; + if (body?.resume) { + body.resume(); + } + }, + write: (chunk, encoding, callback) => { + const { req } = this; + if (req.push(chunk, encoding) || req._readableState.destroyed) { + callback(); + } else { + req[kResume] = callback; + } + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this; + if (!err && !ret._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (abort && err) { + abort(); + } + util2.destroy(body, err); + util2.destroy(req, err); + util2.destroy(res, err); + removeSignal(this); + callback(err); + } + }).on("prefinish", () => { + const { req } = this; + req.push(null); + }); + this.res = null; + addSignal(this, signal3); + } + onConnect(abort, context) { + const { ret, res } = this; + if (this.reason) { + abort(this.reason); + return; + } + assert(!res, "pipeline cannot be retried"); + assert(!ret.destroyed); + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume) { + const { opaque, handler, context } = this; + if (statusCode < 200) { + if (this.onInfo) { + const headers2 = this.responseHeaders === "raw" ? util2.parseRawHeaders(rawHeaders) : util2.parseHeaders(rawHeaders); + this.onInfo({ statusCode, headers: headers2 }); + } + return; + } + this.res = new PipelineResponse(resume); + let body; + try { + this.handler = null; + const headers2 = this.responseHeaders === "raw" ? util2.parseRawHeaders(rawHeaders) : util2.parseHeaders(rawHeaders); + body = this.runInAsyncScope(handler, null, { + statusCode, + headers: headers2, + opaque, + body: this.res, + context + }); + } catch (err) { + this.res.on("error", util2.nop); + throw err; + } + if (!body || typeof body.on !== "function") { + throw new InvalidReturnValueError("expected Readable"); + } + body.on("data", (chunk) => { + const { ret, body: body2 } = this; + if (!ret.push(chunk) && body2.pause) { + body2.pause(); + } + }).on("error", (err) => { + const { ret } = this; + util2.destroy(ret, err); + }).on("end", () => { + const { ret } = this; + ret.push(null); + }).on("close", () => { + const { ret } = this; + if (!ret._readableState.ended) { + util2.destroy(ret, new RequestAbortedError()); + } + }); + this.body = body; + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + res.push(null); + } + onError(err) { + const { ret } = this; + this.handler = null; + util2.destroy(ret, err); + } + }; + function pipeline(opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler); + this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler); + return pipelineHandler.ret; + } catch (err) { + return new PassThrough().destroy(err); + } + } + module.exports = pipeline; + } +}); + +// node_modules/undici/lib/api/api-upgrade.js +var require_api_upgrade = __commonJS({ + "node_modules/undici/lib/api/api-upgrade.js"(exports, module) { + "use strict"; + var { InvalidArgumentError, SocketError } = require_errors(); + var { AsyncResource } = __require("node:async_hooks"); + var util2 = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = __require("node:assert"); + var UpgradeHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal: signal3, opaque, responseHeaders } = opts; + if (signal3 && typeof signal3.on !== "function" && typeof signal3.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_UPGRADE"); + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.abort = null; + this.context = null; + addSignal(this, signal3); + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert(this.callback); + this.abort = abort; + this.context = null; + } + onHeaders() { + throw new SocketError("bad upgrade", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + assert(statusCode === 101); + const { callback, opaque, context } = this; + removeSignal(this); + this.callback = null; + const headers2 = this.responseHeaders === "raw" ? util2.parseRawHeaders(rawHeaders) : util2.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + headers: headers2, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function upgrade(opts, callback) { + if (callback === void 0) { + return new Promise((resolve2, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve2(data); + }); + }); + } + try { + const upgradeHandler = new UpgradeHandler(opts, callback); + this.dispatch({ + ...opts, + method: opts.method || "GET", + upgrade: opts.protocol || "Websocket" + }, upgradeHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = upgrade; + } +}); + +// node_modules/undici/lib/api/api-connect.js +var require_api_connect = __commonJS({ + "node_modules/undici/lib/api/api-connect.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { AsyncResource } = __require("node:async_hooks"); + var { InvalidArgumentError, SocketError } = require_errors(); + var util2 = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var ConnectHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal: signal3, opaque, responseHeaders } = opts; + if (signal3 && typeof signal3.on !== "function" && typeof signal3.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_CONNECT"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.callback = callback; + this.abort = null; + addSignal(this, signal3); + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert(this.callback); + this.abort = abort; + this.context = context; + } + onHeaders() { + throw new SocketError("bad connect", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this; + removeSignal(this); + this.callback = null; + let headers2 = rawHeaders; + if (headers2 != null) { + headers2 = this.responseHeaders === "raw" ? util2.parseRawHeaders(rawHeaders) : util2.parseHeaders(rawHeaders); + } + this.runInAsyncScope(callback, null, null, { + statusCode, + headers: headers2, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function connect(opts, callback) { + if (callback === void 0) { + return new Promise((resolve2, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve2(data); + }); + }); + } + try { + const connectHandler = new ConnectHandler(opts, callback); + this.dispatch({ ...opts, method: "CONNECT" }, connectHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = connect; + } +}); + +// node_modules/undici/lib/api/index.js +var require_api = __commonJS({ + "node_modules/undici/lib/api/index.js"(exports, module) { + "use strict"; + module.exports.request = require_api_request(); + module.exports.stream = require_api_stream(); + module.exports.pipeline = require_api_pipeline(); + module.exports.upgrade = require_api_upgrade(); + module.exports.connect = require_api_connect(); + } +}); + +// node_modules/undici/lib/mock/mock-errors.js +var require_mock_errors = __commonJS({ + "node_modules/undici/lib/mock/mock-errors.js"(exports, module) { + "use strict"; + var { UndiciError } = require_errors(); + var kMockNotMatchedError = /* @__PURE__ */ Symbol.for("undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED"); + var MockNotMatchedError = class _MockNotMatchedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _MockNotMatchedError); + this.name = "MockNotMatchedError"; + this.message = message || "The request does not match any registered mock dispatches"; + this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kMockNotMatchedError] === true; + } + [kMockNotMatchedError] = true; + }; + module.exports = { + MockNotMatchedError + }; + } +}); + +// node_modules/undici/lib/mock/mock-symbols.js +var require_mock_symbols = __commonJS({ + "node_modules/undici/lib/mock/mock-symbols.js"(exports, module) { + "use strict"; + module.exports = { + kAgent: /* @__PURE__ */ Symbol("agent"), + kOptions: /* @__PURE__ */ Symbol("options"), + kFactory: /* @__PURE__ */ Symbol("factory"), + kDispatches: /* @__PURE__ */ Symbol("dispatches"), + kDispatchKey: /* @__PURE__ */ Symbol("dispatch key"), + kDefaultHeaders: /* @__PURE__ */ Symbol("default headers"), + kDefaultTrailers: /* @__PURE__ */ Symbol("default trailers"), + kContentLength: /* @__PURE__ */ Symbol("content length"), + kMockAgent: /* @__PURE__ */ Symbol("mock agent"), + kMockAgentSet: /* @__PURE__ */ Symbol("mock agent set"), + kMockAgentGet: /* @__PURE__ */ Symbol("mock agent get"), + kMockDispatch: /* @__PURE__ */ Symbol("mock dispatch"), + kClose: /* @__PURE__ */ Symbol("close"), + kOriginalClose: /* @__PURE__ */ Symbol("original agent close"), + kOrigin: /* @__PURE__ */ Symbol("origin"), + kIsMockActive: /* @__PURE__ */ Symbol("is mock active"), + kNetConnect: /* @__PURE__ */ Symbol("net connect"), + kGetNetConnect: /* @__PURE__ */ Symbol("get net connect"), + kConnected: /* @__PURE__ */ Symbol("connected") + }; + } +}); + +// node_modules/undici/lib/mock/mock-utils.js +var require_mock_utils = __commonJS({ + "node_modules/undici/lib/mock/mock-utils.js"(exports, module) { + "use strict"; + var { MockNotMatchedError } = require_mock_errors(); + var { + kDispatches, + kMockAgent, + kOriginalDispatch, + kOrigin, + kGetNetConnect + } = require_mock_symbols(); + var { buildURL } = require_util(); + var { STATUS_CODES: STATUS_CODES2 } = __require("node:http"); + var { + types: { + isPromise + } + } = __require("node:util"); + function matchValue(match, value) { + if (typeof match === "string") { + return match === value; + } + if (match instanceof RegExp) { + return match.test(value); + } + if (typeof match === "function") { + return match(value) === true; + } + return false; + } + function lowerCaseEntries(headers2) { + return Object.fromEntries( + Object.entries(headers2).map(([headerName, headerValue]) => { + return [headerName.toLocaleLowerCase(), headerValue]; + }) + ); + } + function getHeaderByName(headers2, key) { + if (Array.isArray(headers2)) { + for (let i = 0; i < headers2.length; i += 2) { + if (headers2[i].toLocaleLowerCase() === key.toLocaleLowerCase()) { + return headers2[i + 1]; + } + } + return void 0; + } else if (typeof headers2.get === "function") { + return headers2.get(key); + } else { + return lowerCaseEntries(headers2)[key.toLocaleLowerCase()]; + } + } + function buildHeadersFromArray(headers2) { + const clone = headers2.slice(); + const entries = []; + for (let index2 = 0; index2 < clone.length; index2 += 2) { + entries.push([clone[index2], clone[index2 + 1]]); + } + return Object.fromEntries(entries); + } + function matchHeaders(mockDispatch2, headers2) { + if (typeof mockDispatch2.headers === "function") { + if (Array.isArray(headers2)) { + headers2 = buildHeadersFromArray(headers2); + } + return mockDispatch2.headers(headers2 ? lowerCaseEntries(headers2) : {}); + } + if (typeof mockDispatch2.headers === "undefined") { + return true; + } + if (typeof headers2 !== "object" || typeof mockDispatch2.headers !== "object") { + return false; + } + for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) { + const headerValue = getHeaderByName(headers2, matchHeaderName); + if (!matchValue(matchHeaderValue, headerValue)) { + return false; + } + } + return true; + } + function safeUrl(path7) { + if (typeof path7 !== "string") { + return path7; + } + const pathSegments = path7.split("?"); + if (pathSegments.length !== 2) { + return path7; + } + const qp = new URLSearchParams(pathSegments.pop()); + qp.sort(); + return [...pathSegments, qp.toString()].join("?"); + } + function matchKey(mockDispatch2, { path: path7, method, body, headers: headers2 }) { + const pathMatch = matchValue(mockDispatch2.path, path7); + const methodMatch = matchValue(mockDispatch2.method, method); + const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true; + const headersMatch = matchHeaders(mockDispatch2, headers2); + return pathMatch && methodMatch && bodyMatch && headersMatch; + } + function getResponseData(data) { + if (Buffer.isBuffer(data)) { + return data; + } else if (data instanceof Uint8Array) { + return data; + } else if (data instanceof ArrayBuffer) { + return data; + } else if (typeof data === "object") { + return JSON.stringify(data); + } else { + return data.toString(); + } + } + function getMockDispatch(mockDispatches, key) { + const basePath = key.query ? buildURL(key.path, key.query) : key.path; + const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath; + let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path7 }) => matchValue(safeUrl(path7), resolvedPath)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers)); + if (matchedMockDispatches.length === 0) { + const headers2 = typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers; + throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers2}' on path '${resolvedPath}'`); + } + return matchedMockDispatches[0]; + } + function addMockDispatch(mockDispatches, key, data) { + const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }; + const replyData = typeof data === "function" ? { callback: data } : { ...data }; + const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }; + mockDispatches.push(newMockDispatch); + return newMockDispatch; + } + function deleteMockDispatch(mockDispatches, key) { + const index2 = mockDispatches.findIndex((dispatch) => { + if (!dispatch.consumed) { + return false; + } + return matchKey(dispatch, key); + }); + if (index2 !== -1) { + mockDispatches.splice(index2, 1); + } + } + function buildKey(opts) { + const { path: path7, method, body, headers: headers2, query } = opts; + return { + path: path7, + method, + body, + headers: headers2, + query + }; + } + function generateKeyValues(data) { + const keys = Object.keys(data); + const result = []; + for (let i = 0; i < keys.length; ++i) { + const key = keys[i]; + const value = data[key]; + const name = Buffer.from(`${key}`); + if (Array.isArray(value)) { + for (let j = 0; j < value.length; ++j) { + result.push(name, Buffer.from(`${value[j]}`)); + } + } else { + result.push(name, Buffer.from(`${value}`)); + } + } + return result; + } + function getStatusText(statusCode) { + return STATUS_CODES2[statusCode] || "unknown"; + } + async function getResponse(body) { + const buffers = []; + for await (const data of body) { + buffers.push(data); + } + return Buffer.concat(buffers).toString("utf8"); + } + function mockDispatch(opts, handler) { + const key = buildKey(opts); + const mockDispatch2 = getMockDispatch(this[kDispatches], key); + mockDispatch2.timesInvoked++; + if (mockDispatch2.data.callback) { + mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) }; + } + const { data: { statusCode, data, headers: headers2, trailers, error: error2 }, delay, persist } = mockDispatch2; + const { timesInvoked, times } = mockDispatch2; + mockDispatch2.consumed = !persist && timesInvoked >= times; + mockDispatch2.pending = timesInvoked < times; + if (error2 !== null) { + deleteMockDispatch(this[kDispatches], key); + handler.onError(error2); + return true; + } + if (typeof delay === "number" && delay > 0) { + setTimeout(() => { + handleReply(this[kDispatches]); + }, delay); + } else { + handleReply(this[kDispatches]); + } + function handleReply(mockDispatches, _data = data) { + const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers; + const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data; + if (isPromise(body)) { + body.then((newData) => handleReply(mockDispatches, newData)); + return; + } + const responseData = getResponseData(body); + const responseHeaders = generateKeyValues(headers2); + const responseTrailers = generateKeyValues(trailers); + handler.onConnect?.((err) => handler.onError(err), null); + handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode)); + handler.onData?.(Buffer.from(responseData)); + handler.onComplete?.(responseTrailers); + deleteMockDispatch(mockDispatches, key); + } + function resume() { + } + return true; + } + function buildMockDispatch() { + const agent = this[kMockAgent]; + const origin = this[kOrigin]; + const originalDispatch = this[kOriginalDispatch]; + return function dispatch(opts, handler) { + if (agent.isMockActive) { + try { + mockDispatch.call(this, opts, handler); + } catch (error2) { + if (error2 instanceof MockNotMatchedError) { + const netConnect = agent[kGetNetConnect](); + if (netConnect === false) { + throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`); + } + if (checkNetConnect(netConnect, origin)) { + originalDispatch.call(this, opts, handler); + } else { + throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`); + } + } else { + throw error2; + } + } + } else { + originalDispatch.call(this, opts, handler); + } + }; + } + function checkNetConnect(netConnect, origin) { + const url = new URL(origin); + if (netConnect === true) { + return true; + } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) { + return true; + } + return false; + } + function buildMockOptions(opts) { + if (opts) { + const { agent, ...mockOptions } = opts; + return mockOptions; + } + } + module.exports = { + getResponseData, + getMockDispatch, + addMockDispatch, + deleteMockDispatch, + buildKey, + generateKeyValues, + matchValue, + getResponse, + getStatusText, + mockDispatch, + buildMockDispatch, + checkNetConnect, + buildMockOptions, + getHeaderByName, + buildHeadersFromArray + }; + } +}); + +// node_modules/undici/lib/mock/mock-interceptor.js +var require_mock_interceptor = __commonJS({ + "node_modules/undici/lib/mock/mock-interceptor.js"(exports, module) { + "use strict"; + var { getResponseData, buildKey, addMockDispatch } = require_mock_utils(); + var { + kDispatches, + kDispatchKey, + kDefaultHeaders, + kDefaultTrailers, + kContentLength, + kMockDispatch + } = require_mock_symbols(); + var { InvalidArgumentError } = require_errors(); + var { buildURL } = require_util(); + var MockScope = class { + constructor(mockDispatch) { + this[kMockDispatch] = mockDispatch; + } + /** + * Delay a reply by a set amount in ms. + */ + delay(waitInMs) { + if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) { + throw new InvalidArgumentError("waitInMs must be a valid integer > 0"); + } + this[kMockDispatch].delay = waitInMs; + return this; + } + /** + * For a defined reply, never mark as consumed. + */ + persist() { + this[kMockDispatch].persist = true; + return this; + } + /** + * Allow one to define a reply for a set amount of matching requests. + */ + times(repeatTimes) { + if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) { + throw new InvalidArgumentError("repeatTimes must be a valid integer > 0"); + } + this[kMockDispatch].times = repeatTimes; + return this; + } + }; + var MockInterceptor = class { + constructor(opts, mockDispatches) { + if (typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object"); + } + if (typeof opts.path === "undefined") { + throw new InvalidArgumentError("opts.path must be defined"); + } + if (typeof opts.method === "undefined") { + opts.method = "GET"; + } + if (typeof opts.path === "string") { + if (opts.query) { + opts.path = buildURL(opts.path, opts.query); + } else { + const parsedURL = new URL(opts.path, "data://"); + opts.path = parsedURL.pathname + parsedURL.search; + } + } + if (typeof opts.method === "string") { + opts.method = opts.method.toUpperCase(); + } + this[kDispatchKey] = buildKey(opts); + this[kDispatches] = mockDispatches; + this[kDefaultHeaders] = {}; + this[kDefaultTrailers] = {}; + this[kContentLength] = false; + } + createMockScopeDispatchData({ statusCode, data, responseOptions }) { + const responseData = getResponseData(data); + const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {}; + const headers2 = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }; + const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }; + return { statusCode, data, headers: headers2, trailers }; + } + validateReplyParameters(replyParameters) { + if (typeof replyParameters.statusCode === "undefined") { + throw new InvalidArgumentError("statusCode must be defined"); + } + if (typeof replyParameters.responseOptions !== "object" || replyParameters.responseOptions === null) { + throw new InvalidArgumentError("responseOptions must be an object"); + } + } + /** + * Mock an undici request with a defined reply. + */ + reply(replyOptionsCallbackOrStatusCode) { + if (typeof replyOptionsCallbackOrStatusCode === "function") { + const wrappedDefaultsCallback = (opts) => { + const resolvedData = replyOptionsCallbackOrStatusCode(opts); + if (typeof resolvedData !== "object" || resolvedData === null) { + throw new InvalidArgumentError("reply options callback must return an object"); + } + const replyParameters2 = { data: "", responseOptions: {}, ...resolvedData }; + this.validateReplyParameters(replyParameters2); + return { + ...this.createMockScopeDispatchData(replyParameters2) + }; + }; + const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback); + return new MockScope(newMockDispatch2); + } + const replyParameters = { + statusCode: replyOptionsCallbackOrStatusCode, + data: arguments[1] === void 0 ? "" : arguments[1], + responseOptions: arguments[2] === void 0 ? {} : arguments[2] + }; + this.validateReplyParameters(replyParameters); + const dispatchData = this.createMockScopeDispatchData(replyParameters); + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData); + return new MockScope(newMockDispatch); + } + /** + * Mock an undici request with a defined error. + */ + replyWithError(error2) { + if (typeof error2 === "undefined") { + throw new InvalidArgumentError("error must be defined"); + } + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error: error2 }); + return new MockScope(newMockDispatch); + } + /** + * Set default reply headers on the interceptor for subsequent replies + */ + defaultReplyHeaders(headers2) { + if (typeof headers2 === "undefined") { + throw new InvalidArgumentError("headers must be defined"); + } + this[kDefaultHeaders] = headers2; + return this; + } + /** + * Set default reply trailers on the interceptor for subsequent replies + */ + defaultReplyTrailers(trailers) { + if (typeof trailers === "undefined") { + throw new InvalidArgumentError("trailers must be defined"); + } + this[kDefaultTrailers] = trailers; + return this; + } + /** + * Set reply content length header for replies on the interceptor + */ + replyContentLength() { + this[kContentLength] = true; + return this; + } + }; + module.exports.MockInterceptor = MockInterceptor; + module.exports.MockScope = MockScope; + } +}); + +// node_modules/undici/lib/mock/mock-client.js +var require_mock_client = __commonJS({ + "node_modules/undici/lib/mock/mock-client.js"(exports, module) { + "use strict"; + var { promisify } = __require("node:util"); + var Client = require_client(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockClient = class extends Client { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module.exports = MockClient; + } +}); + +// node_modules/undici/lib/mock/mock-pool.js +var require_mock_pool = __commonJS({ + "node_modules/undici/lib/mock/mock-pool.js"(exports, module) { + "use strict"; + var { promisify } = __require("node:util"); + var Pool = require_pool(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockPool = class extends Pool { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module.exports = MockPool; + } +}); + +// node_modules/undici/lib/mock/pluralizer.js +var require_pluralizer = __commonJS({ + "node_modules/undici/lib/mock/pluralizer.js"(exports, module) { + "use strict"; + var singulars = { + pronoun: "it", + is: "is", + was: "was", + this: "this" + }; + var plurals = { + pronoun: "they", + is: "are", + was: "were", + this: "these" + }; + module.exports = class Pluralizer { + constructor(singular, plural) { + this.singular = singular; + this.plural = plural; + } + pluralize(count) { + const one = count === 1; + const keys = one ? singulars : plurals; + const noun = one ? this.singular : this.plural; + return { ...keys, count, noun }; + } + }; + } +}); + +// node_modules/undici/lib/mock/pending-interceptors-formatter.js +var require_pending_interceptors_formatter = __commonJS({ + "node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports, module) { + "use strict"; + var { Transform } = __require("node:stream"); + var { Console } = __require("node:console"); + var PERSISTENT = process.versions.icu ? "\u2705" : "Y "; + var NOT_PERSISTENT = process.versions.icu ? "\u274C" : "N "; + module.exports = class PendingInterceptorsFormatter { + constructor({ disableColors } = {}) { + this.transform = new Transform({ + transform(chunk, _enc, cb) { + cb(null, chunk); + } + }); + this.logger = new Console({ + stdout: this.transform, + inspectOptions: { + colors: !disableColors && !process.env.CI + } + }); + } + format(pendingInterceptors) { + const withPrettyHeaders = pendingInterceptors.map( + ({ method, path: path7, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ + Method: method, + Origin: origin, + Path: path7, + "Status code": statusCode, + Persistent: persist ? PERSISTENT : NOT_PERSISTENT, + Invocations: timesInvoked, + Remaining: persist ? Infinity : times - timesInvoked + }) + ); + this.logger.table(withPrettyHeaders); + return this.transform.read().toString(); + } + }; + } +}); + +// node_modules/undici/lib/mock/mock-agent.js +var require_mock_agent = __commonJS({ + "node_modules/undici/lib/mock/mock-agent.js"(exports, module) { + "use strict"; + var { kClients } = require_symbols(); + var Agent = require_agent(); + var { + kAgent, + kMockAgentSet, + kMockAgentGet, + kDispatches, + kIsMockActive, + kNetConnect, + kGetNetConnect, + kOptions, + kFactory + } = require_mock_symbols(); + var MockClient = require_mock_client(); + var MockPool = require_mock_pool(); + var { matchValue, buildMockOptions } = require_mock_utils(); + var { InvalidArgumentError, UndiciError } = require_errors(); + var Dispatcher = require_dispatcher(); + var Pluralizer = require_pluralizer(); + var PendingInterceptorsFormatter = require_pending_interceptors_formatter(); + var MockAgent = class extends Dispatcher { + constructor(opts) { + super(opts); + this[kNetConnect] = true; + this[kIsMockActive] = true; + if (opts?.agent && typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + const agent = opts?.agent ? opts.agent : new Agent(opts); + this[kAgent] = agent; + this[kClients] = agent[kClients]; + this[kOptions] = buildMockOptions(opts); + } + get(origin) { + let dispatcher = this[kMockAgentGet](origin); + if (!dispatcher) { + dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + } + return dispatcher; + } + dispatch(opts, handler) { + this.get(opts.origin); + return this[kAgent].dispatch(opts, handler); + } + async close() { + await this[kAgent].close(); + this[kClients].clear(); + } + deactivate() { + this[kIsMockActive] = false; + } + activate() { + this[kIsMockActive] = true; + } + enableNetConnect(matcher) { + if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) { + if (Array.isArray(this[kNetConnect])) { + this[kNetConnect].push(matcher); + } else { + this[kNetConnect] = [matcher]; + } + } else if (typeof matcher === "undefined") { + this[kNetConnect] = true; + } else { + throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp."); + } + } + disableNetConnect() { + this[kNetConnect] = false; + } + // This is required to bypass issues caused by using global symbols - see: + // https://github.com/nodejs/undici/issues/1447 + get isMockActive() { + return this[kIsMockActive]; + } + [kMockAgentSet](origin, dispatcher) { + this[kClients].set(origin, dispatcher); + } + [kFactory](origin) { + const mockOptions = Object.assign({ agent: this }, this[kOptions]); + return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions); + } + [kMockAgentGet](origin) { + const client = this[kClients].get(origin); + if (client) { + return client; + } + if (typeof origin !== "string") { + const dispatcher = this[kFactory]("http://localhost:9999"); + this[kMockAgentSet](origin, dispatcher); + return dispatcher; + } + for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) { + if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) { + const dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]; + return dispatcher; + } + } + } + [kGetNetConnect]() { + return this[kNetConnect]; + } + pendingInterceptors() { + const mockAgentClients = this[kClients]; + return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending); + } + assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { + const pending = this.pendingInterceptors(); + if (pending.length === 0) { + return; + } + const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length); + throw new UndiciError(` +${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: + +${pendingInterceptorsFormatter.format(pending)} +`.trim()); + } + }; + module.exports = MockAgent; + } +}); + +// node_modules/undici/lib/global.js +var require_global2 = __commonJS({ + "node_modules/undici/lib/global.js"(exports, module) { + "use strict"; + var globalDispatcher = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1"); + var { InvalidArgumentError } = require_errors(); + var Agent = require_agent(); + if (getGlobalDispatcher() === void 0) { + setGlobalDispatcher(new Agent()); + } + function setGlobalDispatcher(agent) { + if (!agent || typeof agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument agent must implement Agent"); + } + Object.defineProperty(globalThis, globalDispatcher, { + value: agent, + writable: true, + enumerable: false, + configurable: false + }); + } + function getGlobalDispatcher() { + return globalThis[globalDispatcher]; + } + module.exports = { + setGlobalDispatcher, + getGlobalDispatcher + }; + } +}); + +// node_modules/undici/lib/handler/decorator-handler.js +var require_decorator_handler = __commonJS({ + "node_modules/undici/lib/handler/decorator-handler.js"(exports, module) { + "use strict"; + module.exports = class DecoratorHandler { + #handler; + constructor(handler) { + if (typeof handler !== "object" || handler === null) { + throw new TypeError("handler must be an object"); + } + this.#handler = handler; + } + onConnect(...args) { + return this.#handler.onConnect?.(...args); + } + onError(...args) { + return this.#handler.onError?.(...args); + } + onUpgrade(...args) { + return this.#handler.onUpgrade?.(...args); + } + onResponseStarted(...args) { + return this.#handler.onResponseStarted?.(...args); + } + onHeaders(...args) { + return this.#handler.onHeaders?.(...args); + } + onData(...args) { + return this.#handler.onData?.(...args); + } + onComplete(...args) { + return this.#handler.onComplete?.(...args); + } + onBodySent(...args) { + return this.#handler.onBodySent?.(...args); + } + }; + } +}); + +// node_modules/undici/lib/interceptor/redirect.js +var require_redirect = __commonJS({ + "node_modules/undici/lib/interceptor/redirect.js"(exports, module) { + "use strict"; + var RedirectHandler = require_redirect_handler(); + module.exports = (opts) => { + const globalMaxRedirections = opts?.maxRedirections; + return (dispatch) => { + return function redirectInterceptor(opts2, handler) { + const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts2; + if (!maxRedirections) { + return dispatch(opts2, handler); + } + const redirectHandler = new RedirectHandler( + dispatch, + maxRedirections, + opts2, + handler + ); + return dispatch(baseOpts, redirectHandler); + }; + }; + }; + } +}); + +// node_modules/undici/lib/interceptor/retry.js +var require_retry = __commonJS({ + "node_modules/undici/lib/interceptor/retry.js"(exports, module) { + "use strict"; + var RetryHandler = require_retry_handler(); + module.exports = (globalOpts) => { + return (dispatch) => { + return function retryInterceptor(opts, handler) { + return dispatch( + opts, + new RetryHandler( + { ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } }, + { + handler, + dispatch + } + ) + ); + }; + }; + }; + } +}); + +// node_modules/undici/lib/interceptor/dump.js +var require_dump = __commonJS({ + "node_modules/undici/lib/interceptor/dump.js"(exports, module) { + "use strict"; + var util2 = require_util(); + var { InvalidArgumentError, RequestAbortedError } = require_errors(); + var DecoratorHandler = require_decorator_handler(); + var DumpHandler = class extends DecoratorHandler { + #maxSize = 1024 * 1024; + #abort = null; + #dumped = false; + #aborted = false; + #size = 0; + #reason = null; + #handler = null; + constructor({ maxSize }, handler) { + super(handler); + if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) { + throw new InvalidArgumentError("maxSize must be a number greater than 0"); + } + this.#maxSize = maxSize ?? this.#maxSize; + this.#handler = handler; + } + onConnect(abort) { + this.#abort = abort; + this.#handler.onConnect(this.#customAbort.bind(this)); + } + #customAbort(reason) { + this.#aborted = true; + this.#reason = reason; + } + // TODO: will require adjustment after new hooks are out + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers2 = util2.parseHeaders(rawHeaders); + const contentLength = headers2["content-length"]; + if (contentLength != null && contentLength > this.#maxSize) { + throw new RequestAbortedError( + `Response size (${contentLength}) larger than maxSize (${this.#maxSize})` + ); + } + if (this.#aborted) { + return true; + } + return this.#handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + onError(err) { + if (this.#dumped) { + return; + } + err = this.#reason ?? err; + this.#handler.onError(err); + } + onData(chunk) { + this.#size = this.#size + chunk.length; + if (this.#size >= this.#maxSize) { + this.#dumped = true; + if (this.#aborted) { + this.#handler.onError(this.#reason); + } else { + this.#handler.onComplete([]); + } + } + return true; + } + onComplete(trailers) { + if (this.#dumped) { + return; + } + if (this.#aborted) { + this.#handler.onError(this.reason); + return; + } + this.#handler.onComplete(trailers); + } + }; + function createDumpInterceptor({ maxSize: defaultMaxSize } = { + maxSize: 1024 * 1024 + }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { dumpMaxSize = defaultMaxSize } = opts; + const dumpHandler = new DumpHandler( + { maxSize: dumpMaxSize }, + handler + ); + return dispatch(opts, dumpHandler); + }; + }; + } + module.exports = createDumpInterceptor; + } +}); + +// node_modules/undici/lib/interceptor/dns.js +var require_dns = __commonJS({ + "node_modules/undici/lib/interceptor/dns.js"(exports, module) { + "use strict"; + var { isIP } = __require("node:net"); + var { lookup } = __require("node:dns"); + var DecoratorHandler = require_decorator_handler(); + var { InvalidArgumentError, InformationalError } = require_errors(); + var maxInt = Math.pow(2, 31) - 1; + var DNSInstance = class { + #maxTTL = 0; + #maxItems = 0; + #records = /* @__PURE__ */ new Map(); + dualStack = true; + affinity = null; + lookup = null; + pick = null; + constructor(opts) { + this.#maxTTL = opts.maxTTL; + this.#maxItems = opts.maxItems; + this.dualStack = opts.dualStack; + this.affinity = opts.affinity; + this.lookup = opts.lookup ?? this.#defaultLookup; + this.pick = opts.pick ?? this.#defaultPick; + } + get full() { + return this.#records.size === this.#maxItems; + } + runLookup(origin, opts, cb) { + const ips = this.#records.get(origin.hostname); + if (ips == null && this.full) { + cb(null, origin.origin); + return; + } + const newOpts = { + affinity: this.affinity, + dualStack: this.dualStack, + lookup: this.lookup, + pick: this.pick, + ...opts.dns, + maxTTL: this.#maxTTL, + maxItems: this.#maxItems + }; + if (ips == null) { + this.lookup(origin, newOpts, (err, addresses) => { + if (err || addresses == null || addresses.length === 0) { + cb(err ?? new InformationalError("No DNS entries found")); + return; + } + this.setRecords(origin, addresses); + const records = this.#records.get(origin.hostname); + const ip = this.pick( + origin, + records, + newOpts.affinity + ); + let port; + if (typeof ip.port === "number") { + port = `:${ip.port}`; + } else if (origin.port !== "") { + port = `:${origin.port}`; + } else { + port = ""; + } + cb( + null, + `${origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}` + ); + }); + } else { + const ip = this.pick( + origin, + ips, + newOpts.affinity + ); + if (ip == null) { + this.#records.delete(origin.hostname); + this.runLookup(origin, opts, cb); + return; + } + let port; + if (typeof ip.port === "number") { + port = `:${ip.port}`; + } else if (origin.port !== "") { + port = `:${origin.port}`; + } else { + port = ""; + } + cb( + null, + `${origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}` + ); + } + } + #defaultLookup(origin, opts, cb) { + lookup( + origin.hostname, + { + all: true, + family: this.dualStack === false ? this.affinity : 0, + order: "ipv4first" + }, + (err, addresses) => { + if (err) { + return cb(err); + } + const results = /* @__PURE__ */ new Map(); + for (const addr of addresses) { + results.set(`${addr.address}:${addr.family}`, addr); + } + cb(null, results.values()); + } + ); + } + #defaultPick(origin, hostnameRecords, affinity) { + let ip = null; + const { records, offset } = hostnameRecords; + let family; + if (this.dualStack) { + if (affinity == null) { + if (offset == null || offset === maxInt) { + hostnameRecords.offset = 0; + affinity = 4; + } else { + hostnameRecords.offset++; + affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4; + } + } + if (records[affinity] != null && records[affinity].ips.length > 0) { + family = records[affinity]; + } else { + family = records[affinity === 4 ? 6 : 4]; + } + } else { + family = records[affinity]; + } + if (family == null || family.ips.length === 0) { + return ip; + } + if (family.offset == null || family.offset === maxInt) { + family.offset = 0; + } else { + family.offset++; + } + const position = family.offset % family.ips.length; + ip = family.ips[position] ?? null; + if (ip == null) { + return ip; + } + if (Date.now() - ip.timestamp > ip.ttl) { + family.ips.splice(position, 1); + return this.pick(origin, hostnameRecords, affinity); + } + return ip; + } + setRecords(origin, addresses) { + const timestamp2 = Date.now(); + const records = { records: { 4: null, 6: null } }; + for (const record of addresses) { + record.timestamp = timestamp2; + if (typeof record.ttl === "number") { + record.ttl = Math.min(record.ttl, this.#maxTTL); + } else { + record.ttl = this.#maxTTL; + } + const familyRecords = records.records[record.family] ?? { ips: [] }; + familyRecords.ips.push(record); + records.records[record.family] = familyRecords; + } + this.#records.set(origin.hostname, records); + } + getHandler(meta, opts) { + return new DNSDispatchHandler(this, meta, opts); + } + }; + var DNSDispatchHandler = class extends DecoratorHandler { + #state = null; + #opts = null; + #dispatch = null; + #handler = null; + #origin = null; + constructor(state, { origin, handler, dispatch }, opts) { + super(handler); + this.#origin = origin; + this.#handler = handler; + this.#opts = { ...opts }; + this.#state = state; + this.#dispatch = dispatch; + } + onError(err) { + switch (err.code) { + case "ETIMEDOUT": + case "ECONNREFUSED": { + if (this.#state.dualStack) { + this.#state.runLookup(this.#origin, this.#opts, (err2, newOrigin) => { + if (err2) { + return this.#handler.onError(err2); + } + const dispatchOpts = { + ...this.#opts, + origin: newOrigin + }; + this.#dispatch(dispatchOpts, this); + }); + return; + } + this.#handler.onError(err); + return; + } + case "ENOTFOUND": + this.#state.deleteRecord(this.#origin); + // eslint-disable-next-line no-fallthrough + default: + this.#handler.onError(err); + break; + } + } + }; + module.exports = (interceptorOpts) => { + if (interceptorOpts?.maxTTL != null && (typeof interceptorOpts?.maxTTL !== "number" || interceptorOpts?.maxTTL < 0)) { + throw new InvalidArgumentError("Invalid maxTTL. Must be a positive number"); + } + if (interceptorOpts?.maxItems != null && (typeof interceptorOpts?.maxItems !== "number" || interceptorOpts?.maxItems < 1)) { + throw new InvalidArgumentError( + "Invalid maxItems. Must be a positive number and greater than zero" + ); + } + if (interceptorOpts?.affinity != null && interceptorOpts?.affinity !== 4 && interceptorOpts?.affinity !== 6) { + throw new InvalidArgumentError("Invalid affinity. Must be either 4 or 6"); + } + if (interceptorOpts?.dualStack != null && typeof interceptorOpts?.dualStack !== "boolean") { + throw new InvalidArgumentError("Invalid dualStack. Must be a boolean"); + } + if (interceptorOpts?.lookup != null && typeof interceptorOpts?.lookup !== "function") { + throw new InvalidArgumentError("Invalid lookup. Must be a function"); + } + if (interceptorOpts?.pick != null && typeof interceptorOpts?.pick !== "function") { + throw new InvalidArgumentError("Invalid pick. Must be a function"); + } + const dualStack = interceptorOpts?.dualStack ?? true; + let affinity; + if (dualStack) { + affinity = interceptorOpts?.affinity ?? null; + } else { + affinity = interceptorOpts?.affinity ?? 4; + } + const opts = { + maxTTL: interceptorOpts?.maxTTL ?? 1e4, + // Expressed in ms + lookup: interceptorOpts?.lookup ?? null, + pick: interceptorOpts?.pick ?? null, + dualStack, + affinity, + maxItems: interceptorOpts?.maxItems ?? Infinity + }; + const instance = new DNSInstance(opts); + return (dispatch) => { + return function dnsInterceptor(origDispatchOpts, handler) { + const origin = origDispatchOpts.origin.constructor === URL ? origDispatchOpts.origin : new URL(origDispatchOpts.origin); + if (isIP(origin.hostname) !== 0) { + return dispatch(origDispatchOpts, handler); + } + instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => { + if (err) { + return handler.onError(err); + } + let dispatchOpts = null; + dispatchOpts = { + ...origDispatchOpts, + servername: origin.hostname, + // For SNI on TLS + origin: newOrigin, + headers: { + host: origin.hostname, + ...origDispatchOpts.headers + } + }; + dispatch( + dispatchOpts, + instance.getHandler({ origin, dispatch, handler }, origDispatchOpts) + ); + }); + return true; + }; + }; + }; + } +}); + +// node_modules/undici/lib/web/fetch/headers.js +var require_headers = __commonJS({ + "node_modules/undici/lib/web/fetch/headers.js"(exports, module) { + "use strict"; + var { kConstruct } = require_symbols(); + var { kEnumerableProperty } = require_util(); + var { + iteratorMixin, + isValidHeaderName, + isValidHeaderValue + } = require_util2(); + var { webidl } = require_webidl(); + var assert = __require("node:assert"); + var util2 = __require("node:util"); + var kHeadersMap = /* @__PURE__ */ Symbol("headers map"); + var kHeadersSortedMap = /* @__PURE__ */ Symbol("headers map sorted"); + function isHTTPWhiteSpaceCharCode(code) { + return code === 10 || code === 13 || code === 9 || code === 32; + } + function headerValueNormalize(potentialValue) { + let i = 0; + let j = potentialValue.length; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i; + return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j); + } + function fill(headers2, object) { + if (Array.isArray(object)) { + for (let i = 0; i < object.length; ++i) { + const header = object[i]; + if (header.length !== 2) { + throw webidl.errors.exception({ + header: "Headers constructor", + message: `expected name/value pair to be length 2, found ${header.length}.` + }); + } + appendHeader(headers2, header[0], header[1]); + } + } else if (typeof object === "object" && object !== null) { + const keys = Object.keys(object); + for (let i = 0; i < keys.length; ++i) { + appendHeader(headers2, keys[i], object[keys[i]]); + } + } else { + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + } + } + function appendHeader(headers2, name, value) { + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value, + type: "header value" + }); + } + if (getHeadersGuard(headers2) === "immutable") { + throw new TypeError("immutable"); + } + return getHeadersList(headers2).append(name, value, false); + } + function compareHeaderName(a, b) { + return a[0] < b[0] ? -1 : 1; + } + var HeadersList = class _HeadersList { + /** @type {[string, string][]|null} */ + cookies = null; + constructor(init) { + if (init instanceof _HeadersList) { + this[kHeadersMap] = new Map(init[kHeadersMap]); + this[kHeadersSortedMap] = init[kHeadersSortedMap]; + this.cookies = init.cookies === null ? null : [...init.cookies]; + } else { + this[kHeadersMap] = new Map(init); + this[kHeadersSortedMap] = null; + } + } + /** + * @see https://fetch.spec.whatwg.org/#header-list-contains + * @param {string} name + * @param {boolean} isLowerCase + */ + contains(name, isLowerCase) { + return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase()); + } + clear() { + this[kHeadersMap].clear(); + this[kHeadersSortedMap] = null; + this.cookies = null; + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-append + * @param {string} name + * @param {string} value + * @param {boolean} isLowerCase + */ + append(name, value, isLowerCase) { + this[kHeadersSortedMap] = null; + const lowercaseName = isLowerCase ? name : name.toLowerCase(); + const exists2 = this[kHeadersMap].get(lowercaseName); + if (exists2) { + const delimiter2 = lowercaseName === "cookie" ? "; " : ", "; + this[kHeadersMap].set(lowercaseName, { + name: exists2.name, + value: `${exists2.value}${delimiter2}${value}` + }); + } else { + this[kHeadersMap].set(lowercaseName, { name, value }); + } + if (lowercaseName === "set-cookie") { + (this.cookies ??= []).push(value); + } + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-set + * @param {string} name + * @param {string} value + * @param {boolean} isLowerCase + */ + set(name, value, isLowerCase) { + this[kHeadersSortedMap] = null; + const lowercaseName = isLowerCase ? name : name.toLowerCase(); + if (lowercaseName === "set-cookie") { + this.cookies = [value]; + } + this[kHeadersMap].set(lowercaseName, { name, value }); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-delete + * @param {string} name + * @param {boolean} isLowerCase + */ + delete(name, isLowerCase) { + this[kHeadersSortedMap] = null; + if (!isLowerCase) name = name.toLowerCase(); + if (name === "set-cookie") { + this.cookies = null; + } + this[kHeadersMap].delete(name); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-get + * @param {string} name + * @param {boolean} isLowerCase + * @returns {string | null} + */ + get(name, isLowerCase) { + return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null; + } + *[Symbol.iterator]() { + for (const { 0: name, 1: { value } } of this[kHeadersMap]) { + yield [name, value]; + } + } + get entries() { + const headers2 = {}; + if (this[kHeadersMap].size !== 0) { + for (const { name, value } of this[kHeadersMap].values()) { + headers2[name] = value; + } + } + return headers2; + } + rawValues() { + return this[kHeadersMap].values(); + } + get entriesList() { + const headers2 = []; + if (this[kHeadersMap].size !== 0) { + for (const { 0: lowerName, 1: { name, value } } of this[kHeadersMap]) { + if (lowerName === "set-cookie") { + for (const cookie of this.cookies) { + headers2.push([name, cookie]); + } + } else { + headers2.push([name, value]); + } + } + } + return headers2; + } + // https://fetch.spec.whatwg.org/#convert-header-names-to-a-sorted-lowercase-set + toSortedArray() { + const size = this[kHeadersMap].size; + const array = new Array(size); + if (size <= 32) { + if (size === 0) { + return array; + } + const iterator = this[kHeadersMap][Symbol.iterator](); + const firstValue = iterator.next().value; + array[0] = [firstValue[0], firstValue[1].value]; + assert(firstValue[1].value !== null); + for (let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value; i < size; ++i) { + value = iterator.next().value; + x = array[i] = [value[0], value[1].value]; + assert(x[1] !== null); + left = 0; + right = i; + while (left < right) { + pivot = left + (right - left >> 1); + if (array[pivot][0] <= x[0]) { + left = pivot + 1; + } else { + right = pivot; + } + } + if (i !== pivot) { + j = i; + while (j > left) { + array[j] = array[--j]; + } + array[left] = x; + } + } + if (!iterator.next().done) { + throw new TypeError("Unreachable"); + } + return array; + } else { + let i = 0; + for (const { 0: name, 1: { value } } of this[kHeadersMap]) { + array[i++] = [name, value]; + assert(value !== null); + } + return array.sort(compareHeaderName); + } + } + }; + var Headers4 = class _Headers { + #guard; + #headersList; + constructor(init = void 0) { + webidl.util.markAsUncloneable(this); + if (init === kConstruct) { + return; + } + this.#headersList = new HeadersList(); + this.#guard = "none"; + if (init !== void 0) { + init = webidl.converters.HeadersInit(init, "Headers contructor", "init"); + fill(this, init); + } + } + // https://fetch.spec.whatwg.org/#dom-headers-append + append(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, "Headers.append"); + const prefix = "Headers.append"; + name = webidl.converters.ByteString(name, prefix, "name"); + value = webidl.converters.ByteString(value, prefix, "value"); + return appendHeader(this, name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-delete + delete(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, "Headers.delete"); + const prefix = "Headers.delete"; + name = webidl.converters.ByteString(name, prefix, "name"); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.delete", + value: name, + type: "header name" + }); + } + if (this.#guard === "immutable") { + throw new TypeError("immutable"); + } + if (!this.#headersList.contains(name, false)) { + return; + } + this.#headersList.delete(name, false); + } + // https://fetch.spec.whatwg.org/#dom-headers-get + get(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, "Headers.get"); + const prefix = "Headers.get"; + name = webidl.converters.ByteString(name, prefix, "name"); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix, + value: name, + type: "header name" + }); + } + return this.#headersList.get(name, false); + } + // https://fetch.spec.whatwg.org/#dom-headers-has + has(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, "Headers.has"); + const prefix = "Headers.has"; + name = webidl.converters.ByteString(name, prefix, "name"); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix, + value: name, + type: "header name" + }); + } + return this.#headersList.contains(name, false); + } + // https://fetch.spec.whatwg.org/#dom-headers-set + set(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, "Headers.set"); + const prefix = "Headers.set"; + name = webidl.converters.ByteString(name, prefix, "name"); + value = webidl.converters.ByteString(value, prefix, "value"); + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix, + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix, + value, + type: "header value" + }); + } + if (this.#guard === "immutable") { + throw new TypeError("immutable"); + } + this.#headersList.set(name, value, false); + } + // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie + getSetCookie() { + webidl.brandCheck(this, _Headers); + const list = this.#headersList.cookies; + if (list) { + return [...list]; + } + return []; + } + // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine + get [kHeadersSortedMap]() { + if (this.#headersList[kHeadersSortedMap]) { + return this.#headersList[kHeadersSortedMap]; + } + const headers2 = []; + const names = this.#headersList.toSortedArray(); + const cookies = this.#headersList.cookies; + if (cookies === null || cookies.length === 1) { + return this.#headersList[kHeadersSortedMap] = names; + } + for (let i = 0; i < names.length; ++i) { + const { 0: name, 1: value } = names[i]; + if (name === "set-cookie") { + for (let j = 0; j < cookies.length; ++j) { + headers2.push([name, cookies[j]]); + } + } else { + headers2.push([name, value]); + } + } + return this.#headersList[kHeadersSortedMap] = headers2; + } + [util2.inspect.custom](depth, options) { + options.depth ??= depth; + return `Headers ${util2.formatWithOptions(options, this.#headersList.entries)}`; + } + static getHeadersGuard(o) { + return o.#guard; + } + static setHeadersGuard(o, guard) { + o.#guard = guard; + } + static getHeadersList(o) { + return o.#headersList; + } + static setHeadersList(o, list) { + o.#headersList = list; + } + }; + var { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers4; + Reflect.deleteProperty(Headers4, "getHeadersGuard"); + Reflect.deleteProperty(Headers4, "setHeadersGuard"); + Reflect.deleteProperty(Headers4, "getHeadersList"); + Reflect.deleteProperty(Headers4, "setHeadersList"); + iteratorMixin("Headers", Headers4, kHeadersSortedMap, 0, 1); + Object.defineProperties(Headers4.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + getSetCookie: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Headers", + configurable: true + }, + [util2.inspect.custom]: { + enumerable: false + } + }); + webidl.converters.HeadersInit = function(V, prefix, argument) { + if (webidl.util.Type(V) === "Object") { + const iterator = Reflect.get(V, Symbol.iterator); + if (!util2.types.isProxy(V) && iterator === Headers4.prototype.entries) { + try { + return getHeadersList(V).entriesList; + } catch { + } + } + if (typeof iterator === "function") { + return webidl.converters["sequence>"](V, prefix, argument, iterator.bind(V)); + } + return webidl.converters["record"](V, prefix, argument); + } + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + }; + module.exports = { + fill, + // for test. + compareHeaderName, + Headers: Headers4, + HeadersList, + getHeadersGuard, + setHeadersGuard, + setHeadersList, + getHeadersList + }; + } +}); + +// node_modules/undici/lib/web/fetch/response.js +var require_response = __commonJS({ + "node_modules/undici/lib/web/fetch/response.js"(exports, module) { + "use strict"; + var { Headers: Headers4, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require_headers(); + var { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require_body(); + var util2 = require_util(); + var nodeUtil = __require("node:util"); + var { kEnumerableProperty } = util2; + var { + isValidReasonPhrase, + isCancelled, + isAborted, + isBlobLike, + serializeJavascriptValueToJSONString, + isErrorLike, + isomorphicEncode, + environmentSettingsObject: relevantRealm + } = require_util2(); + var { + redirectStatusSet, + nullBodyStatus + } = require_constants3(); + var { kState, kHeaders } = require_symbols2(); + var { webidl } = require_webidl(); + var { FormData } = require_formdata(); + var { URLSerializer } = require_data_url(); + var { kConstruct } = require_symbols(); + var assert = __require("node:assert"); + var { types: types2 } = __require("node:util"); + var textEncoder = new TextEncoder("utf-8"); + var Response2 = class _Response { + // Creates network error Response. + static error() { + const responseObject = fromInnerResponse(makeNetworkError(), "immutable"); + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response-json + static json(data, init = {}) { + webidl.argumentLengthCheck(arguments, 1, "Response.json"); + if (init !== null) { + init = webidl.converters.ResponseInit(init); + } + const bytes = textEncoder.encode( + serializeJavascriptValueToJSONString(data) + ); + const body = extractBody(bytes); + const responseObject = fromInnerResponse(makeResponse({}), "response"); + initializeResponse(responseObject, init, { body: body[0], type: "application/json" }); + return responseObject; + } + // Creates a redirect Response that redirects to url with status status. + static redirect(url, status = 302) { + webidl.argumentLengthCheck(arguments, 1, "Response.redirect"); + url = webidl.converters.USVString(url); + status = webidl.converters["unsigned short"](status); + let parsedURL; + try { + parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl); + } catch (err) { + throw new TypeError(`Failed to parse URL from ${url}`, { cause: err }); + } + if (!redirectStatusSet.has(status)) { + throw new RangeError(`Invalid status code ${status}`); + } + const responseObject = fromInnerResponse(makeResponse({}), "immutable"); + responseObject[kState].status = status; + const value = isomorphicEncode(URLSerializer(parsedURL)); + responseObject[kState].headersList.append("location", value, true); + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response + constructor(body = null, init = {}) { + webidl.util.markAsUncloneable(this); + if (body === kConstruct) { + return; + } + if (body !== null) { + body = webidl.converters.BodyInit(body); + } + init = webidl.converters.ResponseInit(init); + this[kState] = makeResponse({}); + this[kHeaders] = new Headers4(kConstruct); + setHeadersGuard(this[kHeaders], "response"); + setHeadersList(this[kHeaders], this[kState].headersList); + let bodyWithType = null; + if (body != null) { + const [extractedBody, type2] = extractBody(body); + bodyWithType = { body: extractedBody, type: type2 }; + } + initializeResponse(this, init, bodyWithType); + } + // Returns response’s type, e.g., "cors". + get type() { + webidl.brandCheck(this, _Response); + return this[kState].type; + } + // Returns response’s URL, if it has one; otherwise the empty string. + get url() { + webidl.brandCheck(this, _Response); + const urlList = this[kState].urlList; + const url = urlList[urlList.length - 1] ?? null; + if (url === null) { + return ""; + } + return URLSerializer(url, true); + } + // Returns whether response was obtained through a redirect. + get redirected() { + webidl.brandCheck(this, _Response); + return this[kState].urlList.length > 1; + } + // Returns response’s status. + get status() { + webidl.brandCheck(this, _Response); + return this[kState].status; + } + // Returns whether response’s status is an ok status. + get ok() { + webidl.brandCheck(this, _Response); + return this[kState].status >= 200 && this[kState].status <= 299; + } + // Returns response’s status message. + get statusText() { + webidl.brandCheck(this, _Response); + return this[kState].statusText; + } + // Returns response’s headers as Headers. + get headers() { + webidl.brandCheck(this, _Response); + return this[kHeaders]; + } + get body() { + webidl.brandCheck(this, _Response); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Response); + return !!this[kState].body && util2.isDisturbed(this[kState].body.stream); + } + // Returns a clone of response. + clone() { + webidl.brandCheck(this, _Response); + if (bodyUnusable(this)) { + throw webidl.errors.exception({ + header: "Response.clone", + message: "Body has already been consumed." + }); + } + const clonedResponse = cloneResponse(this[kState]); + if (hasFinalizationRegistry && this[kState].body?.stream) { + streamRegistry.register(this, new WeakRef(this[kState].body.stream)); + } + return fromInnerResponse(clonedResponse, getHeadersGuard(this[kHeaders])); + } + [nodeUtil.inspect.custom](depth, options) { + if (options.depth === null) { + options.depth = 2; + } + options.colors ??= true; + const properties = { + status: this.status, + statusText: this.statusText, + headers: this.headers, + body: this.body, + bodyUsed: this.bodyUsed, + ok: this.ok, + redirected: this.redirected, + type: this.type, + url: this.url + }; + return `Response ${nodeUtil.formatWithOptions(options, properties)}`; + } + }; + mixinBody(Response2); + Object.defineProperties(Response2.prototype, { + type: kEnumerableProperty, + url: kEnumerableProperty, + status: kEnumerableProperty, + ok: kEnumerableProperty, + redirected: kEnumerableProperty, + statusText: kEnumerableProperty, + headers: kEnumerableProperty, + clone: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Response", + configurable: true + } + }); + Object.defineProperties(Response2, { + json: kEnumerableProperty, + redirect: kEnumerableProperty, + error: kEnumerableProperty + }); + function cloneResponse(response) { + if (response.internalResponse) { + return filterResponse( + cloneResponse(response.internalResponse), + response.type + ); + } + const newResponse = makeResponse({ ...response, body: null }); + if (response.body != null) { + newResponse.body = cloneBody(newResponse, response.body); + } + return newResponse; + } + function makeResponse(init) { + return { + aborted: false, + rangeRequested: false, + timingAllowPassed: false, + requestIncludesCredentials: false, + type: "default", + status: 200, + timingInfo: null, + cacheState: "", + statusText: "", + ...init, + headersList: init?.headersList ? new HeadersList(init?.headersList) : new HeadersList(), + urlList: init?.urlList ? [...init.urlList] : [] + }; + } + function makeNetworkError(reason) { + const isError = isErrorLike(reason); + return makeResponse({ + type: "error", + status: 0, + error: isError ? reason : new Error(reason ? String(reason) : reason), + aborted: reason && reason.name === "AbortError" + }); + } + function isNetworkError(response) { + return ( + // A network error is a response whose type is "error", + response.type === "error" && // status is 0 + response.status === 0 + ); + } + function makeFilteredResponse(response, state) { + state = { + internalResponse: response, + ...state + }; + return new Proxy(response, { + get(target, p) { + return p in state ? state[p] : target[p]; + }, + set(target, p, value) { + assert(!(p in state)); + target[p] = value; + return true; + } + }); + } + function filterResponse(response, type2) { + if (type2 === "basic") { + return makeFilteredResponse(response, { + type: "basic", + headersList: response.headersList + }); + } else if (type2 === "cors") { + return makeFilteredResponse(response, { + type: "cors", + headersList: response.headersList + }); + } else if (type2 === "opaque") { + return makeFilteredResponse(response, { + type: "opaque", + urlList: Object.freeze([]), + status: 0, + statusText: "", + body: null + }); + } else if (type2 === "opaqueredirect") { + return makeFilteredResponse(response, { + type: "opaqueredirect", + status: 0, + statusText: "", + headersList: [], + body: null + }); + } else { + assert(false); + } + } + function makeAppropriateNetworkError(fetchParams, err = null) { + assert(isCancelled(fetchParams)); + return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException("Request was cancelled."), { cause: err })); + } + function initializeResponse(response, init, body) { + if (init.status !== null && (init.status < 200 || init.status > 599)) { + throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.'); + } + if ("statusText" in init && init.statusText != null) { + if (!isValidReasonPhrase(String(init.statusText))) { + throw new TypeError("Invalid statusText"); + } + } + if ("status" in init && init.status != null) { + response[kState].status = init.status; + } + if ("statusText" in init && init.statusText != null) { + response[kState].statusText = init.statusText; + } + if ("headers" in init && init.headers != null) { + fill(response[kHeaders], init.headers); + } + if (body) { + if (nullBodyStatus.includes(response.status)) { + throw webidl.errors.exception({ + header: "Response constructor", + message: `Invalid response status code ${response.status}` + }); + } + response[kState].body = body.body; + if (body.type != null && !response[kState].headersList.contains("content-type", true)) { + response[kState].headersList.append("content-type", body.type, true); + } + } + } + function fromInnerResponse(innerResponse, guard) { + const response = new Response2(kConstruct); + response[kState] = innerResponse; + response[kHeaders] = new Headers4(kConstruct); + setHeadersList(response[kHeaders], innerResponse.headersList); + setHeadersGuard(response[kHeaders], guard); + if (hasFinalizationRegistry && innerResponse.body?.stream) { + streamRegistry.register(response, new WeakRef(innerResponse.body.stream)); + } + return response; + } + webidl.converters.ReadableStream = webidl.interfaceConverter( + ReadableStream + ); + webidl.converters.FormData = webidl.interfaceConverter( + FormData + ); + webidl.converters.URLSearchParams = webidl.interfaceConverter( + URLSearchParams + ); + webidl.converters.XMLHttpRequestBodyInit = function(V, prefix, name) { + if (typeof V === "string") { + return webidl.converters.USVString(V, prefix, name); + } + if (isBlobLike(V)) { + return webidl.converters.Blob(V, prefix, name, { strict: false }); + } + if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) { + return webidl.converters.BufferSource(V, prefix, name); + } + if (util2.isFormDataLike(V)) { + return webidl.converters.FormData(V, prefix, name, { strict: false }); + } + if (V instanceof URLSearchParams) { + return webidl.converters.URLSearchParams(V, prefix, name); + } + return webidl.converters.DOMString(V, prefix, name); + }; + webidl.converters.BodyInit = function(V, prefix, argument) { + if (V instanceof ReadableStream) { + return webidl.converters.ReadableStream(V, prefix, argument); + } + if (V?.[Symbol.asyncIterator]) { + return V; + } + return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument); + }; + webidl.converters.ResponseInit = webidl.dictionaryConverter([ + { + key: "status", + converter: webidl.converters["unsigned short"], + defaultValue: () => 200 + }, + { + key: "statusText", + converter: webidl.converters.ByteString, + defaultValue: () => "" + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + } + ]); + module.exports = { + isNetworkError, + makeNetworkError, + makeResponse, + makeAppropriateNetworkError, + filterResponse, + Response: Response2, + cloneResponse, + fromInnerResponse + }; + } +}); + +// node_modules/undici/lib/web/fetch/dispatcher-weakref.js +var require_dispatcher_weakref = __commonJS({ + "node_modules/undici/lib/web/fetch/dispatcher-weakref.js"(exports, module) { + "use strict"; + var { kConnected, kSize } = require_symbols(); + var CompatWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value; + } + }; + var CompatFinalizer = class { + constructor(finalizer) { + this.finalizer = finalizer; + } + register(dispatcher, key) { + if (dispatcher.on) { + dispatcher.on("disconnect", () => { + if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) { + this.finalizer(key); + } + }); + } + } + unregister(key) { + } + }; + module.exports = function() { + if (process.env.NODE_V8_COVERAGE && process.version.startsWith("v18")) { + process._rawDebug("Using compatibility WeakRef and FinalizationRegistry"); + return { + WeakRef: CompatWeakRef, + FinalizationRegistry: CompatFinalizer + }; + } + return { WeakRef, FinalizationRegistry }; + }; + } +}); + +// node_modules/undici/lib/web/fetch/request.js +var require_request2 = __commonJS({ + "node_modules/undici/lib/web/fetch/request.js"(exports, module) { + "use strict"; + var { extractBody, mixinBody, cloneBody, bodyUnusable } = require_body(); + var { Headers: Headers4, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require_headers(); + var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()(); + var util2 = require_util(); + var nodeUtil = __require("node:util"); + var { + isValidHTTPToken, + sameOrigin, + environmentSettingsObject + } = require_util2(); + var { + forbiddenMethodsSet, + corsSafeListedMethodsSet, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + requestDuplex + } = require_constants3(); + var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util2; + var { kHeaders, kSignal, kState, kDispatcher } = require_symbols2(); + var { webidl } = require_webidl(); + var { URLSerializer } = require_data_url(); + var { kConstruct } = require_symbols(); + var assert = __require("node:assert"); + var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __require("node:events"); + var kAbortController = /* @__PURE__ */ Symbol("abortController"); + var requestFinalizer = new FinalizationRegistry2(({ signal: signal3, abort }) => { + signal3.removeEventListener("abort", abort); + }); + var dependentControllerMap = /* @__PURE__ */ new WeakMap(); + function buildAbort(acRef) { + return abort; + function abort() { + const ac = acRef.deref(); + if (ac !== void 0) { + requestFinalizer.unregister(abort); + this.removeEventListener("abort", abort); + ac.abort(this.reason); + const controllerList = dependentControllerMap.get(ac.signal); + if (controllerList !== void 0) { + if (controllerList.size !== 0) { + for (const ref of controllerList) { + const ctrl = ref.deref(); + if (ctrl !== void 0) { + ctrl.abort(this.reason); + } + } + controllerList.clear(); + } + dependentControllerMap.delete(ac.signal); + } + } + } + } + var patchMethodWarning = false; + var Request2 = class _Request { + // https://fetch.spec.whatwg.org/#dom-request + constructor(input, init = {}) { + webidl.util.markAsUncloneable(this); + if (input === kConstruct) { + return; + } + const prefix = "Request constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + input = webidl.converters.RequestInfo(input, prefix, "input"); + init = webidl.converters.RequestInit(init, prefix, "init"); + let request = null; + let fallbackMode = null; + const baseUrl = environmentSettingsObject.settingsObject.baseUrl; + let signal3 = null; + if (typeof input === "string") { + this[kDispatcher] = init.dispatcher; + let parsedURL; + try { + parsedURL = new URL(input, baseUrl); + } catch (err) { + throw new TypeError("Failed to parse URL from " + input, { cause: err }); + } + if (parsedURL.username || parsedURL.password) { + throw new TypeError( + "Request cannot be constructed from a URL that includes credentials: " + input + ); + } + request = makeRequest({ urlList: [parsedURL] }); + fallbackMode = "cors"; + } else { + this[kDispatcher] = init.dispatcher || input[kDispatcher]; + assert(input instanceof _Request); + request = input[kState]; + signal3 = input[kSignal]; + } + const origin = environmentSettingsObject.settingsObject.origin; + let window2 = "client"; + if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) { + window2 = request.window; + } + if (init.window != null) { + throw new TypeError(`'window' option '${window2}' must be null`); + } + if ("window" in init) { + window2 = "no-window"; + } + request = makeRequest({ + // URL request’s URL. + // undici implementation note: this is set as the first item in request's urlList in makeRequest + // method request’s method. + method: request.method, + // header list A copy of request’s header list. + // undici implementation note: headersList is cloned in makeRequest + headersList: request.headersList, + // unsafe-request flag Set. + unsafeRequest: request.unsafeRequest, + // client This’s relevant settings object. + client: environmentSettingsObject.settingsObject, + // window window. + window: window2, + // priority request’s priority. + priority: request.priority, + // origin request’s origin. The propagation of the origin is only significant for navigation requests + // being handled by a service worker. In this scenario a request can have an origin that is different + // from the current client. + origin: request.origin, + // referrer request’s referrer. + referrer: request.referrer, + // referrer policy request’s referrer policy. + referrerPolicy: request.referrerPolicy, + // mode request’s mode. + mode: request.mode, + // credentials mode request’s credentials mode. + credentials: request.credentials, + // cache mode request’s cache mode. + cache: request.cache, + // redirect mode request’s redirect mode. + redirect: request.redirect, + // integrity metadata request’s integrity metadata. + integrity: request.integrity, + // keepalive request’s keepalive. + keepalive: request.keepalive, + // reload-navigation flag request’s reload-navigation flag. + reloadNavigation: request.reloadNavigation, + // history-navigation flag request’s history-navigation flag. + historyNavigation: request.historyNavigation, + // URL list A clone of request’s URL list. + urlList: [...request.urlList] + }); + const initHasKey = Object.keys(init).length !== 0; + if (initHasKey) { + if (request.mode === "navigate") { + request.mode = "same-origin"; + } + request.reloadNavigation = false; + request.historyNavigation = false; + request.origin = "client"; + request.referrer = "client"; + request.referrerPolicy = ""; + request.url = request.urlList[request.urlList.length - 1]; + request.urlList = [request.url]; + } + if (init.referrer !== void 0) { + const referrer = init.referrer; + if (referrer === "") { + request.referrer = "no-referrer"; + } else { + let parsedReferrer; + try { + parsedReferrer = new URL(referrer, baseUrl); + } catch (err) { + throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }); + } + if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl)) { + request.referrer = "client"; + } else { + request.referrer = parsedReferrer; + } + } + } + if (init.referrerPolicy !== void 0) { + request.referrerPolicy = init.referrerPolicy; + } + let mode; + if (init.mode !== void 0) { + mode = init.mode; + } else { + mode = fallbackMode; + } + if (mode === "navigate") { + throw webidl.errors.exception({ + header: "Request constructor", + message: "invalid request mode navigate." + }); + } + if (mode != null) { + request.mode = mode; + } + if (init.credentials !== void 0) { + request.credentials = init.credentials; + } + if (init.cache !== void 0) { + request.cache = init.cache; + } + if (request.cache === "only-if-cached" && request.mode !== "same-origin") { + throw new TypeError( + "'only-if-cached' can be set only with 'same-origin' mode" + ); + } + if (init.redirect !== void 0) { + request.redirect = init.redirect; + } + if (init.integrity != null) { + request.integrity = String(init.integrity); + } + if (init.keepalive !== void 0) { + request.keepalive = Boolean(init.keepalive); + } + if (init.method !== void 0) { + let method = init.method; + const mayBeNormalized = normalizedMethodRecords[method]; + if (mayBeNormalized !== void 0) { + request.method = mayBeNormalized; + } else { + if (!isValidHTTPToken(method)) { + throw new TypeError(`'${method}' is not a valid HTTP method.`); + } + const upperCase = method.toUpperCase(); + if (forbiddenMethodsSet.has(upperCase)) { + throw new TypeError(`'${method}' HTTP method is unsupported.`); + } + method = normalizedMethodRecordsBase[upperCase] ?? method; + request.method = method; + } + if (!patchMethodWarning && request.method === "patch") { + process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.", { + code: "UNDICI-FETCH-patch" + }); + patchMethodWarning = true; + } + } + if (init.signal !== void 0) { + signal3 = init.signal; + } + this[kState] = request; + const ac = new AbortController(); + this[kSignal] = ac.signal; + if (signal3 != null) { + if (!signal3 || typeof signal3.aborted !== "boolean" || typeof signal3.addEventListener !== "function") { + throw new TypeError( + "Failed to construct 'Request': member signal is not of type AbortSignal." + ); + } + if (signal3.aborted) { + ac.abort(signal3.reason); + } else { + this[kAbortController] = ac; + const acRef = new WeakRef(ac); + const abort = buildAbort(acRef); + try { + if (typeof getMaxListeners === "function" && getMaxListeners(signal3) === defaultMaxListeners) { + setMaxListeners(1500, signal3); + } else if (getEventListeners(signal3, "abort").length >= defaultMaxListeners) { + setMaxListeners(1500, signal3); + } + } catch { + } + util2.addAbortListener(signal3, abort); + requestFinalizer.register(ac, { signal: signal3, abort }, abort); + } + } + this[kHeaders] = new Headers4(kConstruct); + setHeadersList(this[kHeaders], request.headersList); + setHeadersGuard(this[kHeaders], "request"); + if (mode === "no-cors") { + if (!corsSafeListedMethodsSet.has(request.method)) { + throw new TypeError( + `'${request.method} is unsupported in no-cors mode.` + ); + } + setHeadersGuard(this[kHeaders], "request-no-cors"); + } + if (initHasKey) { + const headersList = getHeadersList(this[kHeaders]); + const headers2 = init.headers !== void 0 ? init.headers : new HeadersList(headersList); + headersList.clear(); + if (headers2 instanceof HeadersList) { + for (const { name, value } of headers2.rawValues()) { + headersList.append(name, value, false); + } + headersList.cookies = headers2.cookies; + } else { + fillHeaders(this[kHeaders], headers2); + } + } + const inputBody = input instanceof _Request ? input[kState].body : null; + if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body."); + } + let initBody = null; + if (init.body != null) { + const [extractedBody, contentType] = extractBody( + init.body, + request.keepalive + ); + initBody = extractedBody; + if (contentType && !getHeadersList(this[kHeaders]).contains("content-type", true)) { + this[kHeaders].append("content-type", contentType); + } + } + const inputOrInitBody = initBody ?? inputBody; + if (inputOrInitBody != null && inputOrInitBody.source == null) { + if (initBody != null && init.duplex == null) { + throw new TypeError("RequestInit: duplex option is required when sending a body."); + } + if (request.mode !== "same-origin" && request.mode !== "cors") { + throw new TypeError( + 'If request is made from ReadableStream, mode should be "same-origin" or "cors"' + ); + } + request.useCORSPreflightFlag = true; + } + let finalBody = inputOrInitBody; + if (initBody == null && inputBody != null) { + if (bodyUnusable(input)) { + throw new TypeError( + "Cannot construct a Request with a Request object that has already been used." + ); + } + const identityTransform = new TransformStream(); + inputBody.stream.pipeThrough(identityTransform); + finalBody = { + source: inputBody.source, + length: inputBody.length, + stream: identityTransform.readable + }; + } + this[kState].body = finalBody; + } + // Returns request’s HTTP method, which is "GET" by default. + get method() { + webidl.brandCheck(this, _Request); + return this[kState].method; + } + // Returns the URL of request as a string. + get url() { + webidl.brandCheck(this, _Request); + return URLSerializer(this[kState].url); + } + // Returns a Headers object consisting of the headers associated with request. + // Note that headers added in the network layer by the user agent will not + // be accounted for in this object, e.g., the "Host" header. + get headers() { + webidl.brandCheck(this, _Request); + return this[kHeaders]; + } + // Returns the kind of resource requested by request, e.g., "document" + // or "script". + get destination() { + webidl.brandCheck(this, _Request); + return this[kState].destination; + } + // Returns the referrer of request. Its value can be a same-origin URL if + // explicitly set in init, the empty string to indicate no referrer, and + // "about:client" when defaulting to the global’s default. This is used + // during fetching to determine the value of the `Referer` header of the + // request being made. + get referrer() { + webidl.brandCheck(this, _Request); + if (this[kState].referrer === "no-referrer") { + return ""; + } + if (this[kState].referrer === "client") { + return "about:client"; + } + return this[kState].referrer.toString(); + } + // Returns the referrer policy associated with request. + // This is used during fetching to compute the value of the request’s + // referrer. + get referrerPolicy() { + webidl.brandCheck(this, _Request); + return this[kState].referrerPolicy; + } + // Returns the mode associated with request, which is a string indicating + // whether the request will use CORS, or will be restricted to same-origin + // URLs. + get mode() { + webidl.brandCheck(this, _Request); + return this[kState].mode; + } + // Returns the credentials mode associated with request, + // which is a string indicating whether credentials will be sent with the + // request always, never, or only when sent to a same-origin URL. + get credentials() { + return this[kState].credentials; + } + // Returns the cache mode associated with request, + // which is a string indicating how the request will + // interact with the browser’s cache when fetching. + get cache() { + webidl.brandCheck(this, _Request); + return this[kState].cache; + } + // Returns the redirect mode associated with request, + // which is a string indicating how redirects for the + // request will be handled during fetching. A request + // will follow redirects by default. + get redirect() { + webidl.brandCheck(this, _Request); + return this[kState].redirect; + } + // Returns request’s subresource integrity metadata, which is a + // cryptographic hash of the resource being fetched. Its value + // consists of multiple hashes separated by whitespace. [SRI] + get integrity() { + webidl.brandCheck(this, _Request); + return this[kState].integrity; + } + // Returns a boolean indicating whether or not request can outlive the + // global in which it was created. + get keepalive() { + webidl.brandCheck(this, _Request); + return this[kState].keepalive; + } + // Returns a boolean indicating whether or not request is for a reload + // navigation. + get isReloadNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].reloadNavigation; + } + // Returns a boolean indicating whether or not request is for a history + // navigation (a.k.a. back-forward navigation). + get isHistoryNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].historyNavigation; + } + // Returns the signal associated with request, which is an AbortSignal + // object indicating whether or not request has been aborted, and its + // abort event handler. + get signal() { + webidl.brandCheck(this, _Request); + return this[kSignal]; + } + get body() { + webidl.brandCheck(this, _Request); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Request); + return !!this[kState].body && util2.isDisturbed(this[kState].body.stream); + } + get duplex() { + webidl.brandCheck(this, _Request); + return "half"; + } + // Returns a clone of request. + clone() { + webidl.brandCheck(this, _Request); + if (bodyUnusable(this)) { + throw new TypeError("unusable"); + } + const clonedRequest = cloneRequest(this[kState]); + const ac = new AbortController(); + if (this.signal.aborted) { + ac.abort(this.signal.reason); + } else { + let list = dependentControllerMap.get(this.signal); + if (list === void 0) { + list = /* @__PURE__ */ new Set(); + dependentControllerMap.set(this.signal, list); + } + const acRef = new WeakRef(ac); + list.add(acRef); + util2.addAbortListener( + ac.signal, + buildAbort(acRef) + ); + } + return fromInnerRequest(clonedRequest, ac.signal, getHeadersGuard(this[kHeaders])); + } + [nodeUtil.inspect.custom](depth, options) { + if (options.depth === null) { + options.depth = 2; + } + options.colors ??= true; + const properties = { + method: this.method, + url: this.url, + headers: this.headers, + destination: this.destination, + referrer: this.referrer, + referrerPolicy: this.referrerPolicy, + mode: this.mode, + credentials: this.credentials, + cache: this.cache, + redirect: this.redirect, + integrity: this.integrity, + keepalive: this.keepalive, + isReloadNavigation: this.isReloadNavigation, + isHistoryNavigation: this.isHistoryNavigation, + signal: this.signal + }; + return `Request ${nodeUtil.formatWithOptions(options, properties)}`; + } + }; + mixinBody(Request2); + function makeRequest(init) { + return { + method: init.method ?? "GET", + localURLsOnly: init.localURLsOnly ?? false, + unsafeRequest: init.unsafeRequest ?? false, + body: init.body ?? null, + client: init.client ?? null, + reservedClient: init.reservedClient ?? null, + replacesClientId: init.replacesClientId ?? "", + window: init.window ?? "client", + keepalive: init.keepalive ?? false, + serviceWorkers: init.serviceWorkers ?? "all", + initiator: init.initiator ?? "", + destination: init.destination ?? "", + priority: init.priority ?? null, + origin: init.origin ?? "client", + policyContainer: init.policyContainer ?? "client", + referrer: init.referrer ?? "client", + referrerPolicy: init.referrerPolicy ?? "", + mode: init.mode ?? "no-cors", + useCORSPreflightFlag: init.useCORSPreflightFlag ?? false, + credentials: init.credentials ?? "same-origin", + useCredentials: init.useCredentials ?? false, + cache: init.cache ?? "default", + redirect: init.redirect ?? "follow", + integrity: init.integrity ?? "", + cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? "", + parserMetadata: init.parserMetadata ?? "", + reloadNavigation: init.reloadNavigation ?? false, + historyNavigation: init.historyNavigation ?? false, + userActivation: init.userActivation ?? false, + taintedOrigin: init.taintedOrigin ?? false, + redirectCount: init.redirectCount ?? 0, + responseTainting: init.responseTainting ?? "basic", + preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false, + done: init.done ?? false, + timingAllowFailed: init.timingAllowFailed ?? false, + urlList: init.urlList, + url: init.urlList[0], + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList() + }; + } + function cloneRequest(request) { + const newRequest = makeRequest({ ...request, body: null }); + if (request.body != null) { + newRequest.body = cloneBody(newRequest, request.body); + } + return newRequest; + } + function fromInnerRequest(innerRequest, signal3, guard) { + const request = new Request2(kConstruct); + request[kState] = innerRequest; + request[kSignal] = signal3; + request[kHeaders] = new Headers4(kConstruct); + setHeadersList(request[kHeaders], innerRequest.headersList); + setHeadersGuard(request[kHeaders], guard); + return request; + } + Object.defineProperties(Request2.prototype, { + method: kEnumerableProperty, + url: kEnumerableProperty, + headers: kEnumerableProperty, + redirect: kEnumerableProperty, + clone: kEnumerableProperty, + signal: kEnumerableProperty, + duplex: kEnumerableProperty, + destination: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + isHistoryNavigation: kEnumerableProperty, + isReloadNavigation: kEnumerableProperty, + keepalive: kEnumerableProperty, + integrity: kEnumerableProperty, + cache: kEnumerableProperty, + credentials: kEnumerableProperty, + attribute: kEnumerableProperty, + referrerPolicy: kEnumerableProperty, + referrer: kEnumerableProperty, + mode: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Request", + configurable: true + } + }); + webidl.converters.Request = webidl.interfaceConverter( + Request2 + ); + webidl.converters.RequestInfo = function(V, prefix, argument) { + if (typeof V === "string") { + return webidl.converters.USVString(V, prefix, argument); + } + if (V instanceof Request2) { + return webidl.converters.Request(V, prefix, argument); + } + return webidl.converters.USVString(V, prefix, argument); + }; + webidl.converters.AbortSignal = webidl.interfaceConverter( + AbortSignal + ); + webidl.converters.RequestInit = webidl.dictionaryConverter([ + { + key: "method", + converter: webidl.converters.ByteString + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + }, + { + key: "body", + converter: webidl.nullableConverter( + webidl.converters.BodyInit + ) + }, + { + key: "referrer", + converter: webidl.converters.USVString + }, + { + key: "referrerPolicy", + converter: webidl.converters.DOMString, + // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy + allowedValues: referrerPolicy + }, + { + key: "mode", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#concept-request-mode + allowedValues: requestMode + }, + { + key: "credentials", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcredentials + allowedValues: requestCredentials + }, + { + key: "cache", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcache + allowedValues: requestCache + }, + { + key: "redirect", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestredirect + allowedValues: requestRedirect + }, + { + key: "integrity", + converter: webidl.converters.DOMString + }, + { + key: "keepalive", + converter: webidl.converters.boolean + }, + { + key: "signal", + converter: webidl.nullableConverter( + (signal3) => webidl.converters.AbortSignal( + signal3, + "RequestInit", + "signal", + { strict: false } + ) + ) + }, + { + key: "window", + converter: webidl.converters.any + }, + { + key: "duplex", + converter: webidl.converters.DOMString, + allowedValues: requestDuplex + }, + { + key: "dispatcher", + // undici specific option + converter: webidl.converters.any + } + ]); + module.exports = { Request: Request2, makeRequest, fromInnerRequest, cloneRequest }; + } +}); + +// node_modules/undici/lib/web/fetch/index.js +var require_fetch = __commonJS({ + "node_modules/undici/lib/web/fetch/index.js"(exports, module) { + "use strict"; + var { + makeNetworkError, + makeAppropriateNetworkError, + filterResponse, + makeResponse, + fromInnerResponse + } = require_response(); + var { HeadersList } = require_headers(); + var { Request: Request2, cloneRequest } = require_request2(); + var zlib = __require("node:zlib"); + var { + bytesMatch, + makePolicyContainer, + clonePolicyContainer, + requestBadPort, + TAOCheck, + appendRequestOriginHeader, + responseLocationURL, + requestCurrentURL, + setRequestReferrerPolicyOnRedirect, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + createOpaqueTimingInfo, + appendFetchMetadata, + corsCheck, + crossOriginResourcePolicyCheck, + determineRequestsReferrer, + coarsenedSharedCurrentTime, + createDeferredPromise, + isBlobLike, + sameOrigin, + isCancelled, + isAborted, + isErrorLike, + fullyReadBody, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlIsHttpHttpsScheme, + urlHasHttpsScheme, + clampAndCoarsenConnectionTimingInfo, + simpleRangeHeaderValue, + buildContentRange, + createInflate, + extractMimeType + } = require_util2(); + var { kState, kDispatcher } = require_symbols2(); + var assert = __require("node:assert"); + var { safelyExtractBody, extractBody } = require_body(); + var { + redirectStatusSet, + nullBodyStatus, + safeMethodsSet, + requestBodyHeader, + subresourceSet + } = require_constants3(); + var EE = __require("node:events"); + var { Readable, pipeline, finished } = __require("node:stream"); + var { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = require_util(); + var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url(); + var { getGlobalDispatcher } = require_global2(); + var { webidl } = require_webidl(); + var { STATUS_CODES: STATUS_CODES2 } = __require("node:http"); + var GET_OR_HEAD = ["GET", "HEAD"]; + var defaultUserAgent = typeof __UNDICI_IS_NODE__ !== "undefined" || typeof esbuildDetection !== "undefined" ? "node" : "undici"; + var resolveObjectURL; + var Fetch = class extends EE { + constructor(dispatcher) { + super(); + this.dispatcher = dispatcher; + this.connection = null; + this.dump = false; + this.state = "ongoing"; + } + terminate(reason) { + if (this.state !== "ongoing") { + return; + } + this.state = "terminated"; + this.connection?.destroy(reason); + this.emit("terminated", reason); + } + // https://fetch.spec.whatwg.org/#fetch-controller-abort + abort(error2) { + if (this.state !== "ongoing") { + return; + } + this.state = "aborted"; + if (!error2) { + error2 = new DOMException("The operation was aborted.", "AbortError"); + } + this.serializedAbortReason = error2; + this.connection?.destroy(error2); + this.emit("terminated", error2); + } + }; + function handleFetchDone(response) { + finalizeAndReportTiming(response, "fetch"); + } + function fetch7(input, init = void 0) { + webidl.argumentLengthCheck(arguments, 1, "globalThis.fetch"); + let p = createDeferredPromise(); + let requestObject; + try { + requestObject = new Request2(input, init); + } catch (e2) { + p.reject(e2); + return p.promise; + } + const request = requestObject[kState]; + if (requestObject.signal.aborted) { + abortFetch(p, request, null, requestObject.signal.reason); + return p.promise; + } + const globalObject = request.client.globalObject; + if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") { + request.serviceWorkers = "none"; + } + let responseObject = null; + let locallyAborted = false; + let controller = null; + addAbortListener( + requestObject.signal, + () => { + locallyAborted = true; + assert(controller != null); + controller.abort(requestObject.signal.reason); + const realResponse = responseObject?.deref(); + abortFetch(p, request, realResponse, requestObject.signal.reason); + } + ); + const processResponse = (response) => { + if (locallyAborted) { + return; + } + if (response.aborted) { + abortFetch(p, request, responseObject, controller.serializedAbortReason); + return; + } + if (response.type === "error") { + p.reject(new TypeError("fetch failed", { cause: response.error })); + return; + } + responseObject = new WeakRef(fromInnerResponse(response, "immutable")); + p.resolve(responseObject.deref()); + p = null; + }; + controller = fetching({ + request, + processResponseEndOfBody: handleFetchDone, + processResponse, + dispatcher: requestObject[kDispatcher] + // undici + }); + return p.promise; + } + function finalizeAndReportTiming(response, initiatorType = "other") { + if (response.type === "error" && response.aborted) { + return; + } + if (!response.urlList?.length) { + return; + } + const originalURL = response.urlList[0]; + let timingInfo = response.timingInfo; + let cacheState = response.cacheState; + if (!urlIsHttpHttpsScheme(originalURL)) { + return; + } + if (timingInfo === null) { + return; + } + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo({ + startTime: timingInfo.startTime + }); + cacheState = ""; + } + timingInfo.endTime = coarsenedSharedCurrentTime(); + response.timingInfo = timingInfo; + markResourceTiming( + timingInfo, + originalURL.href, + initiatorType, + globalThis, + cacheState + ); + } + var markResourceTiming = performance.markResourceTiming; + function abortFetch(p, request, responseObject, error2) { + if (p) { + p.reject(error2); + } + if (request.body != null && isReadable(request.body?.stream)) { + request.body.stream.cancel(error2).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + if (responseObject == null) { + return; + } + const response = responseObject[kState]; + if (response.body != null && isReadable(response.body?.stream)) { + response.body.stream.cancel(error2).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + } + function fetching({ + request, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseEndOfBody, + processResponseConsumeBody, + useParallelQueue = false, + dispatcher = getGlobalDispatcher() + // undici + }) { + assert(dispatcher); + let taskDestination = null; + let crossOriginIsolatedCapability = false; + if (request.client != null) { + taskDestination = request.client.globalObject; + crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability; + } + const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability); + const timingInfo = createOpaqueTimingInfo({ + startTime: currentTime + }); + const fetchParams = { + controller: new Fetch(dispatcher), + request, + timingInfo, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseConsumeBody, + processResponseEndOfBody, + taskDestination, + crossOriginIsolatedCapability + }; + assert(!request.body || request.body.stream); + if (request.window === "client") { + request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window"; + } + if (request.origin === "client") { + request.origin = request.client.origin; + } + if (request.policyContainer === "client") { + if (request.client != null) { + request.policyContainer = clonePolicyContainer( + request.client.policyContainer + ); + } else { + request.policyContainer = makePolicyContainer(); + } + } + if (!request.headersList.contains("accept", true)) { + const value = "*/*"; + request.headersList.append("accept", value, true); + } + if (!request.headersList.contains("accept-language", true)) { + request.headersList.append("accept-language", "*", true); + } + if (request.priority === null) { + } + if (subresourceSet.has(request.destination)) { + } + mainFetch(fetchParams).catch((err) => { + fetchParams.controller.terminate(err); + }); + return fetchParams.controller; + } + async function mainFetch(fetchParams, recursive = false) { + const request = fetchParams.request; + let response = null; + if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) { + response = makeNetworkError("local URLs only"); + } + tryUpgradeRequestToAPotentiallyTrustworthyURL(request); + if (requestBadPort(request) === "blocked") { + response = makeNetworkError("bad port"); + } + if (request.referrerPolicy === "") { + request.referrerPolicy = request.policyContainer.referrerPolicy; + } + if (request.referrer !== "no-referrer") { + request.referrer = determineRequestsReferrer(request); + } + if (response === null) { + response = await (async () => { + const currentURL = requestCurrentURL(request); + if ( + // - request’s current URL’s origin is same origin with request’s origin, + // and request’s response tainting is "basic" + sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data" + currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket" + (request.mode === "navigate" || request.mode === "websocket") + ) { + request.responseTainting = "basic"; + return await schemeFetch(fetchParams); + } + if (request.mode === "same-origin") { + return makeNetworkError('request mode cannot be "same-origin"'); + } + if (request.mode === "no-cors") { + if (request.redirect !== "follow") { + return makeNetworkError( + 'redirect mode cannot be "follow" for "no-cors" request' + ); + } + request.responseTainting = "opaque"; + return await schemeFetch(fetchParams); + } + if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) { + return makeNetworkError("URL scheme must be a HTTP(S) scheme"); + } + request.responseTainting = "cors"; + return await httpFetch(fetchParams); + })(); + } + if (recursive) { + return response; + } + if (response.status !== 0 && !response.internalResponse) { + if (request.responseTainting === "cors") { + } + if (request.responseTainting === "basic") { + response = filterResponse(response, "basic"); + } else if (request.responseTainting === "cors") { + response = filterResponse(response, "cors"); + } else if (request.responseTainting === "opaque") { + response = filterResponse(response, "opaque"); + } else { + assert(false); + } + } + let internalResponse = response.status === 0 ? response : response.internalResponse; + if (internalResponse.urlList.length === 0) { + internalResponse.urlList.push(...request.urlList); + } + if (!request.timingAllowFailed) { + response.timingAllowPassed = true; + } + if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range", true)) { + response = internalResponse = makeNetworkError(); + } + if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) { + internalResponse.body = null; + fetchParams.controller.dump = true; + } + if (request.integrity) { + const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason)); + if (request.responseTainting === "opaque" || response.body == null) { + processBodyError(response.error); + return; + } + const processBody = (bytes) => { + if (!bytesMatch(bytes, request.integrity)) { + processBodyError("integrity mismatch"); + return; + } + response.body = safelyExtractBody(bytes)[0]; + fetchFinale(fetchParams, response); + }; + await fullyReadBody(response.body, processBody, processBodyError); + } else { + fetchFinale(fetchParams, response); + } + } + function schemeFetch(fetchParams) { + if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) { + return Promise.resolve(makeAppropriateNetworkError(fetchParams)); + } + const { request } = fetchParams; + const { protocol: scheme } = requestCurrentURL(request); + switch (scheme) { + case "about:": { + return Promise.resolve(makeNetworkError("about scheme is not supported")); + } + case "blob:": { + if (!resolveObjectURL) { + resolveObjectURL = __require("node:buffer").resolveObjectURL; + } + const blobURLEntry = requestCurrentURL(request); + if (blobURLEntry.search.length !== 0) { + return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource.")); + } + const blob = resolveObjectURL(blobURLEntry.toString()); + if (request.method !== "GET" || !isBlobLike(blob)) { + return Promise.resolve(makeNetworkError("invalid method")); + } + const response = makeResponse(); + const fullLength = blob.size; + const serializedFullLength = isomorphicEncode(`${fullLength}`); + const type2 = blob.type; + if (!request.headersList.contains("range", true)) { + const bodyWithType = extractBody(blob); + response.statusText = "OK"; + response.body = bodyWithType[0]; + response.headersList.set("content-length", serializedFullLength, true); + response.headersList.set("content-type", type2, true); + } else { + response.rangeRequested = true; + const rangeHeader = request.headersList.get("range", true); + const rangeValue = simpleRangeHeaderValue(rangeHeader, true); + if (rangeValue === "failure") { + return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + } + let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue; + if (rangeStart === null) { + rangeStart = fullLength - rangeEnd; + rangeEnd = rangeStart + rangeEnd - 1; + } else { + if (rangeStart >= fullLength) { + return Promise.resolve(makeNetworkError("Range start is greater than the blob's size.")); + } + if (rangeEnd === null || rangeEnd >= fullLength) { + rangeEnd = fullLength - 1; + } + } + const slicedBlob = blob.slice(rangeStart, rangeEnd, type2); + const slicedBodyWithType = extractBody(slicedBlob); + response.body = slicedBodyWithType[0]; + const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`); + const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength); + response.status = 206; + response.statusText = "Partial Content"; + response.headersList.set("content-length", serializedSlicedLength, true); + response.headersList.set("content-type", type2, true); + response.headersList.set("content-range", contentRange, true); + } + return Promise.resolve(response); + } + case "data:": { + const currentURL = requestCurrentURL(request); + const dataURLStruct = dataURLProcessor(currentURL); + if (dataURLStruct === "failure") { + return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + } + const mimeType = serializeAMimeType(dataURLStruct.mimeType); + return Promise.resolve(makeResponse({ + statusText: "OK", + headersList: [ + ["content-type", { name: "Content-Type", value: mimeType }] + ], + body: safelyExtractBody(dataURLStruct.body)[0] + })); + } + case "file:": { + return Promise.resolve(makeNetworkError("not implemented... yet...")); + } + case "http:": + case "https:": { + return httpFetch(fetchParams).catch((err) => makeNetworkError(err)); + } + default: { + return Promise.resolve(makeNetworkError("unknown scheme")); + } + } + } + function finalizeResponse(fetchParams, response) { + fetchParams.request.done = true; + if (fetchParams.processResponseDone != null) { + queueMicrotask(() => fetchParams.processResponseDone(response)); + } + } + function fetchFinale(fetchParams, response) { + let timingInfo = fetchParams.timingInfo; + const processResponseEndOfBody = () => { + const unsafeEndTime = Date.now(); + if (fetchParams.request.destination === "document") { + fetchParams.controller.fullTimingInfo = timingInfo; + } + fetchParams.controller.reportTimingSteps = () => { + if (fetchParams.request.url.protocol !== "https:") { + return; + } + timingInfo.endTime = unsafeEndTime; + let cacheState = response.cacheState; + const bodyInfo = response.bodyInfo; + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo(timingInfo); + cacheState = ""; + } + let responseStatus = 0; + if (fetchParams.request.mode !== "navigator" || !response.hasCrossOriginRedirects) { + responseStatus = response.status; + const mimeType = extractMimeType(response.headersList); + if (mimeType !== "failure") { + bodyInfo.contentType = minimizeSupportedMimeType(mimeType); + } + } + if (fetchParams.request.initiatorType != null) { + markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus); + } + }; + const processResponseEndOfBodyTask = () => { + fetchParams.request.done = true; + if (fetchParams.processResponseEndOfBody != null) { + queueMicrotask(() => fetchParams.processResponseEndOfBody(response)); + } + if (fetchParams.request.initiatorType != null) { + fetchParams.controller.reportTimingSteps(); + } + }; + queueMicrotask(() => processResponseEndOfBodyTask()); + }; + if (fetchParams.processResponse != null) { + queueMicrotask(() => { + fetchParams.processResponse(response); + fetchParams.processResponse = null; + }); + } + const internalResponse = response.type === "error" ? response : response.internalResponse ?? response; + if (internalResponse.body == null) { + processResponseEndOfBody(); + } else { + finished(internalResponse.body.stream, () => { + processResponseEndOfBody(); + }); + } + } + async function httpFetch(fetchParams) { + const request = fetchParams.request; + let response = null; + let actualResponse = null; + const timingInfo = fetchParams.timingInfo; + if (request.serviceWorkers === "all") { + } + if (response === null) { + if (request.redirect === "follow") { + request.serviceWorkers = "none"; + } + actualResponse = response = await httpNetworkOrCacheFetch(fetchParams); + if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") { + return makeNetworkError("cors failure"); + } + if (TAOCheck(request, response) === "failure") { + request.timingAllowFailed = true; + } + } + if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck( + request.origin, + request.client, + request.destination, + actualResponse + ) === "blocked") { + return makeNetworkError("blocked"); + } + if (redirectStatusSet.has(actualResponse.status)) { + if (request.redirect !== "manual") { + fetchParams.controller.connection.destroy(void 0, false); + } + if (request.redirect === "error") { + response = makeNetworkError("unexpected redirect"); + } else if (request.redirect === "manual") { + response = actualResponse; + } else if (request.redirect === "follow") { + response = await httpRedirectFetch(fetchParams, response); + } else { + assert(false); + } + } + response.timingInfo = timingInfo; + return response; + } + function httpRedirectFetch(fetchParams, response) { + const request = fetchParams.request; + const actualResponse = response.internalResponse ? response.internalResponse : response; + let locationURL; + try { + locationURL = responseLocationURL( + actualResponse, + requestCurrentURL(request).hash + ); + if (locationURL == null) { + return response; + } + } catch (err) { + return Promise.resolve(makeNetworkError(err)); + } + if (!urlIsHttpHttpsScheme(locationURL)) { + return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme")); + } + if (request.redirectCount === 20) { + return Promise.resolve(makeNetworkError("redirect count exceeded")); + } + request.redirectCount += 1; + if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) { + return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"')); + } + if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) { + return Promise.resolve(makeNetworkError( + 'URL cannot contain credentials for request mode "cors"' + )); + } + if (actualResponse.status !== 303 && request.body != null && request.body.source == null) { + return Promise.resolve(makeNetworkError()); + } + if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) { + request.method = "GET"; + request.body = null; + for (const headerName of requestBodyHeader) { + request.headersList.delete(headerName); + } + } + if (!sameOrigin(requestCurrentURL(request), locationURL)) { + request.headersList.delete("authorization", true); + request.headersList.delete("proxy-authorization", true); + request.headersList.delete("cookie", true); + request.headersList.delete("host", true); + } + if (request.body != null) { + assert(request.body.source != null); + request.body = safelyExtractBody(request.body.source)[0]; + } + const timingInfo = fetchParams.timingInfo; + timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + if (timingInfo.redirectStartTime === 0) { + timingInfo.redirectStartTime = timingInfo.startTime; + } + request.urlList.push(locationURL); + setRequestReferrerPolicyOnRedirect(request, actualResponse); + return mainFetch(fetchParams, true); + } + async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) { + const request = fetchParams.request; + let httpFetchParams = null; + let httpRequest = null; + let response = null; + const httpCache = null; + const revalidatingFlag = false; + if (request.window === "no-window" && request.redirect === "error") { + httpFetchParams = fetchParams; + httpRequest = request; + } else { + httpRequest = cloneRequest(request); + httpFetchParams = { ...fetchParams }; + httpFetchParams.request = httpRequest; + } + const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic"; + const contentLength = httpRequest.body ? httpRequest.body.length : null; + let contentLengthHeaderValue = null; + if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) { + contentLengthHeaderValue = "0"; + } + if (contentLength != null) { + contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); + } + if (contentLengthHeaderValue != null) { + httpRequest.headersList.append("content-length", contentLengthHeaderValue, true); + } + if (contentLength != null && httpRequest.keepalive) { + } + if (httpRequest.referrer instanceof URL) { + httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href), true); + } + appendRequestOriginHeader(httpRequest); + appendFetchMetadata(httpRequest); + if (!httpRequest.headersList.contains("user-agent", true)) { + httpRequest.headersList.append("user-agent", defaultUserAgent); + } + if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since", true) || httpRequest.headersList.contains("if-none-match", true) || httpRequest.headersList.contains("if-unmodified-since", true) || httpRequest.headersList.contains("if-match", true) || httpRequest.headersList.contains("if-range", true))) { + httpRequest.cache = "no-store"; + } + if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control", true)) { + httpRequest.headersList.append("cache-control", "max-age=0", true); + } + if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") { + if (!httpRequest.headersList.contains("pragma", true)) { + httpRequest.headersList.append("pragma", "no-cache", true); + } + if (!httpRequest.headersList.contains("cache-control", true)) { + httpRequest.headersList.append("cache-control", "no-cache", true); + } + } + if (httpRequest.headersList.contains("range", true)) { + httpRequest.headersList.append("accept-encoding", "identity", true); + } + if (!httpRequest.headersList.contains("accept-encoding", true)) { + if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) { + httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", true); + } else { + httpRequest.headersList.append("accept-encoding", "gzip, deflate", true); + } + } + httpRequest.headersList.delete("host", true); + if (includeCredentials) { + } + if (httpCache == null) { + httpRequest.cache = "no-store"; + } + if (httpRequest.cache !== "no-store" && httpRequest.cache !== "reload") { + } + if (response == null) { + if (httpRequest.cache === "only-if-cached") { + return makeNetworkError("only if cached"); + } + const forwardResponse = await httpNetworkFetch( + httpFetchParams, + includeCredentials, + isNewConnectionFetch + ); + if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) { + } + if (revalidatingFlag && forwardResponse.status === 304) { + } + if (response == null) { + response = forwardResponse; + } + } + response.urlList = [...httpRequest.urlList]; + if (httpRequest.headersList.contains("range", true)) { + response.rangeRequested = true; + } + response.requestIncludesCredentials = includeCredentials; + if (response.status === 407) { + if (request.window === "no-window") { + return makeNetworkError(); + } + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + return makeNetworkError("proxy authentication required"); + } + if ( + // response’s status is 421 + response.status === 421 && // isNewConnectionFetch is false + !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null + (request.body == null || request.body.source != null) + ) { + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + fetchParams.controller.connection.destroy(); + response = await httpNetworkOrCacheFetch( + fetchParams, + isAuthenticationFetch, + true + ); + } + if (isAuthenticationFetch) { + } + return response; + } + async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) { + assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed); + fetchParams.controller.connection = { + abort: null, + destroyed: false, + destroy(err, abort = true) { + if (!this.destroyed) { + this.destroyed = true; + if (abort) { + this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError")); + } + } + } + }; + const request = fetchParams.request; + let response = null; + const timingInfo = fetchParams.timingInfo; + const httpCache = null; + if (httpCache == null) { + request.cache = "no-store"; + } + const newConnection = forceNewConnection ? "yes" : "no"; + if (request.mode === "websocket") { + } else { + } + let requestBody = null; + if (request.body == null && fetchParams.processRequestEndOfBody) { + queueMicrotask(() => fetchParams.processRequestEndOfBody()); + } else if (request.body != null) { + const processBodyChunk = async function* (bytes) { + if (isCancelled(fetchParams)) { + return; + } + yield bytes; + fetchParams.processRequestBodyChunkLength?.(bytes.byteLength); + }; + const processEndOfBody = () => { + if (isCancelled(fetchParams)) { + return; + } + if (fetchParams.processRequestEndOfBody) { + fetchParams.processRequestEndOfBody(); + } + }; + const processBodyError = (e2) => { + if (isCancelled(fetchParams)) { + return; + } + if (e2.name === "AbortError") { + fetchParams.controller.abort(); + } else { + fetchParams.controller.terminate(e2); + } + }; + requestBody = (async function* () { + try { + for await (const bytes of request.body.stream) { + yield* processBodyChunk(bytes); + } + processEndOfBody(); + } catch (err) { + processBodyError(err); + } + })(); + } + try { + const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }); + if (socket) { + response = makeResponse({ status, statusText, headersList, socket }); + } else { + const iterator = body[Symbol.asyncIterator](); + fetchParams.controller.next = () => iterator.next(); + response = makeResponse({ status, statusText, headersList }); + } + } catch (err) { + if (err.name === "AbortError") { + fetchParams.controller.connection.destroy(); + return makeAppropriateNetworkError(fetchParams, err); + } + return makeNetworkError(err); + } + const pullAlgorithm = async () => { + await fetchParams.controller.resume(); + }; + const cancelAlgorithm = (reason) => { + if (!isCancelled(fetchParams)) { + fetchParams.controller.abort(reason); + } + }; + const stream = new ReadableStream( + { + async start(controller) { + fetchParams.controller.controller = controller; + }, + async pull(controller) { + await pullAlgorithm(controller); + }, + async cancel(reason) { + await cancelAlgorithm(reason); + }, + type: "bytes" + } + ); + response.body = { stream, source: null, length: null }; + fetchParams.controller.onAborted = onAborted; + fetchParams.controller.on("terminated", onAborted); + fetchParams.controller.resume = async () => { + while (true) { + let bytes; + let isFailure; + try { + const { done, value } = await fetchParams.controller.next(); + if (isAborted(fetchParams)) { + break; + } + bytes = done ? void 0 : value; + } catch (err) { + if (fetchParams.controller.ended && !timingInfo.encodedBodySize) { + bytes = void 0; + } else { + bytes = err; + isFailure = true; + } + } + if (bytes === void 0) { + readableStreamClose(fetchParams.controller.controller); + finalizeResponse(fetchParams, response); + return; + } + timingInfo.decodedBodySize += bytes?.byteLength ?? 0; + if (isFailure) { + fetchParams.controller.terminate(bytes); + return; + } + const buffer = new Uint8Array(bytes); + if (buffer.byteLength) { + fetchParams.controller.controller.enqueue(buffer); + } + if (isErrored(stream)) { + fetchParams.controller.terminate(); + return; + } + if (fetchParams.controller.controller.desiredSize <= 0) { + return; + } + } + }; + function onAborted(reason) { + if (isAborted(fetchParams)) { + response.aborted = true; + if (isReadable(stream)) { + fetchParams.controller.controller.error( + fetchParams.controller.serializedAbortReason + ); + } + } else { + if (isReadable(stream)) { + fetchParams.controller.controller.error(new TypeError("terminated", { + cause: isErrorLike(reason) ? reason : void 0 + })); + } + } + fetchParams.controller.connection.destroy(); + } + return response; + function dispatch({ body }) { + const url = requestCurrentURL(request); + const agent = fetchParams.controller.dispatcher; + return new Promise((resolve2, reject) => agent.dispatch( + { + path: url.pathname + url.search, + origin: url.origin, + method: request.method, + body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body, + headers: request.headersList.entries, + maxRedirections: 0, + upgrade: request.mode === "websocket" ? "websocket" : void 0 + }, + { + body: null, + abort: null, + onConnect(abort) { + const { connection } = fetchParams.controller; + timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(void 0, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability); + if (connection.destroyed) { + abort(new DOMException("The operation was aborted.", "AbortError")); + } else { + fetchParams.controller.on("terminated", abort); + this.abort = connection.abort = abort; + } + timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + }, + onResponseStarted() { + timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + }, + onHeaders(status, rawHeaders, resume, statusText) { + if (status < 200) { + return; + } + let location = ""; + const headersList = new HeadersList(); + for (let i = 0; i < rawHeaders.length; i += 2) { + headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true); + } + location = headersList.get("location", true); + this.body = new Readable({ read: resume }); + const decoders = []; + const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status); + if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) { + const contentEncoding = headersList.get("content-encoding", true); + const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : []; + const maxContentEncodings = 5; + if (codings.length > maxContentEncodings) { + reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`)); + return true; + } + for (let i = codings.length - 1; i >= 0; --i) { + const coding = codings[i].trim(); + if (coding === "x-gzip" || coding === "gzip") { + decoders.push(zlib.createGunzip({ + // Be less strict when decoding compressed responses, since sometimes + // servers send slightly invalid responses that are still accepted + // by common browsers. + // Always using Z_SYNC_FLUSH is what cURL does. + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + } else if (coding === "deflate") { + decoders.push(createInflate({ + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + } else if (coding === "br") { + decoders.push(zlib.createBrotliDecompress({ + flush: zlib.constants.BROTLI_OPERATION_FLUSH, + finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH + })); + } else { + decoders.length = 0; + break; + } + } + } + const onError = this.onError.bind(this); + resolve2({ + status, + statusText, + headersList, + body: decoders.length ? pipeline(this.body, ...decoders, (err) => { + if (err) { + this.onError(err); + } + }).on("error", onError) : this.body.on("error", onError) + }); + return true; + }, + onData(chunk) { + if (fetchParams.controller.dump) { + return; + } + const bytes = chunk; + timingInfo.encodedBodySize += bytes.byteLength; + return this.body.push(bytes); + }, + onComplete() { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + if (fetchParams.controller.onAborted) { + fetchParams.controller.off("terminated", fetchParams.controller.onAborted); + } + fetchParams.controller.ended = true; + this.body.push(null); + }, + onError(error2) { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + this.body?.destroy(error2); + fetchParams.controller.terminate(error2); + reject(error2); + }, + onUpgrade(status, rawHeaders, socket) { + if (status !== 101) { + return; + } + const headersList = new HeadersList(); + for (let i = 0; i < rawHeaders.length; i += 2) { + headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true); + } + resolve2({ + status, + statusText: STATUS_CODES2[status], + headersList, + socket + }); + return true; + } + } + )); + } + } + module.exports = { + fetch: fetch7, + Fetch, + fetching, + finalizeAndReportTiming + }; + } +}); + +// node_modules/undici/lib/web/fileapi/symbols.js +var require_symbols3 = __commonJS({ + "node_modules/undici/lib/web/fileapi/symbols.js"(exports, module) { + "use strict"; + module.exports = { + kState: /* @__PURE__ */ Symbol("FileReader state"), + kResult: /* @__PURE__ */ Symbol("FileReader result"), + kError: /* @__PURE__ */ Symbol("FileReader error"), + kLastProgressEventFired: /* @__PURE__ */ Symbol("FileReader last progress event fired timestamp"), + kEvents: /* @__PURE__ */ Symbol("FileReader events"), + kAborted: /* @__PURE__ */ Symbol("FileReader aborted") + }; + } +}); + +// node_modules/undici/lib/web/fileapi/progressevent.js +var require_progressevent = __commonJS({ + "node_modules/undici/lib/web/fileapi/progressevent.js"(exports, module) { + "use strict"; + var { webidl } = require_webidl(); + var kState = /* @__PURE__ */ Symbol("ProgressEvent state"); + var ProgressEvent = class _ProgressEvent extends Event { + constructor(type2, eventInitDict = {}) { + type2 = webidl.converters.DOMString(type2, "ProgressEvent constructor", "type"); + eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}); + super(type2, eventInitDict); + this[kState] = { + lengthComputable: eventInitDict.lengthComputable, + loaded: eventInitDict.loaded, + total: eventInitDict.total + }; + } + get lengthComputable() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].lengthComputable; + } + get loaded() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].loaded; + } + get total() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].total; + } + }; + webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ + { + key: "lengthComputable", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "loaded", + converter: webidl.converters["unsigned long long"], + defaultValue: () => 0 + }, + { + key: "total", + converter: webidl.converters["unsigned long long"], + defaultValue: () => 0 + }, + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: () => false + } + ]); + module.exports = { + ProgressEvent + }; + } +}); + +// node_modules/undici/lib/web/fileapi/encoding.js +var require_encoding = __commonJS({ + "node_modules/undici/lib/web/fileapi/encoding.js"(exports, module) { + "use strict"; + function getEncoding(label) { + if (!label) { + return "failure"; + } + switch (label.trim().toLowerCase()) { + case "unicode-1-1-utf-8": + case "unicode11utf8": + case "unicode20utf8": + case "utf-8": + case "utf8": + case "x-unicode20utf8": + return "UTF-8"; + case "866": + case "cp866": + case "csibm866": + case "ibm866": + return "IBM866"; + case "csisolatin2": + case "iso-8859-2": + case "iso-ir-101": + case "iso8859-2": + case "iso88592": + case "iso_8859-2": + case "iso_8859-2:1987": + case "l2": + case "latin2": + return "ISO-8859-2"; + case "csisolatin3": + case "iso-8859-3": + case "iso-ir-109": + case "iso8859-3": + case "iso88593": + case "iso_8859-3": + case "iso_8859-3:1988": + case "l3": + case "latin3": + return "ISO-8859-3"; + case "csisolatin4": + case "iso-8859-4": + case "iso-ir-110": + case "iso8859-4": + case "iso88594": + case "iso_8859-4": + case "iso_8859-4:1988": + case "l4": + case "latin4": + return "ISO-8859-4"; + case "csisolatincyrillic": + case "cyrillic": + case "iso-8859-5": + case "iso-ir-144": + case "iso8859-5": + case "iso88595": + case "iso_8859-5": + case "iso_8859-5:1988": + return "ISO-8859-5"; + case "arabic": + case "asmo-708": + case "csiso88596e": + case "csiso88596i": + case "csisolatinarabic": + case "ecma-114": + case "iso-8859-6": + case "iso-8859-6-e": + case "iso-8859-6-i": + case "iso-ir-127": + case "iso8859-6": + case "iso88596": + case "iso_8859-6": + case "iso_8859-6:1987": + return "ISO-8859-6"; + case "csisolatingreek": + case "ecma-118": + case "elot_928": + case "greek": + case "greek8": + case "iso-8859-7": + case "iso-ir-126": + case "iso8859-7": + case "iso88597": + case "iso_8859-7": + case "iso_8859-7:1987": + case "sun_eu_greek": + return "ISO-8859-7"; + case "csiso88598e": + case "csisolatinhebrew": + case "hebrew": + case "iso-8859-8": + case "iso-8859-8-e": + case "iso-ir-138": + case "iso8859-8": + case "iso88598": + case "iso_8859-8": + case "iso_8859-8:1988": + case "visual": + return "ISO-8859-8"; + case "csiso88598i": + case "iso-8859-8-i": + case "logical": + return "ISO-8859-8-I"; + case "csisolatin6": + case "iso-8859-10": + case "iso-ir-157": + case "iso8859-10": + case "iso885910": + case "l6": + case "latin6": + return "ISO-8859-10"; + case "iso-8859-13": + case "iso8859-13": + case "iso885913": + return "ISO-8859-13"; + case "iso-8859-14": + case "iso8859-14": + case "iso885914": + return "ISO-8859-14"; + case "csisolatin9": + case "iso-8859-15": + case "iso8859-15": + case "iso885915": + case "iso_8859-15": + case "l9": + return "ISO-8859-15"; + case "iso-8859-16": + return "ISO-8859-16"; + case "cskoi8r": + case "koi": + case "koi8": + case "koi8-r": + case "koi8_r": + return "KOI8-R"; + case "koi8-ru": + case "koi8-u": + return "KOI8-U"; + case "csmacintosh": + case "mac": + case "macintosh": + case "x-mac-roman": + return "macintosh"; + case "iso-8859-11": + case "iso8859-11": + case "iso885911": + case "tis-620": + case "windows-874": + return "windows-874"; + case "cp1250": + case "windows-1250": + case "x-cp1250": + return "windows-1250"; + case "cp1251": + case "windows-1251": + case "x-cp1251": + return "windows-1251"; + case "ansi_x3.4-1968": + case "ascii": + case "cp1252": + case "cp819": + case "csisolatin1": + case "ibm819": + case "iso-8859-1": + case "iso-ir-100": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "iso_8859-1:1987": + case "l1": + case "latin1": + case "us-ascii": + case "windows-1252": + case "x-cp1252": + return "windows-1252"; + case "cp1253": + case "windows-1253": + case "x-cp1253": + return "windows-1253"; + case "cp1254": + case "csisolatin5": + case "iso-8859-9": + case "iso-ir-148": + case "iso8859-9": + case "iso88599": + case "iso_8859-9": + case "iso_8859-9:1989": + case "l5": + case "latin5": + case "windows-1254": + case "x-cp1254": + return "windows-1254"; + case "cp1255": + case "windows-1255": + case "x-cp1255": + return "windows-1255"; + case "cp1256": + case "windows-1256": + case "x-cp1256": + return "windows-1256"; + case "cp1257": + case "windows-1257": + case "x-cp1257": + return "windows-1257"; + case "cp1258": + case "windows-1258": + case "x-cp1258": + return "windows-1258"; + case "x-mac-cyrillic": + case "x-mac-ukrainian": + return "x-mac-cyrillic"; + case "chinese": + case "csgb2312": + case "csiso58gb231280": + case "gb2312": + case "gb_2312": + case "gb_2312-80": + case "gbk": + case "iso-ir-58": + case "x-gbk": + return "GBK"; + case "gb18030": + return "gb18030"; + case "big5": + case "big5-hkscs": + case "cn-big5": + case "csbig5": + case "x-x-big5": + return "Big5"; + case "cseucpkdfmtjapanese": + case "euc-jp": + case "x-euc-jp": + return "EUC-JP"; + case "csiso2022jp": + case "iso-2022-jp": + return "ISO-2022-JP"; + case "csshiftjis": + case "ms932": + case "ms_kanji": + case "shift-jis": + case "shift_jis": + case "sjis": + case "windows-31j": + case "x-sjis": + return "Shift_JIS"; + case "cseuckr": + case "csksc56011987": + case "euc-kr": + case "iso-ir-149": + case "korean": + case "ks_c_5601-1987": + case "ks_c_5601-1989": + case "ksc5601": + case "ksc_5601": + case "windows-949": + return "EUC-KR"; + case "csiso2022kr": + case "hz-gb-2312": + case "iso-2022-cn": + case "iso-2022-cn-ext": + case "iso-2022-kr": + case "replacement": + return "replacement"; + case "unicodefffe": + case "utf-16be": + return "UTF-16BE"; + case "csunicode": + case "iso-10646-ucs-2": + case "ucs-2": + case "unicode": + case "unicodefeff": + case "utf-16": + case "utf-16le": + return "UTF-16LE"; + case "x-user-defined": + return "x-user-defined"; + default: + return "failure"; + } + } + module.exports = { + getEncoding + }; + } +}); + +// node_modules/undici/lib/web/fileapi/util.js +var require_util4 = __commonJS({ + "node_modules/undici/lib/web/fileapi/util.js"(exports, module) { + "use strict"; + var { + kState, + kError, + kResult, + kAborted, + kLastProgressEventFired + } = require_symbols3(); + var { ProgressEvent } = require_progressevent(); + var { getEncoding } = require_encoding(); + var { serializeAMimeType, parseMIMEType } = require_data_url(); + var { types: types2 } = __require("node:util"); + var { StringDecoder } = __require("string_decoder"); + var { btoa: btoa2 } = __require("node:buffer"); + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + function readOperation(fr, blob, type2, encodingName) { + if (fr[kState] === "loading") { + throw new DOMException("Invalid state", "InvalidStateError"); + } + fr[kState] = "loading"; + fr[kResult] = null; + fr[kError] = null; + const stream = blob.stream(); + const reader = stream.getReader(); + const bytes = []; + let chunkPromise = reader.read(); + let isFirstChunk = true; + (async () => { + while (!fr[kAborted]) { + try { + const { done, value } = await chunkPromise; + if (isFirstChunk && !fr[kAborted]) { + queueMicrotask(() => { + fireAProgressEvent("loadstart", fr); + }); + } + isFirstChunk = false; + if (!done && types2.isUint8Array(value)) { + bytes.push(value); + if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) { + fr[kLastProgressEventFired] = Date.now(); + queueMicrotask(() => { + fireAProgressEvent("progress", fr); + }); + } + chunkPromise = reader.read(); + } else if (done) { + queueMicrotask(() => { + fr[kState] = "done"; + try { + const result = packageData(bytes, type2, blob.type, encodingName); + if (fr[kAborted]) { + return; + } + fr[kResult] = result; + fireAProgressEvent("load", fr); + } catch (error2) { + fr[kError] = error2; + fireAProgressEvent("error", fr); + } + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } catch (error2) { + if (fr[kAborted]) { + return; + } + queueMicrotask(() => { + fr[kState] = "done"; + fr[kError] = error2; + fireAProgressEvent("error", fr); + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } + })(); + } + function fireAProgressEvent(e2, reader) { + const event = new ProgressEvent(e2, { + bubbles: false, + cancelable: false + }); + reader.dispatchEvent(event); + } + function packageData(bytes, type2, mimeType, encodingName) { + switch (type2) { + case "DataURL": { + let dataURL = "data:"; + const parsed = parseMIMEType(mimeType || "application/octet-stream"); + if (parsed !== "failure") { + dataURL += serializeAMimeType(parsed); + } + dataURL += ";base64,"; + const decoder3 = new StringDecoder("latin1"); + for (const chunk of bytes) { + dataURL += btoa2(decoder3.write(chunk)); + } + dataURL += btoa2(decoder3.end()); + return dataURL; + } + case "Text": { + let encoding = "failure"; + if (encodingName) { + encoding = getEncoding(encodingName); + } + if (encoding === "failure" && mimeType) { + const type3 = parseMIMEType(mimeType); + if (type3 !== "failure") { + encoding = getEncoding(type3.parameters.get("charset")); + } + } + if (encoding === "failure") { + encoding = "UTF-8"; + } + return decode(bytes, encoding); + } + case "ArrayBuffer": { + const sequence = combineByteSequences(bytes); + return sequence.buffer; + } + case "BinaryString": { + let binaryString = ""; + const decoder3 = new StringDecoder("latin1"); + for (const chunk of bytes) { + binaryString += decoder3.write(chunk); + } + binaryString += decoder3.end(); + return binaryString; + } + } + } + function decode(ioQueue, encoding) { + const bytes = combineByteSequences(ioQueue); + const BOMEncoding = BOMSniffing(bytes); + let slice = 0; + if (BOMEncoding !== null) { + encoding = BOMEncoding; + slice = BOMEncoding === "UTF-8" ? 3 : 2; + } + const sliced = bytes.slice(slice); + return new TextDecoder(encoding).decode(sliced); + } + function BOMSniffing(ioQueue) { + const [a, b, c] = ioQueue; + if (a === 239 && b === 187 && c === 191) { + return "UTF-8"; + } else if (a === 254 && b === 255) { + return "UTF-16BE"; + } else if (a === 255 && b === 254) { + return "UTF-16LE"; + } + return null; + } + function combineByteSequences(sequences) { + const size = sequences.reduce((a, b) => { + return a + b.byteLength; + }, 0); + let offset = 0; + return sequences.reduce((a, b) => { + a.set(b, offset); + offset += b.byteLength; + return a; + }, new Uint8Array(size)); + } + module.exports = { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + }; + } +}); + +// node_modules/undici/lib/web/fileapi/filereader.js +var require_filereader = __commonJS({ + "node_modules/undici/lib/web/fileapi/filereader.js"(exports, module) { + "use strict"; + var { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + } = require_util4(); + var { + kState, + kError, + kResult, + kEvents, + kAborted + } = require_symbols3(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var FileReader = class _FileReader extends EventTarget { + constructor() { + super(); + this[kState] = "empty"; + this[kResult] = null; + this[kError] = null; + this[kEvents] = { + loadend: null, + error: null, + abort: null, + load: null, + progress: null, + loadstart: null + }; + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer + * @param {import('buffer').Blob} blob + */ + readAsArrayBuffer(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsArrayBuffer"); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "ArrayBuffer"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsBinaryString + * @param {import('buffer').Blob} blob + */ + readAsBinaryString(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsBinaryString"); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "BinaryString"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsDataText + * @param {import('buffer').Blob} blob + * @param {string?} encoding + */ + readAsText(blob, encoding = void 0) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsText"); + blob = webidl.converters.Blob(blob, { strict: false }); + if (encoding !== void 0) { + encoding = webidl.converters.DOMString(encoding, "FileReader.readAsText", "encoding"); + } + readOperation(this, blob, "Text", encoding); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL + * @param {import('buffer').Blob} blob + */ + readAsDataURL(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsDataURL"); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "DataURL"); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-abort + */ + abort() { + if (this[kState] === "empty" || this[kState] === "done") { + this[kResult] = null; + return; + } + if (this[kState] === "loading") { + this[kState] = "done"; + this[kResult] = null; + } + this[kAborted] = true; + fireAProgressEvent("abort", this); + if (this[kState] !== "loading") { + fireAProgressEvent("loadend", this); + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate + */ + get readyState() { + webidl.brandCheck(this, _FileReader); + switch (this[kState]) { + case "empty": + return this.EMPTY; + case "loading": + return this.LOADING; + case "done": + return this.DONE; + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-result + */ + get result() { + webidl.brandCheck(this, _FileReader); + return this[kResult]; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-error + */ + get error() { + webidl.brandCheck(this, _FileReader); + return this[kError]; + } + get onloadend() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadend; + } + set onloadend(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadend) { + this.removeEventListener("loadend", this[kEvents].loadend); + } + if (typeof fn === "function") { + this[kEvents].loadend = fn; + this.addEventListener("loadend", fn); + } else { + this[kEvents].loadend = null; + } + } + get onerror() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].error; + } + set onerror(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].error) { + this.removeEventListener("error", this[kEvents].error); + } + if (typeof fn === "function") { + this[kEvents].error = fn; + this.addEventListener("error", fn); + } else { + this[kEvents].error = null; + } + } + get onloadstart() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadstart; + } + set onloadstart(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadstart) { + this.removeEventListener("loadstart", this[kEvents].loadstart); + } + if (typeof fn === "function") { + this[kEvents].loadstart = fn; + this.addEventListener("loadstart", fn); + } else { + this[kEvents].loadstart = null; + } + } + get onprogress() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].progress; + } + set onprogress(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].progress) { + this.removeEventListener("progress", this[kEvents].progress); + } + if (typeof fn === "function") { + this[kEvents].progress = fn; + this.addEventListener("progress", fn); + } else { + this[kEvents].progress = null; + } + } + get onload() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].load; + } + set onload(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].load) { + this.removeEventListener("load", this[kEvents].load); + } + if (typeof fn === "function") { + this[kEvents].load = fn; + this.addEventListener("load", fn); + } else { + this[kEvents].load = null; + } + } + get onabort() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].abort; + } + set onabort(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].abort) { + this.removeEventListener("abort", this[kEvents].abort); + } + if (typeof fn === "function") { + this[kEvents].abort = fn; + this.addEventListener("abort", fn); + } else { + this[kEvents].abort = null; + } + } + }; + FileReader.EMPTY = FileReader.prototype.EMPTY = 0; + FileReader.LOADING = FileReader.prototype.LOADING = 1; + FileReader.DONE = FileReader.prototype.DONE = 2; + Object.defineProperties(FileReader.prototype, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors, + readAsArrayBuffer: kEnumerableProperty, + readAsBinaryString: kEnumerableProperty, + readAsText: kEnumerableProperty, + readAsDataURL: kEnumerableProperty, + abort: kEnumerableProperty, + readyState: kEnumerableProperty, + result: kEnumerableProperty, + error: kEnumerableProperty, + onloadstart: kEnumerableProperty, + onprogress: kEnumerableProperty, + onload: kEnumerableProperty, + onabort: kEnumerableProperty, + onerror: kEnumerableProperty, + onloadend: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FileReader", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(FileReader, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors + }); + module.exports = { + FileReader + }; + } +}); + +// node_modules/undici/lib/web/cache/symbols.js +var require_symbols4 = __commonJS({ + "node_modules/undici/lib/web/cache/symbols.js"(exports, module) { + "use strict"; + module.exports = { + kConstruct: require_symbols().kConstruct + }; + } +}); + +// node_modules/undici/lib/web/cache/util.js +var require_util5 = __commonJS({ + "node_modules/undici/lib/web/cache/util.js"(exports, module) { + "use strict"; + var assert = __require("node:assert"); + var { URLSerializer } = require_data_url(); + var { isValidHeaderName } = require_util2(); + function urlEquals(A, B, excludeFragment = false) { + const serializedA = URLSerializer(A, excludeFragment); + const serializedB = URLSerializer(B, excludeFragment); + return serializedA === serializedB; + } + function getFieldValues(header) { + assert(header !== null); + const values = []; + for (let value of header.split(",")) { + value = value.trim(); + if (isValidHeaderName(value)) { + values.push(value); + } + } + return values; + } + module.exports = { + urlEquals, + getFieldValues + }; + } +}); + +// node_modules/undici/lib/web/cache/cache.js +var require_cache = __commonJS({ + "node_modules/undici/lib/web/cache/cache.js"(exports, module) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { urlEquals, getFieldValues } = require_util5(); + var { kEnumerableProperty, isDisturbed } = require_util(); + var { webidl } = require_webidl(); + var { Response: Response2, cloneResponse, fromInnerResponse } = require_response(); + var { Request: Request2, fromInnerRequest } = require_request2(); + var { kState } = require_symbols2(); + var { fetching } = require_fetch(); + var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2(); + var assert = __require("node:assert"); + var Cache = class _Cache { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list + * @type {requestResponseList} + */ + #relevantRequestResponseList; + constructor() { + if (arguments[0] !== kConstruct) { + webidl.illegalConstructor(); + } + webidl.util.markAsUncloneable(this); + this.#relevantRequestResponseList = arguments[1]; + } + async match(request, options = {}) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.match"; + webidl.argumentLengthCheck(arguments, 1, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + const p = this.#internalMatchAll(request, options, 1); + if (p.length === 0) { + return; + } + return p[0]; + } + async matchAll(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.matchAll"; + if (request !== void 0) request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + return this.#internalMatchAll(request, options); + } + async add(request) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.add"; + webidl.argumentLengthCheck(arguments, 1, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + const requests = [request]; + const responseArrayPromise = this.addAll(requests); + return await responseArrayPromise; + } + async addAll(requests) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.addAll"; + webidl.argumentLengthCheck(arguments, 1, prefix); + const responsePromises = []; + const requestList = []; + for (let request of requests) { + if (request === void 0) { + throw webidl.errors.conversionFailed({ + prefix, + argument: "Argument 1", + types: ["undefined is not allowed"] + }); + } + request = webidl.converters.RequestInfo(request); + if (typeof request === "string") { + continue; + } + const r = request[kState]; + if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") { + throw webidl.errors.exception({ + header: prefix, + message: "Expected http/s scheme when method is not GET." + }); + } + } + const fetchControllers = []; + for (const request of requests) { + const r = new Request2(request)[kState]; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: prefix, + message: "Expected http/s scheme." + }); + } + r.initiator = "fetch"; + r.destination = "subresource"; + requestList.push(r); + const responsePromise = createDeferredPromise(); + fetchControllers.push(fetching({ + request: r, + processResponse(response) { + if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "Received an invalid status code or the request failed." + })); + } else if (response.headersList.contains("vary")) { + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "invalid vary field value" + })); + for (const controller of fetchControllers) { + controller.abort(); + } + return; + } + } + } + }, + processResponseEndOfBody(response) { + if (response.aborted) { + responsePromise.reject(new DOMException("aborted", "AbortError")); + return; + } + responsePromise.resolve(response); + } + })); + responsePromises.push(responsePromise.promise); + } + const p = Promise.all(responsePromises); + const responses = await p; + const operations = []; + let index2 = 0; + for (const response of responses) { + const operation = { + type: "put", + // 7.3.2 + request: requestList[index2], + // 7.3.3 + response + // 7.3.4 + }; + operations.push(operation); + index2++; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e2) { + errorData = e2; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(void 0); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async put(request, response) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.put"; + webidl.argumentLengthCheck(arguments, 2, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + response = webidl.converters.Response(response, prefix, "response"); + let innerRequest = null; + if (request instanceof Request2) { + innerRequest = request[kState]; + } else { + innerRequest = new Request2(request)[kState]; + } + if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") { + throw webidl.errors.exception({ + header: prefix, + message: "Expected an http/s scheme when method is not GET" + }); + } + const innerResponse = response[kState]; + if (innerResponse.status === 206) { + throw webidl.errors.exception({ + header: prefix, + message: "Got 206 status" + }); + } + if (innerResponse.headersList.contains("vary")) { + const fieldValues = getFieldValues(innerResponse.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + throw webidl.errors.exception({ + header: prefix, + message: "Got * vary field value" + }); + } + } + } + if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) { + throw webidl.errors.exception({ + header: prefix, + message: "Response body is locked or disturbed" + }); + } + const clonedResponse = cloneResponse(innerResponse); + const bodyReadPromise = createDeferredPromise(); + if (innerResponse.body != null) { + const stream = innerResponse.body.stream; + const reader = stream.getReader(); + readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject); + } else { + bodyReadPromise.resolve(void 0); + } + const operations = []; + const operation = { + type: "put", + // 14. + request: innerRequest, + // 15. + response: clonedResponse + // 16. + }; + operations.push(operation); + const bytes = await bodyReadPromise.promise; + if (clonedResponse.body != null) { + clonedResponse.body.source = bytes; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e2) { + errorData = e2; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async delete(request, options = {}) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.delete"; + webidl.argumentLengthCheck(arguments, 1, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + let r = null; + if (request instanceof Request2) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return false; + } + } else { + assert(typeof request === "string"); + r = new Request2(request)[kState]; + } + const operations = []; + const operation = { + type: "delete", + request: r, + options + }; + operations.push(operation); + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + let requestResponses; + try { + requestResponses = this.#batchCacheOperations(operations); + } catch (e2) { + errorData = e2; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(!!requestResponses?.length); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys + * @param {any} request + * @param {import('../../types/cache').CacheQueryOptions} options + * @returns {Promise} + */ + async keys(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + const prefix = "Cache.keys"; + if (request !== void 0) request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + let r = null; + if (request !== void 0) { + if (request instanceof Request2) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request2(request)[kState]; + } + } + const promise = createDeferredPromise(); + const requests = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + requests.push(requestResponse[0]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + requests.push(requestResponse[0]); + } + } + queueMicrotask(() => { + const requestList = []; + for (const request2 of requests) { + const requestObject = fromInnerRequest( + request2, + new AbortController().signal, + "immutable" + ); + requestList.push(requestObject); + } + promise.resolve(Object.freeze(requestList)); + }); + return promise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm + * @param {CacheBatchOperation[]} operations + * @returns {requestResponseList} + */ + #batchCacheOperations(operations) { + const cache = this.#relevantRequestResponseList; + const backupCache = [...cache]; + const addedItems = []; + const resultList = []; + try { + for (const operation of operations) { + if (operation.type !== "delete" && operation.type !== "put") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: 'operation type does not match "delete" or "put"' + }); + } + if (operation.type === "delete" && operation.response != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "delete operation should not have an associated response" + }); + } + if (this.#queryCache(operation.request, operation.options, addedItems).length) { + throw new DOMException("???", "InvalidStateError"); + } + let requestResponses; + if (operation.type === "delete") { + requestResponses = this.#queryCache(operation.request, operation.options); + if (requestResponses.length === 0) { + return []; + } + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + } else if (operation.type === "put") { + if (operation.response == null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "put operation should have an associated response" + }); + } + const r = operation.request; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "expected http or https scheme" + }); + } + if (r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "not get method" + }); + } + if (operation.options != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "options must not be defined" + }); + } + requestResponses = this.#queryCache(operation.request); + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + cache.push([operation.request, operation.response]); + addedItems.push([operation.request, operation.response]); + } + resultList.push([operation.request, operation.response]); + } + return resultList; + } catch (e2) { + this.#relevantRequestResponseList.length = 0; + this.#relevantRequestResponseList = backupCache; + throw e2; + } + } + /** + * @see https://w3c.github.io/ServiceWorker/#query-cache + * @param {any} requestQuery + * @param {import('../../types/cache').CacheQueryOptions} options + * @param {requestResponseList} targetStorage + * @returns {requestResponseList} + */ + #queryCache(requestQuery, options, targetStorage) { + const resultList = []; + const storage = targetStorage ?? this.#relevantRequestResponseList; + for (const requestResponse of storage) { + const [cachedRequest, cachedResponse] = requestResponse; + if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) { + resultList.push(requestResponse); + } + } + return resultList; + } + /** + * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm + * @param {any} requestQuery + * @param {any} request + * @param {any | null} response + * @param {import('../../types/cache').CacheQueryOptions | undefined} options + * @returns {boolean} + */ + #requestMatchesCachedItem(requestQuery, request, response = null, options) { + const queryURL = new URL(requestQuery.url); + const cachedURL = new URL(request.url); + if (options?.ignoreSearch) { + cachedURL.search = ""; + queryURL.search = ""; + } + if (!urlEquals(queryURL, cachedURL, true)) { + return false; + } + if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) { + return true; + } + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + return false; + } + const requestValue = request.headersList.get(fieldValue); + const queryValue = requestQuery.headersList.get(fieldValue); + if (requestValue !== queryValue) { + return false; + } + } + return true; + } + #internalMatchAll(request, options, maxResponses = Infinity) { + let r = null; + if (request !== void 0) { + if (request instanceof Request2) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request2(request)[kState]; + } + } + const responses = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + responses.push(requestResponse[1]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + responses.push(requestResponse[1]); + } + } + const responseList = []; + for (const response of responses) { + const responseObject = fromInnerResponse(response, "immutable"); + responseList.push(responseObject.clone()); + if (responseList.length >= maxResponses) { + break; + } + } + return Object.freeze(responseList); + } + }; + Object.defineProperties(Cache.prototype, { + [Symbol.toStringTag]: { + value: "Cache", + configurable: true + }, + match: kEnumerableProperty, + matchAll: kEnumerableProperty, + add: kEnumerableProperty, + addAll: kEnumerableProperty, + put: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + var cacheQueryOptionConverters = [ + { + key: "ignoreSearch", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "ignoreMethod", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "ignoreVary", + converter: webidl.converters.boolean, + defaultValue: () => false + } + ]; + webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters); + webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([ + ...cacheQueryOptionConverters, + { + key: "cacheName", + converter: webidl.converters.DOMString + } + ]); + webidl.converters.Response = webidl.interfaceConverter(Response2); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.RequestInfo + ); + module.exports = { + Cache + }; + } +}); + +// node_modules/undici/lib/web/cache/cachestorage.js +var require_cachestorage = __commonJS({ + "node_modules/undici/lib/web/cache/cachestorage.js"(exports, module) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { Cache } = require_cache(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var CacheStorage = class _CacheStorage { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map + * @type {Map} + */ + async has(cacheName) { + webidl.brandCheck(this, _CacheStorage); + const prefix = "CacheStorage.has"; + webidl.argumentLengthCheck(arguments, 1, prefix); + cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName"); + return this.#caches.has(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open + * @param {string} cacheName + * @returns {Promise} + */ + async open(cacheName) { + webidl.brandCheck(this, _CacheStorage); + const prefix = "CacheStorage.open"; + webidl.argumentLengthCheck(arguments, 1, prefix); + cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName"); + if (this.#caches.has(cacheName)) { + const cache2 = this.#caches.get(cacheName); + return new Cache(kConstruct, cache2); + } + const cache = []; + this.#caches.set(cacheName, cache); + return new Cache(kConstruct, cache); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete + * @param {string} cacheName + * @returns {Promise} + */ + async delete(cacheName) { + webidl.brandCheck(this, _CacheStorage); + const prefix = "CacheStorage.delete"; + webidl.argumentLengthCheck(arguments, 1, prefix); + cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName"); + return this.#caches.delete(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys + * @returns {Promise} + */ + async keys() { + webidl.brandCheck(this, _CacheStorage); + const keys = this.#caches.keys(); + return [...keys]; + } + }; + Object.defineProperties(CacheStorage.prototype, { + [Symbol.toStringTag]: { + value: "CacheStorage", + configurable: true + }, + match: kEnumerableProperty, + has: kEnumerableProperty, + open: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + module.exports = { + CacheStorage + }; + } +}); + +// node_modules/undici/lib/web/cookies/constants.js +var require_constants4 = __commonJS({ + "node_modules/undici/lib/web/cookies/constants.js"(exports, module) { + "use strict"; + var maxAttributeValueSize = 1024; + var maxNameValuePairSize = 4096; + module.exports = { + maxAttributeValueSize, + maxNameValuePairSize + }; + } +}); + +// node_modules/undici/lib/web/cookies/util.js +var require_util6 = __commonJS({ + "node_modules/undici/lib/web/cookies/util.js"(exports, module) { + "use strict"; + function isCTLExcludingHtab(value) { + for (let i = 0; i < value.length; ++i) { + const code = value.charCodeAt(i); + if (code >= 0 && code <= 8 || code >= 10 && code <= 31 || code === 127) { + return true; + } + } + return false; + } + function validateCookieName(name) { + for (let i = 0; i < name.length; ++i) { + const code = name.charCodeAt(i); + if (code < 33 || // exclude CTLs (0-31), SP and HT + code > 126 || // exclude non-ascii and DEL + code === 34 || // " + code === 40 || // ( + code === 41 || // ) + code === 60 || // < + code === 62 || // > + code === 64 || // @ + code === 44 || // , + code === 59 || // ; + code === 58 || // : + code === 92 || // \ + code === 47 || // / + code === 91 || // [ + code === 93 || // ] + code === 63 || // ? + code === 61 || // = + code === 123 || // { + code === 125) { + throw new Error("Invalid cookie name"); + } + } + } + function validateCookieValue(value) { + let len = value.length; + let i = 0; + if (value[0] === '"') { + if (len === 1 || value[len - 1] !== '"') { + throw new Error("Invalid cookie value"); + } + --len; + ++i; + } + while (i < len) { + const code = value.charCodeAt(i++); + if (code < 33 || // exclude CTLs (0-31) + code > 126 || // non-ascii and DEL (127) + code === 34 || // " + code === 44 || // , + code === 59 || // ; + code === 92) { + throw new Error("Invalid cookie value"); + } + } + } + function validateCookiePath(path7) { + for (let i = 0; i < path7.length; ++i) { + const code = path7.charCodeAt(i); + if (code < 32 || // exclude CTLs (0-31) + code === 127 || // DEL + code === 59) { + throw new Error("Invalid cookie path"); + } + } + } + function validateCookieDomain(domain) { + if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) { + throw new Error("Invalid cookie domain"); + } + } + var IMFDays = [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ]; + var IMFMonths = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + var IMFPaddedNumbers = Array(61).fill(0).map((_, i) => i.toString().padStart(2, "0")); + function toIMFDate(date) { + if (typeof date === "number") { + date = new Date(date); + } + return `${IMFDays[date.getUTCDay()]}, ${IMFPaddedNumbers[date.getUTCDate()]} ${IMFMonths[date.getUTCMonth()]} ${date.getUTCFullYear()} ${IMFPaddedNumbers[date.getUTCHours()]}:${IMFPaddedNumbers[date.getUTCMinutes()]}:${IMFPaddedNumbers[date.getUTCSeconds()]} GMT`; + } + function validateCookieMaxAge(maxAge) { + if (maxAge < 0) { + throw new Error("Invalid cookie max-age"); + } + } + function stringify2(cookie) { + if (cookie.name.length === 0) { + return null; + } + validateCookieName(cookie.name); + validateCookieValue(cookie.value); + const out = [`${cookie.name}=${cookie.value}`]; + if (cookie.name.startsWith("__Secure-")) { + cookie.secure = true; + } + if (cookie.name.startsWith("__Host-")) { + cookie.secure = true; + cookie.domain = null; + cookie.path = "/"; + } + if (cookie.secure) { + out.push("Secure"); + } + if (cookie.httpOnly) { + out.push("HttpOnly"); + } + if (typeof cookie.maxAge === "number") { + validateCookieMaxAge(cookie.maxAge); + out.push(`Max-Age=${cookie.maxAge}`); + } + if (cookie.domain) { + validateCookieDomain(cookie.domain); + out.push(`Domain=${cookie.domain}`); + } + if (cookie.path) { + validateCookiePath(cookie.path); + out.push(`Path=${cookie.path}`); + } + if (cookie.expires && cookie.expires.toString() !== "Invalid Date") { + out.push(`Expires=${toIMFDate(cookie.expires)}`); + } + if (cookie.sameSite) { + out.push(`SameSite=${cookie.sameSite}`); + } + for (const part of cookie.unparsed) { + if (!part.includes("=")) { + throw new Error("Invalid unparsed"); + } + const [key, ...value] = part.split("="); + out.push(`${key.trim()}=${value.join("=")}`); + } + return out.join("; "); + } + module.exports = { + isCTLExcludingHtab, + validateCookieName, + validateCookiePath, + validateCookieValue, + toIMFDate, + stringify: stringify2 + }; + } +}); + +// node_modules/undici/lib/web/cookies/parse.js +var require_parse = __commonJS({ + "node_modules/undici/lib/web/cookies/parse.js"(exports, module) { + "use strict"; + var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4(); + var { isCTLExcludingHtab } = require_util6(); + var { collectASequenceOfCodePointsFast } = require_data_url(); + var assert = __require("node:assert"); + function parseSetCookie(header) { + if (isCTLExcludingHtab(header)) { + return null; + } + let nameValuePair = ""; + let unparsedAttributes = ""; + let name = ""; + let value = ""; + if (header.includes(";")) { + const position = { position: 0 }; + nameValuePair = collectASequenceOfCodePointsFast(";", header, position); + unparsedAttributes = header.slice(position.position); + } else { + nameValuePair = header; + } + if (!nameValuePair.includes("=")) { + value = nameValuePair; + } else { + const position = { position: 0 }; + name = collectASequenceOfCodePointsFast( + "=", + nameValuePair, + position + ); + value = nameValuePair.slice(position.position + 1); + } + name = name.trim(); + value = value.trim(); + if (name.length + value.length > maxNameValuePairSize) { + return null; + } + return { + name, + value, + ...parseUnparsedAttributes(unparsedAttributes) + }; + } + function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) { + if (unparsedAttributes.length === 0) { + return cookieAttributeList; + } + assert(unparsedAttributes[0] === ";"); + unparsedAttributes = unparsedAttributes.slice(1); + let cookieAv = ""; + if (unparsedAttributes.includes(";")) { + cookieAv = collectASequenceOfCodePointsFast( + ";", + unparsedAttributes, + { position: 0 } + ); + unparsedAttributes = unparsedAttributes.slice(cookieAv.length); + } else { + cookieAv = unparsedAttributes; + unparsedAttributes = ""; + } + let attributeName = ""; + let attributeValue = ""; + if (cookieAv.includes("=")) { + const position = { position: 0 }; + attributeName = collectASequenceOfCodePointsFast( + "=", + cookieAv, + position + ); + attributeValue = cookieAv.slice(position.position + 1); + } else { + attributeName = cookieAv; + } + attributeName = attributeName.trim(); + attributeValue = attributeValue.trim(); + if (attributeValue.length > maxAttributeValueSize) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const attributeNameLowercase = attributeName.toLowerCase(); + if (attributeNameLowercase === "expires") { + const expiryTime = new Date(attributeValue); + cookieAttributeList.expires = expiryTime; + } else if (attributeNameLowercase === "max-age") { + const charCode = attributeValue.charCodeAt(0); + if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + if (!/^\d+$/.test(attributeValue)) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const deltaSeconds = Number(attributeValue); + cookieAttributeList.maxAge = deltaSeconds; + } else if (attributeNameLowercase === "domain") { + let cookieDomain = attributeValue; + if (cookieDomain[0] === ".") { + cookieDomain = cookieDomain.slice(1); + } + cookieDomain = cookieDomain.toLowerCase(); + cookieAttributeList.domain = cookieDomain; + } else if (attributeNameLowercase === "path") { + let cookiePath = ""; + if (attributeValue.length === 0 || attributeValue[0] !== "/") { + cookiePath = "/"; + } else { + cookiePath = attributeValue; + } + cookieAttributeList.path = cookiePath; + } else if (attributeNameLowercase === "secure") { + cookieAttributeList.secure = true; + } else if (attributeNameLowercase === "httponly") { + cookieAttributeList.httpOnly = true; + } else if (attributeNameLowercase === "samesite") { + let enforcement = "Default"; + const attributeValueLowercase = attributeValue.toLowerCase(); + if (attributeValueLowercase.includes("none")) { + enforcement = "None"; + } + if (attributeValueLowercase.includes("strict")) { + enforcement = "Strict"; + } + if (attributeValueLowercase.includes("lax")) { + enforcement = "Lax"; + } + cookieAttributeList.sameSite = enforcement; + } else { + cookieAttributeList.unparsed ??= []; + cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`); + } + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + module.exports = { + parseSetCookie, + parseUnparsedAttributes + }; + } +}); + +// node_modules/undici/lib/web/cookies/index.js +var require_cookies = __commonJS({ + "node_modules/undici/lib/web/cookies/index.js"(exports, module) { + "use strict"; + var { parseSetCookie } = require_parse(); + var { stringify: stringify2 } = require_util6(); + var { webidl } = require_webidl(); + var { Headers: Headers4 } = require_headers(); + function getCookies(headers2) { + webidl.argumentLengthCheck(arguments, 1, "getCookies"); + webidl.brandCheck(headers2, Headers4, { strict: false }); + const cookie = headers2.get("cookie"); + const out = {}; + if (!cookie) { + return out; + } + for (const piece of cookie.split(";")) { + const [name, ...value] = piece.split("="); + out[name.trim()] = value.join("="); + } + return out; + } + function deleteCookie(headers2, name, attributes) { + webidl.brandCheck(headers2, Headers4, { strict: false }); + const prefix = "deleteCookie"; + webidl.argumentLengthCheck(arguments, 2, prefix); + name = webidl.converters.DOMString(name, prefix, "name"); + attributes = webidl.converters.DeleteCookieAttributes(attributes); + setCookie(headers2, { + name, + value: "", + expires: /* @__PURE__ */ new Date(0), + ...attributes + }); + } + function getSetCookies(headers2) { + webidl.argumentLengthCheck(arguments, 1, "getSetCookies"); + webidl.brandCheck(headers2, Headers4, { strict: false }); + const cookies = headers2.getSetCookie(); + if (!cookies) { + return []; + } + return cookies.map((pair) => parseSetCookie(pair)); + } + function setCookie(headers2, cookie) { + webidl.argumentLengthCheck(arguments, 2, "setCookie"); + webidl.brandCheck(headers2, Headers4, { strict: false }); + cookie = webidl.converters.Cookie(cookie); + const str2 = stringify2(cookie); + if (str2) { + headers2.append("Set-Cookie", str2); + } + } + webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([ + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: () => null + } + ]); + webidl.converters.Cookie = webidl.dictionaryConverter([ + { + converter: webidl.converters.DOMString, + key: "name" + }, + { + converter: webidl.converters.DOMString, + key: "value" + }, + { + converter: webidl.nullableConverter((value) => { + if (typeof value === "number") { + return webidl.converters["unsigned long long"](value); + } + return new Date(value); + }), + key: "expires", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters["long long"]), + key: "maxAge", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "secure", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "httpOnly", + defaultValue: () => null + }, + { + converter: webidl.converters.USVString, + key: "sameSite", + allowedValues: ["Strict", "Lax", "None"] + }, + { + converter: webidl.sequenceConverter(webidl.converters.DOMString), + key: "unparsed", + defaultValue: () => new Array(0) + } + ]); + module.exports = { + getCookies, + deleteCookie, + getSetCookies, + setCookie + }; + } +}); + +// node_modules/undici/lib/web/websocket/events.js +var require_events = __commonJS({ + "node_modules/undici/lib/web/websocket/events.js"(exports, module) { + "use strict"; + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var { kConstruct } = require_symbols(); + var { MessagePort } = __require("node:worker_threads"); + var MessageEvent = class _MessageEvent extends Event { + #eventInit; + constructor(type2, eventInitDict = {}) { + if (type2 === kConstruct) { + super(arguments[1], arguments[2]); + webidl.util.markAsUncloneable(this); + return; + } + const prefix = "MessageEvent constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + type2 = webidl.converters.DOMString(type2, prefix, "type"); + eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, "eventInitDict"); + super(type2, eventInitDict); + this.#eventInit = eventInitDict; + webidl.util.markAsUncloneable(this); + } + get data() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.data; + } + get origin() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.origin; + } + get lastEventId() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.lastEventId; + } + get source() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.source; + } + get ports() { + webidl.brandCheck(this, _MessageEvent); + if (!Object.isFrozen(this.#eventInit.ports)) { + Object.freeze(this.#eventInit.ports); + } + return this.#eventInit.ports; + } + initMessageEvent(type2, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) { + webidl.brandCheck(this, _MessageEvent); + webidl.argumentLengthCheck(arguments, 1, "MessageEvent.initMessageEvent"); + return new _MessageEvent(type2, { + bubbles, + cancelable, + data, + origin, + lastEventId, + source, + ports + }); + } + static createFastMessageEvent(type2, init) { + const messageEvent = new _MessageEvent(kConstruct, type2, init); + messageEvent.#eventInit = init; + messageEvent.#eventInit.data ??= null; + messageEvent.#eventInit.origin ??= ""; + messageEvent.#eventInit.lastEventId ??= ""; + messageEvent.#eventInit.source ??= null; + messageEvent.#eventInit.ports ??= []; + return messageEvent; + } + }; + var { createFastMessageEvent } = MessageEvent; + delete MessageEvent.createFastMessageEvent; + var CloseEvent = class _CloseEvent extends Event { + #eventInit; + constructor(type2, eventInitDict = {}) { + const prefix = "CloseEvent constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + type2 = webidl.converters.DOMString(type2, prefix, "type"); + eventInitDict = webidl.converters.CloseEventInit(eventInitDict); + super(type2, eventInitDict); + this.#eventInit = eventInitDict; + webidl.util.markAsUncloneable(this); + } + get wasClean() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.wasClean; + } + get code() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.code; + } + get reason() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.reason; + } + }; + var ErrorEvent = class _ErrorEvent extends Event { + #eventInit; + constructor(type2, eventInitDict) { + const prefix = "ErrorEvent constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + super(type2, eventInitDict); + webidl.util.markAsUncloneable(this); + type2 = webidl.converters.DOMString(type2, prefix, "type"); + eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}); + this.#eventInit = eventInitDict; + } + get message() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.message; + } + get filename() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.filename; + } + get lineno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.lineno; + } + get colno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.colno; + } + get error() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.error; + } + }; + Object.defineProperties(MessageEvent.prototype, { + [Symbol.toStringTag]: { + value: "MessageEvent", + configurable: true + }, + data: kEnumerableProperty, + origin: kEnumerableProperty, + lastEventId: kEnumerableProperty, + source: kEnumerableProperty, + ports: kEnumerableProperty, + initMessageEvent: kEnumerableProperty + }); + Object.defineProperties(CloseEvent.prototype, { + [Symbol.toStringTag]: { + value: "CloseEvent", + configurable: true + }, + reason: kEnumerableProperty, + code: kEnumerableProperty, + wasClean: kEnumerableProperty + }); + Object.defineProperties(ErrorEvent.prototype, { + [Symbol.toStringTag]: { + value: "ErrorEvent", + configurable: true + }, + message: kEnumerableProperty, + filename: kEnumerableProperty, + lineno: kEnumerableProperty, + colno: kEnumerableProperty, + error: kEnumerableProperty + }); + webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.MessagePort + ); + var eventInit = [ + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: () => false + } + ]; + webidl.converters.MessageEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "data", + converter: webidl.converters.any, + defaultValue: () => null + }, + { + key: "origin", + converter: webidl.converters.USVString, + defaultValue: () => "" + }, + { + key: "lastEventId", + converter: webidl.converters.DOMString, + defaultValue: () => "" + }, + { + key: "source", + // Node doesn't implement WindowProxy or ServiceWorker, so the only + // valid value for source is a MessagePort. + converter: webidl.nullableConverter(webidl.converters.MessagePort), + defaultValue: () => null + }, + { + key: "ports", + converter: webidl.converters["sequence"], + defaultValue: () => new Array(0) + } + ]); + webidl.converters.CloseEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "wasClean", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "code", + converter: webidl.converters["unsigned short"], + defaultValue: () => 0 + }, + { + key: "reason", + converter: webidl.converters.USVString, + defaultValue: () => "" + } + ]); + webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "message", + converter: webidl.converters.DOMString, + defaultValue: () => "" + }, + { + key: "filename", + converter: webidl.converters.USVString, + defaultValue: () => "" + }, + { + key: "lineno", + converter: webidl.converters["unsigned long"], + defaultValue: () => 0 + }, + { + key: "colno", + converter: webidl.converters["unsigned long"], + defaultValue: () => 0 + }, + { + key: "error", + converter: webidl.converters.any + } + ]); + module.exports = { + MessageEvent, + CloseEvent, + ErrorEvent, + createFastMessageEvent + }; + } +}); + +// node_modules/undici/lib/web/websocket/constants.js +var require_constants5 = __commonJS({ + "node_modules/undici/lib/web/websocket/constants.js"(exports, module) { + "use strict"; + var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + var states = { + CONNECTING: 0, + OPEN: 1, + CLOSING: 2, + CLOSED: 3 + }; + var sentCloseFrameState = { + NOT_SENT: 0, + PROCESSING: 1, + SENT: 2 + }; + var opcodes = { + CONTINUATION: 0, + TEXT: 1, + BINARY: 2, + CLOSE: 8, + PING: 9, + PONG: 10 + }; + var maxUnsigned16Bit = 2 ** 16 - 1; + var parserStates = { + INFO: 0, + PAYLOADLENGTH_16: 2, + PAYLOADLENGTH_64: 3, + READ_DATA: 4 + }; + var emptyBuffer = Buffer.allocUnsafe(0); + var sendHints = { + string: 1, + typedArray: 2, + arrayBuffer: 3, + blob: 4 + }; + module.exports = { + uid, + sentCloseFrameState, + staticPropertyDescriptors, + states, + opcodes, + maxUnsigned16Bit, + parserStates, + emptyBuffer, + sendHints + }; + } +}); + +// node_modules/undici/lib/web/websocket/symbols.js +var require_symbols5 = __commonJS({ + "node_modules/undici/lib/web/websocket/symbols.js"(exports, module) { + "use strict"; + module.exports = { + kWebSocketURL: /* @__PURE__ */ Symbol("url"), + kReadyState: /* @__PURE__ */ Symbol("ready state"), + kController: /* @__PURE__ */ Symbol("controller"), + kResponse: /* @__PURE__ */ Symbol("response"), + kBinaryType: /* @__PURE__ */ Symbol("binary type"), + kSentClose: /* @__PURE__ */ Symbol("sent close"), + kReceivedClose: /* @__PURE__ */ Symbol("received close"), + kByteParser: /* @__PURE__ */ Symbol("byte parser") + }; + } +}); + +// node_modules/undici/lib/web/websocket/util.js +var require_util7 = __commonJS({ + "node_modules/undici/lib/web/websocket/util.js"(exports, module) { + "use strict"; + var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5(); + var { states, opcodes } = require_constants5(); + var { ErrorEvent, createFastMessageEvent } = require_events(); + var { isUtf8 } = __require("node:buffer"); + var { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require_data_url(); + function isConnecting(ws) { + return ws[kReadyState] === states.CONNECTING; + } + function isEstablished(ws) { + return ws[kReadyState] === states.OPEN; + } + function isClosing(ws) { + return ws[kReadyState] === states.CLOSING; + } + function isClosed(ws) { + return ws[kReadyState] === states.CLOSED; + } + function fireEvent(e2, target, eventFactory = (type2, init) => new Event(type2, init), eventInitDict = {}) { + const event = eventFactory(e2, eventInitDict); + target.dispatchEvent(event); + } + function websocketMessageReceived(ws, type2, data) { + if (ws[kReadyState] !== states.OPEN) { + return; + } + let dataForEvent; + if (type2 === opcodes.TEXT) { + try { + dataForEvent = utf8Decode(data); + } catch { + failWebsocketConnection(ws, "Received invalid UTF-8 in text frame."); + return; + } + } else if (type2 === opcodes.BINARY) { + if (ws[kBinaryType] === "blob") { + dataForEvent = new Blob([data]); + } else { + dataForEvent = toArrayBuffer(data); + } + } + fireEvent("message", ws, createFastMessageEvent, { + origin: ws[kWebSocketURL].origin, + data: dataForEvent + }); + } + function toArrayBuffer(buffer) { + if (buffer.byteLength === buffer.buffer.byteLength) { + return buffer.buffer; + } + return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); + } + function isValidSubprotocol(protocol) { + if (protocol.length === 0) { + return false; + } + for (let i = 0; i < protocol.length; ++i) { + const code = protocol.charCodeAt(i); + if (code < 33 || // CTL, contains SP (0x20) and HT (0x09) + code > 126 || code === 34 || // " + code === 40 || // ( + code === 41 || // ) + code === 44 || // , + code === 47 || // / + code === 58 || // : + code === 59 || // ; + code === 60 || // < + code === 61 || // = + code === 62 || // > + code === 63 || // ? + code === 64 || // @ + code === 91 || // [ + code === 92 || // \ + code === 93 || // ] + code === 123 || // { + code === 125) { + return false; + } + } + return true; + } + function isValidStatusCode(code) { + if (code >= 1e3 && code < 1015) { + return code !== 1004 && // reserved + code !== 1005 && // "MUST NOT be set as a status code" + code !== 1006; + } + return code >= 3e3 && code <= 4999; + } + function failWebsocketConnection(ws, reason) { + const { [kController]: controller, [kResponse]: response } = ws; + controller.abort(); + if (response?.socket && !response.socket.destroyed) { + response.socket.destroy(); + } + if (reason) { + fireEvent("error", ws, (type2, init) => new ErrorEvent(type2, init), { + error: new Error(reason), + message: reason + }); + } + } + function isControlFrame(opcode) { + return opcode === opcodes.CLOSE || opcode === opcodes.PING || opcode === opcodes.PONG; + } + function isContinuationFrame(opcode) { + return opcode === opcodes.CONTINUATION; + } + function isTextBinaryFrame(opcode) { + return opcode === opcodes.TEXT || opcode === opcodes.BINARY; + } + function isValidOpcode(opcode) { + return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode); + } + function parseExtensions(extensions) { + const position = { position: 0 }; + const extensionList = /* @__PURE__ */ new Map(); + while (position.position < extensions.length) { + const pair = collectASequenceOfCodePointsFast(";", extensions, position); + const [name, value = ""] = pair.split("="); + extensionList.set( + removeHTTPWhitespace(name, true, false), + removeHTTPWhitespace(value, false, true) + ); + position.position++; + } + return extensionList; + } + function isValidClientWindowBits(value) { + if (value.length === 0) { + return false; + } + for (let i = 0; i < value.length; i++) { + const byte = value.charCodeAt(i); + if (byte < 48 || byte > 57) { + return false; + } + } + const num = Number.parseInt(value, 10); + return num >= 8 && num <= 15; + } + var hasIntl = typeof process.versions.icu === "string"; + var fatalDecoder = hasIntl ? new TextDecoder("utf-8", { fatal: true }) : void 0; + var utf8Decode = hasIntl ? fatalDecoder.decode.bind(fatalDecoder) : function(buffer) { + if (isUtf8(buffer)) { + return buffer.toString("utf-8"); + } + throw new TypeError("Invalid utf-8 received."); + }; + module.exports = { + isConnecting, + isEstablished, + isClosing, + isClosed, + fireEvent, + isValidSubprotocol, + isValidStatusCode, + failWebsocketConnection, + websocketMessageReceived, + utf8Decode, + isControlFrame, + isContinuationFrame, + isTextBinaryFrame, + isValidOpcode, + parseExtensions, + isValidClientWindowBits + }; + } +}); + +// node_modules/undici/lib/web/websocket/frame.js +var require_frame = __commonJS({ + "node_modules/undici/lib/web/websocket/frame.js"(exports, module) { + "use strict"; + var { maxUnsigned16Bit } = require_constants5(); + var BUFFER_SIZE = 16386; + var crypto3; + var buffer = null; + var bufIdx = BUFFER_SIZE; + try { + crypto3 = __require("node:crypto"); + } catch { + crypto3 = { + // not full compatibility, but minimum. + randomFillSync: function randomFillSync(buffer2, _offset, _size) { + for (let i = 0; i < buffer2.length; ++i) { + buffer2[i] = Math.random() * 255 | 0; + } + return buffer2; + } + }; + } + function generateMask() { + if (bufIdx === BUFFER_SIZE) { + bufIdx = 0; + crypto3.randomFillSync(buffer ??= Buffer.allocUnsafe(BUFFER_SIZE), 0, BUFFER_SIZE); + } + return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]; + } + var WebsocketFrameSend = class { + /** + * @param {Buffer|undefined} data + */ + constructor(data) { + this.frameData = data; + } + createFrame(opcode) { + const frameData = this.frameData; + const maskKey = generateMask(); + const bodyLength = frameData?.byteLength ?? 0; + let payloadLength = bodyLength; + let offset = 6; + if (bodyLength > maxUnsigned16Bit) { + offset += 8; + payloadLength = 127; + } else if (bodyLength > 125) { + offset += 2; + payloadLength = 126; + } + const buffer2 = Buffer.allocUnsafe(bodyLength + offset); + buffer2[0] = buffer2[1] = 0; + buffer2[0] |= 128; + buffer2[0] = (buffer2[0] & 240) + opcode; + buffer2[offset - 4] = maskKey[0]; + buffer2[offset - 3] = maskKey[1]; + buffer2[offset - 2] = maskKey[2]; + buffer2[offset - 1] = maskKey[3]; + buffer2[1] = payloadLength; + if (payloadLength === 126) { + buffer2.writeUInt16BE(bodyLength, 2); + } else if (payloadLength === 127) { + buffer2[2] = buffer2[3] = 0; + buffer2.writeUIntBE(bodyLength, 4, 6); + } + buffer2[1] |= 128; + for (let i = 0; i < bodyLength; ++i) { + buffer2[offset + i] = frameData[i] ^ maskKey[i & 3]; + } + return buffer2; + } + }; + module.exports = { + WebsocketFrameSend + }; + } +}); + +// node_modules/undici/lib/web/websocket/connection.js +var require_connection = __commonJS({ + "node_modules/undici/lib/web/websocket/connection.js"(exports, module) { + "use strict"; + var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants5(); + var { + kReadyState, + kSentClose, + kByteParser, + kReceivedClose, + kResponse + } = require_symbols5(); + var { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = require_util7(); + var { channels } = require_diagnostics(); + var { CloseEvent } = require_events(); + var { makeRequest } = require_request2(); + var { fetching } = require_fetch(); + var { Headers: Headers4, getHeadersList } = require_headers(); + var { getDecodeSplit } = require_util2(); + var { WebsocketFrameSend } = require_frame(); + var crypto3; + try { + crypto3 = __require("node:crypto"); + } catch { + } + function establishWebSocketConnection(url, protocols2, client, ws, onEstablish, options) { + const requestURL = url; + requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:"; + const request = makeRequest({ + urlList: [requestURL], + client, + serviceWorkers: "none", + referrer: "no-referrer", + mode: "websocket", + credentials: "include", + cache: "no-store", + redirect: "error" + }); + if (options.headers) { + const headersList = getHeadersList(new Headers4(options.headers)); + request.headersList = headersList; + } + const keyValue = crypto3.randomBytes(16).toString("base64"); + request.headersList.append("sec-websocket-key", keyValue); + request.headersList.append("sec-websocket-version", "13"); + for (const protocol of protocols2) { + request.headersList.append("sec-websocket-protocol", protocol); + } + const permessageDeflate = "permessage-deflate; client_max_window_bits"; + request.headersList.append("sec-websocket-extensions", permessageDeflate); + const controller = fetching({ + request, + useParallelQueue: true, + dispatcher: options.dispatcher, + processResponse(response) { + if (response.type === "error" || response.status !== 101) { + failWebsocketConnection(ws, "Received network error or non-101 status code."); + return; + } + if (protocols2.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Server did not respond with sent protocols."); + return; + } + if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") { + failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".'); + return; + } + if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") { + failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".'); + return; + } + const secWSAccept = response.headersList.get("Sec-WebSocket-Accept"); + const digest = crypto3.createHash("sha1").update(keyValue + uid).digest("base64"); + if (secWSAccept !== digest) { + failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header."); + return; + } + const secExtension = response.headersList.get("Sec-WebSocket-Extensions"); + let extensions; + if (secExtension !== null) { + extensions = parseExtensions(secExtension); + if (!extensions.has("permessage-deflate")) { + failWebsocketConnection(ws, "Sec-WebSocket-Extensions header does not match."); + return; + } + } + const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); + if (secProtocol !== null) { + const requestProtocols = getDecodeSplit("sec-websocket-protocol", request.headersList); + if (!requestProtocols.includes(secProtocol)) { + failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); + return; + } + } + response.socket.on("data", onSocketData); + response.socket.on("close", onSocketClose); + response.socket.on("error", onSocketError); + if (channels.open.hasSubscribers) { + channels.open.publish({ + address: response.socket.address(), + protocol: secProtocol, + extensions: secExtension + }); + } + onEstablish(response, extensions); + } + }); + return controller; + } + function closeWebSocketConnection(ws, code, reason, reasonByteLength) { + if (isClosing(ws) || isClosed(ws)) { + } else if (!isEstablished(ws)) { + failWebsocketConnection(ws, "Connection was closed before it was established."); + ws[kReadyState] = states.CLOSING; + } else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) { + ws[kSentClose] = sentCloseFrameState.PROCESSING; + const frame = new WebsocketFrameSend(); + if (code !== void 0 && reason === void 0) { + frame.frameData = Buffer.allocUnsafe(2); + frame.frameData.writeUInt16BE(code, 0); + } else if (code !== void 0 && reason !== void 0) { + frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength); + frame.frameData.writeUInt16BE(code, 0); + frame.frameData.write(reason, 2, "utf-8"); + } else { + frame.frameData = emptyBuffer; + } + const socket = ws[kResponse].socket; + socket.write(frame.createFrame(opcodes.CLOSE)); + ws[kSentClose] = sentCloseFrameState.SENT; + ws[kReadyState] = states.CLOSING; + } else { + ws[kReadyState] = states.CLOSING; + } + } + function onSocketData(chunk) { + if (!this.ws[kByteParser].write(chunk)) { + this.pause(); + } + } + function onSocketClose() { + const { ws } = this; + const { [kResponse]: response } = ws; + response.socket.off("data", onSocketData); + response.socket.off("close", onSocketClose); + response.socket.off("error", onSocketError); + const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose]; + let code = 1005; + let reason = ""; + const result = ws[kByteParser].closingInfo; + if (result && !result.error) { + code = result.code ?? 1005; + reason = result.reason; + } else if (!ws[kReceivedClose]) { + code = 1006; + } + ws[kReadyState] = states.CLOSED; + fireEvent("close", ws, (type2, init) => new CloseEvent(type2, init), { + wasClean, + code, + reason + }); + if (channels.close.hasSubscribers) { + channels.close.publish({ + websocket: ws, + code, + reason + }); + } + } + function onSocketError(error2) { + const { ws } = this; + ws[kReadyState] = states.CLOSING; + if (channels.socketError.hasSubscribers) { + channels.socketError.publish(error2); + } + this.destroy(); + } + module.exports = { + establishWebSocketConnection, + closeWebSocketConnection + }; + } +}); + +// node_modules/undici/lib/web/websocket/permessage-deflate.js +var require_permessage_deflate = __commonJS({ + "node_modules/undici/lib/web/websocket/permessage-deflate.js"(exports, module) { + "use strict"; + var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("node:zlib"); + var { isValidClientWindowBits } = require_util7(); + var { MessageSizeExceededError } = require_errors(); + var tail = Buffer.from([0, 0, 255, 255]); + var kBuffer = /* @__PURE__ */ Symbol("kBuffer"); + var kLength = /* @__PURE__ */ Symbol("kLength"); + var kDefaultMaxDecompressedSize = 4 * 1024 * 1024; + var PerMessageDeflate = class { + /** @type {import('node:zlib').InflateRaw} */ + #inflate; + #options = {}; + /** @type {boolean} */ + #aborted = false; + /** @type {Function|null} */ + #currentCallback = null; + /** + * @param {Map} extensions + */ + constructor(extensions) { + this.#options.serverNoContextTakeover = extensions.has("server_no_context_takeover"); + this.#options.serverMaxWindowBits = extensions.get("server_max_window_bits"); + } + decompress(chunk, fin, callback) { + if (this.#aborted) { + callback(new MessageSizeExceededError()); + return; + } + if (!this.#inflate) { + let windowBits = Z_DEFAULT_WINDOWBITS; + if (this.#options.serverMaxWindowBits) { + if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) { + callback(new Error("Invalid server_max_window_bits")); + return; + } + windowBits = Number.parseInt(this.#options.serverMaxWindowBits); + } + try { + this.#inflate = createInflateRaw({ windowBits }); + } catch (err) { + callback(err); + return; + } + this.#inflate[kBuffer] = []; + this.#inflate[kLength] = 0; + this.#inflate.on("data", (data) => { + if (this.#aborted) { + return; + } + this.#inflate[kLength] += data.length; + if (this.#inflate[kLength] > kDefaultMaxDecompressedSize) { + this.#aborted = true; + this.#inflate.removeAllListeners(); + this.#inflate.destroy(); + this.#inflate = null; + if (this.#currentCallback) { + const cb = this.#currentCallback; + this.#currentCallback = null; + cb(new MessageSizeExceededError()); + } + return; + } + this.#inflate[kBuffer].push(data); + }); + this.#inflate.on("error", (err) => { + this.#inflate = null; + callback(err); + }); + } + this.#currentCallback = callback; + this.#inflate.write(chunk); + if (fin) { + this.#inflate.write(tail); + } + this.#inflate.flush(() => { + if (this.#aborted || !this.#inflate) { + return; + } + const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength]); + this.#inflate[kBuffer].length = 0; + this.#inflate[kLength] = 0; + this.#currentCallback = null; + callback(null, full); + }); + } + }; + module.exports = { PerMessageDeflate }; + } +}); + +// node_modules/undici/lib/web/websocket/receiver.js +var require_receiver = __commonJS({ + "node_modules/undici/lib/web/websocket/receiver.js"(exports, module) { + "use strict"; + var { Writable } = __require("node:stream"); + var assert = __require("node:assert"); + var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants5(); + var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5(); + var { channels } = require_diagnostics(); + var { + isValidStatusCode, + isValidOpcode, + failWebsocketConnection, + websocketMessageReceived, + utf8Decode, + isControlFrame, + isTextBinaryFrame, + isContinuationFrame + } = require_util7(); + var { WebsocketFrameSend } = require_frame(); + var { closeWebSocketConnection } = require_connection(); + var { PerMessageDeflate } = require_permessage_deflate(); + var ByteParser = class extends Writable { + #buffers = []; + #byteOffset = 0; + #loop = false; + #state = parserStates.INFO; + #info = {}; + #fragments = []; + /** @type {Map} */ + #extensions; + /** + * @param {import('./websocket').WebSocket} ws + * @param {Map|null} extensions + */ + constructor(ws, extensions) { + super(); + this.ws = ws; + this.#extensions = extensions == null ? /* @__PURE__ */ new Map() : extensions; + if (this.#extensions.has("permessage-deflate")) { + this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions)); + } + } + /** + * @param {Buffer} chunk + * @param {() => void} callback + */ + _write(chunk, _, callback) { + this.#buffers.push(chunk); + this.#byteOffset += chunk.length; + this.#loop = true; + this.run(callback); + } + /** + * Runs whenever a new chunk is received. + * Callback is called whenever there are no more chunks buffering, + * or not enough bytes are buffered to parse. + */ + run(callback) { + while (this.#loop) { + if (this.#state === parserStates.INFO) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + const fin = (buffer[0] & 128) !== 0; + const opcode = buffer[0] & 15; + const masked = (buffer[1] & 128) === 128; + const fragmented = !fin && opcode !== opcodes.CONTINUATION; + const payloadLength = buffer[1] & 127; + const rsv1 = buffer[0] & 64; + const rsv2 = buffer[0] & 32; + const rsv3 = buffer[0] & 16; + if (!isValidOpcode(opcode)) { + failWebsocketConnection(this.ws, "Invalid opcode received"); + return callback(); + } + if (masked) { + failWebsocketConnection(this.ws, "Frame cannot be masked"); + return callback(); + } + if (rsv1 !== 0 && !this.#extensions.has("permessage-deflate")) { + failWebsocketConnection(this.ws, "Expected RSV1 to be clear."); + return; + } + if (rsv2 !== 0 || rsv3 !== 0) { + failWebsocketConnection(this.ws, "RSV1, RSV2, RSV3 must be clear"); + return; + } + if (fragmented && !isTextBinaryFrame(opcode)) { + failWebsocketConnection(this.ws, "Invalid frame type was fragmented."); + return; + } + if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) { + failWebsocketConnection(this.ws, "Expected continuation frame"); + return; + } + if (this.#info.fragmented && fragmented) { + failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes."); + return; + } + if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) { + failWebsocketConnection(this.ws, "Control frame either too large or fragmented"); + return; + } + if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) { + failWebsocketConnection(this.ws, "Unexpected continuation frame"); + return; + } + if (payloadLength <= 125) { + this.#info.payloadLength = payloadLength; + this.#state = parserStates.READ_DATA; + } else if (payloadLength === 126) { + this.#state = parserStates.PAYLOADLENGTH_16; + } else if (payloadLength === 127) { + this.#state = parserStates.PAYLOADLENGTH_64; + } + if (isTextBinaryFrame(opcode)) { + this.#info.binaryType = opcode; + this.#info.compressed = rsv1 !== 0; + } + this.#info.opcode = opcode; + this.#info.masked = masked; + this.#info.fin = fin; + this.#info.fragmented = fragmented; + } else if (this.#state === parserStates.PAYLOADLENGTH_16) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.payloadLength = buffer.readUInt16BE(0); + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.PAYLOADLENGTH_64) { + if (this.#byteOffset < 8) { + return callback(); + } + const buffer = this.consume(8); + const upper = buffer.readUInt32BE(0); + const lower = buffer.readUInt32BE(4); + if (upper !== 0 || lower > 2 ** 31 - 1) { + failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes."); + return; + } + this.#info.payloadLength = lower; + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.READ_DATA) { + if (this.#byteOffset < this.#info.payloadLength) { + return callback(); + } + const body = this.consume(this.#info.payloadLength); + if (isControlFrame(this.#info.opcode)) { + this.#loop = this.parseControlFrame(body); + this.#state = parserStates.INFO; + } else { + if (!this.#info.compressed) { + this.#fragments.push(body); + if (!this.#info.fragmented && this.#info.fin) { + const fullMessage = Buffer.concat(this.#fragments); + websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage); + this.#fragments.length = 0; + } + this.#state = parserStates.INFO; + } else { + this.#extensions.get("permessage-deflate").decompress(body, this.#info.fin, (error2, data) => { + if (error2) { + failWebsocketConnection(this.ws, error2.message); + return; + } + this.#fragments.push(data); + if (!this.#info.fin) { + this.#state = parserStates.INFO; + this.#loop = true; + this.run(callback); + return; + } + websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments)); + this.#loop = true; + this.#state = parserStates.INFO; + this.#fragments.length = 0; + this.run(callback); + }); + this.#loop = false; + break; + } + } + } + } + } + /** + * Take n bytes from the buffered Buffers + * @param {number} n + * @returns {Buffer} + */ + consume(n) { + if (n > this.#byteOffset) { + throw new Error("Called consume() before buffers satiated."); + } else if (n === 0) { + return emptyBuffer; + } + if (this.#buffers[0].length === n) { + this.#byteOffset -= this.#buffers[0].length; + return this.#buffers.shift(); + } + const buffer = Buffer.allocUnsafe(n); + let offset = 0; + while (offset !== n) { + const next = this.#buffers[0]; + const { length } = next; + if (length + offset === n) { + buffer.set(this.#buffers.shift(), offset); + break; + } else if (length + offset > n) { + buffer.set(next.subarray(0, n - offset), offset); + this.#buffers[0] = next.subarray(n - offset); + break; + } else { + buffer.set(this.#buffers.shift(), offset); + offset += next.length; + } + } + this.#byteOffset -= n; + return buffer; + } + parseCloseBody(data) { + assert(data.length !== 1); + let code; + if (data.length >= 2) { + code = data.readUInt16BE(0); + } + if (code !== void 0 && !isValidStatusCode(code)) { + return { code: 1002, reason: "Invalid status code", error: true }; + } + let reason = data.subarray(2); + if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) { + reason = reason.subarray(3); + } + try { + reason = utf8Decode(reason); + } catch { + return { code: 1007, reason: "Invalid UTF-8", error: true }; + } + return { code, reason, error: false }; + } + /** + * Parses control frames. + * @param {Buffer} body + */ + parseControlFrame(body) { + const { opcode, payloadLength } = this.#info; + if (opcode === opcodes.CLOSE) { + if (payloadLength === 1) { + failWebsocketConnection(this.ws, "Received close frame with a 1-byte body."); + return false; + } + this.#info.closeInfo = this.parseCloseBody(body); + if (this.#info.closeInfo.error) { + const { code, reason } = this.#info.closeInfo; + closeWebSocketConnection(this.ws, code, reason, reason.length); + failWebsocketConnection(this.ws, reason); + return false; + } + if (this.ws[kSentClose] !== sentCloseFrameState.SENT) { + let body2 = emptyBuffer; + if (this.#info.closeInfo.code) { + body2 = Buffer.allocUnsafe(2); + body2.writeUInt16BE(this.#info.closeInfo.code, 0); + } + const closeFrame = new WebsocketFrameSend(body2); + this.ws[kResponse].socket.write( + closeFrame.createFrame(opcodes.CLOSE), + (err) => { + if (!err) { + this.ws[kSentClose] = sentCloseFrameState.SENT; + } + } + ); + } + this.ws[kReadyState] = states.CLOSING; + this.ws[kReceivedClose] = true; + return false; + } else if (opcode === opcodes.PING) { + if (!this.ws[kReceivedClose]) { + const frame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)); + if (channels.ping.hasSubscribers) { + channels.ping.publish({ + payload: body + }); + } + } + } else if (opcode === opcodes.PONG) { + if (channels.pong.hasSubscribers) { + channels.pong.publish({ + payload: body + }); + } + } + return true; + } + get closingInfo() { + return this.#info.closeInfo; + } + }; + module.exports = { + ByteParser + }; + } +}); + +// node_modules/undici/lib/web/websocket/sender.js +var require_sender = __commonJS({ + "node_modules/undici/lib/web/websocket/sender.js"(exports, module) { + "use strict"; + var { WebsocketFrameSend } = require_frame(); + var { opcodes, sendHints } = require_constants5(); + var FixedQueue = require_fixed_queue(); + var FastBuffer = Buffer[Symbol.species]; + var SendQueue = class { + /** + * @type {FixedQueue} + */ + #queue = new FixedQueue(); + /** + * @type {boolean} + */ + #running = false; + /** @type {import('node:net').Socket} */ + #socket; + constructor(socket) { + this.#socket = socket; + } + add(item, cb, hint) { + if (hint !== sendHints.blob) { + const frame = createFrame(item, hint); + if (!this.#running) { + this.#socket.write(frame, cb); + } else { + const node2 = { + promise: null, + callback: cb, + frame + }; + this.#queue.push(node2); + } + return; + } + const node = { + promise: item.arrayBuffer().then((ab) => { + node.promise = null; + node.frame = createFrame(ab, hint); + }), + callback: cb, + frame: null + }; + this.#queue.push(node); + if (!this.#running) { + this.#run(); + } + } + async #run() { + this.#running = true; + const queue = this.#queue; + while (!queue.isEmpty()) { + const node = queue.shift(); + if (node.promise !== null) { + await node.promise; + } + this.#socket.write(node.frame, node.callback); + node.callback = node.frame = null; + } + this.#running = false; + } + }; + function createFrame(data, hint) { + return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY); + } + function toBuffer(data, hint) { + switch (hint) { + case sendHints.string: + return Buffer.from(data); + case sendHints.arrayBuffer: + case sendHints.blob: + return new FastBuffer(data); + case sendHints.typedArray: + return new FastBuffer(data.buffer, data.byteOffset, data.byteLength); + } + } + module.exports = { SendQueue }; + } +}); + +// node_modules/undici/lib/web/websocket/websocket.js +var require_websocket = __commonJS({ + "node_modules/undici/lib/web/websocket/websocket.js"(exports, module) { + "use strict"; + var { webidl } = require_webidl(); + var { URLSerializer } = require_data_url(); + var { environmentSettingsObject } = require_util2(); + var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require_constants5(); + var { + kWebSocketURL, + kReadyState, + kController, + kBinaryType, + kResponse, + kSentClose, + kByteParser + } = require_symbols5(); + var { + isConnecting, + isEstablished, + isClosing, + isValidSubprotocol, + fireEvent + } = require_util7(); + var { establishWebSocketConnection, closeWebSocketConnection } = require_connection(); + var { ByteParser } = require_receiver(); + var { kEnumerableProperty, isBlobLike } = require_util(); + var { getGlobalDispatcher } = require_global2(); + var { types: types2 } = __require("node:util"); + var { ErrorEvent, CloseEvent } = require_events(); + var { SendQueue } = require_sender(); + var WebSocket2 = class _WebSocket extends EventTarget { + #events = { + open: null, + error: null, + close: null, + message: null + }; + #bufferedAmount = 0; + #protocol = ""; + #extensions = ""; + /** @type {SendQueue} */ + #sendQueue; + /** + * @param {string} url + * @param {string|string[]} protocols + */ + constructor(url, protocols2 = []) { + super(); + webidl.util.markAsUncloneable(this); + const prefix = "WebSocket constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + const options = webidl.converters["DOMString or sequence or WebSocketInit"](protocols2, prefix, "options"); + url = webidl.converters.USVString(url, prefix, "url"); + protocols2 = options.protocols; + const baseURL = environmentSettingsObject.settingsObject.baseUrl; + let urlRecord; + try { + urlRecord = new URL(url, baseURL); + } catch (e2) { + throw new DOMException(e2, "SyntaxError"); + } + if (urlRecord.protocol === "http:") { + urlRecord.protocol = "ws:"; + } else if (urlRecord.protocol === "https:") { + urlRecord.protocol = "wss:"; + } + if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") { + throw new DOMException( + `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, + "SyntaxError" + ); + } + if (urlRecord.hash || urlRecord.href.endsWith("#")) { + throw new DOMException("Got fragment", "SyntaxError"); + } + if (typeof protocols2 === "string") { + protocols2 = [protocols2]; + } + if (protocols2.length !== new Set(protocols2.map((p) => p.toLowerCase())).size) { + throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + if (protocols2.length > 0 && !protocols2.every((p) => isValidSubprotocol(p))) { + throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + this[kWebSocketURL] = new URL(urlRecord.href); + const client = environmentSettingsObject.settingsObject; + this[kController] = establishWebSocketConnection( + urlRecord, + protocols2, + client, + this, + (response, extensions) => this.#onConnectionEstablished(response, extensions), + options + ); + this[kReadyState] = _WebSocket.CONNECTING; + this[kSentClose] = sentCloseFrameState.NOT_SENT; + this[kBinaryType] = "blob"; + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-close + * @param {number|undefined} code + * @param {string|undefined} reason + */ + close(code = void 0, reason = void 0) { + webidl.brandCheck(this, _WebSocket); + const prefix = "WebSocket.close"; + if (code !== void 0) { + code = webidl.converters["unsigned short"](code, prefix, "code", { clamp: true }); + } + if (reason !== void 0) { + reason = webidl.converters.USVString(reason, prefix, "reason"); + } + if (code !== void 0) { + if (code !== 1e3 && (code < 3e3 || code > 4999)) { + throw new DOMException("invalid code", "InvalidAccessError"); + } + } + let reasonByteLength = 0; + if (reason !== void 0) { + reasonByteLength = Buffer.byteLength(reason); + if (reasonByteLength > 123) { + throw new DOMException( + `Reason must be less than 123 bytes; received ${reasonByteLength}`, + "SyntaxError" + ); + } + } + closeWebSocketConnection(this, code, reason, reasonByteLength); + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-send + * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data + */ + send(data) { + webidl.brandCheck(this, _WebSocket); + const prefix = "WebSocket.send"; + webidl.argumentLengthCheck(arguments, 1, prefix); + data = webidl.converters.WebSocketSendData(data, prefix, "data"); + if (isConnecting(this)) { + throw new DOMException("Sent before connected.", "InvalidStateError"); + } + if (!isEstablished(this) || isClosing(this)) { + return; + } + if (typeof data === "string") { + const length = Buffer.byteLength(data); + this.#bufferedAmount += length; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= length; + }, sendHints.string); + } else if (types2.isArrayBuffer(data)) { + this.#bufferedAmount += data.byteLength; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= data.byteLength; + }, sendHints.arrayBuffer); + } else if (ArrayBuffer.isView(data)) { + this.#bufferedAmount += data.byteLength; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= data.byteLength; + }, sendHints.typedArray); + } else if (isBlobLike(data)) { + this.#bufferedAmount += data.size; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= data.size; + }, sendHints.blob); + } + } + get readyState() { + webidl.brandCheck(this, _WebSocket); + return this[kReadyState]; + } + get bufferedAmount() { + webidl.brandCheck(this, _WebSocket); + return this.#bufferedAmount; + } + get url() { + webidl.brandCheck(this, _WebSocket); + return URLSerializer(this[kWebSocketURL]); + } + get extensions() { + webidl.brandCheck(this, _WebSocket); + return this.#extensions; + } + get protocol() { + webidl.brandCheck(this, _WebSocket); + return this.#protocol; + } + get onopen() { + webidl.brandCheck(this, _WebSocket); + return this.#events.open; + } + set onopen(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.open) { + this.removeEventListener("open", this.#events.open); + } + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else { + this.#events.open = null; + } + } + get onerror() { + webidl.brandCheck(this, _WebSocket); + return this.#events.error; + } + set onerror(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.error) { + this.removeEventListener("error", this.#events.error); + } + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else { + this.#events.error = null; + } + } + get onclose() { + webidl.brandCheck(this, _WebSocket); + return this.#events.close; + } + set onclose(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.close) { + this.removeEventListener("close", this.#events.close); + } + if (typeof fn === "function") { + this.#events.close = fn; + this.addEventListener("close", fn); + } else { + this.#events.close = null; + } + } + get onmessage() { + webidl.brandCheck(this, _WebSocket); + return this.#events.message; + } + set onmessage(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.message) { + this.removeEventListener("message", this.#events.message); + } + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else { + this.#events.message = null; + } + } + get binaryType() { + webidl.brandCheck(this, _WebSocket); + return this[kBinaryType]; + } + set binaryType(type2) { + webidl.brandCheck(this, _WebSocket); + if (type2 !== "blob" && type2 !== "arraybuffer") { + this[kBinaryType] = "blob"; + } else { + this[kBinaryType] = type2; + } + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + */ + #onConnectionEstablished(response, parsedExtensions) { + this[kResponse] = response; + const parser = new ByteParser(this, parsedExtensions); + parser.on("drain", onParserDrain); + parser.on("error", onParserError.bind(this)); + response.socket.ws = this; + this[kByteParser] = parser; + this.#sendQueue = new SendQueue(response.socket); + this[kReadyState] = states.OPEN; + const extensions = response.headersList.get("sec-websocket-extensions"); + if (extensions !== null) { + this.#extensions = extensions; + } + const protocol = response.headersList.get("sec-websocket-protocol"); + if (protocol !== null) { + this.#protocol = protocol; + } + fireEvent("open", this); + } + }; + WebSocket2.CONNECTING = WebSocket2.prototype.CONNECTING = states.CONNECTING; + WebSocket2.OPEN = WebSocket2.prototype.OPEN = states.OPEN; + WebSocket2.CLOSING = WebSocket2.prototype.CLOSING = states.CLOSING; + WebSocket2.CLOSED = WebSocket2.prototype.CLOSED = states.CLOSED; + Object.defineProperties(WebSocket2.prototype, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors, + url: kEnumerableProperty, + readyState: kEnumerableProperty, + bufferedAmount: kEnumerableProperty, + onopen: kEnumerableProperty, + onerror: kEnumerableProperty, + onclose: kEnumerableProperty, + close: kEnumerableProperty, + onmessage: kEnumerableProperty, + binaryType: kEnumerableProperty, + send: kEnumerableProperty, + extensions: kEnumerableProperty, + protocol: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "WebSocket", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(WebSocket2, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors + }); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.DOMString + ); + webidl.converters["DOMString or sequence"] = function(V, prefix, argument) { + if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) { + return webidl.converters["sequence"](V); + } + return webidl.converters.DOMString(V, prefix, argument); + }; + webidl.converters.WebSocketInit = webidl.dictionaryConverter([ + { + key: "protocols", + converter: webidl.converters["DOMString or sequence"], + defaultValue: () => new Array(0) + }, + { + key: "dispatcher", + converter: webidl.converters.any, + defaultValue: () => getGlobalDispatcher() + }, + { + key: "headers", + converter: webidl.nullableConverter(webidl.converters.HeadersInit) + } + ]); + webidl.converters["DOMString or sequence or WebSocketInit"] = function(V) { + if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) { + return webidl.converters.WebSocketInit(V); + } + return { protocols: webidl.converters["DOMString or sequence"](V) }; + }; + webidl.converters.WebSocketSendData = function(V) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) { + return webidl.converters.BufferSource(V); + } + } + return webidl.converters.USVString(V); + }; + function onParserDrain() { + this.ws[kResponse].socket.resume(); + } + function onParserError(err) { + let message; + let code; + if (err instanceof CloseEvent) { + message = err.reason; + code = err.code; + } else { + message = err.message; + } + fireEvent("error", this, () => new ErrorEvent("error", { error: err, message })); + closeWebSocketConnection(this, code); + } + module.exports = { + WebSocket: WebSocket2 + }; + } +}); + +// node_modules/undici/lib/web/eventsource/util.js +var require_util8 = __commonJS({ + "node_modules/undici/lib/web/eventsource/util.js"(exports, module) { + "use strict"; + function isValidLastEventId(value) { + return value.indexOf("\0") === -1; + } + function isASCIINumber(value) { + if (value.length === 0) return false; + for (let i = 0; i < value.length; i++) { + if (value.charCodeAt(i) < 48 || value.charCodeAt(i) > 57) return false; + } + return true; + } + function delay(ms) { + return new Promise((resolve2) => { + setTimeout(resolve2, ms).unref(); + }); + } + module.exports = { + isValidLastEventId, + isASCIINumber, + delay + }; + } +}); + +// node_modules/undici/lib/web/eventsource/eventsource-stream.js +var require_eventsource_stream = __commonJS({ + "node_modules/undici/lib/web/eventsource/eventsource-stream.js"(exports, module) { + "use strict"; + var { Transform } = __require("node:stream"); + var { isASCIINumber, isValidLastEventId } = require_util8(); + var BOM = [239, 187, 191]; + var LF = 10; + var CR = 13; + var COLON = 58; + var SPACE = 32; + var EventSourceStream = class extends Transform { + /** + * @type {eventSourceSettings} + */ + state = null; + /** + * Leading byte-order-mark check. + * @type {boolean} + */ + checkBOM = true; + /** + * @type {boolean} + */ + crlfCheck = false; + /** + * @type {boolean} + */ + eventEndCheck = false; + /** + * @type {Buffer} + */ + buffer = null; + pos = 0; + event = { + data: void 0, + event: void 0, + id: void 0, + retry: void 0 + }; + /** + * @param {object} options + * @param {eventSourceSettings} options.eventSourceSettings + * @param {Function} [options.push] + */ + constructor(options = {}) { + options.readableObjectMode = true; + super(options); + this.state = options.eventSourceSettings || {}; + if (options.push) { + this.push = options.push; + } + } + /** + * @param {Buffer} chunk + * @param {string} _encoding + * @param {Function} callback + * @returns {void} + */ + _transform(chunk, _encoding, callback) { + if (chunk.length === 0) { + callback(); + return; + } + if (this.buffer) { + this.buffer = Buffer.concat([this.buffer, chunk]); + } else { + this.buffer = chunk; + } + if (this.checkBOM) { + switch (this.buffer.length) { + case 1: + if (this.buffer[0] === BOM[0]) { + callback(); + return; + } + this.checkBOM = false; + callback(); + return; + case 2: + if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1]) { + callback(); + return; + } + this.checkBOM = false; + break; + case 3: + if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) { + this.buffer = Buffer.alloc(0); + this.checkBOM = false; + callback(); + return; + } + this.checkBOM = false; + break; + default: + if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) { + this.buffer = this.buffer.subarray(3); + } + this.checkBOM = false; + break; + } + } + while (this.pos < this.buffer.length) { + if (this.eventEndCheck) { + if (this.crlfCheck) { + if (this.buffer[this.pos] === LF) { + this.buffer = this.buffer.subarray(this.pos + 1); + this.pos = 0; + this.crlfCheck = false; + continue; + } + this.crlfCheck = false; + } + if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (this.buffer[this.pos] === CR) { + this.crlfCheck = true; + } + this.buffer = this.buffer.subarray(this.pos + 1); + this.pos = 0; + if (this.event.data !== void 0 || this.event.event || this.event.id || this.event.retry) { + this.processEvent(this.event); + } + this.clearEvent(); + continue; + } + this.eventEndCheck = false; + continue; + } + if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (this.buffer[this.pos] === CR) { + this.crlfCheck = true; + } + this.parseLine(this.buffer.subarray(0, this.pos), this.event); + this.buffer = this.buffer.subarray(this.pos + 1); + this.pos = 0; + this.eventEndCheck = true; + continue; + } + this.pos++; + } + callback(); + } + /** + * @param {Buffer} line + * @param {EventStreamEvent} event + */ + parseLine(line, event) { + if (line.length === 0) { + return; + } + const colonPosition = line.indexOf(COLON); + if (colonPosition === 0) { + return; + } + let field = ""; + let value = ""; + if (colonPosition !== -1) { + field = line.subarray(0, colonPosition).toString("utf8"); + let valueStart = colonPosition + 1; + if (line[valueStart] === SPACE) { + ++valueStart; + } + value = line.subarray(valueStart).toString("utf8"); + } else { + field = line.toString("utf8"); + value = ""; + } + switch (field) { + case "data": + if (event[field] === void 0) { + event[field] = value; + } else { + event[field] += ` +${value}`; + } + break; + case "retry": + if (isASCIINumber(value)) { + event[field] = value; + } + break; + case "id": + if (isValidLastEventId(value)) { + event[field] = value; + } + break; + case "event": + if (value.length > 0) { + event[field] = value; + } + break; + } + } + /** + * @param {EventSourceStreamEvent} event + */ + processEvent(event) { + if (event.retry && isASCIINumber(event.retry)) { + this.state.reconnectionTime = parseInt(event.retry, 10); + } + if (event.id && isValidLastEventId(event.id)) { + this.state.lastEventId = event.id; + } + if (event.data !== void 0) { + this.push({ + type: event.event || "message", + options: { + data: event.data, + lastEventId: this.state.lastEventId, + origin: this.state.origin + } + }); + } + } + clearEvent() { + this.event = { + data: void 0, + event: void 0, + id: void 0, + retry: void 0 + }; + } + }; + module.exports = { + EventSourceStream + }; + } +}); + +// node_modules/undici/lib/web/eventsource/eventsource.js +var require_eventsource = __commonJS({ + "node_modules/undici/lib/web/eventsource/eventsource.js"(exports, module) { + "use strict"; + var { pipeline } = __require("node:stream"); + var { fetching } = require_fetch(); + var { makeRequest } = require_request2(); + var { webidl } = require_webidl(); + var { EventSourceStream } = require_eventsource_stream(); + var { parseMIMEType } = require_data_url(); + var { createFastMessageEvent } = require_events(); + var { isNetworkError } = require_response(); + var { delay } = require_util8(); + var { kEnumerableProperty } = require_util(); + var { environmentSettingsObject } = require_util2(); + var experimentalWarned = false; + var defaultReconnectionTime = 3e3; + var CONNECTING = 0; + var OPEN = 1; + var CLOSED = 2; + var ANONYMOUS = "anonymous"; + var USE_CREDENTIALS = "use-credentials"; + var EventSource = class _EventSource extends EventTarget { + #events = { + open: null, + error: null, + message: null + }; + #url = null; + #withCredentials = false; + #readyState = CONNECTING; + #request = null; + #controller = null; + #dispatcher; + /** + * @type {import('./eventsource-stream').eventSourceSettings} + */ + #state; + /** + * Creates a new EventSource object. + * @param {string} url + * @param {EventSourceInit} [eventSourceInitDict] + * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface + */ + constructor(url, eventSourceInitDict = {}) { + super(); + webidl.util.markAsUncloneable(this); + const prefix = "EventSource constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("EventSource is experimental, expect them to change at any time.", { + code: "UNDICI-ES" + }); + } + url = webidl.converters.USVString(url, prefix, "url"); + eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict, prefix, "eventSourceInitDict"); + this.#dispatcher = eventSourceInitDict.dispatcher; + this.#state = { + lastEventId: "", + reconnectionTime: defaultReconnectionTime + }; + const settings = environmentSettingsObject; + let urlRecord; + try { + urlRecord = new URL(url, settings.settingsObject.baseUrl); + this.#state.origin = urlRecord.origin; + } catch (e2) { + throw new DOMException(e2, "SyntaxError"); + } + this.#url = urlRecord.href; + let corsAttributeState = ANONYMOUS; + if (eventSourceInitDict.withCredentials) { + corsAttributeState = USE_CREDENTIALS; + this.#withCredentials = true; + } + const initRequest = { + redirect: "follow", + keepalive: true, + // @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes + mode: "cors", + credentials: corsAttributeState === "anonymous" ? "same-origin" : "omit", + referrer: "no-referrer" + }; + initRequest.client = environmentSettingsObject.settingsObject; + initRequest.headersList = [["accept", { name: "accept", value: "text/event-stream" }]]; + initRequest.cache = "no-store"; + initRequest.initiator = "other"; + initRequest.urlList = [new URL(this.#url)]; + this.#request = makeRequest(initRequest); + this.#connect(); + } + /** + * Returns the state of this EventSource object's connection. It can have the + * values described below. + * @returns {0|1|2} + * @readonly + */ + get readyState() { + return this.#readyState; + } + /** + * Returns the URL providing the event stream. + * @readonly + * @returns {string} + */ + get url() { + return this.#url; + } + /** + * Returns a boolean indicating whether the EventSource object was + * instantiated with CORS credentials set (true), or not (false, the default). + */ + get withCredentials() { + return this.#withCredentials; + } + #connect() { + if (this.#readyState === CLOSED) return; + this.#readyState = CONNECTING; + const fetchParams = { + request: this.#request, + dispatcher: this.#dispatcher + }; + const processEventSourceEndOfBody = (response) => { + if (isNetworkError(response)) { + this.dispatchEvent(new Event("error")); + this.close(); + } + this.#reconnect(); + }; + fetchParams.processResponseEndOfBody = processEventSourceEndOfBody; + fetchParams.processResponse = (response) => { + if (isNetworkError(response)) { + if (response.aborted) { + this.close(); + this.dispatchEvent(new Event("error")); + return; + } else { + this.#reconnect(); + return; + } + } + const contentType = response.headersList.get("content-type", true); + const mimeType = contentType !== null ? parseMIMEType(contentType) : "failure"; + const contentTypeValid = mimeType !== "failure" && mimeType.essence === "text/event-stream"; + if (response.status !== 200 || contentTypeValid === false) { + this.close(); + this.dispatchEvent(new Event("error")); + return; + } + this.#readyState = OPEN; + this.dispatchEvent(new Event("open")); + this.#state.origin = response.urlList[response.urlList.length - 1].origin; + const eventSourceStream = new EventSourceStream({ + eventSourceSettings: this.#state, + push: (event) => { + this.dispatchEvent(createFastMessageEvent( + event.type, + event.options + )); + } + }); + pipeline( + response.body.stream, + eventSourceStream, + (error2) => { + if (error2?.aborted === false) { + this.close(); + this.dispatchEvent(new Event("error")); + } + } + ); + }; + this.#controller = fetching(fetchParams); + } + /** + * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model + * @returns {Promise} + */ + async #reconnect() { + if (this.#readyState === CLOSED) return; + this.#readyState = CONNECTING; + this.dispatchEvent(new Event("error")); + await delay(this.#state.reconnectionTime); + if (this.#readyState !== CONNECTING) return; + if (this.#state.lastEventId.length) { + this.#request.headersList.set("last-event-id", this.#state.lastEventId, true); + } + this.#connect(); + } + /** + * Closes the connection, if any, and sets the readyState attribute to + * CLOSED. + */ + close() { + webidl.brandCheck(this, _EventSource); + if (this.#readyState === CLOSED) return; + this.#readyState = CLOSED; + this.#controller.abort(); + this.#request = null; + } + get onopen() { + return this.#events.open; + } + set onopen(fn) { + if (this.#events.open) { + this.removeEventListener("open", this.#events.open); + } + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else { + this.#events.open = null; + } + } + get onmessage() { + return this.#events.message; + } + set onmessage(fn) { + if (this.#events.message) { + this.removeEventListener("message", this.#events.message); + } + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else { + this.#events.message = null; + } + } + get onerror() { + return this.#events.error; + } + set onerror(fn) { + if (this.#events.error) { + this.removeEventListener("error", this.#events.error); + } + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else { + this.#events.error = null; + } + } + }; + var constantsPropertyDescriptors = { + CONNECTING: { + __proto__: null, + configurable: false, + enumerable: true, + value: CONNECTING, + writable: false + }, + OPEN: { + __proto__: null, + configurable: false, + enumerable: true, + value: OPEN, + writable: false + }, + CLOSED: { + __proto__: null, + configurable: false, + enumerable: true, + value: CLOSED, + writable: false + } + }; + Object.defineProperties(EventSource, constantsPropertyDescriptors); + Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors); + Object.defineProperties(EventSource.prototype, { + close: kEnumerableProperty, + onerror: kEnumerableProperty, + onmessage: kEnumerableProperty, + onopen: kEnumerableProperty, + readyState: kEnumerableProperty, + url: kEnumerableProperty, + withCredentials: kEnumerableProperty + }); + webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([ + { + key: "withCredentials", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "dispatcher", + // undici only + converter: webidl.converters.any + } + ]); + module.exports = { + EventSource, + defaultReconnectionTime + }; + } +}); + +// node_modules/undici/index.js +var require_undici = __commonJS({ + "node_modules/undici/index.js"(exports, module) { + "use strict"; + var Client = require_client(); + var Dispatcher = require_dispatcher(); + var Pool = require_pool(); + var BalancedPool = require_balanced_pool(); + var Agent = require_agent(); + var ProxyAgent2 = require_proxy_agent(); + var EnvHttpProxyAgent = require_env_http_proxy_agent(); + var RetryAgent = require_retry_agent(); + var errors = require_errors(); + var util2 = require_util(); + var { InvalidArgumentError } = errors; + var api = require_api(); + var buildConnector = require_connect(); + var MockClient = require_mock_client(); + var MockAgent = require_mock_agent(); + var MockPool = require_mock_pool(); + var mockErrors = require_mock_errors(); + var RetryHandler = require_retry_handler(); + var { getGlobalDispatcher, setGlobalDispatcher } = require_global2(); + var DecoratorHandler = require_decorator_handler(); + var RedirectHandler = require_redirect_handler(); + var createRedirectInterceptor = require_redirect_interceptor(); + Object.assign(Dispatcher.prototype, api); + module.exports.Dispatcher = Dispatcher; + module.exports.Client = Client; + module.exports.Pool = Pool; + module.exports.BalancedPool = BalancedPool; + module.exports.Agent = Agent; + module.exports.ProxyAgent = ProxyAgent2; + module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent; + module.exports.RetryAgent = RetryAgent; + module.exports.RetryHandler = RetryHandler; + module.exports.DecoratorHandler = DecoratorHandler; + module.exports.RedirectHandler = RedirectHandler; + module.exports.createRedirectInterceptor = createRedirectInterceptor; + module.exports.interceptors = { + redirect: require_redirect(), + retry: require_retry(), + dump: require_dump(), + dns: require_dns() + }; + module.exports.buildConnector = buildConnector; + module.exports.errors = errors; + module.exports.util = { + parseHeaders: util2.parseHeaders, + headerNameToString: util2.headerNameToString + }; + function makeDispatcher(fn) { + return (url, opts, handler) => { + if (typeof opts === "function") { + handler = opts; + opts = null; + } + if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) { + throw new InvalidArgumentError("invalid url"); + } + if (opts != null && typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (opts && opts.path != null) { + if (typeof opts.path !== "string") { + throw new InvalidArgumentError("invalid opts.path"); + } + let path7 = opts.path; + if (!opts.path.startsWith("/")) { + path7 = `/${path7}`; + } + url = new URL(util2.parseOrigin(url).origin + path7); + } else { + if (!opts) { + opts = typeof url === "object" ? url : {}; + } + url = util2.parseURL(url); + } + const { agent, dispatcher = getGlobalDispatcher() } = opts; + if (agent) { + throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?"); + } + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? "PUT" : "GET") + }, handler); + }; + } + module.exports.setGlobalDispatcher = setGlobalDispatcher; + module.exports.getGlobalDispatcher = getGlobalDispatcher; + var fetchImpl = require_fetch().fetch; + module.exports.fetch = async function fetch7(init, options = void 0) { + try { + return await fetchImpl(init, options); + } catch (err) { + if (err && typeof err === "object") { + Error.captureStackTrace(err); + } + throw err; + } + }; + module.exports.Headers = require_headers().Headers; + module.exports.Response = require_response().Response; + module.exports.Request = require_request2().Request; + module.exports.FormData = require_formdata().FormData; + module.exports.File = globalThis.File ?? __require("node:buffer").File; + module.exports.FileReader = require_filereader().FileReader; + var { setGlobalOrigin, getGlobalOrigin } = require_global(); + module.exports.setGlobalOrigin = setGlobalOrigin; + module.exports.getGlobalOrigin = getGlobalOrigin; + var { CacheStorage } = require_cachestorage(); + var { kConstruct } = require_symbols4(); + module.exports.caches = new CacheStorage(kConstruct); + var { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies(); + module.exports.deleteCookie = deleteCookie; + module.exports.getCookies = getCookies; + module.exports.getSetCookies = getSetCookies; + module.exports.setCookie = setCookie; + var { parseMIMEType, serializeAMimeType } = require_data_url(); + module.exports.parseMIMEType = parseMIMEType; + module.exports.serializeAMimeType = serializeAMimeType; + var { CloseEvent, ErrorEvent, MessageEvent } = require_events(); + module.exports.WebSocket = require_websocket().WebSocket; + module.exports.CloseEvent = CloseEvent; + module.exports.ErrorEvent = ErrorEvent; + module.exports.MessageEvent = MessageEvent; + module.exports.request = makeDispatcher(api.request); + module.exports.stream = makeDispatcher(api.stream); + module.exports.pipeline = makeDispatcher(api.pipeline); + module.exports.connect = makeDispatcher(api.connect); + module.exports.upgrade = makeDispatcher(api.upgrade); + module.exports.MockClient = MockClient; + module.exports.MockPool = MockPool; + module.exports.MockAgent = MockAgent; + module.exports.mockErrors = mockErrors; + var { EventSource } = require_eventsource(); + module.exports.EventSource = EventSource; + } +}); + +// node_modules/webidl-conversions/lib/index.js +var require_lib = __commonJS({ + "node_modules/webidl-conversions/lib/index.js"(exports, module) { + "use strict"; + var conversions = {}; + module.exports = conversions; + function sign(x) { + return x < 0 ? -1 : 1; + } + function evenRound(x) { + if (x % 1 === 0.5 && (x & 1) === 0) { + return Math.floor(x); + } else { + return Math.round(x); + } + } + function createNumberConversion(bitLength, typeOpts) { + if (!typeOpts.unsigned) { + --bitLength; + } + const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength); + const upperBound = Math.pow(2, bitLength) - 1; + const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength); + const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1); + return function(V, opts) { + if (!opts) opts = {}; + let x = +V; + if (opts.enforceRange) { + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite number"); + } + x = sign(x) * Math.floor(Math.abs(x)); + if (x < lowerBound || x > upperBound) { + throw new TypeError("Argument is not in byte range"); + } + return x; + } + if (!isNaN(x) && opts.clamp) { + x = evenRound(x); + if (x < lowerBound) x = lowerBound; + if (x > upperBound) x = upperBound; + return x; + } + if (!Number.isFinite(x) || x === 0) { + return 0; + } + x = sign(x) * Math.floor(Math.abs(x)); + x = x % moduloVal; + if (!typeOpts.unsigned && x >= moduloBound) { + return x - moduloVal; + } else if (typeOpts.unsigned) { + if (x < 0) { + x += moduloVal; + } else if (x === -0) { + return 0; + } + } + return x; + }; + } + conversions["void"] = function() { + return void 0; + }; + conversions["boolean"] = function(val) { + return !!val; + }; + conversions["byte"] = createNumberConversion(8, { unsigned: false }); + conversions["octet"] = createNumberConversion(8, { unsigned: true }); + conversions["short"] = createNumberConversion(16, { unsigned: false }); + conversions["unsigned short"] = createNumberConversion(16, { unsigned: true }); + conversions["long"] = createNumberConversion(32, { unsigned: false }); + conversions["unsigned long"] = createNumberConversion(32, { unsigned: true }); + conversions["long long"] = createNumberConversion(32, { unsigned: false, moduloBitLength: 64 }); + conversions["unsigned long long"] = createNumberConversion(32, { unsigned: true, moduloBitLength: 64 }); + conversions["double"] = function(V) { + const x = +V; + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite floating-point value"); + } + return x; + }; + conversions["unrestricted double"] = function(V) { + const x = +V; + if (isNaN(x)) { + throw new TypeError("Argument is NaN"); + } + return x; + }; + conversions["float"] = conversions["double"]; + conversions["unrestricted float"] = conversions["unrestricted double"]; + conversions["DOMString"] = function(V, opts) { + if (!opts) opts = {}; + if (opts.treatNullAsEmptyString && V === null) { + return ""; + } + return String(V); + }; + conversions["ByteString"] = function(V, opts) { + const x = String(V); + let c = void 0; + for (let i = 0; (c = x.codePointAt(i)) !== void 0; ++i) { + if (c > 255) { + throw new TypeError("Argument is not a valid bytestring"); + } + } + return x; + }; + conversions["USVString"] = function(V) { + const S = String(V); + const n = S.length; + const U = []; + for (let i = 0; i < n; ++i) { + const c = S.charCodeAt(i); + if (c < 55296 || c > 57343) { + U.push(String.fromCodePoint(c)); + } else if (56320 <= c && c <= 57343) { + U.push(String.fromCodePoint(65533)); + } else { + if (i === n - 1) { + U.push(String.fromCodePoint(65533)); + } else { + const d = S.charCodeAt(i + 1); + if (56320 <= d && d <= 57343) { + const a = c & 1023; + const b = d & 1023; + U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b)); + ++i; + } else { + U.push(String.fromCodePoint(65533)); + } + } + } + } + return U.join(""); + }; + conversions["Date"] = function(V, opts) { + if (!(V instanceof Date)) { + throw new TypeError("Argument is not a Date object"); + } + if (isNaN(V)) { + return void 0; + } + return V; + }; + conversions["RegExp"] = function(V, opts) { + if (!(V instanceof RegExp)) { + V = new RegExp(V); + } + return V; + }; + } +}); + +// node_modules/whatwg-url/lib/utils.js +var require_utils2 = __commonJS({ + "node_modules/whatwg-url/lib/utils.js"(exports, module) { + "use strict"; + module.exports.mixin = function mixin(target, source) { + const keys = Object.getOwnPropertyNames(source); + for (let i = 0; i < keys.length; ++i) { + Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i])); + } + }; + module.exports.wrapperSymbol = /* @__PURE__ */ Symbol("wrapper"); + module.exports.implSymbol = /* @__PURE__ */ Symbol("impl"); + module.exports.wrapperForImpl = function(impl) { + return impl[module.exports.wrapperSymbol]; + }; + module.exports.implForWrapper = function(wrapper) { + return wrapper[module.exports.implSymbol]; + }; + } +}); + +// node_modules/tr46/lib/mappingTable.json +var require_mappingTable = __commonJS({ + "node_modules/tr46/lib/mappingTable.json"(exports, module) { + module.exports = [[[0, 44], "disallowed_STD3_valid"], [[45, 46], "valid"], [[47, 47], "disallowed_STD3_valid"], [[48, 57], "valid"], [[58, 64], "disallowed_STD3_valid"], [[65, 65], "mapped", [97]], [[66, 66], "mapped", [98]], [[67, 67], "mapped", [99]], [[68, 68], "mapped", [100]], [[69, 69], "mapped", [101]], [[70, 70], "mapped", [102]], [[71, 71], "mapped", [103]], [[72, 72], "mapped", [104]], [[73, 73], "mapped", [105]], [[74, 74], "mapped", [106]], [[75, 75], "mapped", [107]], [[76, 76], "mapped", [108]], [[77, 77], "mapped", [109]], [[78, 78], "mapped", [110]], [[79, 79], "mapped", [111]], [[80, 80], "mapped", [112]], [[81, 81], "mapped", [113]], [[82, 82], "mapped", [114]], [[83, 83], "mapped", [115]], [[84, 84], "mapped", [116]], [[85, 85], "mapped", [117]], [[86, 86], "mapped", [118]], [[87, 87], "mapped", [119]], [[88, 88], "mapped", [120]], [[89, 89], "mapped", [121]], [[90, 90], "mapped", [122]], [[91, 96], "disallowed_STD3_valid"], [[97, 122], "valid"], [[123, 127], "disallowed_STD3_valid"], [[128, 159], "disallowed"], [[160, 160], "disallowed_STD3_mapped", [32]], [[161, 167], "valid", [], "NV8"], [[168, 168], "disallowed_STD3_mapped", [32, 776]], [[169, 169], "valid", [], "NV8"], [[170, 170], "mapped", [97]], [[171, 172], "valid", [], "NV8"], [[173, 173], "ignored"], [[174, 174], "valid", [], "NV8"], [[175, 175], "disallowed_STD3_mapped", [32, 772]], [[176, 177], "valid", [], "NV8"], [[178, 178], "mapped", [50]], [[179, 179], "mapped", [51]], [[180, 180], "disallowed_STD3_mapped", [32, 769]], [[181, 181], "mapped", [956]], [[182, 182], "valid", [], "NV8"], [[183, 183], "valid"], [[184, 184], "disallowed_STD3_mapped", [32, 807]], [[185, 185], "mapped", [49]], [[186, 186], "mapped", [111]], [[187, 187], "valid", [], "NV8"], [[188, 188], "mapped", [49, 8260, 52]], [[189, 189], "mapped", [49, 8260, 50]], [[190, 190], "mapped", [51, 8260, 52]], [[191, 191], "valid", [], "NV8"], [[192, 192], "mapped", [224]], [[193, 193], "mapped", [225]], [[194, 194], "mapped", [226]], [[195, 195], "mapped", [227]], [[196, 196], "mapped", [228]], [[197, 197], "mapped", [229]], [[198, 198], "mapped", [230]], [[199, 199], "mapped", [231]], [[200, 200], "mapped", [232]], [[201, 201], "mapped", [233]], [[202, 202], "mapped", [234]], [[203, 203], "mapped", [235]], [[204, 204], "mapped", [236]], [[205, 205], "mapped", [237]], [[206, 206], "mapped", [238]], [[207, 207], "mapped", [239]], [[208, 208], "mapped", [240]], [[209, 209], "mapped", [241]], [[210, 210], "mapped", [242]], [[211, 211], "mapped", [243]], [[212, 212], "mapped", [244]], [[213, 213], "mapped", [245]], [[214, 214], "mapped", [246]], [[215, 215], "valid", [], "NV8"], [[216, 216], "mapped", [248]], [[217, 217], "mapped", [249]], [[218, 218], "mapped", [250]], [[219, 219], "mapped", [251]], [[220, 220], "mapped", [252]], [[221, 221], "mapped", [253]], [[222, 222], "mapped", [254]], [[223, 223], "deviation", [115, 115]], [[224, 246], "valid"], [[247, 247], "valid", [], "NV8"], [[248, 255], "valid"], [[256, 256], "mapped", [257]], [[257, 257], "valid"], [[258, 258], "mapped", [259]], [[259, 259], "valid"], [[260, 260], "mapped", [261]], [[261, 261], "valid"], [[262, 262], "mapped", [263]], [[263, 263], "valid"], [[264, 264], "mapped", [265]], [[265, 265], "valid"], [[266, 266], "mapped", [267]], [[267, 267], "valid"], [[268, 268], "mapped", [269]], [[269, 269], "valid"], [[270, 270], "mapped", [271]], [[271, 271], "valid"], [[272, 272], "mapped", [273]], [[273, 273], "valid"], [[274, 274], "mapped", [275]], [[275, 275], "valid"], [[276, 276], "mapped", [277]], [[277, 277], "valid"], [[278, 278], "mapped", [279]], [[279, 279], "valid"], [[280, 280], "mapped", [281]], [[281, 281], "valid"], [[282, 282], "mapped", [283]], [[283, 283], "valid"], [[284, 284], "mapped", [285]], [[285, 285], "valid"], [[286, 286], "mapped", [287]], [[287, 287], "valid"], [[288, 288], "mapped", [289]], [[289, 289], "valid"], [[290, 290], "mapped", [291]], [[291, 291], "valid"], [[292, 292], "mapped", [293]], [[293, 293], "valid"], [[294, 294], "mapped", [295]], [[295, 295], "valid"], [[296, 296], "mapped", [297]], [[297, 297], "valid"], [[298, 298], "mapped", [299]], [[299, 299], "valid"], [[300, 300], "mapped", [301]], [[301, 301], "valid"], [[302, 302], "mapped", [303]], [[303, 303], "valid"], [[304, 304], "mapped", [105, 775]], [[305, 305], "valid"], [[306, 307], "mapped", [105, 106]], [[308, 308], "mapped", [309]], [[309, 309], "valid"], [[310, 310], "mapped", [311]], [[311, 312], "valid"], [[313, 313], "mapped", [314]], [[314, 314], "valid"], [[315, 315], "mapped", [316]], [[316, 316], "valid"], [[317, 317], "mapped", [318]], [[318, 318], "valid"], [[319, 320], "mapped", [108, 183]], [[321, 321], "mapped", [322]], [[322, 322], "valid"], [[323, 323], "mapped", [324]], [[324, 324], "valid"], [[325, 325], "mapped", [326]], [[326, 326], "valid"], [[327, 327], "mapped", [328]], [[328, 328], "valid"], [[329, 329], "mapped", [700, 110]], [[330, 330], "mapped", [331]], [[331, 331], "valid"], [[332, 332], "mapped", [333]], [[333, 333], "valid"], [[334, 334], "mapped", [335]], [[335, 335], "valid"], [[336, 336], "mapped", [337]], [[337, 337], "valid"], [[338, 338], "mapped", [339]], [[339, 339], "valid"], [[340, 340], "mapped", [341]], [[341, 341], "valid"], [[342, 342], "mapped", [343]], [[343, 343], "valid"], [[344, 344], "mapped", [345]], [[345, 345], "valid"], [[346, 346], "mapped", [347]], [[347, 347], "valid"], [[348, 348], "mapped", [349]], [[349, 349], "valid"], [[350, 350], "mapped", [351]], [[351, 351], "valid"], [[352, 352], "mapped", [353]], [[353, 353], "valid"], [[354, 354], "mapped", [355]], [[355, 355], "valid"], [[356, 356], "mapped", [357]], [[357, 357], "valid"], [[358, 358], "mapped", [359]], [[359, 359], "valid"], [[360, 360], "mapped", [361]], [[361, 361], "valid"], [[362, 362], "mapped", [363]], [[363, 363], "valid"], [[364, 364], "mapped", [365]], [[365, 365], "valid"], [[366, 366], "mapped", [367]], [[367, 367], "valid"], [[368, 368], "mapped", [369]], [[369, 369], "valid"], [[370, 370], "mapped", [371]], [[371, 371], "valid"], [[372, 372], "mapped", [373]], [[373, 373], "valid"], [[374, 374], "mapped", [375]], [[375, 375], "valid"], [[376, 376], "mapped", [255]], [[377, 377], "mapped", [378]], [[378, 378], "valid"], [[379, 379], "mapped", [380]], [[380, 380], "valid"], [[381, 381], "mapped", [382]], [[382, 382], "valid"], [[383, 383], "mapped", [115]], [[384, 384], "valid"], [[385, 385], "mapped", [595]], [[386, 386], "mapped", [387]], [[387, 387], "valid"], [[388, 388], "mapped", [389]], [[389, 389], "valid"], [[390, 390], "mapped", [596]], [[391, 391], "mapped", [392]], [[392, 392], "valid"], [[393, 393], "mapped", [598]], [[394, 394], "mapped", [599]], [[395, 395], "mapped", [396]], [[396, 397], "valid"], [[398, 398], "mapped", [477]], [[399, 399], "mapped", [601]], [[400, 400], "mapped", [603]], [[401, 401], "mapped", [402]], [[402, 402], "valid"], [[403, 403], "mapped", [608]], [[404, 404], "mapped", [611]], [[405, 405], "valid"], [[406, 406], "mapped", [617]], [[407, 407], "mapped", [616]], [[408, 408], "mapped", [409]], [[409, 411], "valid"], [[412, 412], "mapped", [623]], [[413, 413], "mapped", [626]], [[414, 414], "valid"], [[415, 415], "mapped", [629]], [[416, 416], "mapped", [417]], [[417, 417], "valid"], [[418, 418], "mapped", [419]], [[419, 419], "valid"], [[420, 420], "mapped", [421]], [[421, 421], "valid"], [[422, 422], "mapped", [640]], [[423, 423], "mapped", [424]], [[424, 424], "valid"], [[425, 425], "mapped", [643]], [[426, 427], "valid"], [[428, 428], "mapped", [429]], [[429, 429], "valid"], [[430, 430], "mapped", [648]], [[431, 431], "mapped", [432]], [[432, 432], "valid"], [[433, 433], "mapped", [650]], [[434, 434], "mapped", [651]], [[435, 435], "mapped", [436]], [[436, 436], "valid"], [[437, 437], "mapped", [438]], [[438, 438], "valid"], [[439, 439], "mapped", [658]], [[440, 440], "mapped", [441]], [[441, 443], "valid"], [[444, 444], "mapped", [445]], [[445, 451], "valid"], [[452, 454], "mapped", [100, 382]], [[455, 457], "mapped", [108, 106]], [[458, 460], "mapped", [110, 106]], [[461, 461], "mapped", [462]], [[462, 462], "valid"], [[463, 463], "mapped", [464]], [[464, 464], "valid"], [[465, 465], "mapped", [466]], [[466, 466], "valid"], [[467, 467], "mapped", [468]], [[468, 468], "valid"], [[469, 469], "mapped", [470]], [[470, 470], "valid"], [[471, 471], "mapped", [472]], [[472, 472], "valid"], [[473, 473], "mapped", [474]], [[474, 474], "valid"], [[475, 475], "mapped", [476]], [[476, 477], "valid"], [[478, 478], "mapped", [479]], [[479, 479], "valid"], [[480, 480], "mapped", [481]], [[481, 481], "valid"], [[482, 482], "mapped", [483]], [[483, 483], "valid"], [[484, 484], "mapped", [485]], [[485, 485], "valid"], [[486, 486], "mapped", [487]], [[487, 487], "valid"], [[488, 488], "mapped", [489]], [[489, 489], "valid"], [[490, 490], "mapped", [491]], [[491, 491], "valid"], [[492, 492], "mapped", [493]], [[493, 493], "valid"], [[494, 494], "mapped", [495]], [[495, 496], "valid"], [[497, 499], "mapped", [100, 122]], [[500, 500], "mapped", [501]], [[501, 501], "valid"], [[502, 502], "mapped", [405]], [[503, 503], "mapped", [447]], [[504, 504], "mapped", [505]], [[505, 505], "valid"], [[506, 506], "mapped", [507]], [[507, 507], "valid"], [[508, 508], "mapped", [509]], [[509, 509], "valid"], [[510, 510], "mapped", [511]], [[511, 511], "valid"], [[512, 512], "mapped", [513]], [[513, 513], "valid"], [[514, 514], "mapped", [515]], [[515, 515], "valid"], [[516, 516], "mapped", [517]], [[517, 517], "valid"], [[518, 518], "mapped", [519]], [[519, 519], "valid"], [[520, 520], "mapped", [521]], [[521, 521], "valid"], [[522, 522], "mapped", [523]], [[523, 523], "valid"], [[524, 524], "mapped", [525]], [[525, 525], "valid"], [[526, 526], "mapped", [527]], [[527, 527], "valid"], [[528, 528], "mapped", [529]], [[529, 529], "valid"], [[530, 530], "mapped", [531]], [[531, 531], "valid"], [[532, 532], "mapped", [533]], [[533, 533], "valid"], [[534, 534], "mapped", [535]], [[535, 535], "valid"], [[536, 536], "mapped", [537]], [[537, 537], "valid"], [[538, 538], "mapped", [539]], [[539, 539], "valid"], [[540, 540], "mapped", [541]], [[541, 541], "valid"], [[542, 542], "mapped", [543]], [[543, 543], "valid"], [[544, 544], "mapped", [414]], [[545, 545], "valid"], [[546, 546], "mapped", [547]], [[547, 547], "valid"], [[548, 548], "mapped", [549]], [[549, 549], "valid"], [[550, 550], "mapped", [551]], [[551, 551], "valid"], [[552, 552], "mapped", [553]], [[553, 553], "valid"], [[554, 554], "mapped", [555]], [[555, 555], "valid"], [[556, 556], "mapped", [557]], [[557, 557], "valid"], [[558, 558], "mapped", [559]], [[559, 559], "valid"], [[560, 560], "mapped", [561]], [[561, 561], "valid"], [[562, 562], "mapped", [563]], [[563, 563], "valid"], [[564, 566], "valid"], [[567, 569], "valid"], [[570, 570], "mapped", [11365]], [[571, 571], "mapped", [572]], [[572, 572], "valid"], [[573, 573], "mapped", [410]], [[574, 574], "mapped", [11366]], [[575, 576], "valid"], [[577, 577], "mapped", [578]], [[578, 578], "valid"], [[579, 579], "mapped", [384]], [[580, 580], "mapped", [649]], [[581, 581], "mapped", [652]], [[582, 582], "mapped", [583]], [[583, 583], "valid"], [[584, 584], "mapped", [585]], [[585, 585], "valid"], [[586, 586], "mapped", [587]], [[587, 587], "valid"], [[588, 588], "mapped", [589]], [[589, 589], "valid"], [[590, 590], "mapped", [591]], [[591, 591], "valid"], [[592, 680], "valid"], [[681, 685], "valid"], [[686, 687], "valid"], [[688, 688], "mapped", [104]], [[689, 689], "mapped", [614]], [[690, 690], "mapped", [106]], [[691, 691], "mapped", [114]], [[692, 692], "mapped", [633]], [[693, 693], "mapped", [635]], [[694, 694], "mapped", [641]], [[695, 695], "mapped", [119]], [[696, 696], "mapped", [121]], [[697, 705], "valid"], [[706, 709], "valid", [], "NV8"], [[710, 721], "valid"], [[722, 727], "valid", [], "NV8"], [[728, 728], "disallowed_STD3_mapped", [32, 774]], [[729, 729], "disallowed_STD3_mapped", [32, 775]], [[730, 730], "disallowed_STD3_mapped", [32, 778]], [[731, 731], "disallowed_STD3_mapped", [32, 808]], [[732, 732], "disallowed_STD3_mapped", [32, 771]], [[733, 733], "disallowed_STD3_mapped", [32, 779]], [[734, 734], "valid", [], "NV8"], [[735, 735], "valid", [], "NV8"], [[736, 736], "mapped", [611]], [[737, 737], "mapped", [108]], [[738, 738], "mapped", [115]], [[739, 739], "mapped", [120]], [[740, 740], "mapped", [661]], [[741, 745], "valid", [], "NV8"], [[746, 747], "valid", [], "NV8"], [[748, 748], "valid"], [[749, 749], "valid", [], "NV8"], [[750, 750], "valid"], [[751, 767], "valid", [], "NV8"], [[768, 831], "valid"], [[832, 832], "mapped", [768]], [[833, 833], "mapped", [769]], [[834, 834], "valid"], [[835, 835], "mapped", [787]], [[836, 836], "mapped", [776, 769]], [[837, 837], "mapped", [953]], [[838, 846], "valid"], [[847, 847], "ignored"], [[848, 855], "valid"], [[856, 860], "valid"], [[861, 863], "valid"], [[864, 865], "valid"], [[866, 866], "valid"], [[867, 879], "valid"], [[880, 880], "mapped", [881]], [[881, 881], "valid"], [[882, 882], "mapped", [883]], [[883, 883], "valid"], [[884, 884], "mapped", [697]], [[885, 885], "valid"], [[886, 886], "mapped", [887]], [[887, 887], "valid"], [[888, 889], "disallowed"], [[890, 890], "disallowed_STD3_mapped", [32, 953]], [[891, 893], "valid"], [[894, 894], "disallowed_STD3_mapped", [59]], [[895, 895], "mapped", [1011]], [[896, 899], "disallowed"], [[900, 900], "disallowed_STD3_mapped", [32, 769]], [[901, 901], "disallowed_STD3_mapped", [32, 776, 769]], [[902, 902], "mapped", [940]], [[903, 903], "mapped", [183]], [[904, 904], "mapped", [941]], [[905, 905], "mapped", [942]], [[906, 906], "mapped", [943]], [[907, 907], "disallowed"], [[908, 908], "mapped", [972]], [[909, 909], "disallowed"], [[910, 910], "mapped", [973]], [[911, 911], "mapped", [974]], [[912, 912], "valid"], [[913, 913], "mapped", [945]], [[914, 914], "mapped", [946]], [[915, 915], "mapped", [947]], [[916, 916], "mapped", [948]], [[917, 917], "mapped", [949]], [[918, 918], "mapped", [950]], [[919, 919], "mapped", [951]], [[920, 920], "mapped", [952]], [[921, 921], "mapped", [953]], [[922, 922], "mapped", [954]], [[923, 923], "mapped", [955]], [[924, 924], "mapped", [956]], [[925, 925], "mapped", [957]], [[926, 926], "mapped", [958]], [[927, 927], "mapped", [959]], [[928, 928], "mapped", [960]], [[929, 929], "mapped", [961]], [[930, 930], "disallowed"], [[931, 931], "mapped", [963]], [[932, 932], "mapped", [964]], [[933, 933], "mapped", [965]], [[934, 934], "mapped", [966]], [[935, 935], "mapped", [967]], [[936, 936], "mapped", [968]], [[937, 937], "mapped", [969]], [[938, 938], "mapped", [970]], [[939, 939], "mapped", [971]], [[940, 961], "valid"], [[962, 962], "deviation", [963]], [[963, 974], "valid"], [[975, 975], "mapped", [983]], [[976, 976], "mapped", [946]], [[977, 977], "mapped", [952]], [[978, 978], "mapped", [965]], [[979, 979], "mapped", [973]], [[980, 980], "mapped", [971]], [[981, 981], "mapped", [966]], [[982, 982], "mapped", [960]], [[983, 983], "valid"], [[984, 984], "mapped", [985]], [[985, 985], "valid"], [[986, 986], "mapped", [987]], [[987, 987], "valid"], [[988, 988], "mapped", [989]], [[989, 989], "valid"], [[990, 990], "mapped", [991]], [[991, 991], "valid"], [[992, 992], "mapped", [993]], [[993, 993], "valid"], [[994, 994], "mapped", [995]], [[995, 995], "valid"], [[996, 996], "mapped", [997]], [[997, 997], "valid"], [[998, 998], "mapped", [999]], [[999, 999], "valid"], [[1e3, 1e3], "mapped", [1001]], [[1001, 1001], "valid"], [[1002, 1002], "mapped", [1003]], [[1003, 1003], "valid"], [[1004, 1004], "mapped", [1005]], [[1005, 1005], "valid"], [[1006, 1006], "mapped", [1007]], [[1007, 1007], "valid"], [[1008, 1008], "mapped", [954]], [[1009, 1009], "mapped", [961]], [[1010, 1010], "mapped", [963]], [[1011, 1011], "valid"], [[1012, 1012], "mapped", [952]], [[1013, 1013], "mapped", [949]], [[1014, 1014], "valid", [], "NV8"], [[1015, 1015], "mapped", [1016]], [[1016, 1016], "valid"], [[1017, 1017], "mapped", [963]], [[1018, 1018], "mapped", [1019]], [[1019, 1019], "valid"], [[1020, 1020], "valid"], [[1021, 1021], "mapped", [891]], [[1022, 1022], "mapped", [892]], [[1023, 1023], "mapped", [893]], [[1024, 1024], "mapped", [1104]], [[1025, 1025], "mapped", [1105]], [[1026, 1026], "mapped", [1106]], [[1027, 1027], "mapped", [1107]], [[1028, 1028], "mapped", [1108]], [[1029, 1029], "mapped", [1109]], [[1030, 1030], "mapped", [1110]], [[1031, 1031], "mapped", [1111]], [[1032, 1032], "mapped", [1112]], [[1033, 1033], "mapped", [1113]], [[1034, 1034], "mapped", [1114]], [[1035, 1035], "mapped", [1115]], [[1036, 1036], "mapped", [1116]], [[1037, 1037], "mapped", [1117]], [[1038, 1038], "mapped", [1118]], [[1039, 1039], "mapped", [1119]], [[1040, 1040], "mapped", [1072]], [[1041, 1041], "mapped", [1073]], [[1042, 1042], "mapped", [1074]], [[1043, 1043], "mapped", [1075]], [[1044, 1044], "mapped", [1076]], [[1045, 1045], "mapped", [1077]], [[1046, 1046], "mapped", [1078]], [[1047, 1047], "mapped", [1079]], [[1048, 1048], "mapped", [1080]], [[1049, 1049], "mapped", [1081]], [[1050, 1050], "mapped", [1082]], [[1051, 1051], "mapped", [1083]], [[1052, 1052], "mapped", [1084]], [[1053, 1053], "mapped", [1085]], [[1054, 1054], "mapped", [1086]], [[1055, 1055], "mapped", [1087]], [[1056, 1056], "mapped", [1088]], [[1057, 1057], "mapped", [1089]], [[1058, 1058], "mapped", [1090]], [[1059, 1059], "mapped", [1091]], [[1060, 1060], "mapped", [1092]], [[1061, 1061], "mapped", [1093]], [[1062, 1062], "mapped", [1094]], [[1063, 1063], "mapped", [1095]], [[1064, 1064], "mapped", [1096]], [[1065, 1065], "mapped", [1097]], [[1066, 1066], "mapped", [1098]], [[1067, 1067], "mapped", [1099]], [[1068, 1068], "mapped", [1100]], [[1069, 1069], "mapped", [1101]], [[1070, 1070], "mapped", [1102]], [[1071, 1071], "mapped", [1103]], [[1072, 1103], "valid"], [[1104, 1104], "valid"], [[1105, 1116], "valid"], [[1117, 1117], "valid"], [[1118, 1119], "valid"], [[1120, 1120], "mapped", [1121]], [[1121, 1121], "valid"], [[1122, 1122], "mapped", [1123]], [[1123, 1123], "valid"], [[1124, 1124], "mapped", [1125]], [[1125, 1125], "valid"], [[1126, 1126], "mapped", [1127]], [[1127, 1127], "valid"], [[1128, 1128], "mapped", [1129]], [[1129, 1129], "valid"], [[1130, 1130], "mapped", [1131]], [[1131, 1131], "valid"], [[1132, 1132], "mapped", [1133]], [[1133, 1133], "valid"], [[1134, 1134], "mapped", [1135]], [[1135, 1135], "valid"], [[1136, 1136], "mapped", [1137]], [[1137, 1137], "valid"], [[1138, 1138], "mapped", [1139]], [[1139, 1139], "valid"], [[1140, 1140], "mapped", [1141]], [[1141, 1141], "valid"], [[1142, 1142], "mapped", [1143]], [[1143, 1143], "valid"], [[1144, 1144], "mapped", [1145]], [[1145, 1145], "valid"], [[1146, 1146], "mapped", [1147]], [[1147, 1147], "valid"], [[1148, 1148], "mapped", [1149]], [[1149, 1149], "valid"], [[1150, 1150], "mapped", [1151]], [[1151, 1151], "valid"], [[1152, 1152], "mapped", [1153]], [[1153, 1153], "valid"], [[1154, 1154], "valid", [], "NV8"], [[1155, 1158], "valid"], [[1159, 1159], "valid"], [[1160, 1161], "valid", [], "NV8"], [[1162, 1162], "mapped", [1163]], [[1163, 1163], "valid"], [[1164, 1164], "mapped", [1165]], [[1165, 1165], "valid"], [[1166, 1166], "mapped", [1167]], [[1167, 1167], "valid"], [[1168, 1168], "mapped", [1169]], [[1169, 1169], "valid"], [[1170, 1170], "mapped", [1171]], [[1171, 1171], "valid"], [[1172, 1172], "mapped", [1173]], [[1173, 1173], "valid"], [[1174, 1174], "mapped", [1175]], [[1175, 1175], "valid"], [[1176, 1176], "mapped", [1177]], [[1177, 1177], "valid"], [[1178, 1178], "mapped", [1179]], [[1179, 1179], "valid"], [[1180, 1180], "mapped", [1181]], [[1181, 1181], "valid"], [[1182, 1182], "mapped", [1183]], [[1183, 1183], "valid"], [[1184, 1184], "mapped", [1185]], [[1185, 1185], "valid"], [[1186, 1186], "mapped", [1187]], [[1187, 1187], "valid"], [[1188, 1188], "mapped", [1189]], [[1189, 1189], "valid"], [[1190, 1190], "mapped", [1191]], [[1191, 1191], "valid"], [[1192, 1192], "mapped", [1193]], [[1193, 1193], "valid"], [[1194, 1194], "mapped", [1195]], [[1195, 1195], "valid"], [[1196, 1196], "mapped", [1197]], [[1197, 1197], "valid"], [[1198, 1198], "mapped", [1199]], [[1199, 1199], "valid"], [[1200, 1200], "mapped", [1201]], [[1201, 1201], "valid"], [[1202, 1202], "mapped", [1203]], [[1203, 1203], "valid"], [[1204, 1204], "mapped", [1205]], [[1205, 1205], "valid"], [[1206, 1206], "mapped", [1207]], [[1207, 1207], "valid"], [[1208, 1208], "mapped", [1209]], [[1209, 1209], "valid"], [[1210, 1210], "mapped", [1211]], [[1211, 1211], "valid"], [[1212, 1212], "mapped", [1213]], [[1213, 1213], "valid"], [[1214, 1214], "mapped", [1215]], [[1215, 1215], "valid"], [[1216, 1216], "disallowed"], [[1217, 1217], "mapped", [1218]], [[1218, 1218], "valid"], [[1219, 1219], "mapped", [1220]], [[1220, 1220], "valid"], [[1221, 1221], "mapped", [1222]], [[1222, 1222], "valid"], [[1223, 1223], "mapped", [1224]], [[1224, 1224], "valid"], [[1225, 1225], "mapped", [1226]], [[1226, 1226], "valid"], [[1227, 1227], "mapped", [1228]], [[1228, 1228], "valid"], [[1229, 1229], "mapped", [1230]], [[1230, 1230], "valid"], [[1231, 1231], "valid"], [[1232, 1232], "mapped", [1233]], [[1233, 1233], "valid"], [[1234, 1234], "mapped", [1235]], [[1235, 1235], "valid"], [[1236, 1236], "mapped", [1237]], [[1237, 1237], "valid"], [[1238, 1238], "mapped", [1239]], [[1239, 1239], "valid"], [[1240, 1240], "mapped", [1241]], [[1241, 1241], "valid"], [[1242, 1242], "mapped", [1243]], [[1243, 1243], "valid"], [[1244, 1244], "mapped", [1245]], [[1245, 1245], "valid"], [[1246, 1246], "mapped", [1247]], [[1247, 1247], "valid"], [[1248, 1248], "mapped", [1249]], [[1249, 1249], "valid"], [[1250, 1250], "mapped", [1251]], [[1251, 1251], "valid"], [[1252, 1252], "mapped", [1253]], [[1253, 1253], "valid"], [[1254, 1254], "mapped", [1255]], [[1255, 1255], "valid"], [[1256, 1256], "mapped", [1257]], [[1257, 1257], "valid"], [[1258, 1258], "mapped", [1259]], [[1259, 1259], "valid"], [[1260, 1260], "mapped", [1261]], [[1261, 1261], "valid"], [[1262, 1262], "mapped", [1263]], [[1263, 1263], "valid"], [[1264, 1264], "mapped", [1265]], [[1265, 1265], "valid"], [[1266, 1266], "mapped", [1267]], [[1267, 1267], "valid"], [[1268, 1268], "mapped", [1269]], [[1269, 1269], "valid"], [[1270, 1270], "mapped", [1271]], [[1271, 1271], "valid"], [[1272, 1272], "mapped", [1273]], [[1273, 1273], "valid"], [[1274, 1274], "mapped", [1275]], [[1275, 1275], "valid"], [[1276, 1276], "mapped", [1277]], [[1277, 1277], "valid"], [[1278, 1278], "mapped", [1279]], [[1279, 1279], "valid"], [[1280, 1280], "mapped", [1281]], [[1281, 1281], "valid"], [[1282, 1282], "mapped", [1283]], [[1283, 1283], "valid"], [[1284, 1284], "mapped", [1285]], [[1285, 1285], "valid"], [[1286, 1286], "mapped", [1287]], [[1287, 1287], "valid"], [[1288, 1288], "mapped", [1289]], [[1289, 1289], "valid"], [[1290, 1290], "mapped", [1291]], [[1291, 1291], "valid"], [[1292, 1292], "mapped", [1293]], [[1293, 1293], "valid"], [[1294, 1294], "mapped", [1295]], [[1295, 1295], "valid"], [[1296, 1296], "mapped", [1297]], [[1297, 1297], "valid"], [[1298, 1298], "mapped", [1299]], [[1299, 1299], "valid"], [[1300, 1300], "mapped", [1301]], [[1301, 1301], "valid"], [[1302, 1302], "mapped", [1303]], [[1303, 1303], "valid"], [[1304, 1304], "mapped", [1305]], [[1305, 1305], "valid"], [[1306, 1306], "mapped", [1307]], [[1307, 1307], "valid"], [[1308, 1308], "mapped", [1309]], [[1309, 1309], "valid"], [[1310, 1310], "mapped", [1311]], [[1311, 1311], "valid"], [[1312, 1312], "mapped", [1313]], [[1313, 1313], "valid"], [[1314, 1314], "mapped", [1315]], [[1315, 1315], "valid"], [[1316, 1316], "mapped", [1317]], [[1317, 1317], "valid"], [[1318, 1318], "mapped", [1319]], [[1319, 1319], "valid"], [[1320, 1320], "mapped", [1321]], [[1321, 1321], "valid"], [[1322, 1322], "mapped", [1323]], [[1323, 1323], "valid"], [[1324, 1324], "mapped", [1325]], [[1325, 1325], "valid"], [[1326, 1326], "mapped", [1327]], [[1327, 1327], "valid"], [[1328, 1328], "disallowed"], [[1329, 1329], "mapped", [1377]], [[1330, 1330], "mapped", [1378]], [[1331, 1331], "mapped", [1379]], [[1332, 1332], "mapped", [1380]], [[1333, 1333], "mapped", [1381]], [[1334, 1334], "mapped", [1382]], [[1335, 1335], "mapped", [1383]], [[1336, 1336], "mapped", [1384]], [[1337, 1337], "mapped", [1385]], [[1338, 1338], "mapped", [1386]], [[1339, 1339], "mapped", [1387]], [[1340, 1340], "mapped", [1388]], [[1341, 1341], "mapped", [1389]], [[1342, 1342], "mapped", [1390]], [[1343, 1343], "mapped", [1391]], [[1344, 1344], "mapped", [1392]], [[1345, 1345], "mapped", [1393]], [[1346, 1346], "mapped", [1394]], [[1347, 1347], "mapped", [1395]], [[1348, 1348], "mapped", [1396]], [[1349, 1349], "mapped", [1397]], [[1350, 1350], "mapped", [1398]], [[1351, 1351], "mapped", [1399]], [[1352, 1352], "mapped", [1400]], [[1353, 1353], "mapped", [1401]], [[1354, 1354], "mapped", [1402]], [[1355, 1355], "mapped", [1403]], [[1356, 1356], "mapped", [1404]], [[1357, 1357], "mapped", [1405]], [[1358, 1358], "mapped", [1406]], [[1359, 1359], "mapped", [1407]], [[1360, 1360], "mapped", [1408]], [[1361, 1361], "mapped", [1409]], [[1362, 1362], "mapped", [1410]], [[1363, 1363], "mapped", [1411]], [[1364, 1364], "mapped", [1412]], [[1365, 1365], "mapped", [1413]], [[1366, 1366], "mapped", [1414]], [[1367, 1368], "disallowed"], [[1369, 1369], "valid"], [[1370, 1375], "valid", [], "NV8"], [[1376, 1376], "disallowed"], [[1377, 1414], "valid"], [[1415, 1415], "mapped", [1381, 1410]], [[1416, 1416], "disallowed"], [[1417, 1417], "valid", [], "NV8"], [[1418, 1418], "valid", [], "NV8"], [[1419, 1420], "disallowed"], [[1421, 1422], "valid", [], "NV8"], [[1423, 1423], "valid", [], "NV8"], [[1424, 1424], "disallowed"], [[1425, 1441], "valid"], [[1442, 1442], "valid"], [[1443, 1455], "valid"], [[1456, 1465], "valid"], [[1466, 1466], "valid"], [[1467, 1469], "valid"], [[1470, 1470], "valid", [], "NV8"], [[1471, 1471], "valid"], [[1472, 1472], "valid", [], "NV8"], [[1473, 1474], "valid"], [[1475, 1475], "valid", [], "NV8"], [[1476, 1476], "valid"], [[1477, 1477], "valid"], [[1478, 1478], "valid", [], "NV8"], [[1479, 1479], "valid"], [[1480, 1487], "disallowed"], [[1488, 1514], "valid"], [[1515, 1519], "disallowed"], [[1520, 1524], "valid"], [[1525, 1535], "disallowed"], [[1536, 1539], "disallowed"], [[1540, 1540], "disallowed"], [[1541, 1541], "disallowed"], [[1542, 1546], "valid", [], "NV8"], [[1547, 1547], "valid", [], "NV8"], [[1548, 1548], "valid", [], "NV8"], [[1549, 1551], "valid", [], "NV8"], [[1552, 1557], "valid"], [[1558, 1562], "valid"], [[1563, 1563], "valid", [], "NV8"], [[1564, 1564], "disallowed"], [[1565, 1565], "disallowed"], [[1566, 1566], "valid", [], "NV8"], [[1567, 1567], "valid", [], "NV8"], [[1568, 1568], "valid"], [[1569, 1594], "valid"], [[1595, 1599], "valid"], [[1600, 1600], "valid", [], "NV8"], [[1601, 1618], "valid"], [[1619, 1621], "valid"], [[1622, 1624], "valid"], [[1625, 1630], "valid"], [[1631, 1631], "valid"], [[1632, 1641], "valid"], [[1642, 1645], "valid", [], "NV8"], [[1646, 1647], "valid"], [[1648, 1652], "valid"], [[1653, 1653], "mapped", [1575, 1652]], [[1654, 1654], "mapped", [1608, 1652]], [[1655, 1655], "mapped", [1735, 1652]], [[1656, 1656], "mapped", [1610, 1652]], [[1657, 1719], "valid"], [[1720, 1721], "valid"], [[1722, 1726], "valid"], [[1727, 1727], "valid"], [[1728, 1742], "valid"], [[1743, 1743], "valid"], [[1744, 1747], "valid"], [[1748, 1748], "valid", [], "NV8"], [[1749, 1756], "valid"], [[1757, 1757], "disallowed"], [[1758, 1758], "valid", [], "NV8"], [[1759, 1768], "valid"], [[1769, 1769], "valid", [], "NV8"], [[1770, 1773], "valid"], [[1774, 1775], "valid"], [[1776, 1785], "valid"], [[1786, 1790], "valid"], [[1791, 1791], "valid"], [[1792, 1805], "valid", [], "NV8"], [[1806, 1806], "disallowed"], [[1807, 1807], "disallowed"], [[1808, 1836], "valid"], [[1837, 1839], "valid"], [[1840, 1866], "valid"], [[1867, 1868], "disallowed"], [[1869, 1871], "valid"], [[1872, 1901], "valid"], [[1902, 1919], "valid"], [[1920, 1968], "valid"], [[1969, 1969], "valid"], [[1970, 1983], "disallowed"], [[1984, 2037], "valid"], [[2038, 2042], "valid", [], "NV8"], [[2043, 2047], "disallowed"], [[2048, 2093], "valid"], [[2094, 2095], "disallowed"], [[2096, 2110], "valid", [], "NV8"], [[2111, 2111], "disallowed"], [[2112, 2139], "valid"], [[2140, 2141], "disallowed"], [[2142, 2142], "valid", [], "NV8"], [[2143, 2207], "disallowed"], [[2208, 2208], "valid"], [[2209, 2209], "valid"], [[2210, 2220], "valid"], [[2221, 2226], "valid"], [[2227, 2228], "valid"], [[2229, 2274], "disallowed"], [[2275, 2275], "valid"], [[2276, 2302], "valid"], [[2303, 2303], "valid"], [[2304, 2304], "valid"], [[2305, 2307], "valid"], [[2308, 2308], "valid"], [[2309, 2361], "valid"], [[2362, 2363], "valid"], [[2364, 2381], "valid"], [[2382, 2382], "valid"], [[2383, 2383], "valid"], [[2384, 2388], "valid"], [[2389, 2389], "valid"], [[2390, 2391], "valid"], [[2392, 2392], "mapped", [2325, 2364]], [[2393, 2393], "mapped", [2326, 2364]], [[2394, 2394], "mapped", [2327, 2364]], [[2395, 2395], "mapped", [2332, 2364]], [[2396, 2396], "mapped", [2337, 2364]], [[2397, 2397], "mapped", [2338, 2364]], [[2398, 2398], "mapped", [2347, 2364]], [[2399, 2399], "mapped", [2351, 2364]], [[2400, 2403], "valid"], [[2404, 2405], "valid", [], "NV8"], [[2406, 2415], "valid"], [[2416, 2416], "valid", [], "NV8"], [[2417, 2418], "valid"], [[2419, 2423], "valid"], [[2424, 2424], "valid"], [[2425, 2426], "valid"], [[2427, 2428], "valid"], [[2429, 2429], "valid"], [[2430, 2431], "valid"], [[2432, 2432], "valid"], [[2433, 2435], "valid"], [[2436, 2436], "disallowed"], [[2437, 2444], "valid"], [[2445, 2446], "disallowed"], [[2447, 2448], "valid"], [[2449, 2450], "disallowed"], [[2451, 2472], "valid"], [[2473, 2473], "disallowed"], [[2474, 2480], "valid"], [[2481, 2481], "disallowed"], [[2482, 2482], "valid"], [[2483, 2485], "disallowed"], [[2486, 2489], "valid"], [[2490, 2491], "disallowed"], [[2492, 2492], "valid"], [[2493, 2493], "valid"], [[2494, 2500], "valid"], [[2501, 2502], "disallowed"], [[2503, 2504], "valid"], [[2505, 2506], "disallowed"], [[2507, 2509], "valid"], [[2510, 2510], "valid"], [[2511, 2518], "disallowed"], [[2519, 2519], "valid"], [[2520, 2523], "disallowed"], [[2524, 2524], "mapped", [2465, 2492]], [[2525, 2525], "mapped", [2466, 2492]], [[2526, 2526], "disallowed"], [[2527, 2527], "mapped", [2479, 2492]], [[2528, 2531], "valid"], [[2532, 2533], "disallowed"], [[2534, 2545], "valid"], [[2546, 2554], "valid", [], "NV8"], [[2555, 2555], "valid", [], "NV8"], [[2556, 2560], "disallowed"], [[2561, 2561], "valid"], [[2562, 2562], "valid"], [[2563, 2563], "valid"], [[2564, 2564], "disallowed"], [[2565, 2570], "valid"], [[2571, 2574], "disallowed"], [[2575, 2576], "valid"], [[2577, 2578], "disallowed"], [[2579, 2600], "valid"], [[2601, 2601], "disallowed"], [[2602, 2608], "valid"], [[2609, 2609], "disallowed"], [[2610, 2610], "valid"], [[2611, 2611], "mapped", [2610, 2620]], [[2612, 2612], "disallowed"], [[2613, 2613], "valid"], [[2614, 2614], "mapped", [2616, 2620]], [[2615, 2615], "disallowed"], [[2616, 2617], "valid"], [[2618, 2619], "disallowed"], [[2620, 2620], "valid"], [[2621, 2621], "disallowed"], [[2622, 2626], "valid"], [[2627, 2630], "disallowed"], [[2631, 2632], "valid"], [[2633, 2634], "disallowed"], [[2635, 2637], "valid"], [[2638, 2640], "disallowed"], [[2641, 2641], "valid"], [[2642, 2648], "disallowed"], [[2649, 2649], "mapped", [2582, 2620]], [[2650, 2650], "mapped", [2583, 2620]], [[2651, 2651], "mapped", [2588, 2620]], [[2652, 2652], "valid"], [[2653, 2653], "disallowed"], [[2654, 2654], "mapped", [2603, 2620]], [[2655, 2661], "disallowed"], [[2662, 2676], "valid"], [[2677, 2677], "valid"], [[2678, 2688], "disallowed"], [[2689, 2691], "valid"], [[2692, 2692], "disallowed"], [[2693, 2699], "valid"], [[2700, 2700], "valid"], [[2701, 2701], "valid"], [[2702, 2702], "disallowed"], [[2703, 2705], "valid"], [[2706, 2706], "disallowed"], [[2707, 2728], "valid"], [[2729, 2729], "disallowed"], [[2730, 2736], "valid"], [[2737, 2737], "disallowed"], [[2738, 2739], "valid"], [[2740, 2740], "disallowed"], [[2741, 2745], "valid"], [[2746, 2747], "disallowed"], [[2748, 2757], "valid"], [[2758, 2758], "disallowed"], [[2759, 2761], "valid"], [[2762, 2762], "disallowed"], [[2763, 2765], "valid"], [[2766, 2767], "disallowed"], [[2768, 2768], "valid"], [[2769, 2783], "disallowed"], [[2784, 2784], "valid"], [[2785, 2787], "valid"], [[2788, 2789], "disallowed"], [[2790, 2799], "valid"], [[2800, 2800], "valid", [], "NV8"], [[2801, 2801], "valid", [], "NV8"], [[2802, 2808], "disallowed"], [[2809, 2809], "valid"], [[2810, 2816], "disallowed"], [[2817, 2819], "valid"], [[2820, 2820], "disallowed"], [[2821, 2828], "valid"], [[2829, 2830], "disallowed"], [[2831, 2832], "valid"], [[2833, 2834], "disallowed"], [[2835, 2856], "valid"], [[2857, 2857], "disallowed"], [[2858, 2864], "valid"], [[2865, 2865], "disallowed"], [[2866, 2867], "valid"], [[2868, 2868], "disallowed"], [[2869, 2869], "valid"], [[2870, 2873], "valid"], [[2874, 2875], "disallowed"], [[2876, 2883], "valid"], [[2884, 2884], "valid"], [[2885, 2886], "disallowed"], [[2887, 2888], "valid"], [[2889, 2890], "disallowed"], [[2891, 2893], "valid"], [[2894, 2901], "disallowed"], [[2902, 2903], "valid"], [[2904, 2907], "disallowed"], [[2908, 2908], "mapped", [2849, 2876]], [[2909, 2909], "mapped", [2850, 2876]], [[2910, 2910], "disallowed"], [[2911, 2913], "valid"], [[2914, 2915], "valid"], [[2916, 2917], "disallowed"], [[2918, 2927], "valid"], [[2928, 2928], "valid", [], "NV8"], [[2929, 2929], "valid"], [[2930, 2935], "valid", [], "NV8"], [[2936, 2945], "disallowed"], [[2946, 2947], "valid"], [[2948, 2948], "disallowed"], [[2949, 2954], "valid"], [[2955, 2957], "disallowed"], [[2958, 2960], "valid"], [[2961, 2961], "disallowed"], [[2962, 2965], "valid"], [[2966, 2968], "disallowed"], [[2969, 2970], "valid"], [[2971, 2971], "disallowed"], [[2972, 2972], "valid"], [[2973, 2973], "disallowed"], [[2974, 2975], "valid"], [[2976, 2978], "disallowed"], [[2979, 2980], "valid"], [[2981, 2983], "disallowed"], [[2984, 2986], "valid"], [[2987, 2989], "disallowed"], [[2990, 2997], "valid"], [[2998, 2998], "valid"], [[2999, 3001], "valid"], [[3002, 3005], "disallowed"], [[3006, 3010], "valid"], [[3011, 3013], "disallowed"], [[3014, 3016], "valid"], [[3017, 3017], "disallowed"], [[3018, 3021], "valid"], [[3022, 3023], "disallowed"], [[3024, 3024], "valid"], [[3025, 3030], "disallowed"], [[3031, 3031], "valid"], [[3032, 3045], "disallowed"], [[3046, 3046], "valid"], [[3047, 3055], "valid"], [[3056, 3058], "valid", [], "NV8"], [[3059, 3066], "valid", [], "NV8"], [[3067, 3071], "disallowed"], [[3072, 3072], "valid"], [[3073, 3075], "valid"], [[3076, 3076], "disallowed"], [[3077, 3084], "valid"], [[3085, 3085], "disallowed"], [[3086, 3088], "valid"], [[3089, 3089], "disallowed"], [[3090, 3112], "valid"], [[3113, 3113], "disallowed"], [[3114, 3123], "valid"], [[3124, 3124], "valid"], [[3125, 3129], "valid"], [[3130, 3132], "disallowed"], [[3133, 3133], "valid"], [[3134, 3140], "valid"], [[3141, 3141], "disallowed"], [[3142, 3144], "valid"], [[3145, 3145], "disallowed"], [[3146, 3149], "valid"], [[3150, 3156], "disallowed"], [[3157, 3158], "valid"], [[3159, 3159], "disallowed"], [[3160, 3161], "valid"], [[3162, 3162], "valid"], [[3163, 3167], "disallowed"], [[3168, 3169], "valid"], [[3170, 3171], "valid"], [[3172, 3173], "disallowed"], [[3174, 3183], "valid"], [[3184, 3191], "disallowed"], [[3192, 3199], "valid", [], "NV8"], [[3200, 3200], "disallowed"], [[3201, 3201], "valid"], [[3202, 3203], "valid"], [[3204, 3204], "disallowed"], [[3205, 3212], "valid"], [[3213, 3213], "disallowed"], [[3214, 3216], "valid"], [[3217, 3217], "disallowed"], [[3218, 3240], "valid"], [[3241, 3241], "disallowed"], [[3242, 3251], "valid"], [[3252, 3252], "disallowed"], [[3253, 3257], "valid"], [[3258, 3259], "disallowed"], [[3260, 3261], "valid"], [[3262, 3268], "valid"], [[3269, 3269], "disallowed"], [[3270, 3272], "valid"], [[3273, 3273], "disallowed"], [[3274, 3277], "valid"], [[3278, 3284], "disallowed"], [[3285, 3286], "valid"], [[3287, 3293], "disallowed"], [[3294, 3294], "valid"], [[3295, 3295], "disallowed"], [[3296, 3297], "valid"], [[3298, 3299], "valid"], [[3300, 3301], "disallowed"], [[3302, 3311], "valid"], [[3312, 3312], "disallowed"], [[3313, 3314], "valid"], [[3315, 3328], "disallowed"], [[3329, 3329], "valid"], [[3330, 3331], "valid"], [[3332, 3332], "disallowed"], [[3333, 3340], "valid"], [[3341, 3341], "disallowed"], [[3342, 3344], "valid"], [[3345, 3345], "disallowed"], [[3346, 3368], "valid"], [[3369, 3369], "valid"], [[3370, 3385], "valid"], [[3386, 3386], "valid"], [[3387, 3388], "disallowed"], [[3389, 3389], "valid"], [[3390, 3395], "valid"], [[3396, 3396], "valid"], [[3397, 3397], "disallowed"], [[3398, 3400], "valid"], [[3401, 3401], "disallowed"], [[3402, 3405], "valid"], [[3406, 3406], "valid"], [[3407, 3414], "disallowed"], [[3415, 3415], "valid"], [[3416, 3422], "disallowed"], [[3423, 3423], "valid"], [[3424, 3425], "valid"], [[3426, 3427], "valid"], [[3428, 3429], "disallowed"], [[3430, 3439], "valid"], [[3440, 3445], "valid", [], "NV8"], [[3446, 3448], "disallowed"], [[3449, 3449], "valid", [], "NV8"], [[3450, 3455], "valid"], [[3456, 3457], "disallowed"], [[3458, 3459], "valid"], [[3460, 3460], "disallowed"], [[3461, 3478], "valid"], [[3479, 3481], "disallowed"], [[3482, 3505], "valid"], [[3506, 3506], "disallowed"], [[3507, 3515], "valid"], [[3516, 3516], "disallowed"], [[3517, 3517], "valid"], [[3518, 3519], "disallowed"], [[3520, 3526], "valid"], [[3527, 3529], "disallowed"], [[3530, 3530], "valid"], [[3531, 3534], "disallowed"], [[3535, 3540], "valid"], [[3541, 3541], "disallowed"], [[3542, 3542], "valid"], [[3543, 3543], "disallowed"], [[3544, 3551], "valid"], [[3552, 3557], "disallowed"], [[3558, 3567], "valid"], [[3568, 3569], "disallowed"], [[3570, 3571], "valid"], [[3572, 3572], "valid", [], "NV8"], [[3573, 3584], "disallowed"], [[3585, 3634], "valid"], [[3635, 3635], "mapped", [3661, 3634]], [[3636, 3642], "valid"], [[3643, 3646], "disallowed"], [[3647, 3647], "valid", [], "NV8"], [[3648, 3662], "valid"], [[3663, 3663], "valid", [], "NV8"], [[3664, 3673], "valid"], [[3674, 3675], "valid", [], "NV8"], [[3676, 3712], "disallowed"], [[3713, 3714], "valid"], [[3715, 3715], "disallowed"], [[3716, 3716], "valid"], [[3717, 3718], "disallowed"], [[3719, 3720], "valid"], [[3721, 3721], "disallowed"], [[3722, 3722], "valid"], [[3723, 3724], "disallowed"], [[3725, 3725], "valid"], [[3726, 3731], "disallowed"], [[3732, 3735], "valid"], [[3736, 3736], "disallowed"], [[3737, 3743], "valid"], [[3744, 3744], "disallowed"], [[3745, 3747], "valid"], [[3748, 3748], "disallowed"], [[3749, 3749], "valid"], [[3750, 3750], "disallowed"], [[3751, 3751], "valid"], [[3752, 3753], "disallowed"], [[3754, 3755], "valid"], [[3756, 3756], "disallowed"], [[3757, 3762], "valid"], [[3763, 3763], "mapped", [3789, 3762]], [[3764, 3769], "valid"], [[3770, 3770], "disallowed"], [[3771, 3773], "valid"], [[3774, 3775], "disallowed"], [[3776, 3780], "valid"], [[3781, 3781], "disallowed"], [[3782, 3782], "valid"], [[3783, 3783], "disallowed"], [[3784, 3789], "valid"], [[3790, 3791], "disallowed"], [[3792, 3801], "valid"], [[3802, 3803], "disallowed"], [[3804, 3804], "mapped", [3755, 3737]], [[3805, 3805], "mapped", [3755, 3745]], [[3806, 3807], "valid"], [[3808, 3839], "disallowed"], [[3840, 3840], "valid"], [[3841, 3850], "valid", [], "NV8"], [[3851, 3851], "valid"], [[3852, 3852], "mapped", [3851]], [[3853, 3863], "valid", [], "NV8"], [[3864, 3865], "valid"], [[3866, 3871], "valid", [], "NV8"], [[3872, 3881], "valid"], [[3882, 3892], "valid", [], "NV8"], [[3893, 3893], "valid"], [[3894, 3894], "valid", [], "NV8"], [[3895, 3895], "valid"], [[3896, 3896], "valid", [], "NV8"], [[3897, 3897], "valid"], [[3898, 3901], "valid", [], "NV8"], [[3902, 3906], "valid"], [[3907, 3907], "mapped", [3906, 4023]], [[3908, 3911], "valid"], [[3912, 3912], "disallowed"], [[3913, 3916], "valid"], [[3917, 3917], "mapped", [3916, 4023]], [[3918, 3921], "valid"], [[3922, 3922], "mapped", [3921, 4023]], [[3923, 3926], "valid"], [[3927, 3927], "mapped", [3926, 4023]], [[3928, 3931], "valid"], [[3932, 3932], "mapped", [3931, 4023]], [[3933, 3944], "valid"], [[3945, 3945], "mapped", [3904, 4021]], [[3946, 3946], "valid"], [[3947, 3948], "valid"], [[3949, 3952], "disallowed"], [[3953, 3954], "valid"], [[3955, 3955], "mapped", [3953, 3954]], [[3956, 3956], "valid"], [[3957, 3957], "mapped", [3953, 3956]], [[3958, 3958], "mapped", [4018, 3968]], [[3959, 3959], "mapped", [4018, 3953, 3968]], [[3960, 3960], "mapped", [4019, 3968]], [[3961, 3961], "mapped", [4019, 3953, 3968]], [[3962, 3968], "valid"], [[3969, 3969], "mapped", [3953, 3968]], [[3970, 3972], "valid"], [[3973, 3973], "valid", [], "NV8"], [[3974, 3979], "valid"], [[3980, 3983], "valid"], [[3984, 3986], "valid"], [[3987, 3987], "mapped", [3986, 4023]], [[3988, 3989], "valid"], [[3990, 3990], "valid"], [[3991, 3991], "valid"], [[3992, 3992], "disallowed"], [[3993, 3996], "valid"], [[3997, 3997], "mapped", [3996, 4023]], [[3998, 4001], "valid"], [[4002, 4002], "mapped", [4001, 4023]], [[4003, 4006], "valid"], [[4007, 4007], "mapped", [4006, 4023]], [[4008, 4011], "valid"], [[4012, 4012], "mapped", [4011, 4023]], [[4013, 4013], "valid"], [[4014, 4016], "valid"], [[4017, 4023], "valid"], [[4024, 4024], "valid"], [[4025, 4025], "mapped", [3984, 4021]], [[4026, 4028], "valid"], [[4029, 4029], "disallowed"], [[4030, 4037], "valid", [], "NV8"], [[4038, 4038], "valid"], [[4039, 4044], "valid", [], "NV8"], [[4045, 4045], "disallowed"], [[4046, 4046], "valid", [], "NV8"], [[4047, 4047], "valid", [], "NV8"], [[4048, 4049], "valid", [], "NV8"], [[4050, 4052], "valid", [], "NV8"], [[4053, 4056], "valid", [], "NV8"], [[4057, 4058], "valid", [], "NV8"], [[4059, 4095], "disallowed"], [[4096, 4129], "valid"], [[4130, 4130], "valid"], [[4131, 4135], "valid"], [[4136, 4136], "valid"], [[4137, 4138], "valid"], [[4139, 4139], "valid"], [[4140, 4146], "valid"], [[4147, 4149], "valid"], [[4150, 4153], "valid"], [[4154, 4159], "valid"], [[4160, 4169], "valid"], [[4170, 4175], "valid", [], "NV8"], [[4176, 4185], "valid"], [[4186, 4249], "valid"], [[4250, 4253], "valid"], [[4254, 4255], "valid", [], "NV8"], [[4256, 4293], "disallowed"], [[4294, 4294], "disallowed"], [[4295, 4295], "mapped", [11559]], [[4296, 4300], "disallowed"], [[4301, 4301], "mapped", [11565]], [[4302, 4303], "disallowed"], [[4304, 4342], "valid"], [[4343, 4344], "valid"], [[4345, 4346], "valid"], [[4347, 4347], "valid", [], "NV8"], [[4348, 4348], "mapped", [4316]], [[4349, 4351], "valid"], [[4352, 4441], "valid", [], "NV8"], [[4442, 4446], "valid", [], "NV8"], [[4447, 4448], "disallowed"], [[4449, 4514], "valid", [], "NV8"], [[4515, 4519], "valid", [], "NV8"], [[4520, 4601], "valid", [], "NV8"], [[4602, 4607], "valid", [], "NV8"], [[4608, 4614], "valid"], [[4615, 4615], "valid"], [[4616, 4678], "valid"], [[4679, 4679], "valid"], [[4680, 4680], "valid"], [[4681, 4681], "disallowed"], [[4682, 4685], "valid"], [[4686, 4687], "disallowed"], [[4688, 4694], "valid"], [[4695, 4695], "disallowed"], [[4696, 4696], "valid"], [[4697, 4697], "disallowed"], [[4698, 4701], "valid"], [[4702, 4703], "disallowed"], [[4704, 4742], "valid"], [[4743, 4743], "valid"], [[4744, 4744], "valid"], [[4745, 4745], "disallowed"], [[4746, 4749], "valid"], [[4750, 4751], "disallowed"], [[4752, 4782], "valid"], [[4783, 4783], "valid"], [[4784, 4784], "valid"], [[4785, 4785], "disallowed"], [[4786, 4789], "valid"], [[4790, 4791], "disallowed"], [[4792, 4798], "valid"], [[4799, 4799], "disallowed"], [[4800, 4800], "valid"], [[4801, 4801], "disallowed"], [[4802, 4805], "valid"], [[4806, 4807], "disallowed"], [[4808, 4814], "valid"], [[4815, 4815], "valid"], [[4816, 4822], "valid"], [[4823, 4823], "disallowed"], [[4824, 4846], "valid"], [[4847, 4847], "valid"], [[4848, 4878], "valid"], [[4879, 4879], "valid"], [[4880, 4880], "valid"], [[4881, 4881], "disallowed"], [[4882, 4885], "valid"], [[4886, 4887], "disallowed"], [[4888, 4894], "valid"], [[4895, 4895], "valid"], [[4896, 4934], "valid"], [[4935, 4935], "valid"], [[4936, 4954], "valid"], [[4955, 4956], "disallowed"], [[4957, 4958], "valid"], [[4959, 4959], "valid"], [[4960, 4960], "valid", [], "NV8"], [[4961, 4988], "valid", [], "NV8"], [[4989, 4991], "disallowed"], [[4992, 5007], "valid"], [[5008, 5017], "valid", [], "NV8"], [[5018, 5023], "disallowed"], [[5024, 5108], "valid"], [[5109, 5109], "valid"], [[5110, 5111], "disallowed"], [[5112, 5112], "mapped", [5104]], [[5113, 5113], "mapped", [5105]], [[5114, 5114], "mapped", [5106]], [[5115, 5115], "mapped", [5107]], [[5116, 5116], "mapped", [5108]], [[5117, 5117], "mapped", [5109]], [[5118, 5119], "disallowed"], [[5120, 5120], "valid", [], "NV8"], [[5121, 5740], "valid"], [[5741, 5742], "valid", [], "NV8"], [[5743, 5750], "valid"], [[5751, 5759], "valid"], [[5760, 5760], "disallowed"], [[5761, 5786], "valid"], [[5787, 5788], "valid", [], "NV8"], [[5789, 5791], "disallowed"], [[5792, 5866], "valid"], [[5867, 5872], "valid", [], "NV8"], [[5873, 5880], "valid"], [[5881, 5887], "disallowed"], [[5888, 5900], "valid"], [[5901, 5901], "disallowed"], [[5902, 5908], "valid"], [[5909, 5919], "disallowed"], [[5920, 5940], "valid"], [[5941, 5942], "valid", [], "NV8"], [[5943, 5951], "disallowed"], [[5952, 5971], "valid"], [[5972, 5983], "disallowed"], [[5984, 5996], "valid"], [[5997, 5997], "disallowed"], [[5998, 6e3], "valid"], [[6001, 6001], "disallowed"], [[6002, 6003], "valid"], [[6004, 6015], "disallowed"], [[6016, 6067], "valid"], [[6068, 6069], "disallowed"], [[6070, 6099], "valid"], [[6100, 6102], "valid", [], "NV8"], [[6103, 6103], "valid"], [[6104, 6107], "valid", [], "NV8"], [[6108, 6108], "valid"], [[6109, 6109], "valid"], [[6110, 6111], "disallowed"], [[6112, 6121], "valid"], [[6122, 6127], "disallowed"], [[6128, 6137], "valid", [], "NV8"], [[6138, 6143], "disallowed"], [[6144, 6149], "valid", [], "NV8"], [[6150, 6150], "disallowed"], [[6151, 6154], "valid", [], "NV8"], [[6155, 6157], "ignored"], [[6158, 6158], "disallowed"], [[6159, 6159], "disallowed"], [[6160, 6169], "valid"], [[6170, 6175], "disallowed"], [[6176, 6263], "valid"], [[6264, 6271], "disallowed"], [[6272, 6313], "valid"], [[6314, 6314], "valid"], [[6315, 6319], "disallowed"], [[6320, 6389], "valid"], [[6390, 6399], "disallowed"], [[6400, 6428], "valid"], [[6429, 6430], "valid"], [[6431, 6431], "disallowed"], [[6432, 6443], "valid"], [[6444, 6447], "disallowed"], [[6448, 6459], "valid"], [[6460, 6463], "disallowed"], [[6464, 6464], "valid", [], "NV8"], [[6465, 6467], "disallowed"], [[6468, 6469], "valid", [], "NV8"], [[6470, 6509], "valid"], [[6510, 6511], "disallowed"], [[6512, 6516], "valid"], [[6517, 6527], "disallowed"], [[6528, 6569], "valid"], [[6570, 6571], "valid"], [[6572, 6575], "disallowed"], [[6576, 6601], "valid"], [[6602, 6607], "disallowed"], [[6608, 6617], "valid"], [[6618, 6618], "valid", [], "XV8"], [[6619, 6621], "disallowed"], [[6622, 6623], "valid", [], "NV8"], [[6624, 6655], "valid", [], "NV8"], [[6656, 6683], "valid"], [[6684, 6685], "disallowed"], [[6686, 6687], "valid", [], "NV8"], [[6688, 6750], "valid"], [[6751, 6751], "disallowed"], [[6752, 6780], "valid"], [[6781, 6782], "disallowed"], [[6783, 6793], "valid"], [[6794, 6799], "disallowed"], [[6800, 6809], "valid"], [[6810, 6815], "disallowed"], [[6816, 6822], "valid", [], "NV8"], [[6823, 6823], "valid"], [[6824, 6829], "valid", [], "NV8"], [[6830, 6831], "disallowed"], [[6832, 6845], "valid"], [[6846, 6846], "valid", [], "NV8"], [[6847, 6911], "disallowed"], [[6912, 6987], "valid"], [[6988, 6991], "disallowed"], [[6992, 7001], "valid"], [[7002, 7018], "valid", [], "NV8"], [[7019, 7027], "valid"], [[7028, 7036], "valid", [], "NV8"], [[7037, 7039], "disallowed"], [[7040, 7082], "valid"], [[7083, 7085], "valid"], [[7086, 7097], "valid"], [[7098, 7103], "valid"], [[7104, 7155], "valid"], [[7156, 7163], "disallowed"], [[7164, 7167], "valid", [], "NV8"], [[7168, 7223], "valid"], [[7224, 7226], "disallowed"], [[7227, 7231], "valid", [], "NV8"], [[7232, 7241], "valid"], [[7242, 7244], "disallowed"], [[7245, 7293], "valid"], [[7294, 7295], "valid", [], "NV8"], [[7296, 7359], "disallowed"], [[7360, 7367], "valid", [], "NV8"], [[7368, 7375], "disallowed"], [[7376, 7378], "valid"], [[7379, 7379], "valid", [], "NV8"], [[7380, 7410], "valid"], [[7411, 7414], "valid"], [[7415, 7415], "disallowed"], [[7416, 7417], "valid"], [[7418, 7423], "disallowed"], [[7424, 7467], "valid"], [[7468, 7468], "mapped", [97]], [[7469, 7469], "mapped", [230]], [[7470, 7470], "mapped", [98]], [[7471, 7471], "valid"], [[7472, 7472], "mapped", [100]], [[7473, 7473], "mapped", [101]], [[7474, 7474], "mapped", [477]], [[7475, 7475], "mapped", [103]], [[7476, 7476], "mapped", [104]], [[7477, 7477], "mapped", [105]], [[7478, 7478], "mapped", [106]], [[7479, 7479], "mapped", [107]], [[7480, 7480], "mapped", [108]], [[7481, 7481], "mapped", [109]], [[7482, 7482], "mapped", [110]], [[7483, 7483], "valid"], [[7484, 7484], "mapped", [111]], [[7485, 7485], "mapped", [547]], [[7486, 7486], "mapped", [112]], [[7487, 7487], "mapped", [114]], [[7488, 7488], "mapped", [116]], [[7489, 7489], "mapped", [117]], [[7490, 7490], "mapped", [119]], [[7491, 7491], "mapped", [97]], [[7492, 7492], "mapped", [592]], [[7493, 7493], "mapped", [593]], [[7494, 7494], "mapped", [7426]], [[7495, 7495], "mapped", [98]], [[7496, 7496], "mapped", [100]], [[7497, 7497], "mapped", [101]], [[7498, 7498], "mapped", [601]], [[7499, 7499], "mapped", [603]], [[7500, 7500], "mapped", [604]], [[7501, 7501], "mapped", [103]], [[7502, 7502], "valid"], [[7503, 7503], "mapped", [107]], [[7504, 7504], "mapped", [109]], [[7505, 7505], "mapped", [331]], [[7506, 7506], "mapped", [111]], [[7507, 7507], "mapped", [596]], [[7508, 7508], "mapped", [7446]], [[7509, 7509], "mapped", [7447]], [[7510, 7510], "mapped", [112]], [[7511, 7511], "mapped", [116]], [[7512, 7512], "mapped", [117]], [[7513, 7513], "mapped", [7453]], [[7514, 7514], "mapped", [623]], [[7515, 7515], "mapped", [118]], [[7516, 7516], "mapped", [7461]], [[7517, 7517], "mapped", [946]], [[7518, 7518], "mapped", [947]], [[7519, 7519], "mapped", [948]], [[7520, 7520], "mapped", [966]], [[7521, 7521], "mapped", [967]], [[7522, 7522], "mapped", [105]], [[7523, 7523], "mapped", [114]], [[7524, 7524], "mapped", [117]], [[7525, 7525], "mapped", [118]], [[7526, 7526], "mapped", [946]], [[7527, 7527], "mapped", [947]], [[7528, 7528], "mapped", [961]], [[7529, 7529], "mapped", [966]], [[7530, 7530], "mapped", [967]], [[7531, 7531], "valid"], [[7532, 7543], "valid"], [[7544, 7544], "mapped", [1085]], [[7545, 7578], "valid"], [[7579, 7579], "mapped", [594]], [[7580, 7580], "mapped", [99]], [[7581, 7581], "mapped", [597]], [[7582, 7582], "mapped", [240]], [[7583, 7583], "mapped", [604]], [[7584, 7584], "mapped", [102]], [[7585, 7585], "mapped", [607]], [[7586, 7586], "mapped", [609]], [[7587, 7587], "mapped", [613]], [[7588, 7588], "mapped", [616]], [[7589, 7589], "mapped", [617]], [[7590, 7590], "mapped", [618]], [[7591, 7591], "mapped", [7547]], [[7592, 7592], "mapped", [669]], [[7593, 7593], "mapped", [621]], [[7594, 7594], "mapped", [7557]], [[7595, 7595], "mapped", [671]], [[7596, 7596], "mapped", [625]], [[7597, 7597], "mapped", [624]], [[7598, 7598], "mapped", [626]], [[7599, 7599], "mapped", [627]], [[7600, 7600], "mapped", [628]], [[7601, 7601], "mapped", [629]], [[7602, 7602], "mapped", [632]], [[7603, 7603], "mapped", [642]], [[7604, 7604], "mapped", [643]], [[7605, 7605], "mapped", [427]], [[7606, 7606], "mapped", [649]], [[7607, 7607], "mapped", [650]], [[7608, 7608], "mapped", [7452]], [[7609, 7609], "mapped", [651]], [[7610, 7610], "mapped", [652]], [[7611, 7611], "mapped", [122]], [[7612, 7612], "mapped", [656]], [[7613, 7613], "mapped", [657]], [[7614, 7614], "mapped", [658]], [[7615, 7615], "mapped", [952]], [[7616, 7619], "valid"], [[7620, 7626], "valid"], [[7627, 7654], "valid"], [[7655, 7669], "valid"], [[7670, 7675], "disallowed"], [[7676, 7676], "valid"], [[7677, 7677], "valid"], [[7678, 7679], "valid"], [[7680, 7680], "mapped", [7681]], [[7681, 7681], "valid"], [[7682, 7682], "mapped", [7683]], [[7683, 7683], "valid"], [[7684, 7684], "mapped", [7685]], [[7685, 7685], "valid"], [[7686, 7686], "mapped", [7687]], [[7687, 7687], "valid"], [[7688, 7688], "mapped", [7689]], [[7689, 7689], "valid"], [[7690, 7690], "mapped", [7691]], [[7691, 7691], "valid"], [[7692, 7692], "mapped", [7693]], [[7693, 7693], "valid"], [[7694, 7694], "mapped", [7695]], [[7695, 7695], "valid"], [[7696, 7696], "mapped", [7697]], [[7697, 7697], "valid"], [[7698, 7698], "mapped", [7699]], [[7699, 7699], "valid"], [[7700, 7700], "mapped", [7701]], [[7701, 7701], "valid"], [[7702, 7702], "mapped", [7703]], [[7703, 7703], "valid"], [[7704, 7704], "mapped", [7705]], [[7705, 7705], "valid"], [[7706, 7706], "mapped", [7707]], [[7707, 7707], "valid"], [[7708, 7708], "mapped", [7709]], [[7709, 7709], "valid"], [[7710, 7710], "mapped", [7711]], [[7711, 7711], "valid"], [[7712, 7712], "mapped", [7713]], [[7713, 7713], "valid"], [[7714, 7714], "mapped", [7715]], [[7715, 7715], "valid"], [[7716, 7716], "mapped", [7717]], [[7717, 7717], "valid"], [[7718, 7718], "mapped", [7719]], [[7719, 7719], "valid"], [[7720, 7720], "mapped", [7721]], [[7721, 7721], "valid"], [[7722, 7722], "mapped", [7723]], [[7723, 7723], "valid"], [[7724, 7724], "mapped", [7725]], [[7725, 7725], "valid"], [[7726, 7726], "mapped", [7727]], [[7727, 7727], "valid"], [[7728, 7728], "mapped", [7729]], [[7729, 7729], "valid"], [[7730, 7730], "mapped", [7731]], [[7731, 7731], "valid"], [[7732, 7732], "mapped", [7733]], [[7733, 7733], "valid"], [[7734, 7734], "mapped", [7735]], [[7735, 7735], "valid"], [[7736, 7736], "mapped", [7737]], [[7737, 7737], "valid"], [[7738, 7738], "mapped", [7739]], [[7739, 7739], "valid"], [[7740, 7740], "mapped", [7741]], [[7741, 7741], "valid"], [[7742, 7742], "mapped", [7743]], [[7743, 7743], "valid"], [[7744, 7744], "mapped", [7745]], [[7745, 7745], "valid"], [[7746, 7746], "mapped", [7747]], [[7747, 7747], "valid"], [[7748, 7748], "mapped", [7749]], [[7749, 7749], "valid"], [[7750, 7750], "mapped", [7751]], [[7751, 7751], "valid"], [[7752, 7752], "mapped", [7753]], [[7753, 7753], "valid"], [[7754, 7754], "mapped", [7755]], [[7755, 7755], "valid"], [[7756, 7756], "mapped", [7757]], [[7757, 7757], "valid"], [[7758, 7758], "mapped", [7759]], [[7759, 7759], "valid"], [[7760, 7760], "mapped", [7761]], [[7761, 7761], "valid"], [[7762, 7762], "mapped", [7763]], [[7763, 7763], "valid"], [[7764, 7764], "mapped", [7765]], [[7765, 7765], "valid"], [[7766, 7766], "mapped", [7767]], [[7767, 7767], "valid"], [[7768, 7768], "mapped", [7769]], [[7769, 7769], "valid"], [[7770, 7770], "mapped", [7771]], [[7771, 7771], "valid"], [[7772, 7772], "mapped", [7773]], [[7773, 7773], "valid"], [[7774, 7774], "mapped", [7775]], [[7775, 7775], "valid"], [[7776, 7776], "mapped", [7777]], [[7777, 7777], "valid"], [[7778, 7778], "mapped", [7779]], [[7779, 7779], "valid"], [[7780, 7780], "mapped", [7781]], [[7781, 7781], "valid"], [[7782, 7782], "mapped", [7783]], [[7783, 7783], "valid"], [[7784, 7784], "mapped", [7785]], [[7785, 7785], "valid"], [[7786, 7786], "mapped", [7787]], [[7787, 7787], "valid"], [[7788, 7788], "mapped", [7789]], [[7789, 7789], "valid"], [[7790, 7790], "mapped", [7791]], [[7791, 7791], "valid"], [[7792, 7792], "mapped", [7793]], [[7793, 7793], "valid"], [[7794, 7794], "mapped", [7795]], [[7795, 7795], "valid"], [[7796, 7796], "mapped", [7797]], [[7797, 7797], "valid"], [[7798, 7798], "mapped", [7799]], [[7799, 7799], "valid"], [[7800, 7800], "mapped", [7801]], [[7801, 7801], "valid"], [[7802, 7802], "mapped", [7803]], [[7803, 7803], "valid"], [[7804, 7804], "mapped", [7805]], [[7805, 7805], "valid"], [[7806, 7806], "mapped", [7807]], [[7807, 7807], "valid"], [[7808, 7808], "mapped", [7809]], [[7809, 7809], "valid"], [[7810, 7810], "mapped", [7811]], [[7811, 7811], "valid"], [[7812, 7812], "mapped", [7813]], [[7813, 7813], "valid"], [[7814, 7814], "mapped", [7815]], [[7815, 7815], "valid"], [[7816, 7816], "mapped", [7817]], [[7817, 7817], "valid"], [[7818, 7818], "mapped", [7819]], [[7819, 7819], "valid"], [[7820, 7820], "mapped", [7821]], [[7821, 7821], "valid"], [[7822, 7822], "mapped", [7823]], [[7823, 7823], "valid"], [[7824, 7824], "mapped", [7825]], [[7825, 7825], "valid"], [[7826, 7826], "mapped", [7827]], [[7827, 7827], "valid"], [[7828, 7828], "mapped", [7829]], [[7829, 7833], "valid"], [[7834, 7834], "mapped", [97, 702]], [[7835, 7835], "mapped", [7777]], [[7836, 7837], "valid"], [[7838, 7838], "mapped", [115, 115]], [[7839, 7839], "valid"], [[7840, 7840], "mapped", [7841]], [[7841, 7841], "valid"], [[7842, 7842], "mapped", [7843]], [[7843, 7843], "valid"], [[7844, 7844], "mapped", [7845]], [[7845, 7845], "valid"], [[7846, 7846], "mapped", [7847]], [[7847, 7847], "valid"], [[7848, 7848], "mapped", [7849]], [[7849, 7849], "valid"], [[7850, 7850], "mapped", [7851]], [[7851, 7851], "valid"], [[7852, 7852], "mapped", [7853]], [[7853, 7853], "valid"], [[7854, 7854], "mapped", [7855]], [[7855, 7855], "valid"], [[7856, 7856], "mapped", [7857]], [[7857, 7857], "valid"], [[7858, 7858], "mapped", [7859]], [[7859, 7859], "valid"], [[7860, 7860], "mapped", [7861]], [[7861, 7861], "valid"], [[7862, 7862], "mapped", [7863]], [[7863, 7863], "valid"], [[7864, 7864], "mapped", [7865]], [[7865, 7865], "valid"], [[7866, 7866], "mapped", [7867]], [[7867, 7867], "valid"], [[7868, 7868], "mapped", [7869]], [[7869, 7869], "valid"], [[7870, 7870], "mapped", [7871]], [[7871, 7871], "valid"], [[7872, 7872], "mapped", [7873]], [[7873, 7873], "valid"], [[7874, 7874], "mapped", [7875]], [[7875, 7875], "valid"], [[7876, 7876], "mapped", [7877]], [[7877, 7877], "valid"], [[7878, 7878], "mapped", [7879]], [[7879, 7879], "valid"], [[7880, 7880], "mapped", [7881]], [[7881, 7881], "valid"], [[7882, 7882], "mapped", [7883]], [[7883, 7883], "valid"], [[7884, 7884], "mapped", [7885]], [[7885, 7885], "valid"], [[7886, 7886], "mapped", [7887]], [[7887, 7887], "valid"], [[7888, 7888], "mapped", [7889]], [[7889, 7889], "valid"], [[7890, 7890], "mapped", [7891]], [[7891, 7891], "valid"], [[7892, 7892], "mapped", [7893]], [[7893, 7893], "valid"], [[7894, 7894], "mapped", [7895]], [[7895, 7895], "valid"], [[7896, 7896], "mapped", [7897]], [[7897, 7897], "valid"], [[7898, 7898], "mapped", [7899]], [[7899, 7899], "valid"], [[7900, 7900], "mapped", [7901]], [[7901, 7901], "valid"], [[7902, 7902], "mapped", [7903]], [[7903, 7903], "valid"], [[7904, 7904], "mapped", [7905]], [[7905, 7905], "valid"], [[7906, 7906], "mapped", [7907]], [[7907, 7907], "valid"], [[7908, 7908], "mapped", [7909]], [[7909, 7909], "valid"], [[7910, 7910], "mapped", [7911]], [[7911, 7911], "valid"], [[7912, 7912], "mapped", [7913]], [[7913, 7913], "valid"], [[7914, 7914], "mapped", [7915]], [[7915, 7915], "valid"], [[7916, 7916], "mapped", [7917]], [[7917, 7917], "valid"], [[7918, 7918], "mapped", [7919]], [[7919, 7919], "valid"], [[7920, 7920], "mapped", [7921]], [[7921, 7921], "valid"], [[7922, 7922], "mapped", [7923]], [[7923, 7923], "valid"], [[7924, 7924], "mapped", [7925]], [[7925, 7925], "valid"], [[7926, 7926], "mapped", [7927]], [[7927, 7927], "valid"], [[7928, 7928], "mapped", [7929]], [[7929, 7929], "valid"], [[7930, 7930], "mapped", [7931]], [[7931, 7931], "valid"], [[7932, 7932], "mapped", [7933]], [[7933, 7933], "valid"], [[7934, 7934], "mapped", [7935]], [[7935, 7935], "valid"], [[7936, 7943], "valid"], [[7944, 7944], "mapped", [7936]], [[7945, 7945], "mapped", [7937]], [[7946, 7946], "mapped", [7938]], [[7947, 7947], "mapped", [7939]], [[7948, 7948], "mapped", [7940]], [[7949, 7949], "mapped", [7941]], [[7950, 7950], "mapped", [7942]], [[7951, 7951], "mapped", [7943]], [[7952, 7957], "valid"], [[7958, 7959], "disallowed"], [[7960, 7960], "mapped", [7952]], [[7961, 7961], "mapped", [7953]], [[7962, 7962], "mapped", [7954]], [[7963, 7963], "mapped", [7955]], [[7964, 7964], "mapped", [7956]], [[7965, 7965], "mapped", [7957]], [[7966, 7967], "disallowed"], [[7968, 7975], "valid"], [[7976, 7976], "mapped", [7968]], [[7977, 7977], "mapped", [7969]], [[7978, 7978], "mapped", [7970]], [[7979, 7979], "mapped", [7971]], [[7980, 7980], "mapped", [7972]], [[7981, 7981], "mapped", [7973]], [[7982, 7982], "mapped", [7974]], [[7983, 7983], "mapped", [7975]], [[7984, 7991], "valid"], [[7992, 7992], "mapped", [7984]], [[7993, 7993], "mapped", [7985]], [[7994, 7994], "mapped", [7986]], [[7995, 7995], "mapped", [7987]], [[7996, 7996], "mapped", [7988]], [[7997, 7997], "mapped", [7989]], [[7998, 7998], "mapped", [7990]], [[7999, 7999], "mapped", [7991]], [[8e3, 8005], "valid"], [[8006, 8007], "disallowed"], [[8008, 8008], "mapped", [8e3]], [[8009, 8009], "mapped", [8001]], [[8010, 8010], "mapped", [8002]], [[8011, 8011], "mapped", [8003]], [[8012, 8012], "mapped", [8004]], [[8013, 8013], "mapped", [8005]], [[8014, 8015], "disallowed"], [[8016, 8023], "valid"], [[8024, 8024], "disallowed"], [[8025, 8025], "mapped", [8017]], [[8026, 8026], "disallowed"], [[8027, 8027], "mapped", [8019]], [[8028, 8028], "disallowed"], [[8029, 8029], "mapped", [8021]], [[8030, 8030], "disallowed"], [[8031, 8031], "mapped", [8023]], [[8032, 8039], "valid"], [[8040, 8040], "mapped", [8032]], [[8041, 8041], "mapped", [8033]], [[8042, 8042], "mapped", [8034]], [[8043, 8043], "mapped", [8035]], [[8044, 8044], "mapped", [8036]], [[8045, 8045], "mapped", [8037]], [[8046, 8046], "mapped", [8038]], [[8047, 8047], "mapped", [8039]], [[8048, 8048], "valid"], [[8049, 8049], "mapped", [940]], [[8050, 8050], "valid"], [[8051, 8051], "mapped", [941]], [[8052, 8052], "valid"], [[8053, 8053], "mapped", [942]], [[8054, 8054], "valid"], [[8055, 8055], "mapped", [943]], [[8056, 8056], "valid"], [[8057, 8057], "mapped", [972]], [[8058, 8058], "valid"], [[8059, 8059], "mapped", [973]], [[8060, 8060], "valid"], [[8061, 8061], "mapped", [974]], [[8062, 8063], "disallowed"], [[8064, 8064], "mapped", [7936, 953]], [[8065, 8065], "mapped", [7937, 953]], [[8066, 8066], "mapped", [7938, 953]], [[8067, 8067], "mapped", [7939, 953]], [[8068, 8068], "mapped", [7940, 953]], [[8069, 8069], "mapped", [7941, 953]], [[8070, 8070], "mapped", [7942, 953]], [[8071, 8071], "mapped", [7943, 953]], [[8072, 8072], "mapped", [7936, 953]], [[8073, 8073], "mapped", [7937, 953]], [[8074, 8074], "mapped", [7938, 953]], [[8075, 8075], "mapped", [7939, 953]], [[8076, 8076], "mapped", [7940, 953]], [[8077, 8077], "mapped", [7941, 953]], [[8078, 8078], "mapped", [7942, 953]], [[8079, 8079], "mapped", [7943, 953]], [[8080, 8080], "mapped", [7968, 953]], [[8081, 8081], "mapped", [7969, 953]], [[8082, 8082], "mapped", [7970, 953]], [[8083, 8083], "mapped", [7971, 953]], [[8084, 8084], "mapped", [7972, 953]], [[8085, 8085], "mapped", [7973, 953]], [[8086, 8086], "mapped", [7974, 953]], [[8087, 8087], "mapped", [7975, 953]], [[8088, 8088], "mapped", [7968, 953]], [[8089, 8089], "mapped", [7969, 953]], [[8090, 8090], "mapped", [7970, 953]], [[8091, 8091], "mapped", [7971, 953]], [[8092, 8092], "mapped", [7972, 953]], [[8093, 8093], "mapped", [7973, 953]], [[8094, 8094], "mapped", [7974, 953]], [[8095, 8095], "mapped", [7975, 953]], [[8096, 8096], "mapped", [8032, 953]], [[8097, 8097], "mapped", [8033, 953]], [[8098, 8098], "mapped", [8034, 953]], [[8099, 8099], "mapped", [8035, 953]], [[8100, 8100], "mapped", [8036, 953]], [[8101, 8101], "mapped", [8037, 953]], [[8102, 8102], "mapped", [8038, 953]], [[8103, 8103], "mapped", [8039, 953]], [[8104, 8104], "mapped", [8032, 953]], [[8105, 8105], "mapped", [8033, 953]], [[8106, 8106], "mapped", [8034, 953]], [[8107, 8107], "mapped", [8035, 953]], [[8108, 8108], "mapped", [8036, 953]], [[8109, 8109], "mapped", [8037, 953]], [[8110, 8110], "mapped", [8038, 953]], [[8111, 8111], "mapped", [8039, 953]], [[8112, 8113], "valid"], [[8114, 8114], "mapped", [8048, 953]], [[8115, 8115], "mapped", [945, 953]], [[8116, 8116], "mapped", [940, 953]], [[8117, 8117], "disallowed"], [[8118, 8118], "valid"], [[8119, 8119], "mapped", [8118, 953]], [[8120, 8120], "mapped", [8112]], [[8121, 8121], "mapped", [8113]], [[8122, 8122], "mapped", [8048]], [[8123, 8123], "mapped", [940]], [[8124, 8124], "mapped", [945, 953]], [[8125, 8125], "disallowed_STD3_mapped", [32, 787]], [[8126, 8126], "mapped", [953]], [[8127, 8127], "disallowed_STD3_mapped", [32, 787]], [[8128, 8128], "disallowed_STD3_mapped", [32, 834]], [[8129, 8129], "disallowed_STD3_mapped", [32, 776, 834]], [[8130, 8130], "mapped", [8052, 953]], [[8131, 8131], "mapped", [951, 953]], [[8132, 8132], "mapped", [942, 953]], [[8133, 8133], "disallowed"], [[8134, 8134], "valid"], [[8135, 8135], "mapped", [8134, 953]], [[8136, 8136], "mapped", [8050]], [[8137, 8137], "mapped", [941]], [[8138, 8138], "mapped", [8052]], [[8139, 8139], "mapped", [942]], [[8140, 8140], "mapped", [951, 953]], [[8141, 8141], "disallowed_STD3_mapped", [32, 787, 768]], [[8142, 8142], "disallowed_STD3_mapped", [32, 787, 769]], [[8143, 8143], "disallowed_STD3_mapped", [32, 787, 834]], [[8144, 8146], "valid"], [[8147, 8147], "mapped", [912]], [[8148, 8149], "disallowed"], [[8150, 8151], "valid"], [[8152, 8152], "mapped", [8144]], [[8153, 8153], "mapped", [8145]], [[8154, 8154], "mapped", [8054]], [[8155, 8155], "mapped", [943]], [[8156, 8156], "disallowed"], [[8157, 8157], "disallowed_STD3_mapped", [32, 788, 768]], [[8158, 8158], "disallowed_STD3_mapped", [32, 788, 769]], [[8159, 8159], "disallowed_STD3_mapped", [32, 788, 834]], [[8160, 8162], "valid"], [[8163, 8163], "mapped", [944]], [[8164, 8167], "valid"], [[8168, 8168], "mapped", [8160]], [[8169, 8169], "mapped", [8161]], [[8170, 8170], "mapped", [8058]], [[8171, 8171], "mapped", [973]], [[8172, 8172], "mapped", [8165]], [[8173, 8173], "disallowed_STD3_mapped", [32, 776, 768]], [[8174, 8174], "disallowed_STD3_mapped", [32, 776, 769]], [[8175, 8175], "disallowed_STD3_mapped", [96]], [[8176, 8177], "disallowed"], [[8178, 8178], "mapped", [8060, 953]], [[8179, 8179], "mapped", [969, 953]], [[8180, 8180], "mapped", [974, 953]], [[8181, 8181], "disallowed"], [[8182, 8182], "valid"], [[8183, 8183], "mapped", [8182, 953]], [[8184, 8184], "mapped", [8056]], [[8185, 8185], "mapped", [972]], [[8186, 8186], "mapped", [8060]], [[8187, 8187], "mapped", [974]], [[8188, 8188], "mapped", [969, 953]], [[8189, 8189], "disallowed_STD3_mapped", [32, 769]], [[8190, 8190], "disallowed_STD3_mapped", [32, 788]], [[8191, 8191], "disallowed"], [[8192, 8202], "disallowed_STD3_mapped", [32]], [[8203, 8203], "ignored"], [[8204, 8205], "deviation", []], [[8206, 8207], "disallowed"], [[8208, 8208], "valid", [], "NV8"], [[8209, 8209], "mapped", [8208]], [[8210, 8214], "valid", [], "NV8"], [[8215, 8215], "disallowed_STD3_mapped", [32, 819]], [[8216, 8227], "valid", [], "NV8"], [[8228, 8230], "disallowed"], [[8231, 8231], "valid", [], "NV8"], [[8232, 8238], "disallowed"], [[8239, 8239], "disallowed_STD3_mapped", [32]], [[8240, 8242], "valid", [], "NV8"], [[8243, 8243], "mapped", [8242, 8242]], [[8244, 8244], "mapped", [8242, 8242, 8242]], [[8245, 8245], "valid", [], "NV8"], [[8246, 8246], "mapped", [8245, 8245]], [[8247, 8247], "mapped", [8245, 8245, 8245]], [[8248, 8251], "valid", [], "NV8"], [[8252, 8252], "disallowed_STD3_mapped", [33, 33]], [[8253, 8253], "valid", [], "NV8"], [[8254, 8254], "disallowed_STD3_mapped", [32, 773]], [[8255, 8262], "valid", [], "NV8"], [[8263, 8263], "disallowed_STD3_mapped", [63, 63]], [[8264, 8264], "disallowed_STD3_mapped", [63, 33]], [[8265, 8265], "disallowed_STD3_mapped", [33, 63]], [[8266, 8269], "valid", [], "NV8"], [[8270, 8274], "valid", [], "NV8"], [[8275, 8276], "valid", [], "NV8"], [[8277, 8278], "valid", [], "NV8"], [[8279, 8279], "mapped", [8242, 8242, 8242, 8242]], [[8280, 8286], "valid", [], "NV8"], [[8287, 8287], "disallowed_STD3_mapped", [32]], [[8288, 8288], "ignored"], [[8289, 8291], "disallowed"], [[8292, 8292], "ignored"], [[8293, 8293], "disallowed"], [[8294, 8297], "disallowed"], [[8298, 8303], "disallowed"], [[8304, 8304], "mapped", [48]], [[8305, 8305], "mapped", [105]], [[8306, 8307], "disallowed"], [[8308, 8308], "mapped", [52]], [[8309, 8309], "mapped", [53]], [[8310, 8310], "mapped", [54]], [[8311, 8311], "mapped", [55]], [[8312, 8312], "mapped", [56]], [[8313, 8313], "mapped", [57]], [[8314, 8314], "disallowed_STD3_mapped", [43]], [[8315, 8315], "mapped", [8722]], [[8316, 8316], "disallowed_STD3_mapped", [61]], [[8317, 8317], "disallowed_STD3_mapped", [40]], [[8318, 8318], "disallowed_STD3_mapped", [41]], [[8319, 8319], "mapped", [110]], [[8320, 8320], "mapped", [48]], [[8321, 8321], "mapped", [49]], [[8322, 8322], "mapped", [50]], [[8323, 8323], "mapped", [51]], [[8324, 8324], "mapped", [52]], [[8325, 8325], "mapped", [53]], [[8326, 8326], "mapped", [54]], [[8327, 8327], "mapped", [55]], [[8328, 8328], "mapped", [56]], [[8329, 8329], "mapped", [57]], [[8330, 8330], "disallowed_STD3_mapped", [43]], [[8331, 8331], "mapped", [8722]], [[8332, 8332], "disallowed_STD3_mapped", [61]], [[8333, 8333], "disallowed_STD3_mapped", [40]], [[8334, 8334], "disallowed_STD3_mapped", [41]], [[8335, 8335], "disallowed"], [[8336, 8336], "mapped", [97]], [[8337, 8337], "mapped", [101]], [[8338, 8338], "mapped", [111]], [[8339, 8339], "mapped", [120]], [[8340, 8340], "mapped", [601]], [[8341, 8341], "mapped", [104]], [[8342, 8342], "mapped", [107]], [[8343, 8343], "mapped", [108]], [[8344, 8344], "mapped", [109]], [[8345, 8345], "mapped", [110]], [[8346, 8346], "mapped", [112]], [[8347, 8347], "mapped", [115]], [[8348, 8348], "mapped", [116]], [[8349, 8351], "disallowed"], [[8352, 8359], "valid", [], "NV8"], [[8360, 8360], "mapped", [114, 115]], [[8361, 8362], "valid", [], "NV8"], [[8363, 8363], "valid", [], "NV8"], [[8364, 8364], "valid", [], "NV8"], [[8365, 8367], "valid", [], "NV8"], [[8368, 8369], "valid", [], "NV8"], [[8370, 8373], "valid", [], "NV8"], [[8374, 8376], "valid", [], "NV8"], [[8377, 8377], "valid", [], "NV8"], [[8378, 8378], "valid", [], "NV8"], [[8379, 8381], "valid", [], "NV8"], [[8382, 8382], "valid", [], "NV8"], [[8383, 8399], "disallowed"], [[8400, 8417], "valid", [], "NV8"], [[8418, 8419], "valid", [], "NV8"], [[8420, 8426], "valid", [], "NV8"], [[8427, 8427], "valid", [], "NV8"], [[8428, 8431], "valid", [], "NV8"], [[8432, 8432], "valid", [], "NV8"], [[8433, 8447], "disallowed"], [[8448, 8448], "disallowed_STD3_mapped", [97, 47, 99]], [[8449, 8449], "disallowed_STD3_mapped", [97, 47, 115]], [[8450, 8450], "mapped", [99]], [[8451, 8451], "mapped", [176, 99]], [[8452, 8452], "valid", [], "NV8"], [[8453, 8453], "disallowed_STD3_mapped", [99, 47, 111]], [[8454, 8454], "disallowed_STD3_mapped", [99, 47, 117]], [[8455, 8455], "mapped", [603]], [[8456, 8456], "valid", [], "NV8"], [[8457, 8457], "mapped", [176, 102]], [[8458, 8458], "mapped", [103]], [[8459, 8462], "mapped", [104]], [[8463, 8463], "mapped", [295]], [[8464, 8465], "mapped", [105]], [[8466, 8467], "mapped", [108]], [[8468, 8468], "valid", [], "NV8"], [[8469, 8469], "mapped", [110]], [[8470, 8470], "mapped", [110, 111]], [[8471, 8472], "valid", [], "NV8"], [[8473, 8473], "mapped", [112]], [[8474, 8474], "mapped", [113]], [[8475, 8477], "mapped", [114]], [[8478, 8479], "valid", [], "NV8"], [[8480, 8480], "mapped", [115, 109]], [[8481, 8481], "mapped", [116, 101, 108]], [[8482, 8482], "mapped", [116, 109]], [[8483, 8483], "valid", [], "NV8"], [[8484, 8484], "mapped", [122]], [[8485, 8485], "valid", [], "NV8"], [[8486, 8486], "mapped", [969]], [[8487, 8487], "valid", [], "NV8"], [[8488, 8488], "mapped", [122]], [[8489, 8489], "valid", [], "NV8"], [[8490, 8490], "mapped", [107]], [[8491, 8491], "mapped", [229]], [[8492, 8492], "mapped", [98]], [[8493, 8493], "mapped", [99]], [[8494, 8494], "valid", [], "NV8"], [[8495, 8496], "mapped", [101]], [[8497, 8497], "mapped", [102]], [[8498, 8498], "disallowed"], [[8499, 8499], "mapped", [109]], [[8500, 8500], "mapped", [111]], [[8501, 8501], "mapped", [1488]], [[8502, 8502], "mapped", [1489]], [[8503, 8503], "mapped", [1490]], [[8504, 8504], "mapped", [1491]], [[8505, 8505], "mapped", [105]], [[8506, 8506], "valid", [], "NV8"], [[8507, 8507], "mapped", [102, 97, 120]], [[8508, 8508], "mapped", [960]], [[8509, 8510], "mapped", [947]], [[8511, 8511], "mapped", [960]], [[8512, 8512], "mapped", [8721]], [[8513, 8516], "valid", [], "NV8"], [[8517, 8518], "mapped", [100]], [[8519, 8519], "mapped", [101]], [[8520, 8520], "mapped", [105]], [[8521, 8521], "mapped", [106]], [[8522, 8523], "valid", [], "NV8"], [[8524, 8524], "valid", [], "NV8"], [[8525, 8525], "valid", [], "NV8"], [[8526, 8526], "valid"], [[8527, 8527], "valid", [], "NV8"], [[8528, 8528], "mapped", [49, 8260, 55]], [[8529, 8529], "mapped", [49, 8260, 57]], [[8530, 8530], "mapped", [49, 8260, 49, 48]], [[8531, 8531], "mapped", [49, 8260, 51]], [[8532, 8532], "mapped", [50, 8260, 51]], [[8533, 8533], "mapped", [49, 8260, 53]], [[8534, 8534], "mapped", [50, 8260, 53]], [[8535, 8535], "mapped", [51, 8260, 53]], [[8536, 8536], "mapped", [52, 8260, 53]], [[8537, 8537], "mapped", [49, 8260, 54]], [[8538, 8538], "mapped", [53, 8260, 54]], [[8539, 8539], "mapped", [49, 8260, 56]], [[8540, 8540], "mapped", [51, 8260, 56]], [[8541, 8541], "mapped", [53, 8260, 56]], [[8542, 8542], "mapped", [55, 8260, 56]], [[8543, 8543], "mapped", [49, 8260]], [[8544, 8544], "mapped", [105]], [[8545, 8545], "mapped", [105, 105]], [[8546, 8546], "mapped", [105, 105, 105]], [[8547, 8547], "mapped", [105, 118]], [[8548, 8548], "mapped", [118]], [[8549, 8549], "mapped", [118, 105]], [[8550, 8550], "mapped", [118, 105, 105]], [[8551, 8551], "mapped", [118, 105, 105, 105]], [[8552, 8552], "mapped", [105, 120]], [[8553, 8553], "mapped", [120]], [[8554, 8554], "mapped", [120, 105]], [[8555, 8555], "mapped", [120, 105, 105]], [[8556, 8556], "mapped", [108]], [[8557, 8557], "mapped", [99]], [[8558, 8558], "mapped", [100]], [[8559, 8559], "mapped", [109]], [[8560, 8560], "mapped", [105]], [[8561, 8561], "mapped", [105, 105]], [[8562, 8562], "mapped", [105, 105, 105]], [[8563, 8563], "mapped", [105, 118]], [[8564, 8564], "mapped", [118]], [[8565, 8565], "mapped", [118, 105]], [[8566, 8566], "mapped", [118, 105, 105]], [[8567, 8567], "mapped", [118, 105, 105, 105]], [[8568, 8568], "mapped", [105, 120]], [[8569, 8569], "mapped", [120]], [[8570, 8570], "mapped", [120, 105]], [[8571, 8571], "mapped", [120, 105, 105]], [[8572, 8572], "mapped", [108]], [[8573, 8573], "mapped", [99]], [[8574, 8574], "mapped", [100]], [[8575, 8575], "mapped", [109]], [[8576, 8578], "valid", [], "NV8"], [[8579, 8579], "disallowed"], [[8580, 8580], "valid"], [[8581, 8584], "valid", [], "NV8"], [[8585, 8585], "mapped", [48, 8260, 51]], [[8586, 8587], "valid", [], "NV8"], [[8588, 8591], "disallowed"], [[8592, 8682], "valid", [], "NV8"], [[8683, 8691], "valid", [], "NV8"], [[8692, 8703], "valid", [], "NV8"], [[8704, 8747], "valid", [], "NV8"], [[8748, 8748], "mapped", [8747, 8747]], [[8749, 8749], "mapped", [8747, 8747, 8747]], [[8750, 8750], "valid", [], "NV8"], [[8751, 8751], "mapped", [8750, 8750]], [[8752, 8752], "mapped", [8750, 8750, 8750]], [[8753, 8799], "valid", [], "NV8"], [[8800, 8800], "disallowed_STD3_valid"], [[8801, 8813], "valid", [], "NV8"], [[8814, 8815], "disallowed_STD3_valid"], [[8816, 8945], "valid", [], "NV8"], [[8946, 8959], "valid", [], "NV8"], [[8960, 8960], "valid", [], "NV8"], [[8961, 8961], "valid", [], "NV8"], [[8962, 9e3], "valid", [], "NV8"], [[9001, 9001], "mapped", [12296]], [[9002, 9002], "mapped", [12297]], [[9003, 9082], "valid", [], "NV8"], [[9083, 9083], "valid", [], "NV8"], [[9084, 9084], "valid", [], "NV8"], [[9085, 9114], "valid", [], "NV8"], [[9115, 9166], "valid", [], "NV8"], [[9167, 9168], "valid", [], "NV8"], [[9169, 9179], "valid", [], "NV8"], [[9180, 9191], "valid", [], "NV8"], [[9192, 9192], "valid", [], "NV8"], [[9193, 9203], "valid", [], "NV8"], [[9204, 9210], "valid", [], "NV8"], [[9211, 9215], "disallowed"], [[9216, 9252], "valid", [], "NV8"], [[9253, 9254], "valid", [], "NV8"], [[9255, 9279], "disallowed"], [[9280, 9290], "valid", [], "NV8"], [[9291, 9311], "disallowed"], [[9312, 9312], "mapped", [49]], [[9313, 9313], "mapped", [50]], [[9314, 9314], "mapped", [51]], [[9315, 9315], "mapped", [52]], [[9316, 9316], "mapped", [53]], [[9317, 9317], "mapped", [54]], [[9318, 9318], "mapped", [55]], [[9319, 9319], "mapped", [56]], [[9320, 9320], "mapped", [57]], [[9321, 9321], "mapped", [49, 48]], [[9322, 9322], "mapped", [49, 49]], [[9323, 9323], "mapped", [49, 50]], [[9324, 9324], "mapped", [49, 51]], [[9325, 9325], "mapped", [49, 52]], [[9326, 9326], "mapped", [49, 53]], [[9327, 9327], "mapped", [49, 54]], [[9328, 9328], "mapped", [49, 55]], [[9329, 9329], "mapped", [49, 56]], [[9330, 9330], "mapped", [49, 57]], [[9331, 9331], "mapped", [50, 48]], [[9332, 9332], "disallowed_STD3_mapped", [40, 49, 41]], [[9333, 9333], "disallowed_STD3_mapped", [40, 50, 41]], [[9334, 9334], "disallowed_STD3_mapped", [40, 51, 41]], [[9335, 9335], "disallowed_STD3_mapped", [40, 52, 41]], [[9336, 9336], "disallowed_STD3_mapped", [40, 53, 41]], [[9337, 9337], "disallowed_STD3_mapped", [40, 54, 41]], [[9338, 9338], "disallowed_STD3_mapped", [40, 55, 41]], [[9339, 9339], "disallowed_STD3_mapped", [40, 56, 41]], [[9340, 9340], "disallowed_STD3_mapped", [40, 57, 41]], [[9341, 9341], "disallowed_STD3_mapped", [40, 49, 48, 41]], [[9342, 9342], "disallowed_STD3_mapped", [40, 49, 49, 41]], [[9343, 9343], "disallowed_STD3_mapped", [40, 49, 50, 41]], [[9344, 9344], "disallowed_STD3_mapped", [40, 49, 51, 41]], [[9345, 9345], "disallowed_STD3_mapped", [40, 49, 52, 41]], [[9346, 9346], "disallowed_STD3_mapped", [40, 49, 53, 41]], [[9347, 9347], "disallowed_STD3_mapped", [40, 49, 54, 41]], [[9348, 9348], "disallowed_STD3_mapped", [40, 49, 55, 41]], [[9349, 9349], "disallowed_STD3_mapped", [40, 49, 56, 41]], [[9350, 9350], "disallowed_STD3_mapped", [40, 49, 57, 41]], [[9351, 9351], "disallowed_STD3_mapped", [40, 50, 48, 41]], [[9352, 9371], "disallowed"], [[9372, 9372], "disallowed_STD3_mapped", [40, 97, 41]], [[9373, 9373], "disallowed_STD3_mapped", [40, 98, 41]], [[9374, 9374], "disallowed_STD3_mapped", [40, 99, 41]], [[9375, 9375], "disallowed_STD3_mapped", [40, 100, 41]], [[9376, 9376], "disallowed_STD3_mapped", [40, 101, 41]], [[9377, 9377], "disallowed_STD3_mapped", [40, 102, 41]], [[9378, 9378], "disallowed_STD3_mapped", [40, 103, 41]], [[9379, 9379], "disallowed_STD3_mapped", [40, 104, 41]], [[9380, 9380], "disallowed_STD3_mapped", [40, 105, 41]], [[9381, 9381], "disallowed_STD3_mapped", [40, 106, 41]], [[9382, 9382], "disallowed_STD3_mapped", [40, 107, 41]], [[9383, 9383], "disallowed_STD3_mapped", [40, 108, 41]], [[9384, 9384], "disallowed_STD3_mapped", [40, 109, 41]], [[9385, 9385], "disallowed_STD3_mapped", [40, 110, 41]], [[9386, 9386], "disallowed_STD3_mapped", [40, 111, 41]], [[9387, 9387], "disallowed_STD3_mapped", [40, 112, 41]], [[9388, 9388], "disallowed_STD3_mapped", [40, 113, 41]], [[9389, 9389], "disallowed_STD3_mapped", [40, 114, 41]], [[9390, 9390], "disallowed_STD3_mapped", [40, 115, 41]], [[9391, 9391], "disallowed_STD3_mapped", [40, 116, 41]], [[9392, 9392], "disallowed_STD3_mapped", [40, 117, 41]], [[9393, 9393], "disallowed_STD3_mapped", [40, 118, 41]], [[9394, 9394], "disallowed_STD3_mapped", [40, 119, 41]], [[9395, 9395], "disallowed_STD3_mapped", [40, 120, 41]], [[9396, 9396], "disallowed_STD3_mapped", [40, 121, 41]], [[9397, 9397], "disallowed_STD3_mapped", [40, 122, 41]], [[9398, 9398], "mapped", [97]], [[9399, 9399], "mapped", [98]], [[9400, 9400], "mapped", [99]], [[9401, 9401], "mapped", [100]], [[9402, 9402], "mapped", [101]], [[9403, 9403], "mapped", [102]], [[9404, 9404], "mapped", [103]], [[9405, 9405], "mapped", [104]], [[9406, 9406], "mapped", [105]], [[9407, 9407], "mapped", [106]], [[9408, 9408], "mapped", [107]], [[9409, 9409], "mapped", [108]], [[9410, 9410], "mapped", [109]], [[9411, 9411], "mapped", [110]], [[9412, 9412], "mapped", [111]], [[9413, 9413], "mapped", [112]], [[9414, 9414], "mapped", [113]], [[9415, 9415], "mapped", [114]], [[9416, 9416], "mapped", [115]], [[9417, 9417], "mapped", [116]], [[9418, 9418], "mapped", [117]], [[9419, 9419], "mapped", [118]], [[9420, 9420], "mapped", [119]], [[9421, 9421], "mapped", [120]], [[9422, 9422], "mapped", [121]], [[9423, 9423], "mapped", [122]], [[9424, 9424], "mapped", [97]], [[9425, 9425], "mapped", [98]], [[9426, 9426], "mapped", [99]], [[9427, 9427], "mapped", [100]], [[9428, 9428], "mapped", [101]], [[9429, 9429], "mapped", [102]], [[9430, 9430], "mapped", [103]], [[9431, 9431], "mapped", [104]], [[9432, 9432], "mapped", [105]], [[9433, 9433], "mapped", [106]], [[9434, 9434], "mapped", [107]], [[9435, 9435], "mapped", [108]], [[9436, 9436], "mapped", [109]], [[9437, 9437], "mapped", [110]], [[9438, 9438], "mapped", [111]], [[9439, 9439], "mapped", [112]], [[9440, 9440], "mapped", [113]], [[9441, 9441], "mapped", [114]], [[9442, 9442], "mapped", [115]], [[9443, 9443], "mapped", [116]], [[9444, 9444], "mapped", [117]], [[9445, 9445], "mapped", [118]], [[9446, 9446], "mapped", [119]], [[9447, 9447], "mapped", [120]], [[9448, 9448], "mapped", [121]], [[9449, 9449], "mapped", [122]], [[9450, 9450], "mapped", [48]], [[9451, 9470], "valid", [], "NV8"], [[9471, 9471], "valid", [], "NV8"], [[9472, 9621], "valid", [], "NV8"], [[9622, 9631], "valid", [], "NV8"], [[9632, 9711], "valid", [], "NV8"], [[9712, 9719], "valid", [], "NV8"], [[9720, 9727], "valid", [], "NV8"], [[9728, 9747], "valid", [], "NV8"], [[9748, 9749], "valid", [], "NV8"], [[9750, 9751], "valid", [], "NV8"], [[9752, 9752], "valid", [], "NV8"], [[9753, 9753], "valid", [], "NV8"], [[9754, 9839], "valid", [], "NV8"], [[9840, 9841], "valid", [], "NV8"], [[9842, 9853], "valid", [], "NV8"], [[9854, 9855], "valid", [], "NV8"], [[9856, 9865], "valid", [], "NV8"], [[9866, 9873], "valid", [], "NV8"], [[9874, 9884], "valid", [], "NV8"], [[9885, 9885], "valid", [], "NV8"], [[9886, 9887], "valid", [], "NV8"], [[9888, 9889], "valid", [], "NV8"], [[9890, 9905], "valid", [], "NV8"], [[9906, 9906], "valid", [], "NV8"], [[9907, 9916], "valid", [], "NV8"], [[9917, 9919], "valid", [], "NV8"], [[9920, 9923], "valid", [], "NV8"], [[9924, 9933], "valid", [], "NV8"], [[9934, 9934], "valid", [], "NV8"], [[9935, 9953], "valid", [], "NV8"], [[9954, 9954], "valid", [], "NV8"], [[9955, 9955], "valid", [], "NV8"], [[9956, 9959], "valid", [], "NV8"], [[9960, 9983], "valid", [], "NV8"], [[9984, 9984], "valid", [], "NV8"], [[9985, 9988], "valid", [], "NV8"], [[9989, 9989], "valid", [], "NV8"], [[9990, 9993], "valid", [], "NV8"], [[9994, 9995], "valid", [], "NV8"], [[9996, 10023], "valid", [], "NV8"], [[10024, 10024], "valid", [], "NV8"], [[10025, 10059], "valid", [], "NV8"], [[10060, 10060], "valid", [], "NV8"], [[10061, 10061], "valid", [], "NV8"], [[10062, 10062], "valid", [], "NV8"], [[10063, 10066], "valid", [], "NV8"], [[10067, 10069], "valid", [], "NV8"], [[10070, 10070], "valid", [], "NV8"], [[10071, 10071], "valid", [], "NV8"], [[10072, 10078], "valid", [], "NV8"], [[10079, 10080], "valid", [], "NV8"], [[10081, 10087], "valid", [], "NV8"], [[10088, 10101], "valid", [], "NV8"], [[10102, 10132], "valid", [], "NV8"], [[10133, 10135], "valid", [], "NV8"], [[10136, 10159], "valid", [], "NV8"], [[10160, 10160], "valid", [], "NV8"], [[10161, 10174], "valid", [], "NV8"], [[10175, 10175], "valid", [], "NV8"], [[10176, 10182], "valid", [], "NV8"], [[10183, 10186], "valid", [], "NV8"], [[10187, 10187], "valid", [], "NV8"], [[10188, 10188], "valid", [], "NV8"], [[10189, 10189], "valid", [], "NV8"], [[10190, 10191], "valid", [], "NV8"], [[10192, 10219], "valid", [], "NV8"], [[10220, 10223], "valid", [], "NV8"], [[10224, 10239], "valid", [], "NV8"], [[10240, 10495], "valid", [], "NV8"], [[10496, 10763], "valid", [], "NV8"], [[10764, 10764], "mapped", [8747, 8747, 8747, 8747]], [[10765, 10867], "valid", [], "NV8"], [[10868, 10868], "disallowed_STD3_mapped", [58, 58, 61]], [[10869, 10869], "disallowed_STD3_mapped", [61, 61]], [[10870, 10870], "disallowed_STD3_mapped", [61, 61, 61]], [[10871, 10971], "valid", [], "NV8"], [[10972, 10972], "mapped", [10973, 824]], [[10973, 11007], "valid", [], "NV8"], [[11008, 11021], "valid", [], "NV8"], [[11022, 11027], "valid", [], "NV8"], [[11028, 11034], "valid", [], "NV8"], [[11035, 11039], "valid", [], "NV8"], [[11040, 11043], "valid", [], "NV8"], [[11044, 11084], "valid", [], "NV8"], [[11085, 11087], "valid", [], "NV8"], [[11088, 11092], "valid", [], "NV8"], [[11093, 11097], "valid", [], "NV8"], [[11098, 11123], "valid", [], "NV8"], [[11124, 11125], "disallowed"], [[11126, 11157], "valid", [], "NV8"], [[11158, 11159], "disallowed"], [[11160, 11193], "valid", [], "NV8"], [[11194, 11196], "disallowed"], [[11197, 11208], "valid", [], "NV8"], [[11209, 11209], "disallowed"], [[11210, 11217], "valid", [], "NV8"], [[11218, 11243], "disallowed"], [[11244, 11247], "valid", [], "NV8"], [[11248, 11263], "disallowed"], [[11264, 11264], "mapped", [11312]], [[11265, 11265], "mapped", [11313]], [[11266, 11266], "mapped", [11314]], [[11267, 11267], "mapped", [11315]], [[11268, 11268], "mapped", [11316]], [[11269, 11269], "mapped", [11317]], [[11270, 11270], "mapped", [11318]], [[11271, 11271], "mapped", [11319]], [[11272, 11272], "mapped", [11320]], [[11273, 11273], "mapped", [11321]], [[11274, 11274], "mapped", [11322]], [[11275, 11275], "mapped", [11323]], [[11276, 11276], "mapped", [11324]], [[11277, 11277], "mapped", [11325]], [[11278, 11278], "mapped", [11326]], [[11279, 11279], "mapped", [11327]], [[11280, 11280], "mapped", [11328]], [[11281, 11281], "mapped", [11329]], [[11282, 11282], "mapped", [11330]], [[11283, 11283], "mapped", [11331]], [[11284, 11284], "mapped", [11332]], [[11285, 11285], "mapped", [11333]], [[11286, 11286], "mapped", [11334]], [[11287, 11287], "mapped", [11335]], [[11288, 11288], "mapped", [11336]], [[11289, 11289], "mapped", [11337]], [[11290, 11290], "mapped", [11338]], [[11291, 11291], "mapped", [11339]], [[11292, 11292], "mapped", [11340]], [[11293, 11293], "mapped", [11341]], [[11294, 11294], "mapped", [11342]], [[11295, 11295], "mapped", [11343]], [[11296, 11296], "mapped", [11344]], [[11297, 11297], "mapped", [11345]], [[11298, 11298], "mapped", [11346]], [[11299, 11299], "mapped", [11347]], [[11300, 11300], "mapped", [11348]], [[11301, 11301], "mapped", [11349]], [[11302, 11302], "mapped", [11350]], [[11303, 11303], "mapped", [11351]], [[11304, 11304], "mapped", [11352]], [[11305, 11305], "mapped", [11353]], [[11306, 11306], "mapped", [11354]], [[11307, 11307], "mapped", [11355]], [[11308, 11308], "mapped", [11356]], [[11309, 11309], "mapped", [11357]], [[11310, 11310], "mapped", [11358]], [[11311, 11311], "disallowed"], [[11312, 11358], "valid"], [[11359, 11359], "disallowed"], [[11360, 11360], "mapped", [11361]], [[11361, 11361], "valid"], [[11362, 11362], "mapped", [619]], [[11363, 11363], "mapped", [7549]], [[11364, 11364], "mapped", [637]], [[11365, 11366], "valid"], [[11367, 11367], "mapped", [11368]], [[11368, 11368], "valid"], [[11369, 11369], "mapped", [11370]], [[11370, 11370], "valid"], [[11371, 11371], "mapped", [11372]], [[11372, 11372], "valid"], [[11373, 11373], "mapped", [593]], [[11374, 11374], "mapped", [625]], [[11375, 11375], "mapped", [592]], [[11376, 11376], "mapped", [594]], [[11377, 11377], "valid"], [[11378, 11378], "mapped", [11379]], [[11379, 11379], "valid"], [[11380, 11380], "valid"], [[11381, 11381], "mapped", [11382]], [[11382, 11383], "valid"], [[11384, 11387], "valid"], [[11388, 11388], "mapped", [106]], [[11389, 11389], "mapped", [118]], [[11390, 11390], "mapped", [575]], [[11391, 11391], "mapped", [576]], [[11392, 11392], "mapped", [11393]], [[11393, 11393], "valid"], [[11394, 11394], "mapped", [11395]], [[11395, 11395], "valid"], [[11396, 11396], "mapped", [11397]], [[11397, 11397], "valid"], [[11398, 11398], "mapped", [11399]], [[11399, 11399], "valid"], [[11400, 11400], "mapped", [11401]], [[11401, 11401], "valid"], [[11402, 11402], "mapped", [11403]], [[11403, 11403], "valid"], [[11404, 11404], "mapped", [11405]], [[11405, 11405], "valid"], [[11406, 11406], "mapped", [11407]], [[11407, 11407], "valid"], [[11408, 11408], "mapped", [11409]], [[11409, 11409], "valid"], [[11410, 11410], "mapped", [11411]], [[11411, 11411], "valid"], [[11412, 11412], "mapped", [11413]], [[11413, 11413], "valid"], [[11414, 11414], "mapped", [11415]], [[11415, 11415], "valid"], [[11416, 11416], "mapped", [11417]], [[11417, 11417], "valid"], [[11418, 11418], "mapped", [11419]], [[11419, 11419], "valid"], [[11420, 11420], "mapped", [11421]], [[11421, 11421], "valid"], [[11422, 11422], "mapped", [11423]], [[11423, 11423], "valid"], [[11424, 11424], "mapped", [11425]], [[11425, 11425], "valid"], [[11426, 11426], "mapped", [11427]], [[11427, 11427], "valid"], [[11428, 11428], "mapped", [11429]], [[11429, 11429], "valid"], [[11430, 11430], "mapped", [11431]], [[11431, 11431], "valid"], [[11432, 11432], "mapped", [11433]], [[11433, 11433], "valid"], [[11434, 11434], "mapped", [11435]], [[11435, 11435], "valid"], [[11436, 11436], "mapped", [11437]], [[11437, 11437], "valid"], [[11438, 11438], "mapped", [11439]], [[11439, 11439], "valid"], [[11440, 11440], "mapped", [11441]], [[11441, 11441], "valid"], [[11442, 11442], "mapped", [11443]], [[11443, 11443], "valid"], [[11444, 11444], "mapped", [11445]], [[11445, 11445], "valid"], [[11446, 11446], "mapped", [11447]], [[11447, 11447], "valid"], [[11448, 11448], "mapped", [11449]], [[11449, 11449], "valid"], [[11450, 11450], "mapped", [11451]], [[11451, 11451], "valid"], [[11452, 11452], "mapped", [11453]], [[11453, 11453], "valid"], [[11454, 11454], "mapped", [11455]], [[11455, 11455], "valid"], [[11456, 11456], "mapped", [11457]], [[11457, 11457], "valid"], [[11458, 11458], "mapped", [11459]], [[11459, 11459], "valid"], [[11460, 11460], "mapped", [11461]], [[11461, 11461], "valid"], [[11462, 11462], "mapped", [11463]], [[11463, 11463], "valid"], [[11464, 11464], "mapped", [11465]], [[11465, 11465], "valid"], [[11466, 11466], "mapped", [11467]], [[11467, 11467], "valid"], [[11468, 11468], "mapped", [11469]], [[11469, 11469], "valid"], [[11470, 11470], "mapped", [11471]], [[11471, 11471], "valid"], [[11472, 11472], "mapped", [11473]], [[11473, 11473], "valid"], [[11474, 11474], "mapped", [11475]], [[11475, 11475], "valid"], [[11476, 11476], "mapped", [11477]], [[11477, 11477], "valid"], [[11478, 11478], "mapped", [11479]], [[11479, 11479], "valid"], [[11480, 11480], "mapped", [11481]], [[11481, 11481], "valid"], [[11482, 11482], "mapped", [11483]], [[11483, 11483], "valid"], [[11484, 11484], "mapped", [11485]], [[11485, 11485], "valid"], [[11486, 11486], "mapped", [11487]], [[11487, 11487], "valid"], [[11488, 11488], "mapped", [11489]], [[11489, 11489], "valid"], [[11490, 11490], "mapped", [11491]], [[11491, 11492], "valid"], [[11493, 11498], "valid", [], "NV8"], [[11499, 11499], "mapped", [11500]], [[11500, 11500], "valid"], [[11501, 11501], "mapped", [11502]], [[11502, 11505], "valid"], [[11506, 11506], "mapped", [11507]], [[11507, 11507], "valid"], [[11508, 11512], "disallowed"], [[11513, 11519], "valid", [], "NV8"], [[11520, 11557], "valid"], [[11558, 11558], "disallowed"], [[11559, 11559], "valid"], [[11560, 11564], "disallowed"], [[11565, 11565], "valid"], [[11566, 11567], "disallowed"], [[11568, 11621], "valid"], [[11622, 11623], "valid"], [[11624, 11630], "disallowed"], [[11631, 11631], "mapped", [11617]], [[11632, 11632], "valid", [], "NV8"], [[11633, 11646], "disallowed"], [[11647, 11647], "valid"], [[11648, 11670], "valid"], [[11671, 11679], "disallowed"], [[11680, 11686], "valid"], [[11687, 11687], "disallowed"], [[11688, 11694], "valid"], [[11695, 11695], "disallowed"], [[11696, 11702], "valid"], [[11703, 11703], "disallowed"], [[11704, 11710], "valid"], [[11711, 11711], "disallowed"], [[11712, 11718], "valid"], [[11719, 11719], "disallowed"], [[11720, 11726], "valid"], [[11727, 11727], "disallowed"], [[11728, 11734], "valid"], [[11735, 11735], "disallowed"], [[11736, 11742], "valid"], [[11743, 11743], "disallowed"], [[11744, 11775], "valid"], [[11776, 11799], "valid", [], "NV8"], [[11800, 11803], "valid", [], "NV8"], [[11804, 11805], "valid", [], "NV8"], [[11806, 11822], "valid", [], "NV8"], [[11823, 11823], "valid"], [[11824, 11824], "valid", [], "NV8"], [[11825, 11825], "valid", [], "NV8"], [[11826, 11835], "valid", [], "NV8"], [[11836, 11842], "valid", [], "NV8"], [[11843, 11903], "disallowed"], [[11904, 11929], "valid", [], "NV8"], [[11930, 11930], "disallowed"], [[11931, 11934], "valid", [], "NV8"], [[11935, 11935], "mapped", [27597]], [[11936, 12018], "valid", [], "NV8"], [[12019, 12019], "mapped", [40863]], [[12020, 12031], "disallowed"], [[12032, 12032], "mapped", [19968]], [[12033, 12033], "mapped", [20008]], [[12034, 12034], "mapped", [20022]], [[12035, 12035], "mapped", [20031]], [[12036, 12036], "mapped", [20057]], [[12037, 12037], "mapped", [20101]], [[12038, 12038], "mapped", [20108]], [[12039, 12039], "mapped", [20128]], [[12040, 12040], "mapped", [20154]], [[12041, 12041], "mapped", [20799]], [[12042, 12042], "mapped", [20837]], [[12043, 12043], "mapped", [20843]], [[12044, 12044], "mapped", [20866]], [[12045, 12045], "mapped", [20886]], [[12046, 12046], "mapped", [20907]], [[12047, 12047], "mapped", [20960]], [[12048, 12048], "mapped", [20981]], [[12049, 12049], "mapped", [20992]], [[12050, 12050], "mapped", [21147]], [[12051, 12051], "mapped", [21241]], [[12052, 12052], "mapped", [21269]], [[12053, 12053], "mapped", [21274]], [[12054, 12054], "mapped", [21304]], [[12055, 12055], "mapped", [21313]], [[12056, 12056], "mapped", [21340]], [[12057, 12057], "mapped", [21353]], [[12058, 12058], "mapped", [21378]], [[12059, 12059], "mapped", [21430]], [[12060, 12060], "mapped", [21448]], [[12061, 12061], "mapped", [21475]], [[12062, 12062], "mapped", [22231]], [[12063, 12063], "mapped", [22303]], [[12064, 12064], "mapped", [22763]], [[12065, 12065], "mapped", [22786]], [[12066, 12066], "mapped", [22794]], [[12067, 12067], "mapped", [22805]], [[12068, 12068], "mapped", [22823]], [[12069, 12069], "mapped", [22899]], [[12070, 12070], "mapped", [23376]], [[12071, 12071], "mapped", [23424]], [[12072, 12072], "mapped", [23544]], [[12073, 12073], "mapped", [23567]], [[12074, 12074], "mapped", [23586]], [[12075, 12075], "mapped", [23608]], [[12076, 12076], "mapped", [23662]], [[12077, 12077], "mapped", [23665]], [[12078, 12078], "mapped", [24027]], [[12079, 12079], "mapped", [24037]], [[12080, 12080], "mapped", [24049]], [[12081, 12081], "mapped", [24062]], [[12082, 12082], "mapped", [24178]], [[12083, 12083], "mapped", [24186]], [[12084, 12084], "mapped", [24191]], [[12085, 12085], "mapped", [24308]], [[12086, 12086], "mapped", [24318]], [[12087, 12087], "mapped", [24331]], [[12088, 12088], "mapped", [24339]], [[12089, 12089], "mapped", [24400]], [[12090, 12090], "mapped", [24417]], [[12091, 12091], "mapped", [24435]], [[12092, 12092], "mapped", [24515]], [[12093, 12093], "mapped", [25096]], [[12094, 12094], "mapped", [25142]], [[12095, 12095], "mapped", [25163]], [[12096, 12096], "mapped", [25903]], [[12097, 12097], "mapped", [25908]], [[12098, 12098], "mapped", [25991]], [[12099, 12099], "mapped", [26007]], [[12100, 12100], "mapped", [26020]], [[12101, 12101], "mapped", [26041]], [[12102, 12102], "mapped", [26080]], [[12103, 12103], "mapped", [26085]], [[12104, 12104], "mapped", [26352]], [[12105, 12105], "mapped", [26376]], [[12106, 12106], "mapped", [26408]], [[12107, 12107], "mapped", [27424]], [[12108, 12108], "mapped", [27490]], [[12109, 12109], "mapped", [27513]], [[12110, 12110], "mapped", [27571]], [[12111, 12111], "mapped", [27595]], [[12112, 12112], "mapped", [27604]], [[12113, 12113], "mapped", [27611]], [[12114, 12114], "mapped", [27663]], [[12115, 12115], "mapped", [27668]], [[12116, 12116], "mapped", [27700]], [[12117, 12117], "mapped", [28779]], [[12118, 12118], "mapped", [29226]], [[12119, 12119], "mapped", [29238]], [[12120, 12120], "mapped", [29243]], [[12121, 12121], "mapped", [29247]], [[12122, 12122], "mapped", [29255]], [[12123, 12123], "mapped", [29273]], [[12124, 12124], "mapped", [29275]], [[12125, 12125], "mapped", [29356]], [[12126, 12126], "mapped", [29572]], [[12127, 12127], "mapped", [29577]], [[12128, 12128], "mapped", [29916]], [[12129, 12129], "mapped", [29926]], [[12130, 12130], "mapped", [29976]], [[12131, 12131], "mapped", [29983]], [[12132, 12132], "mapped", [29992]], [[12133, 12133], "mapped", [3e4]], [[12134, 12134], "mapped", [30091]], [[12135, 12135], "mapped", [30098]], [[12136, 12136], "mapped", [30326]], [[12137, 12137], "mapped", [30333]], [[12138, 12138], "mapped", [30382]], [[12139, 12139], "mapped", [30399]], [[12140, 12140], "mapped", [30446]], [[12141, 12141], "mapped", [30683]], [[12142, 12142], "mapped", [30690]], [[12143, 12143], "mapped", [30707]], [[12144, 12144], "mapped", [31034]], [[12145, 12145], "mapped", [31160]], [[12146, 12146], "mapped", [31166]], [[12147, 12147], "mapped", [31348]], [[12148, 12148], "mapped", [31435]], [[12149, 12149], "mapped", [31481]], [[12150, 12150], "mapped", [31859]], [[12151, 12151], "mapped", [31992]], [[12152, 12152], "mapped", [32566]], [[12153, 12153], "mapped", [32593]], [[12154, 12154], "mapped", [32650]], [[12155, 12155], "mapped", [32701]], [[12156, 12156], "mapped", [32769]], [[12157, 12157], "mapped", [32780]], [[12158, 12158], "mapped", [32786]], [[12159, 12159], "mapped", [32819]], [[12160, 12160], "mapped", [32895]], [[12161, 12161], "mapped", [32905]], [[12162, 12162], "mapped", [33251]], [[12163, 12163], "mapped", [33258]], [[12164, 12164], "mapped", [33267]], [[12165, 12165], "mapped", [33276]], [[12166, 12166], "mapped", [33292]], [[12167, 12167], "mapped", [33307]], [[12168, 12168], "mapped", [33311]], [[12169, 12169], "mapped", [33390]], [[12170, 12170], "mapped", [33394]], [[12171, 12171], "mapped", [33400]], [[12172, 12172], "mapped", [34381]], [[12173, 12173], "mapped", [34411]], [[12174, 12174], "mapped", [34880]], [[12175, 12175], "mapped", [34892]], [[12176, 12176], "mapped", [34915]], [[12177, 12177], "mapped", [35198]], [[12178, 12178], "mapped", [35211]], [[12179, 12179], "mapped", [35282]], [[12180, 12180], "mapped", [35328]], [[12181, 12181], "mapped", [35895]], [[12182, 12182], "mapped", [35910]], [[12183, 12183], "mapped", [35925]], [[12184, 12184], "mapped", [35960]], [[12185, 12185], "mapped", [35997]], [[12186, 12186], "mapped", [36196]], [[12187, 12187], "mapped", [36208]], [[12188, 12188], "mapped", [36275]], [[12189, 12189], "mapped", [36523]], [[12190, 12190], "mapped", [36554]], [[12191, 12191], "mapped", [36763]], [[12192, 12192], "mapped", [36784]], [[12193, 12193], "mapped", [36789]], [[12194, 12194], "mapped", [37009]], [[12195, 12195], "mapped", [37193]], [[12196, 12196], "mapped", [37318]], [[12197, 12197], "mapped", [37324]], [[12198, 12198], "mapped", [37329]], [[12199, 12199], "mapped", [38263]], [[12200, 12200], "mapped", [38272]], [[12201, 12201], "mapped", [38428]], [[12202, 12202], "mapped", [38582]], [[12203, 12203], "mapped", [38585]], [[12204, 12204], "mapped", [38632]], [[12205, 12205], "mapped", [38737]], [[12206, 12206], "mapped", [38750]], [[12207, 12207], "mapped", [38754]], [[12208, 12208], "mapped", [38761]], [[12209, 12209], "mapped", [38859]], [[12210, 12210], "mapped", [38893]], [[12211, 12211], "mapped", [38899]], [[12212, 12212], "mapped", [38913]], [[12213, 12213], "mapped", [39080]], [[12214, 12214], "mapped", [39131]], [[12215, 12215], "mapped", [39135]], [[12216, 12216], "mapped", [39318]], [[12217, 12217], "mapped", [39321]], [[12218, 12218], "mapped", [39340]], [[12219, 12219], "mapped", [39592]], [[12220, 12220], "mapped", [39640]], [[12221, 12221], "mapped", [39647]], [[12222, 12222], "mapped", [39717]], [[12223, 12223], "mapped", [39727]], [[12224, 12224], "mapped", [39730]], [[12225, 12225], "mapped", [39740]], [[12226, 12226], "mapped", [39770]], [[12227, 12227], "mapped", [40165]], [[12228, 12228], "mapped", [40565]], [[12229, 12229], "mapped", [40575]], [[12230, 12230], "mapped", [40613]], [[12231, 12231], "mapped", [40635]], [[12232, 12232], "mapped", [40643]], [[12233, 12233], "mapped", [40653]], [[12234, 12234], "mapped", [40657]], [[12235, 12235], "mapped", [40697]], [[12236, 12236], "mapped", [40701]], [[12237, 12237], "mapped", [40718]], [[12238, 12238], "mapped", [40723]], [[12239, 12239], "mapped", [40736]], [[12240, 12240], "mapped", [40763]], [[12241, 12241], "mapped", [40778]], [[12242, 12242], "mapped", [40786]], [[12243, 12243], "mapped", [40845]], [[12244, 12244], "mapped", [40860]], [[12245, 12245], "mapped", [40864]], [[12246, 12271], "disallowed"], [[12272, 12283], "disallowed"], [[12284, 12287], "disallowed"], [[12288, 12288], "disallowed_STD3_mapped", [32]], [[12289, 12289], "valid", [], "NV8"], [[12290, 12290], "mapped", [46]], [[12291, 12292], "valid", [], "NV8"], [[12293, 12295], "valid"], [[12296, 12329], "valid", [], "NV8"], [[12330, 12333], "valid"], [[12334, 12341], "valid", [], "NV8"], [[12342, 12342], "mapped", [12306]], [[12343, 12343], "valid", [], "NV8"], [[12344, 12344], "mapped", [21313]], [[12345, 12345], "mapped", [21316]], [[12346, 12346], "mapped", [21317]], [[12347, 12347], "valid", [], "NV8"], [[12348, 12348], "valid"], [[12349, 12349], "valid", [], "NV8"], [[12350, 12350], "valid", [], "NV8"], [[12351, 12351], "valid", [], "NV8"], [[12352, 12352], "disallowed"], [[12353, 12436], "valid"], [[12437, 12438], "valid"], [[12439, 12440], "disallowed"], [[12441, 12442], "valid"], [[12443, 12443], "disallowed_STD3_mapped", [32, 12441]], [[12444, 12444], "disallowed_STD3_mapped", [32, 12442]], [[12445, 12446], "valid"], [[12447, 12447], "mapped", [12424, 12426]], [[12448, 12448], "valid", [], "NV8"], [[12449, 12542], "valid"], [[12543, 12543], "mapped", [12467, 12488]], [[12544, 12548], "disallowed"], [[12549, 12588], "valid"], [[12589, 12589], "valid"], [[12590, 12592], "disallowed"], [[12593, 12593], "mapped", [4352]], [[12594, 12594], "mapped", [4353]], [[12595, 12595], "mapped", [4522]], [[12596, 12596], "mapped", [4354]], [[12597, 12597], "mapped", [4524]], [[12598, 12598], "mapped", [4525]], [[12599, 12599], "mapped", [4355]], [[12600, 12600], "mapped", [4356]], [[12601, 12601], "mapped", [4357]], [[12602, 12602], "mapped", [4528]], [[12603, 12603], "mapped", [4529]], [[12604, 12604], "mapped", [4530]], [[12605, 12605], "mapped", [4531]], [[12606, 12606], "mapped", [4532]], [[12607, 12607], "mapped", [4533]], [[12608, 12608], "mapped", [4378]], [[12609, 12609], "mapped", [4358]], [[12610, 12610], "mapped", [4359]], [[12611, 12611], "mapped", [4360]], [[12612, 12612], "mapped", [4385]], [[12613, 12613], "mapped", [4361]], [[12614, 12614], "mapped", [4362]], [[12615, 12615], "mapped", [4363]], [[12616, 12616], "mapped", [4364]], [[12617, 12617], "mapped", [4365]], [[12618, 12618], "mapped", [4366]], [[12619, 12619], "mapped", [4367]], [[12620, 12620], "mapped", [4368]], [[12621, 12621], "mapped", [4369]], [[12622, 12622], "mapped", [4370]], [[12623, 12623], "mapped", [4449]], [[12624, 12624], "mapped", [4450]], [[12625, 12625], "mapped", [4451]], [[12626, 12626], "mapped", [4452]], [[12627, 12627], "mapped", [4453]], [[12628, 12628], "mapped", [4454]], [[12629, 12629], "mapped", [4455]], [[12630, 12630], "mapped", [4456]], [[12631, 12631], "mapped", [4457]], [[12632, 12632], "mapped", [4458]], [[12633, 12633], "mapped", [4459]], [[12634, 12634], "mapped", [4460]], [[12635, 12635], "mapped", [4461]], [[12636, 12636], "mapped", [4462]], [[12637, 12637], "mapped", [4463]], [[12638, 12638], "mapped", [4464]], [[12639, 12639], "mapped", [4465]], [[12640, 12640], "mapped", [4466]], [[12641, 12641], "mapped", [4467]], [[12642, 12642], "mapped", [4468]], [[12643, 12643], "mapped", [4469]], [[12644, 12644], "disallowed"], [[12645, 12645], "mapped", [4372]], [[12646, 12646], "mapped", [4373]], [[12647, 12647], "mapped", [4551]], [[12648, 12648], "mapped", [4552]], [[12649, 12649], "mapped", [4556]], [[12650, 12650], "mapped", [4558]], [[12651, 12651], "mapped", [4563]], [[12652, 12652], "mapped", [4567]], [[12653, 12653], "mapped", [4569]], [[12654, 12654], "mapped", [4380]], [[12655, 12655], "mapped", [4573]], [[12656, 12656], "mapped", [4575]], [[12657, 12657], "mapped", [4381]], [[12658, 12658], "mapped", [4382]], [[12659, 12659], "mapped", [4384]], [[12660, 12660], "mapped", [4386]], [[12661, 12661], "mapped", [4387]], [[12662, 12662], "mapped", [4391]], [[12663, 12663], "mapped", [4393]], [[12664, 12664], "mapped", [4395]], [[12665, 12665], "mapped", [4396]], [[12666, 12666], "mapped", [4397]], [[12667, 12667], "mapped", [4398]], [[12668, 12668], "mapped", [4399]], [[12669, 12669], "mapped", [4402]], [[12670, 12670], "mapped", [4406]], [[12671, 12671], "mapped", [4416]], [[12672, 12672], "mapped", [4423]], [[12673, 12673], "mapped", [4428]], [[12674, 12674], "mapped", [4593]], [[12675, 12675], "mapped", [4594]], [[12676, 12676], "mapped", [4439]], [[12677, 12677], "mapped", [4440]], [[12678, 12678], "mapped", [4441]], [[12679, 12679], "mapped", [4484]], [[12680, 12680], "mapped", [4485]], [[12681, 12681], "mapped", [4488]], [[12682, 12682], "mapped", [4497]], [[12683, 12683], "mapped", [4498]], [[12684, 12684], "mapped", [4500]], [[12685, 12685], "mapped", [4510]], [[12686, 12686], "mapped", [4513]], [[12687, 12687], "disallowed"], [[12688, 12689], "valid", [], "NV8"], [[12690, 12690], "mapped", [19968]], [[12691, 12691], "mapped", [20108]], [[12692, 12692], "mapped", [19977]], [[12693, 12693], "mapped", [22235]], [[12694, 12694], "mapped", [19978]], [[12695, 12695], "mapped", [20013]], [[12696, 12696], "mapped", [19979]], [[12697, 12697], "mapped", [30002]], [[12698, 12698], "mapped", [20057]], [[12699, 12699], "mapped", [19993]], [[12700, 12700], "mapped", [19969]], [[12701, 12701], "mapped", [22825]], [[12702, 12702], "mapped", [22320]], [[12703, 12703], "mapped", [20154]], [[12704, 12727], "valid"], [[12728, 12730], "valid"], [[12731, 12735], "disallowed"], [[12736, 12751], "valid", [], "NV8"], [[12752, 12771], "valid", [], "NV8"], [[12772, 12783], "disallowed"], [[12784, 12799], "valid"], [[12800, 12800], "disallowed_STD3_mapped", [40, 4352, 41]], [[12801, 12801], "disallowed_STD3_mapped", [40, 4354, 41]], [[12802, 12802], "disallowed_STD3_mapped", [40, 4355, 41]], [[12803, 12803], "disallowed_STD3_mapped", [40, 4357, 41]], [[12804, 12804], "disallowed_STD3_mapped", [40, 4358, 41]], [[12805, 12805], "disallowed_STD3_mapped", [40, 4359, 41]], [[12806, 12806], "disallowed_STD3_mapped", [40, 4361, 41]], [[12807, 12807], "disallowed_STD3_mapped", [40, 4363, 41]], [[12808, 12808], "disallowed_STD3_mapped", [40, 4364, 41]], [[12809, 12809], "disallowed_STD3_mapped", [40, 4366, 41]], [[12810, 12810], "disallowed_STD3_mapped", [40, 4367, 41]], [[12811, 12811], "disallowed_STD3_mapped", [40, 4368, 41]], [[12812, 12812], "disallowed_STD3_mapped", [40, 4369, 41]], [[12813, 12813], "disallowed_STD3_mapped", [40, 4370, 41]], [[12814, 12814], "disallowed_STD3_mapped", [40, 44032, 41]], [[12815, 12815], "disallowed_STD3_mapped", [40, 45208, 41]], [[12816, 12816], "disallowed_STD3_mapped", [40, 45796, 41]], [[12817, 12817], "disallowed_STD3_mapped", [40, 46972, 41]], [[12818, 12818], "disallowed_STD3_mapped", [40, 47560, 41]], [[12819, 12819], "disallowed_STD3_mapped", [40, 48148, 41]], [[12820, 12820], "disallowed_STD3_mapped", [40, 49324, 41]], [[12821, 12821], "disallowed_STD3_mapped", [40, 50500, 41]], [[12822, 12822], "disallowed_STD3_mapped", [40, 51088, 41]], [[12823, 12823], "disallowed_STD3_mapped", [40, 52264, 41]], [[12824, 12824], "disallowed_STD3_mapped", [40, 52852, 41]], [[12825, 12825], "disallowed_STD3_mapped", [40, 53440, 41]], [[12826, 12826], "disallowed_STD3_mapped", [40, 54028, 41]], [[12827, 12827], "disallowed_STD3_mapped", [40, 54616, 41]], [[12828, 12828], "disallowed_STD3_mapped", [40, 51452, 41]], [[12829, 12829], "disallowed_STD3_mapped", [40, 50724, 51204, 41]], [[12830, 12830], "disallowed_STD3_mapped", [40, 50724, 54980, 41]], [[12831, 12831], "disallowed"], [[12832, 12832], "disallowed_STD3_mapped", [40, 19968, 41]], [[12833, 12833], "disallowed_STD3_mapped", [40, 20108, 41]], [[12834, 12834], "disallowed_STD3_mapped", [40, 19977, 41]], [[12835, 12835], "disallowed_STD3_mapped", [40, 22235, 41]], [[12836, 12836], "disallowed_STD3_mapped", [40, 20116, 41]], [[12837, 12837], "disallowed_STD3_mapped", [40, 20845, 41]], [[12838, 12838], "disallowed_STD3_mapped", [40, 19971, 41]], [[12839, 12839], "disallowed_STD3_mapped", [40, 20843, 41]], [[12840, 12840], "disallowed_STD3_mapped", [40, 20061, 41]], [[12841, 12841], "disallowed_STD3_mapped", [40, 21313, 41]], [[12842, 12842], "disallowed_STD3_mapped", [40, 26376, 41]], [[12843, 12843], "disallowed_STD3_mapped", [40, 28779, 41]], [[12844, 12844], "disallowed_STD3_mapped", [40, 27700, 41]], [[12845, 12845], "disallowed_STD3_mapped", [40, 26408, 41]], [[12846, 12846], "disallowed_STD3_mapped", [40, 37329, 41]], [[12847, 12847], "disallowed_STD3_mapped", [40, 22303, 41]], [[12848, 12848], "disallowed_STD3_mapped", [40, 26085, 41]], [[12849, 12849], "disallowed_STD3_mapped", [40, 26666, 41]], [[12850, 12850], "disallowed_STD3_mapped", [40, 26377, 41]], [[12851, 12851], "disallowed_STD3_mapped", [40, 31038, 41]], [[12852, 12852], "disallowed_STD3_mapped", [40, 21517, 41]], [[12853, 12853], "disallowed_STD3_mapped", [40, 29305, 41]], [[12854, 12854], "disallowed_STD3_mapped", [40, 36001, 41]], [[12855, 12855], "disallowed_STD3_mapped", [40, 31069, 41]], [[12856, 12856], "disallowed_STD3_mapped", [40, 21172, 41]], [[12857, 12857], "disallowed_STD3_mapped", [40, 20195, 41]], [[12858, 12858], "disallowed_STD3_mapped", [40, 21628, 41]], [[12859, 12859], "disallowed_STD3_mapped", [40, 23398, 41]], [[12860, 12860], "disallowed_STD3_mapped", [40, 30435, 41]], [[12861, 12861], "disallowed_STD3_mapped", [40, 20225, 41]], [[12862, 12862], "disallowed_STD3_mapped", [40, 36039, 41]], [[12863, 12863], "disallowed_STD3_mapped", [40, 21332, 41]], [[12864, 12864], "disallowed_STD3_mapped", [40, 31085, 41]], [[12865, 12865], "disallowed_STD3_mapped", [40, 20241, 41]], [[12866, 12866], "disallowed_STD3_mapped", [40, 33258, 41]], [[12867, 12867], "disallowed_STD3_mapped", [40, 33267, 41]], [[12868, 12868], "mapped", [21839]], [[12869, 12869], "mapped", [24188]], [[12870, 12870], "mapped", [25991]], [[12871, 12871], "mapped", [31631]], [[12872, 12879], "valid", [], "NV8"], [[12880, 12880], "mapped", [112, 116, 101]], [[12881, 12881], "mapped", [50, 49]], [[12882, 12882], "mapped", [50, 50]], [[12883, 12883], "mapped", [50, 51]], [[12884, 12884], "mapped", [50, 52]], [[12885, 12885], "mapped", [50, 53]], [[12886, 12886], "mapped", [50, 54]], [[12887, 12887], "mapped", [50, 55]], [[12888, 12888], "mapped", [50, 56]], [[12889, 12889], "mapped", [50, 57]], [[12890, 12890], "mapped", [51, 48]], [[12891, 12891], "mapped", [51, 49]], [[12892, 12892], "mapped", [51, 50]], [[12893, 12893], "mapped", [51, 51]], [[12894, 12894], "mapped", [51, 52]], [[12895, 12895], "mapped", [51, 53]], [[12896, 12896], "mapped", [4352]], [[12897, 12897], "mapped", [4354]], [[12898, 12898], "mapped", [4355]], [[12899, 12899], "mapped", [4357]], [[12900, 12900], "mapped", [4358]], [[12901, 12901], "mapped", [4359]], [[12902, 12902], "mapped", [4361]], [[12903, 12903], "mapped", [4363]], [[12904, 12904], "mapped", [4364]], [[12905, 12905], "mapped", [4366]], [[12906, 12906], "mapped", [4367]], [[12907, 12907], "mapped", [4368]], [[12908, 12908], "mapped", [4369]], [[12909, 12909], "mapped", [4370]], [[12910, 12910], "mapped", [44032]], [[12911, 12911], "mapped", [45208]], [[12912, 12912], "mapped", [45796]], [[12913, 12913], "mapped", [46972]], [[12914, 12914], "mapped", [47560]], [[12915, 12915], "mapped", [48148]], [[12916, 12916], "mapped", [49324]], [[12917, 12917], "mapped", [50500]], [[12918, 12918], "mapped", [51088]], [[12919, 12919], "mapped", [52264]], [[12920, 12920], "mapped", [52852]], [[12921, 12921], "mapped", [53440]], [[12922, 12922], "mapped", [54028]], [[12923, 12923], "mapped", [54616]], [[12924, 12924], "mapped", [52280, 44256]], [[12925, 12925], "mapped", [51452, 51032]], [[12926, 12926], "mapped", [50864]], [[12927, 12927], "valid", [], "NV8"], [[12928, 12928], "mapped", [19968]], [[12929, 12929], "mapped", [20108]], [[12930, 12930], "mapped", [19977]], [[12931, 12931], "mapped", [22235]], [[12932, 12932], "mapped", [20116]], [[12933, 12933], "mapped", [20845]], [[12934, 12934], "mapped", [19971]], [[12935, 12935], "mapped", [20843]], [[12936, 12936], "mapped", [20061]], [[12937, 12937], "mapped", [21313]], [[12938, 12938], "mapped", [26376]], [[12939, 12939], "mapped", [28779]], [[12940, 12940], "mapped", [27700]], [[12941, 12941], "mapped", [26408]], [[12942, 12942], "mapped", [37329]], [[12943, 12943], "mapped", [22303]], [[12944, 12944], "mapped", [26085]], [[12945, 12945], "mapped", [26666]], [[12946, 12946], "mapped", [26377]], [[12947, 12947], "mapped", [31038]], [[12948, 12948], "mapped", [21517]], [[12949, 12949], "mapped", [29305]], [[12950, 12950], "mapped", [36001]], [[12951, 12951], "mapped", [31069]], [[12952, 12952], "mapped", [21172]], [[12953, 12953], "mapped", [31192]], [[12954, 12954], "mapped", [30007]], [[12955, 12955], "mapped", [22899]], [[12956, 12956], "mapped", [36969]], [[12957, 12957], "mapped", [20778]], [[12958, 12958], "mapped", [21360]], [[12959, 12959], "mapped", [27880]], [[12960, 12960], "mapped", [38917]], [[12961, 12961], "mapped", [20241]], [[12962, 12962], "mapped", [20889]], [[12963, 12963], "mapped", [27491]], [[12964, 12964], "mapped", [19978]], [[12965, 12965], "mapped", [20013]], [[12966, 12966], "mapped", [19979]], [[12967, 12967], "mapped", [24038]], [[12968, 12968], "mapped", [21491]], [[12969, 12969], "mapped", [21307]], [[12970, 12970], "mapped", [23447]], [[12971, 12971], "mapped", [23398]], [[12972, 12972], "mapped", [30435]], [[12973, 12973], "mapped", [20225]], [[12974, 12974], "mapped", [36039]], [[12975, 12975], "mapped", [21332]], [[12976, 12976], "mapped", [22812]], [[12977, 12977], "mapped", [51, 54]], [[12978, 12978], "mapped", [51, 55]], [[12979, 12979], "mapped", [51, 56]], [[12980, 12980], "mapped", [51, 57]], [[12981, 12981], "mapped", [52, 48]], [[12982, 12982], "mapped", [52, 49]], [[12983, 12983], "mapped", [52, 50]], [[12984, 12984], "mapped", [52, 51]], [[12985, 12985], "mapped", [52, 52]], [[12986, 12986], "mapped", [52, 53]], [[12987, 12987], "mapped", [52, 54]], [[12988, 12988], "mapped", [52, 55]], [[12989, 12989], "mapped", [52, 56]], [[12990, 12990], "mapped", [52, 57]], [[12991, 12991], "mapped", [53, 48]], [[12992, 12992], "mapped", [49, 26376]], [[12993, 12993], "mapped", [50, 26376]], [[12994, 12994], "mapped", [51, 26376]], [[12995, 12995], "mapped", [52, 26376]], [[12996, 12996], "mapped", [53, 26376]], [[12997, 12997], "mapped", [54, 26376]], [[12998, 12998], "mapped", [55, 26376]], [[12999, 12999], "mapped", [56, 26376]], [[13e3, 13e3], "mapped", [57, 26376]], [[13001, 13001], "mapped", [49, 48, 26376]], [[13002, 13002], "mapped", [49, 49, 26376]], [[13003, 13003], "mapped", [49, 50, 26376]], [[13004, 13004], "mapped", [104, 103]], [[13005, 13005], "mapped", [101, 114, 103]], [[13006, 13006], "mapped", [101, 118]], [[13007, 13007], "mapped", [108, 116, 100]], [[13008, 13008], "mapped", [12450]], [[13009, 13009], "mapped", [12452]], [[13010, 13010], "mapped", [12454]], [[13011, 13011], "mapped", [12456]], [[13012, 13012], "mapped", [12458]], [[13013, 13013], "mapped", [12459]], [[13014, 13014], "mapped", [12461]], [[13015, 13015], "mapped", [12463]], [[13016, 13016], "mapped", [12465]], [[13017, 13017], "mapped", [12467]], [[13018, 13018], "mapped", [12469]], [[13019, 13019], "mapped", [12471]], [[13020, 13020], "mapped", [12473]], [[13021, 13021], "mapped", [12475]], [[13022, 13022], "mapped", [12477]], [[13023, 13023], "mapped", [12479]], [[13024, 13024], "mapped", [12481]], [[13025, 13025], "mapped", [12484]], [[13026, 13026], "mapped", [12486]], [[13027, 13027], "mapped", [12488]], [[13028, 13028], "mapped", [12490]], [[13029, 13029], "mapped", [12491]], [[13030, 13030], "mapped", [12492]], [[13031, 13031], "mapped", [12493]], [[13032, 13032], "mapped", [12494]], [[13033, 13033], "mapped", [12495]], [[13034, 13034], "mapped", [12498]], [[13035, 13035], "mapped", [12501]], [[13036, 13036], "mapped", [12504]], [[13037, 13037], "mapped", [12507]], [[13038, 13038], "mapped", [12510]], [[13039, 13039], "mapped", [12511]], [[13040, 13040], "mapped", [12512]], [[13041, 13041], "mapped", [12513]], [[13042, 13042], "mapped", [12514]], [[13043, 13043], "mapped", [12516]], [[13044, 13044], "mapped", [12518]], [[13045, 13045], "mapped", [12520]], [[13046, 13046], "mapped", [12521]], [[13047, 13047], "mapped", [12522]], [[13048, 13048], "mapped", [12523]], [[13049, 13049], "mapped", [12524]], [[13050, 13050], "mapped", [12525]], [[13051, 13051], "mapped", [12527]], [[13052, 13052], "mapped", [12528]], [[13053, 13053], "mapped", [12529]], [[13054, 13054], "mapped", [12530]], [[13055, 13055], "disallowed"], [[13056, 13056], "mapped", [12450, 12497, 12540, 12488]], [[13057, 13057], "mapped", [12450, 12523, 12501, 12449]], [[13058, 13058], "mapped", [12450, 12531, 12506, 12450]], [[13059, 13059], "mapped", [12450, 12540, 12523]], [[13060, 13060], "mapped", [12452, 12491, 12531, 12464]], [[13061, 13061], "mapped", [12452, 12531, 12481]], [[13062, 13062], "mapped", [12454, 12457, 12531]], [[13063, 13063], "mapped", [12456, 12473, 12463, 12540, 12489]], [[13064, 13064], "mapped", [12456, 12540, 12459, 12540]], [[13065, 13065], "mapped", [12458, 12531, 12473]], [[13066, 13066], "mapped", [12458, 12540, 12512]], [[13067, 13067], "mapped", [12459, 12452, 12522]], [[13068, 13068], "mapped", [12459, 12521, 12483, 12488]], [[13069, 13069], "mapped", [12459, 12525, 12522, 12540]], [[13070, 13070], "mapped", [12460, 12525, 12531]], [[13071, 13071], "mapped", [12460, 12531, 12510]], [[13072, 13072], "mapped", [12462, 12460]], [[13073, 13073], "mapped", [12462, 12491, 12540]], [[13074, 13074], "mapped", [12461, 12517, 12522, 12540]], [[13075, 13075], "mapped", [12462, 12523, 12480, 12540]], [[13076, 13076], "mapped", [12461, 12525]], [[13077, 13077], "mapped", [12461, 12525, 12464, 12521, 12512]], [[13078, 13078], "mapped", [12461, 12525, 12513, 12540, 12488, 12523]], [[13079, 13079], "mapped", [12461, 12525, 12527, 12483, 12488]], [[13080, 13080], "mapped", [12464, 12521, 12512]], [[13081, 13081], "mapped", [12464, 12521, 12512, 12488, 12531]], [[13082, 13082], "mapped", [12463, 12523, 12476, 12452, 12525]], [[13083, 13083], "mapped", [12463, 12525, 12540, 12493]], [[13084, 13084], "mapped", [12465, 12540, 12473]], [[13085, 13085], "mapped", [12467, 12523, 12490]], [[13086, 13086], "mapped", [12467, 12540, 12509]], [[13087, 13087], "mapped", [12469, 12452, 12463, 12523]], [[13088, 13088], "mapped", [12469, 12531, 12481, 12540, 12512]], [[13089, 13089], "mapped", [12471, 12522, 12531, 12464]], [[13090, 13090], "mapped", [12475, 12531, 12481]], [[13091, 13091], "mapped", [12475, 12531, 12488]], [[13092, 13092], "mapped", [12480, 12540, 12473]], [[13093, 13093], "mapped", [12487, 12471]], [[13094, 13094], "mapped", [12489, 12523]], [[13095, 13095], "mapped", [12488, 12531]], [[13096, 13096], "mapped", [12490, 12494]], [[13097, 13097], "mapped", [12494, 12483, 12488]], [[13098, 13098], "mapped", [12495, 12452, 12484]], [[13099, 13099], "mapped", [12497, 12540, 12475, 12531, 12488]], [[13100, 13100], "mapped", [12497, 12540, 12484]], [[13101, 13101], "mapped", [12496, 12540, 12524, 12523]], [[13102, 13102], "mapped", [12500, 12450, 12473, 12488, 12523]], [[13103, 13103], "mapped", [12500, 12463, 12523]], [[13104, 13104], "mapped", [12500, 12467]], [[13105, 13105], "mapped", [12499, 12523]], [[13106, 13106], "mapped", [12501, 12449, 12521, 12483, 12489]], [[13107, 13107], "mapped", [12501, 12451, 12540, 12488]], [[13108, 13108], "mapped", [12502, 12483, 12471, 12455, 12523]], [[13109, 13109], "mapped", [12501, 12521, 12531]], [[13110, 13110], "mapped", [12504, 12463, 12479, 12540, 12523]], [[13111, 13111], "mapped", [12506, 12477]], [[13112, 13112], "mapped", [12506, 12491, 12498]], [[13113, 13113], "mapped", [12504, 12523, 12484]], [[13114, 13114], "mapped", [12506, 12531, 12473]], [[13115, 13115], "mapped", [12506, 12540, 12472]], [[13116, 13116], "mapped", [12505, 12540, 12479]], [[13117, 13117], "mapped", [12509, 12452, 12531, 12488]], [[13118, 13118], "mapped", [12508, 12523, 12488]], [[13119, 13119], "mapped", [12507, 12531]], [[13120, 13120], "mapped", [12509, 12531, 12489]], [[13121, 13121], "mapped", [12507, 12540, 12523]], [[13122, 13122], "mapped", [12507, 12540, 12531]], [[13123, 13123], "mapped", [12510, 12452, 12463, 12525]], [[13124, 13124], "mapped", [12510, 12452, 12523]], [[13125, 13125], "mapped", [12510, 12483, 12495]], [[13126, 13126], "mapped", [12510, 12523, 12463]], [[13127, 13127], "mapped", [12510, 12531, 12471, 12519, 12531]], [[13128, 13128], "mapped", [12511, 12463, 12525, 12531]], [[13129, 13129], "mapped", [12511, 12522]], [[13130, 13130], "mapped", [12511, 12522, 12496, 12540, 12523]], [[13131, 13131], "mapped", [12513, 12460]], [[13132, 13132], "mapped", [12513, 12460, 12488, 12531]], [[13133, 13133], "mapped", [12513, 12540, 12488, 12523]], [[13134, 13134], "mapped", [12516, 12540, 12489]], [[13135, 13135], "mapped", [12516, 12540, 12523]], [[13136, 13136], "mapped", [12518, 12450, 12531]], [[13137, 13137], "mapped", [12522, 12483, 12488, 12523]], [[13138, 13138], "mapped", [12522, 12521]], [[13139, 13139], "mapped", [12523, 12500, 12540]], [[13140, 13140], "mapped", [12523, 12540, 12502, 12523]], [[13141, 13141], "mapped", [12524, 12512]], [[13142, 13142], "mapped", [12524, 12531, 12488, 12466, 12531]], [[13143, 13143], "mapped", [12527, 12483, 12488]], [[13144, 13144], "mapped", [48, 28857]], [[13145, 13145], "mapped", [49, 28857]], [[13146, 13146], "mapped", [50, 28857]], [[13147, 13147], "mapped", [51, 28857]], [[13148, 13148], "mapped", [52, 28857]], [[13149, 13149], "mapped", [53, 28857]], [[13150, 13150], "mapped", [54, 28857]], [[13151, 13151], "mapped", [55, 28857]], [[13152, 13152], "mapped", [56, 28857]], [[13153, 13153], "mapped", [57, 28857]], [[13154, 13154], "mapped", [49, 48, 28857]], [[13155, 13155], "mapped", [49, 49, 28857]], [[13156, 13156], "mapped", [49, 50, 28857]], [[13157, 13157], "mapped", [49, 51, 28857]], [[13158, 13158], "mapped", [49, 52, 28857]], [[13159, 13159], "mapped", [49, 53, 28857]], [[13160, 13160], "mapped", [49, 54, 28857]], [[13161, 13161], "mapped", [49, 55, 28857]], [[13162, 13162], "mapped", [49, 56, 28857]], [[13163, 13163], "mapped", [49, 57, 28857]], [[13164, 13164], "mapped", [50, 48, 28857]], [[13165, 13165], "mapped", [50, 49, 28857]], [[13166, 13166], "mapped", [50, 50, 28857]], [[13167, 13167], "mapped", [50, 51, 28857]], [[13168, 13168], "mapped", [50, 52, 28857]], [[13169, 13169], "mapped", [104, 112, 97]], [[13170, 13170], "mapped", [100, 97]], [[13171, 13171], "mapped", [97, 117]], [[13172, 13172], "mapped", [98, 97, 114]], [[13173, 13173], "mapped", [111, 118]], [[13174, 13174], "mapped", [112, 99]], [[13175, 13175], "mapped", [100, 109]], [[13176, 13176], "mapped", [100, 109, 50]], [[13177, 13177], "mapped", [100, 109, 51]], [[13178, 13178], "mapped", [105, 117]], [[13179, 13179], "mapped", [24179, 25104]], [[13180, 13180], "mapped", [26157, 21644]], [[13181, 13181], "mapped", [22823, 27491]], [[13182, 13182], "mapped", [26126, 27835]], [[13183, 13183], "mapped", [26666, 24335, 20250, 31038]], [[13184, 13184], "mapped", [112, 97]], [[13185, 13185], "mapped", [110, 97]], [[13186, 13186], "mapped", [956, 97]], [[13187, 13187], "mapped", [109, 97]], [[13188, 13188], "mapped", [107, 97]], [[13189, 13189], "mapped", [107, 98]], [[13190, 13190], "mapped", [109, 98]], [[13191, 13191], "mapped", [103, 98]], [[13192, 13192], "mapped", [99, 97, 108]], [[13193, 13193], "mapped", [107, 99, 97, 108]], [[13194, 13194], "mapped", [112, 102]], [[13195, 13195], "mapped", [110, 102]], [[13196, 13196], "mapped", [956, 102]], [[13197, 13197], "mapped", [956, 103]], [[13198, 13198], "mapped", [109, 103]], [[13199, 13199], "mapped", [107, 103]], [[13200, 13200], "mapped", [104, 122]], [[13201, 13201], "mapped", [107, 104, 122]], [[13202, 13202], "mapped", [109, 104, 122]], [[13203, 13203], "mapped", [103, 104, 122]], [[13204, 13204], "mapped", [116, 104, 122]], [[13205, 13205], "mapped", [956, 108]], [[13206, 13206], "mapped", [109, 108]], [[13207, 13207], "mapped", [100, 108]], [[13208, 13208], "mapped", [107, 108]], [[13209, 13209], "mapped", [102, 109]], [[13210, 13210], "mapped", [110, 109]], [[13211, 13211], "mapped", [956, 109]], [[13212, 13212], "mapped", [109, 109]], [[13213, 13213], "mapped", [99, 109]], [[13214, 13214], "mapped", [107, 109]], [[13215, 13215], "mapped", [109, 109, 50]], [[13216, 13216], "mapped", [99, 109, 50]], [[13217, 13217], "mapped", [109, 50]], [[13218, 13218], "mapped", [107, 109, 50]], [[13219, 13219], "mapped", [109, 109, 51]], [[13220, 13220], "mapped", [99, 109, 51]], [[13221, 13221], "mapped", [109, 51]], [[13222, 13222], "mapped", [107, 109, 51]], [[13223, 13223], "mapped", [109, 8725, 115]], [[13224, 13224], "mapped", [109, 8725, 115, 50]], [[13225, 13225], "mapped", [112, 97]], [[13226, 13226], "mapped", [107, 112, 97]], [[13227, 13227], "mapped", [109, 112, 97]], [[13228, 13228], "mapped", [103, 112, 97]], [[13229, 13229], "mapped", [114, 97, 100]], [[13230, 13230], "mapped", [114, 97, 100, 8725, 115]], [[13231, 13231], "mapped", [114, 97, 100, 8725, 115, 50]], [[13232, 13232], "mapped", [112, 115]], [[13233, 13233], "mapped", [110, 115]], [[13234, 13234], "mapped", [956, 115]], [[13235, 13235], "mapped", [109, 115]], [[13236, 13236], "mapped", [112, 118]], [[13237, 13237], "mapped", [110, 118]], [[13238, 13238], "mapped", [956, 118]], [[13239, 13239], "mapped", [109, 118]], [[13240, 13240], "mapped", [107, 118]], [[13241, 13241], "mapped", [109, 118]], [[13242, 13242], "mapped", [112, 119]], [[13243, 13243], "mapped", [110, 119]], [[13244, 13244], "mapped", [956, 119]], [[13245, 13245], "mapped", [109, 119]], [[13246, 13246], "mapped", [107, 119]], [[13247, 13247], "mapped", [109, 119]], [[13248, 13248], "mapped", [107, 969]], [[13249, 13249], "mapped", [109, 969]], [[13250, 13250], "disallowed"], [[13251, 13251], "mapped", [98, 113]], [[13252, 13252], "mapped", [99, 99]], [[13253, 13253], "mapped", [99, 100]], [[13254, 13254], "mapped", [99, 8725, 107, 103]], [[13255, 13255], "disallowed"], [[13256, 13256], "mapped", [100, 98]], [[13257, 13257], "mapped", [103, 121]], [[13258, 13258], "mapped", [104, 97]], [[13259, 13259], "mapped", [104, 112]], [[13260, 13260], "mapped", [105, 110]], [[13261, 13261], "mapped", [107, 107]], [[13262, 13262], "mapped", [107, 109]], [[13263, 13263], "mapped", [107, 116]], [[13264, 13264], "mapped", [108, 109]], [[13265, 13265], "mapped", [108, 110]], [[13266, 13266], "mapped", [108, 111, 103]], [[13267, 13267], "mapped", [108, 120]], [[13268, 13268], "mapped", [109, 98]], [[13269, 13269], "mapped", [109, 105, 108]], [[13270, 13270], "mapped", [109, 111, 108]], [[13271, 13271], "mapped", [112, 104]], [[13272, 13272], "disallowed"], [[13273, 13273], "mapped", [112, 112, 109]], [[13274, 13274], "mapped", [112, 114]], [[13275, 13275], "mapped", [115, 114]], [[13276, 13276], "mapped", [115, 118]], [[13277, 13277], "mapped", [119, 98]], [[13278, 13278], "mapped", [118, 8725, 109]], [[13279, 13279], "mapped", [97, 8725, 109]], [[13280, 13280], "mapped", [49, 26085]], [[13281, 13281], "mapped", [50, 26085]], [[13282, 13282], "mapped", [51, 26085]], [[13283, 13283], "mapped", [52, 26085]], [[13284, 13284], "mapped", [53, 26085]], [[13285, 13285], "mapped", [54, 26085]], [[13286, 13286], "mapped", [55, 26085]], [[13287, 13287], "mapped", [56, 26085]], [[13288, 13288], "mapped", [57, 26085]], [[13289, 13289], "mapped", [49, 48, 26085]], [[13290, 13290], "mapped", [49, 49, 26085]], [[13291, 13291], "mapped", [49, 50, 26085]], [[13292, 13292], "mapped", [49, 51, 26085]], [[13293, 13293], "mapped", [49, 52, 26085]], [[13294, 13294], "mapped", [49, 53, 26085]], [[13295, 13295], "mapped", [49, 54, 26085]], [[13296, 13296], "mapped", [49, 55, 26085]], [[13297, 13297], "mapped", [49, 56, 26085]], [[13298, 13298], "mapped", [49, 57, 26085]], [[13299, 13299], "mapped", [50, 48, 26085]], [[13300, 13300], "mapped", [50, 49, 26085]], [[13301, 13301], "mapped", [50, 50, 26085]], [[13302, 13302], "mapped", [50, 51, 26085]], [[13303, 13303], "mapped", [50, 52, 26085]], [[13304, 13304], "mapped", [50, 53, 26085]], [[13305, 13305], "mapped", [50, 54, 26085]], [[13306, 13306], "mapped", [50, 55, 26085]], [[13307, 13307], "mapped", [50, 56, 26085]], [[13308, 13308], "mapped", [50, 57, 26085]], [[13309, 13309], "mapped", [51, 48, 26085]], [[13310, 13310], "mapped", [51, 49, 26085]], [[13311, 13311], "mapped", [103, 97, 108]], [[13312, 19893], "valid"], [[19894, 19903], "disallowed"], [[19904, 19967], "valid", [], "NV8"], [[19968, 40869], "valid"], [[40870, 40891], "valid"], [[40892, 40899], "valid"], [[40900, 40907], "valid"], [[40908, 40908], "valid"], [[40909, 40917], "valid"], [[40918, 40959], "disallowed"], [[40960, 42124], "valid"], [[42125, 42127], "disallowed"], [[42128, 42145], "valid", [], "NV8"], [[42146, 42147], "valid", [], "NV8"], [[42148, 42163], "valid", [], "NV8"], [[42164, 42164], "valid", [], "NV8"], [[42165, 42176], "valid", [], "NV8"], [[42177, 42177], "valid", [], "NV8"], [[42178, 42180], "valid", [], "NV8"], [[42181, 42181], "valid", [], "NV8"], [[42182, 42182], "valid", [], "NV8"], [[42183, 42191], "disallowed"], [[42192, 42237], "valid"], [[42238, 42239], "valid", [], "NV8"], [[42240, 42508], "valid"], [[42509, 42511], "valid", [], "NV8"], [[42512, 42539], "valid"], [[42540, 42559], "disallowed"], [[42560, 42560], "mapped", [42561]], [[42561, 42561], "valid"], [[42562, 42562], "mapped", [42563]], [[42563, 42563], "valid"], [[42564, 42564], "mapped", [42565]], [[42565, 42565], "valid"], [[42566, 42566], "mapped", [42567]], [[42567, 42567], "valid"], [[42568, 42568], "mapped", [42569]], [[42569, 42569], "valid"], [[42570, 42570], "mapped", [42571]], [[42571, 42571], "valid"], [[42572, 42572], "mapped", [42573]], [[42573, 42573], "valid"], [[42574, 42574], "mapped", [42575]], [[42575, 42575], "valid"], [[42576, 42576], "mapped", [42577]], [[42577, 42577], "valid"], [[42578, 42578], "mapped", [42579]], [[42579, 42579], "valid"], [[42580, 42580], "mapped", [42581]], [[42581, 42581], "valid"], [[42582, 42582], "mapped", [42583]], [[42583, 42583], "valid"], [[42584, 42584], "mapped", [42585]], [[42585, 42585], "valid"], [[42586, 42586], "mapped", [42587]], [[42587, 42587], "valid"], [[42588, 42588], "mapped", [42589]], [[42589, 42589], "valid"], [[42590, 42590], "mapped", [42591]], [[42591, 42591], "valid"], [[42592, 42592], "mapped", [42593]], [[42593, 42593], "valid"], [[42594, 42594], "mapped", [42595]], [[42595, 42595], "valid"], [[42596, 42596], "mapped", [42597]], [[42597, 42597], "valid"], [[42598, 42598], "mapped", [42599]], [[42599, 42599], "valid"], [[42600, 42600], "mapped", [42601]], [[42601, 42601], "valid"], [[42602, 42602], "mapped", [42603]], [[42603, 42603], "valid"], [[42604, 42604], "mapped", [42605]], [[42605, 42607], "valid"], [[42608, 42611], "valid", [], "NV8"], [[42612, 42619], "valid"], [[42620, 42621], "valid"], [[42622, 42622], "valid", [], "NV8"], [[42623, 42623], "valid"], [[42624, 42624], "mapped", [42625]], [[42625, 42625], "valid"], [[42626, 42626], "mapped", [42627]], [[42627, 42627], "valid"], [[42628, 42628], "mapped", [42629]], [[42629, 42629], "valid"], [[42630, 42630], "mapped", [42631]], [[42631, 42631], "valid"], [[42632, 42632], "mapped", [42633]], [[42633, 42633], "valid"], [[42634, 42634], "mapped", [42635]], [[42635, 42635], "valid"], [[42636, 42636], "mapped", [42637]], [[42637, 42637], "valid"], [[42638, 42638], "mapped", [42639]], [[42639, 42639], "valid"], [[42640, 42640], "mapped", [42641]], [[42641, 42641], "valid"], [[42642, 42642], "mapped", [42643]], [[42643, 42643], "valid"], [[42644, 42644], "mapped", [42645]], [[42645, 42645], "valid"], [[42646, 42646], "mapped", [42647]], [[42647, 42647], "valid"], [[42648, 42648], "mapped", [42649]], [[42649, 42649], "valid"], [[42650, 42650], "mapped", [42651]], [[42651, 42651], "valid"], [[42652, 42652], "mapped", [1098]], [[42653, 42653], "mapped", [1100]], [[42654, 42654], "valid"], [[42655, 42655], "valid"], [[42656, 42725], "valid"], [[42726, 42735], "valid", [], "NV8"], [[42736, 42737], "valid"], [[42738, 42743], "valid", [], "NV8"], [[42744, 42751], "disallowed"], [[42752, 42774], "valid", [], "NV8"], [[42775, 42778], "valid"], [[42779, 42783], "valid"], [[42784, 42785], "valid", [], "NV8"], [[42786, 42786], "mapped", [42787]], [[42787, 42787], "valid"], [[42788, 42788], "mapped", [42789]], [[42789, 42789], "valid"], [[42790, 42790], "mapped", [42791]], [[42791, 42791], "valid"], [[42792, 42792], "mapped", [42793]], [[42793, 42793], "valid"], [[42794, 42794], "mapped", [42795]], [[42795, 42795], "valid"], [[42796, 42796], "mapped", [42797]], [[42797, 42797], "valid"], [[42798, 42798], "mapped", [42799]], [[42799, 42801], "valid"], [[42802, 42802], "mapped", [42803]], [[42803, 42803], "valid"], [[42804, 42804], "mapped", [42805]], [[42805, 42805], "valid"], [[42806, 42806], "mapped", [42807]], [[42807, 42807], "valid"], [[42808, 42808], "mapped", [42809]], [[42809, 42809], "valid"], [[42810, 42810], "mapped", [42811]], [[42811, 42811], "valid"], [[42812, 42812], "mapped", [42813]], [[42813, 42813], "valid"], [[42814, 42814], "mapped", [42815]], [[42815, 42815], "valid"], [[42816, 42816], "mapped", [42817]], [[42817, 42817], "valid"], [[42818, 42818], "mapped", [42819]], [[42819, 42819], "valid"], [[42820, 42820], "mapped", [42821]], [[42821, 42821], "valid"], [[42822, 42822], "mapped", [42823]], [[42823, 42823], "valid"], [[42824, 42824], "mapped", [42825]], [[42825, 42825], "valid"], [[42826, 42826], "mapped", [42827]], [[42827, 42827], "valid"], [[42828, 42828], "mapped", [42829]], [[42829, 42829], "valid"], [[42830, 42830], "mapped", [42831]], [[42831, 42831], "valid"], [[42832, 42832], "mapped", [42833]], [[42833, 42833], "valid"], [[42834, 42834], "mapped", [42835]], [[42835, 42835], "valid"], [[42836, 42836], "mapped", [42837]], [[42837, 42837], "valid"], [[42838, 42838], "mapped", [42839]], [[42839, 42839], "valid"], [[42840, 42840], "mapped", [42841]], [[42841, 42841], "valid"], [[42842, 42842], "mapped", [42843]], [[42843, 42843], "valid"], [[42844, 42844], "mapped", [42845]], [[42845, 42845], "valid"], [[42846, 42846], "mapped", [42847]], [[42847, 42847], "valid"], [[42848, 42848], "mapped", [42849]], [[42849, 42849], "valid"], [[42850, 42850], "mapped", [42851]], [[42851, 42851], "valid"], [[42852, 42852], "mapped", [42853]], [[42853, 42853], "valid"], [[42854, 42854], "mapped", [42855]], [[42855, 42855], "valid"], [[42856, 42856], "mapped", [42857]], [[42857, 42857], "valid"], [[42858, 42858], "mapped", [42859]], [[42859, 42859], "valid"], [[42860, 42860], "mapped", [42861]], [[42861, 42861], "valid"], [[42862, 42862], "mapped", [42863]], [[42863, 42863], "valid"], [[42864, 42864], "mapped", [42863]], [[42865, 42872], "valid"], [[42873, 42873], "mapped", [42874]], [[42874, 42874], "valid"], [[42875, 42875], "mapped", [42876]], [[42876, 42876], "valid"], [[42877, 42877], "mapped", [7545]], [[42878, 42878], "mapped", [42879]], [[42879, 42879], "valid"], [[42880, 42880], "mapped", [42881]], [[42881, 42881], "valid"], [[42882, 42882], "mapped", [42883]], [[42883, 42883], "valid"], [[42884, 42884], "mapped", [42885]], [[42885, 42885], "valid"], [[42886, 42886], "mapped", [42887]], [[42887, 42888], "valid"], [[42889, 42890], "valid", [], "NV8"], [[42891, 42891], "mapped", [42892]], [[42892, 42892], "valid"], [[42893, 42893], "mapped", [613]], [[42894, 42894], "valid"], [[42895, 42895], "valid"], [[42896, 42896], "mapped", [42897]], [[42897, 42897], "valid"], [[42898, 42898], "mapped", [42899]], [[42899, 42899], "valid"], [[42900, 42901], "valid"], [[42902, 42902], "mapped", [42903]], [[42903, 42903], "valid"], [[42904, 42904], "mapped", [42905]], [[42905, 42905], "valid"], [[42906, 42906], "mapped", [42907]], [[42907, 42907], "valid"], [[42908, 42908], "mapped", [42909]], [[42909, 42909], "valid"], [[42910, 42910], "mapped", [42911]], [[42911, 42911], "valid"], [[42912, 42912], "mapped", [42913]], [[42913, 42913], "valid"], [[42914, 42914], "mapped", [42915]], [[42915, 42915], "valid"], [[42916, 42916], "mapped", [42917]], [[42917, 42917], "valid"], [[42918, 42918], "mapped", [42919]], [[42919, 42919], "valid"], [[42920, 42920], "mapped", [42921]], [[42921, 42921], "valid"], [[42922, 42922], "mapped", [614]], [[42923, 42923], "mapped", [604]], [[42924, 42924], "mapped", [609]], [[42925, 42925], "mapped", [620]], [[42926, 42927], "disallowed"], [[42928, 42928], "mapped", [670]], [[42929, 42929], "mapped", [647]], [[42930, 42930], "mapped", [669]], [[42931, 42931], "mapped", [43859]], [[42932, 42932], "mapped", [42933]], [[42933, 42933], "valid"], [[42934, 42934], "mapped", [42935]], [[42935, 42935], "valid"], [[42936, 42998], "disallowed"], [[42999, 42999], "valid"], [[43e3, 43e3], "mapped", [295]], [[43001, 43001], "mapped", [339]], [[43002, 43002], "valid"], [[43003, 43007], "valid"], [[43008, 43047], "valid"], [[43048, 43051], "valid", [], "NV8"], [[43052, 43055], "disallowed"], [[43056, 43065], "valid", [], "NV8"], [[43066, 43071], "disallowed"], [[43072, 43123], "valid"], [[43124, 43127], "valid", [], "NV8"], [[43128, 43135], "disallowed"], [[43136, 43204], "valid"], [[43205, 43213], "disallowed"], [[43214, 43215], "valid", [], "NV8"], [[43216, 43225], "valid"], [[43226, 43231], "disallowed"], [[43232, 43255], "valid"], [[43256, 43258], "valid", [], "NV8"], [[43259, 43259], "valid"], [[43260, 43260], "valid", [], "NV8"], [[43261, 43261], "valid"], [[43262, 43263], "disallowed"], [[43264, 43309], "valid"], [[43310, 43311], "valid", [], "NV8"], [[43312, 43347], "valid"], [[43348, 43358], "disallowed"], [[43359, 43359], "valid", [], "NV8"], [[43360, 43388], "valid", [], "NV8"], [[43389, 43391], "disallowed"], [[43392, 43456], "valid"], [[43457, 43469], "valid", [], "NV8"], [[43470, 43470], "disallowed"], [[43471, 43481], "valid"], [[43482, 43485], "disallowed"], [[43486, 43487], "valid", [], "NV8"], [[43488, 43518], "valid"], [[43519, 43519], "disallowed"], [[43520, 43574], "valid"], [[43575, 43583], "disallowed"], [[43584, 43597], "valid"], [[43598, 43599], "disallowed"], [[43600, 43609], "valid"], [[43610, 43611], "disallowed"], [[43612, 43615], "valid", [], "NV8"], [[43616, 43638], "valid"], [[43639, 43641], "valid", [], "NV8"], [[43642, 43643], "valid"], [[43644, 43647], "valid"], [[43648, 43714], "valid"], [[43715, 43738], "disallowed"], [[43739, 43741], "valid"], [[43742, 43743], "valid", [], "NV8"], [[43744, 43759], "valid"], [[43760, 43761], "valid", [], "NV8"], [[43762, 43766], "valid"], [[43767, 43776], "disallowed"], [[43777, 43782], "valid"], [[43783, 43784], "disallowed"], [[43785, 43790], "valid"], [[43791, 43792], "disallowed"], [[43793, 43798], "valid"], [[43799, 43807], "disallowed"], [[43808, 43814], "valid"], [[43815, 43815], "disallowed"], [[43816, 43822], "valid"], [[43823, 43823], "disallowed"], [[43824, 43866], "valid"], [[43867, 43867], "valid", [], "NV8"], [[43868, 43868], "mapped", [42791]], [[43869, 43869], "mapped", [43831]], [[43870, 43870], "mapped", [619]], [[43871, 43871], "mapped", [43858]], [[43872, 43875], "valid"], [[43876, 43877], "valid"], [[43878, 43887], "disallowed"], [[43888, 43888], "mapped", [5024]], [[43889, 43889], "mapped", [5025]], [[43890, 43890], "mapped", [5026]], [[43891, 43891], "mapped", [5027]], [[43892, 43892], "mapped", [5028]], [[43893, 43893], "mapped", [5029]], [[43894, 43894], "mapped", [5030]], [[43895, 43895], "mapped", [5031]], [[43896, 43896], "mapped", [5032]], [[43897, 43897], "mapped", [5033]], [[43898, 43898], "mapped", [5034]], [[43899, 43899], "mapped", [5035]], [[43900, 43900], "mapped", [5036]], [[43901, 43901], "mapped", [5037]], [[43902, 43902], "mapped", [5038]], [[43903, 43903], "mapped", [5039]], [[43904, 43904], "mapped", [5040]], [[43905, 43905], "mapped", [5041]], [[43906, 43906], "mapped", [5042]], [[43907, 43907], "mapped", [5043]], [[43908, 43908], "mapped", [5044]], [[43909, 43909], "mapped", [5045]], [[43910, 43910], "mapped", [5046]], [[43911, 43911], "mapped", [5047]], [[43912, 43912], "mapped", [5048]], [[43913, 43913], "mapped", [5049]], [[43914, 43914], "mapped", [5050]], [[43915, 43915], "mapped", [5051]], [[43916, 43916], "mapped", [5052]], [[43917, 43917], "mapped", [5053]], [[43918, 43918], "mapped", [5054]], [[43919, 43919], "mapped", [5055]], [[43920, 43920], "mapped", [5056]], [[43921, 43921], "mapped", [5057]], [[43922, 43922], "mapped", [5058]], [[43923, 43923], "mapped", [5059]], [[43924, 43924], "mapped", [5060]], [[43925, 43925], "mapped", [5061]], [[43926, 43926], "mapped", [5062]], [[43927, 43927], "mapped", [5063]], [[43928, 43928], "mapped", [5064]], [[43929, 43929], "mapped", [5065]], [[43930, 43930], "mapped", [5066]], [[43931, 43931], "mapped", [5067]], [[43932, 43932], "mapped", [5068]], [[43933, 43933], "mapped", [5069]], [[43934, 43934], "mapped", [5070]], [[43935, 43935], "mapped", [5071]], [[43936, 43936], "mapped", [5072]], [[43937, 43937], "mapped", [5073]], [[43938, 43938], "mapped", [5074]], [[43939, 43939], "mapped", [5075]], [[43940, 43940], "mapped", [5076]], [[43941, 43941], "mapped", [5077]], [[43942, 43942], "mapped", [5078]], [[43943, 43943], "mapped", [5079]], [[43944, 43944], "mapped", [5080]], [[43945, 43945], "mapped", [5081]], [[43946, 43946], "mapped", [5082]], [[43947, 43947], "mapped", [5083]], [[43948, 43948], "mapped", [5084]], [[43949, 43949], "mapped", [5085]], [[43950, 43950], "mapped", [5086]], [[43951, 43951], "mapped", [5087]], [[43952, 43952], "mapped", [5088]], [[43953, 43953], "mapped", [5089]], [[43954, 43954], "mapped", [5090]], [[43955, 43955], "mapped", [5091]], [[43956, 43956], "mapped", [5092]], [[43957, 43957], "mapped", [5093]], [[43958, 43958], "mapped", [5094]], [[43959, 43959], "mapped", [5095]], [[43960, 43960], "mapped", [5096]], [[43961, 43961], "mapped", [5097]], [[43962, 43962], "mapped", [5098]], [[43963, 43963], "mapped", [5099]], [[43964, 43964], "mapped", [5100]], [[43965, 43965], "mapped", [5101]], [[43966, 43966], "mapped", [5102]], [[43967, 43967], "mapped", [5103]], [[43968, 44010], "valid"], [[44011, 44011], "valid", [], "NV8"], [[44012, 44013], "valid"], [[44014, 44015], "disallowed"], [[44016, 44025], "valid"], [[44026, 44031], "disallowed"], [[44032, 55203], "valid"], [[55204, 55215], "disallowed"], [[55216, 55238], "valid", [], "NV8"], [[55239, 55242], "disallowed"], [[55243, 55291], "valid", [], "NV8"], [[55292, 55295], "disallowed"], [[55296, 57343], "disallowed"], [[57344, 63743], "disallowed"], [[63744, 63744], "mapped", [35912]], [[63745, 63745], "mapped", [26356]], [[63746, 63746], "mapped", [36554]], [[63747, 63747], "mapped", [36040]], [[63748, 63748], "mapped", [28369]], [[63749, 63749], "mapped", [20018]], [[63750, 63750], "mapped", [21477]], [[63751, 63752], "mapped", [40860]], [[63753, 63753], "mapped", [22865]], [[63754, 63754], "mapped", [37329]], [[63755, 63755], "mapped", [21895]], [[63756, 63756], "mapped", [22856]], [[63757, 63757], "mapped", [25078]], [[63758, 63758], "mapped", [30313]], [[63759, 63759], "mapped", [32645]], [[63760, 63760], "mapped", [34367]], [[63761, 63761], "mapped", [34746]], [[63762, 63762], "mapped", [35064]], [[63763, 63763], "mapped", [37007]], [[63764, 63764], "mapped", [27138]], [[63765, 63765], "mapped", [27931]], [[63766, 63766], "mapped", [28889]], [[63767, 63767], "mapped", [29662]], [[63768, 63768], "mapped", [33853]], [[63769, 63769], "mapped", [37226]], [[63770, 63770], "mapped", [39409]], [[63771, 63771], "mapped", [20098]], [[63772, 63772], "mapped", [21365]], [[63773, 63773], "mapped", [27396]], [[63774, 63774], "mapped", [29211]], [[63775, 63775], "mapped", [34349]], [[63776, 63776], "mapped", [40478]], [[63777, 63777], "mapped", [23888]], [[63778, 63778], "mapped", [28651]], [[63779, 63779], "mapped", [34253]], [[63780, 63780], "mapped", [35172]], [[63781, 63781], "mapped", [25289]], [[63782, 63782], "mapped", [33240]], [[63783, 63783], "mapped", [34847]], [[63784, 63784], "mapped", [24266]], [[63785, 63785], "mapped", [26391]], [[63786, 63786], "mapped", [28010]], [[63787, 63787], "mapped", [29436]], [[63788, 63788], "mapped", [37070]], [[63789, 63789], "mapped", [20358]], [[63790, 63790], "mapped", [20919]], [[63791, 63791], "mapped", [21214]], [[63792, 63792], "mapped", [25796]], [[63793, 63793], "mapped", [27347]], [[63794, 63794], "mapped", [29200]], [[63795, 63795], "mapped", [30439]], [[63796, 63796], "mapped", [32769]], [[63797, 63797], "mapped", [34310]], [[63798, 63798], "mapped", [34396]], [[63799, 63799], "mapped", [36335]], [[63800, 63800], "mapped", [38706]], [[63801, 63801], "mapped", [39791]], [[63802, 63802], "mapped", [40442]], [[63803, 63803], "mapped", [30860]], [[63804, 63804], "mapped", [31103]], [[63805, 63805], "mapped", [32160]], [[63806, 63806], "mapped", [33737]], [[63807, 63807], "mapped", [37636]], [[63808, 63808], "mapped", [40575]], [[63809, 63809], "mapped", [35542]], [[63810, 63810], "mapped", [22751]], [[63811, 63811], "mapped", [24324]], [[63812, 63812], "mapped", [31840]], [[63813, 63813], "mapped", [32894]], [[63814, 63814], "mapped", [29282]], [[63815, 63815], "mapped", [30922]], [[63816, 63816], "mapped", [36034]], [[63817, 63817], "mapped", [38647]], [[63818, 63818], "mapped", [22744]], [[63819, 63819], "mapped", [23650]], [[63820, 63820], "mapped", [27155]], [[63821, 63821], "mapped", [28122]], [[63822, 63822], "mapped", [28431]], [[63823, 63823], "mapped", [32047]], [[63824, 63824], "mapped", [32311]], [[63825, 63825], "mapped", [38475]], [[63826, 63826], "mapped", [21202]], [[63827, 63827], "mapped", [32907]], [[63828, 63828], "mapped", [20956]], [[63829, 63829], "mapped", [20940]], [[63830, 63830], "mapped", [31260]], [[63831, 63831], "mapped", [32190]], [[63832, 63832], "mapped", [33777]], [[63833, 63833], "mapped", [38517]], [[63834, 63834], "mapped", [35712]], [[63835, 63835], "mapped", [25295]], [[63836, 63836], "mapped", [27138]], [[63837, 63837], "mapped", [35582]], [[63838, 63838], "mapped", [20025]], [[63839, 63839], "mapped", [23527]], [[63840, 63840], "mapped", [24594]], [[63841, 63841], "mapped", [29575]], [[63842, 63842], "mapped", [30064]], [[63843, 63843], "mapped", [21271]], [[63844, 63844], "mapped", [30971]], [[63845, 63845], "mapped", [20415]], [[63846, 63846], "mapped", [24489]], [[63847, 63847], "mapped", [19981]], [[63848, 63848], "mapped", [27852]], [[63849, 63849], "mapped", [25976]], [[63850, 63850], "mapped", [32034]], [[63851, 63851], "mapped", [21443]], [[63852, 63852], "mapped", [22622]], [[63853, 63853], "mapped", [30465]], [[63854, 63854], "mapped", [33865]], [[63855, 63855], "mapped", [35498]], [[63856, 63856], "mapped", [27578]], [[63857, 63857], "mapped", [36784]], [[63858, 63858], "mapped", [27784]], [[63859, 63859], "mapped", [25342]], [[63860, 63860], "mapped", [33509]], [[63861, 63861], "mapped", [25504]], [[63862, 63862], "mapped", [30053]], [[63863, 63863], "mapped", [20142]], [[63864, 63864], "mapped", [20841]], [[63865, 63865], "mapped", [20937]], [[63866, 63866], "mapped", [26753]], [[63867, 63867], "mapped", [31975]], [[63868, 63868], "mapped", [33391]], [[63869, 63869], "mapped", [35538]], [[63870, 63870], "mapped", [37327]], [[63871, 63871], "mapped", [21237]], [[63872, 63872], "mapped", [21570]], [[63873, 63873], "mapped", [22899]], [[63874, 63874], "mapped", [24300]], [[63875, 63875], "mapped", [26053]], [[63876, 63876], "mapped", [28670]], [[63877, 63877], "mapped", [31018]], [[63878, 63878], "mapped", [38317]], [[63879, 63879], "mapped", [39530]], [[63880, 63880], "mapped", [40599]], [[63881, 63881], "mapped", [40654]], [[63882, 63882], "mapped", [21147]], [[63883, 63883], "mapped", [26310]], [[63884, 63884], "mapped", [27511]], [[63885, 63885], "mapped", [36706]], [[63886, 63886], "mapped", [24180]], [[63887, 63887], "mapped", [24976]], [[63888, 63888], "mapped", [25088]], [[63889, 63889], "mapped", [25754]], [[63890, 63890], "mapped", [28451]], [[63891, 63891], "mapped", [29001]], [[63892, 63892], "mapped", [29833]], [[63893, 63893], "mapped", [31178]], [[63894, 63894], "mapped", [32244]], [[63895, 63895], "mapped", [32879]], [[63896, 63896], "mapped", [36646]], [[63897, 63897], "mapped", [34030]], [[63898, 63898], "mapped", [36899]], [[63899, 63899], "mapped", [37706]], [[63900, 63900], "mapped", [21015]], [[63901, 63901], "mapped", [21155]], [[63902, 63902], "mapped", [21693]], [[63903, 63903], "mapped", [28872]], [[63904, 63904], "mapped", [35010]], [[63905, 63905], "mapped", [35498]], [[63906, 63906], "mapped", [24265]], [[63907, 63907], "mapped", [24565]], [[63908, 63908], "mapped", [25467]], [[63909, 63909], "mapped", [27566]], [[63910, 63910], "mapped", [31806]], [[63911, 63911], "mapped", [29557]], [[63912, 63912], "mapped", [20196]], [[63913, 63913], "mapped", [22265]], [[63914, 63914], "mapped", [23527]], [[63915, 63915], "mapped", [23994]], [[63916, 63916], "mapped", [24604]], [[63917, 63917], "mapped", [29618]], [[63918, 63918], "mapped", [29801]], [[63919, 63919], "mapped", [32666]], [[63920, 63920], "mapped", [32838]], [[63921, 63921], "mapped", [37428]], [[63922, 63922], "mapped", [38646]], [[63923, 63923], "mapped", [38728]], [[63924, 63924], "mapped", [38936]], [[63925, 63925], "mapped", [20363]], [[63926, 63926], "mapped", [31150]], [[63927, 63927], "mapped", [37300]], [[63928, 63928], "mapped", [38584]], [[63929, 63929], "mapped", [24801]], [[63930, 63930], "mapped", [20102]], [[63931, 63931], "mapped", [20698]], [[63932, 63932], "mapped", [23534]], [[63933, 63933], "mapped", [23615]], [[63934, 63934], "mapped", [26009]], [[63935, 63935], "mapped", [27138]], [[63936, 63936], "mapped", [29134]], [[63937, 63937], "mapped", [30274]], [[63938, 63938], "mapped", [34044]], [[63939, 63939], "mapped", [36988]], [[63940, 63940], "mapped", [40845]], [[63941, 63941], "mapped", [26248]], [[63942, 63942], "mapped", [38446]], [[63943, 63943], "mapped", [21129]], [[63944, 63944], "mapped", [26491]], [[63945, 63945], "mapped", [26611]], [[63946, 63946], "mapped", [27969]], [[63947, 63947], "mapped", [28316]], [[63948, 63948], "mapped", [29705]], [[63949, 63949], "mapped", [30041]], [[63950, 63950], "mapped", [30827]], [[63951, 63951], "mapped", [32016]], [[63952, 63952], "mapped", [39006]], [[63953, 63953], "mapped", [20845]], [[63954, 63954], "mapped", [25134]], [[63955, 63955], "mapped", [38520]], [[63956, 63956], "mapped", [20523]], [[63957, 63957], "mapped", [23833]], [[63958, 63958], "mapped", [28138]], [[63959, 63959], "mapped", [36650]], [[63960, 63960], "mapped", [24459]], [[63961, 63961], "mapped", [24900]], [[63962, 63962], "mapped", [26647]], [[63963, 63963], "mapped", [29575]], [[63964, 63964], "mapped", [38534]], [[63965, 63965], "mapped", [21033]], [[63966, 63966], "mapped", [21519]], [[63967, 63967], "mapped", [23653]], [[63968, 63968], "mapped", [26131]], [[63969, 63969], "mapped", [26446]], [[63970, 63970], "mapped", [26792]], [[63971, 63971], "mapped", [27877]], [[63972, 63972], "mapped", [29702]], [[63973, 63973], "mapped", [30178]], [[63974, 63974], "mapped", [32633]], [[63975, 63975], "mapped", [35023]], [[63976, 63976], "mapped", [35041]], [[63977, 63977], "mapped", [37324]], [[63978, 63978], "mapped", [38626]], [[63979, 63979], "mapped", [21311]], [[63980, 63980], "mapped", [28346]], [[63981, 63981], "mapped", [21533]], [[63982, 63982], "mapped", [29136]], [[63983, 63983], "mapped", [29848]], [[63984, 63984], "mapped", [34298]], [[63985, 63985], "mapped", [38563]], [[63986, 63986], "mapped", [40023]], [[63987, 63987], "mapped", [40607]], [[63988, 63988], "mapped", [26519]], [[63989, 63989], "mapped", [28107]], [[63990, 63990], "mapped", [33256]], [[63991, 63991], "mapped", [31435]], [[63992, 63992], "mapped", [31520]], [[63993, 63993], "mapped", [31890]], [[63994, 63994], "mapped", [29376]], [[63995, 63995], "mapped", [28825]], [[63996, 63996], "mapped", [35672]], [[63997, 63997], "mapped", [20160]], [[63998, 63998], "mapped", [33590]], [[63999, 63999], "mapped", [21050]], [[64e3, 64e3], "mapped", [20999]], [[64001, 64001], "mapped", [24230]], [[64002, 64002], "mapped", [25299]], [[64003, 64003], "mapped", [31958]], [[64004, 64004], "mapped", [23429]], [[64005, 64005], "mapped", [27934]], [[64006, 64006], "mapped", [26292]], [[64007, 64007], "mapped", [36667]], [[64008, 64008], "mapped", [34892]], [[64009, 64009], "mapped", [38477]], [[64010, 64010], "mapped", [35211]], [[64011, 64011], "mapped", [24275]], [[64012, 64012], "mapped", [20800]], [[64013, 64013], "mapped", [21952]], [[64014, 64015], "valid"], [[64016, 64016], "mapped", [22618]], [[64017, 64017], "valid"], [[64018, 64018], "mapped", [26228]], [[64019, 64020], "valid"], [[64021, 64021], "mapped", [20958]], [[64022, 64022], "mapped", [29482]], [[64023, 64023], "mapped", [30410]], [[64024, 64024], "mapped", [31036]], [[64025, 64025], "mapped", [31070]], [[64026, 64026], "mapped", [31077]], [[64027, 64027], "mapped", [31119]], [[64028, 64028], "mapped", [38742]], [[64029, 64029], "mapped", [31934]], [[64030, 64030], "mapped", [32701]], [[64031, 64031], "valid"], [[64032, 64032], "mapped", [34322]], [[64033, 64033], "valid"], [[64034, 64034], "mapped", [35576]], [[64035, 64036], "valid"], [[64037, 64037], "mapped", [36920]], [[64038, 64038], "mapped", [37117]], [[64039, 64041], "valid"], [[64042, 64042], "mapped", [39151]], [[64043, 64043], "mapped", [39164]], [[64044, 64044], "mapped", [39208]], [[64045, 64045], "mapped", [40372]], [[64046, 64046], "mapped", [37086]], [[64047, 64047], "mapped", [38583]], [[64048, 64048], "mapped", [20398]], [[64049, 64049], "mapped", [20711]], [[64050, 64050], "mapped", [20813]], [[64051, 64051], "mapped", [21193]], [[64052, 64052], "mapped", [21220]], [[64053, 64053], "mapped", [21329]], [[64054, 64054], "mapped", [21917]], [[64055, 64055], "mapped", [22022]], [[64056, 64056], "mapped", [22120]], [[64057, 64057], "mapped", [22592]], [[64058, 64058], "mapped", [22696]], [[64059, 64059], "mapped", [23652]], [[64060, 64060], "mapped", [23662]], [[64061, 64061], "mapped", [24724]], [[64062, 64062], "mapped", [24936]], [[64063, 64063], "mapped", [24974]], [[64064, 64064], "mapped", [25074]], [[64065, 64065], "mapped", [25935]], [[64066, 64066], "mapped", [26082]], [[64067, 64067], "mapped", [26257]], [[64068, 64068], "mapped", [26757]], [[64069, 64069], "mapped", [28023]], [[64070, 64070], "mapped", [28186]], [[64071, 64071], "mapped", [28450]], [[64072, 64072], "mapped", [29038]], [[64073, 64073], "mapped", [29227]], [[64074, 64074], "mapped", [29730]], [[64075, 64075], "mapped", [30865]], [[64076, 64076], "mapped", [31038]], [[64077, 64077], "mapped", [31049]], [[64078, 64078], "mapped", [31048]], [[64079, 64079], "mapped", [31056]], [[64080, 64080], "mapped", [31062]], [[64081, 64081], "mapped", [31069]], [[64082, 64082], "mapped", [31117]], [[64083, 64083], "mapped", [31118]], [[64084, 64084], "mapped", [31296]], [[64085, 64085], "mapped", [31361]], [[64086, 64086], "mapped", [31680]], [[64087, 64087], "mapped", [32244]], [[64088, 64088], "mapped", [32265]], [[64089, 64089], "mapped", [32321]], [[64090, 64090], "mapped", [32626]], [[64091, 64091], "mapped", [32773]], [[64092, 64092], "mapped", [33261]], [[64093, 64094], "mapped", [33401]], [[64095, 64095], "mapped", [33879]], [[64096, 64096], "mapped", [35088]], [[64097, 64097], "mapped", [35222]], [[64098, 64098], "mapped", [35585]], [[64099, 64099], "mapped", [35641]], [[64100, 64100], "mapped", [36051]], [[64101, 64101], "mapped", [36104]], [[64102, 64102], "mapped", [36790]], [[64103, 64103], "mapped", [36920]], [[64104, 64104], "mapped", [38627]], [[64105, 64105], "mapped", [38911]], [[64106, 64106], "mapped", [38971]], [[64107, 64107], "mapped", [24693]], [[64108, 64108], "mapped", [148206]], [[64109, 64109], "mapped", [33304]], [[64110, 64111], "disallowed"], [[64112, 64112], "mapped", [20006]], [[64113, 64113], "mapped", [20917]], [[64114, 64114], "mapped", [20840]], [[64115, 64115], "mapped", [20352]], [[64116, 64116], "mapped", [20805]], [[64117, 64117], "mapped", [20864]], [[64118, 64118], "mapped", [21191]], [[64119, 64119], "mapped", [21242]], [[64120, 64120], "mapped", [21917]], [[64121, 64121], "mapped", [21845]], [[64122, 64122], "mapped", [21913]], [[64123, 64123], "mapped", [21986]], [[64124, 64124], "mapped", [22618]], [[64125, 64125], "mapped", [22707]], [[64126, 64126], "mapped", [22852]], [[64127, 64127], "mapped", [22868]], [[64128, 64128], "mapped", [23138]], [[64129, 64129], "mapped", [23336]], [[64130, 64130], "mapped", [24274]], [[64131, 64131], "mapped", [24281]], [[64132, 64132], "mapped", [24425]], [[64133, 64133], "mapped", [24493]], [[64134, 64134], "mapped", [24792]], [[64135, 64135], "mapped", [24910]], [[64136, 64136], "mapped", [24840]], [[64137, 64137], "mapped", [24974]], [[64138, 64138], "mapped", [24928]], [[64139, 64139], "mapped", [25074]], [[64140, 64140], "mapped", [25140]], [[64141, 64141], "mapped", [25540]], [[64142, 64142], "mapped", [25628]], [[64143, 64143], "mapped", [25682]], [[64144, 64144], "mapped", [25942]], [[64145, 64145], "mapped", [26228]], [[64146, 64146], "mapped", [26391]], [[64147, 64147], "mapped", [26395]], [[64148, 64148], "mapped", [26454]], [[64149, 64149], "mapped", [27513]], [[64150, 64150], "mapped", [27578]], [[64151, 64151], "mapped", [27969]], [[64152, 64152], "mapped", [28379]], [[64153, 64153], "mapped", [28363]], [[64154, 64154], "mapped", [28450]], [[64155, 64155], "mapped", [28702]], [[64156, 64156], "mapped", [29038]], [[64157, 64157], "mapped", [30631]], [[64158, 64158], "mapped", [29237]], [[64159, 64159], "mapped", [29359]], [[64160, 64160], "mapped", [29482]], [[64161, 64161], "mapped", [29809]], [[64162, 64162], "mapped", [29958]], [[64163, 64163], "mapped", [30011]], [[64164, 64164], "mapped", [30237]], [[64165, 64165], "mapped", [30239]], [[64166, 64166], "mapped", [30410]], [[64167, 64167], "mapped", [30427]], [[64168, 64168], "mapped", [30452]], [[64169, 64169], "mapped", [30538]], [[64170, 64170], "mapped", [30528]], [[64171, 64171], "mapped", [30924]], [[64172, 64172], "mapped", [31409]], [[64173, 64173], "mapped", [31680]], [[64174, 64174], "mapped", [31867]], [[64175, 64175], "mapped", [32091]], [[64176, 64176], "mapped", [32244]], [[64177, 64177], "mapped", [32574]], [[64178, 64178], "mapped", [32773]], [[64179, 64179], "mapped", [33618]], [[64180, 64180], "mapped", [33775]], [[64181, 64181], "mapped", [34681]], [[64182, 64182], "mapped", [35137]], [[64183, 64183], "mapped", [35206]], [[64184, 64184], "mapped", [35222]], [[64185, 64185], "mapped", [35519]], [[64186, 64186], "mapped", [35576]], [[64187, 64187], "mapped", [35531]], [[64188, 64188], "mapped", [35585]], [[64189, 64189], "mapped", [35582]], [[64190, 64190], "mapped", [35565]], [[64191, 64191], "mapped", [35641]], [[64192, 64192], "mapped", [35722]], [[64193, 64193], "mapped", [36104]], [[64194, 64194], "mapped", [36664]], [[64195, 64195], "mapped", [36978]], [[64196, 64196], "mapped", [37273]], [[64197, 64197], "mapped", [37494]], [[64198, 64198], "mapped", [38524]], [[64199, 64199], "mapped", [38627]], [[64200, 64200], "mapped", [38742]], [[64201, 64201], "mapped", [38875]], [[64202, 64202], "mapped", [38911]], [[64203, 64203], "mapped", [38923]], [[64204, 64204], "mapped", [38971]], [[64205, 64205], "mapped", [39698]], [[64206, 64206], "mapped", [40860]], [[64207, 64207], "mapped", [141386]], [[64208, 64208], "mapped", [141380]], [[64209, 64209], "mapped", [144341]], [[64210, 64210], "mapped", [15261]], [[64211, 64211], "mapped", [16408]], [[64212, 64212], "mapped", [16441]], [[64213, 64213], "mapped", [152137]], [[64214, 64214], "mapped", [154832]], [[64215, 64215], "mapped", [163539]], [[64216, 64216], "mapped", [40771]], [[64217, 64217], "mapped", [40846]], [[64218, 64255], "disallowed"], [[64256, 64256], "mapped", [102, 102]], [[64257, 64257], "mapped", [102, 105]], [[64258, 64258], "mapped", [102, 108]], [[64259, 64259], "mapped", [102, 102, 105]], [[64260, 64260], "mapped", [102, 102, 108]], [[64261, 64262], "mapped", [115, 116]], [[64263, 64274], "disallowed"], [[64275, 64275], "mapped", [1396, 1398]], [[64276, 64276], "mapped", [1396, 1381]], [[64277, 64277], "mapped", [1396, 1387]], [[64278, 64278], "mapped", [1406, 1398]], [[64279, 64279], "mapped", [1396, 1389]], [[64280, 64284], "disallowed"], [[64285, 64285], "mapped", [1497, 1460]], [[64286, 64286], "valid"], [[64287, 64287], "mapped", [1522, 1463]], [[64288, 64288], "mapped", [1506]], [[64289, 64289], "mapped", [1488]], [[64290, 64290], "mapped", [1491]], [[64291, 64291], "mapped", [1492]], [[64292, 64292], "mapped", [1499]], [[64293, 64293], "mapped", [1500]], [[64294, 64294], "mapped", [1501]], [[64295, 64295], "mapped", [1512]], [[64296, 64296], "mapped", [1514]], [[64297, 64297], "disallowed_STD3_mapped", [43]], [[64298, 64298], "mapped", [1513, 1473]], [[64299, 64299], "mapped", [1513, 1474]], [[64300, 64300], "mapped", [1513, 1468, 1473]], [[64301, 64301], "mapped", [1513, 1468, 1474]], [[64302, 64302], "mapped", [1488, 1463]], [[64303, 64303], "mapped", [1488, 1464]], [[64304, 64304], "mapped", [1488, 1468]], [[64305, 64305], "mapped", [1489, 1468]], [[64306, 64306], "mapped", [1490, 1468]], [[64307, 64307], "mapped", [1491, 1468]], [[64308, 64308], "mapped", [1492, 1468]], [[64309, 64309], "mapped", [1493, 1468]], [[64310, 64310], "mapped", [1494, 1468]], [[64311, 64311], "disallowed"], [[64312, 64312], "mapped", [1496, 1468]], [[64313, 64313], "mapped", [1497, 1468]], [[64314, 64314], "mapped", [1498, 1468]], [[64315, 64315], "mapped", [1499, 1468]], [[64316, 64316], "mapped", [1500, 1468]], [[64317, 64317], "disallowed"], [[64318, 64318], "mapped", [1502, 1468]], [[64319, 64319], "disallowed"], [[64320, 64320], "mapped", [1504, 1468]], [[64321, 64321], "mapped", [1505, 1468]], [[64322, 64322], "disallowed"], [[64323, 64323], "mapped", [1507, 1468]], [[64324, 64324], "mapped", [1508, 1468]], [[64325, 64325], "disallowed"], [[64326, 64326], "mapped", [1510, 1468]], [[64327, 64327], "mapped", [1511, 1468]], [[64328, 64328], "mapped", [1512, 1468]], [[64329, 64329], "mapped", [1513, 1468]], [[64330, 64330], "mapped", [1514, 1468]], [[64331, 64331], "mapped", [1493, 1465]], [[64332, 64332], "mapped", [1489, 1471]], [[64333, 64333], "mapped", [1499, 1471]], [[64334, 64334], "mapped", [1508, 1471]], [[64335, 64335], "mapped", [1488, 1500]], [[64336, 64337], "mapped", [1649]], [[64338, 64341], "mapped", [1659]], [[64342, 64345], "mapped", [1662]], [[64346, 64349], "mapped", [1664]], [[64350, 64353], "mapped", [1658]], [[64354, 64357], "mapped", [1663]], [[64358, 64361], "mapped", [1657]], [[64362, 64365], "mapped", [1700]], [[64366, 64369], "mapped", [1702]], [[64370, 64373], "mapped", [1668]], [[64374, 64377], "mapped", [1667]], [[64378, 64381], "mapped", [1670]], [[64382, 64385], "mapped", [1671]], [[64386, 64387], "mapped", [1677]], [[64388, 64389], "mapped", [1676]], [[64390, 64391], "mapped", [1678]], [[64392, 64393], "mapped", [1672]], [[64394, 64395], "mapped", [1688]], [[64396, 64397], "mapped", [1681]], [[64398, 64401], "mapped", [1705]], [[64402, 64405], "mapped", [1711]], [[64406, 64409], "mapped", [1715]], [[64410, 64413], "mapped", [1713]], [[64414, 64415], "mapped", [1722]], [[64416, 64419], "mapped", [1723]], [[64420, 64421], "mapped", [1728]], [[64422, 64425], "mapped", [1729]], [[64426, 64429], "mapped", [1726]], [[64430, 64431], "mapped", [1746]], [[64432, 64433], "mapped", [1747]], [[64434, 64449], "valid", [], "NV8"], [[64450, 64466], "disallowed"], [[64467, 64470], "mapped", [1709]], [[64471, 64472], "mapped", [1735]], [[64473, 64474], "mapped", [1734]], [[64475, 64476], "mapped", [1736]], [[64477, 64477], "mapped", [1735, 1652]], [[64478, 64479], "mapped", [1739]], [[64480, 64481], "mapped", [1733]], [[64482, 64483], "mapped", [1737]], [[64484, 64487], "mapped", [1744]], [[64488, 64489], "mapped", [1609]], [[64490, 64491], "mapped", [1574, 1575]], [[64492, 64493], "mapped", [1574, 1749]], [[64494, 64495], "mapped", [1574, 1608]], [[64496, 64497], "mapped", [1574, 1735]], [[64498, 64499], "mapped", [1574, 1734]], [[64500, 64501], "mapped", [1574, 1736]], [[64502, 64504], "mapped", [1574, 1744]], [[64505, 64507], "mapped", [1574, 1609]], [[64508, 64511], "mapped", [1740]], [[64512, 64512], "mapped", [1574, 1580]], [[64513, 64513], "mapped", [1574, 1581]], [[64514, 64514], "mapped", [1574, 1605]], [[64515, 64515], "mapped", [1574, 1609]], [[64516, 64516], "mapped", [1574, 1610]], [[64517, 64517], "mapped", [1576, 1580]], [[64518, 64518], "mapped", [1576, 1581]], [[64519, 64519], "mapped", [1576, 1582]], [[64520, 64520], "mapped", [1576, 1605]], [[64521, 64521], "mapped", [1576, 1609]], [[64522, 64522], "mapped", [1576, 1610]], [[64523, 64523], "mapped", [1578, 1580]], [[64524, 64524], "mapped", [1578, 1581]], [[64525, 64525], "mapped", [1578, 1582]], [[64526, 64526], "mapped", [1578, 1605]], [[64527, 64527], "mapped", [1578, 1609]], [[64528, 64528], "mapped", [1578, 1610]], [[64529, 64529], "mapped", [1579, 1580]], [[64530, 64530], "mapped", [1579, 1605]], [[64531, 64531], "mapped", [1579, 1609]], [[64532, 64532], "mapped", [1579, 1610]], [[64533, 64533], "mapped", [1580, 1581]], [[64534, 64534], "mapped", [1580, 1605]], [[64535, 64535], "mapped", [1581, 1580]], [[64536, 64536], "mapped", [1581, 1605]], [[64537, 64537], "mapped", [1582, 1580]], [[64538, 64538], "mapped", [1582, 1581]], [[64539, 64539], "mapped", [1582, 1605]], [[64540, 64540], "mapped", [1587, 1580]], [[64541, 64541], "mapped", [1587, 1581]], [[64542, 64542], "mapped", [1587, 1582]], [[64543, 64543], "mapped", [1587, 1605]], [[64544, 64544], "mapped", [1589, 1581]], [[64545, 64545], "mapped", [1589, 1605]], [[64546, 64546], "mapped", [1590, 1580]], [[64547, 64547], "mapped", [1590, 1581]], [[64548, 64548], "mapped", [1590, 1582]], [[64549, 64549], "mapped", [1590, 1605]], [[64550, 64550], "mapped", [1591, 1581]], [[64551, 64551], "mapped", [1591, 1605]], [[64552, 64552], "mapped", [1592, 1605]], [[64553, 64553], "mapped", [1593, 1580]], [[64554, 64554], "mapped", [1593, 1605]], [[64555, 64555], "mapped", [1594, 1580]], [[64556, 64556], "mapped", [1594, 1605]], [[64557, 64557], "mapped", [1601, 1580]], [[64558, 64558], "mapped", [1601, 1581]], [[64559, 64559], "mapped", [1601, 1582]], [[64560, 64560], "mapped", [1601, 1605]], [[64561, 64561], "mapped", [1601, 1609]], [[64562, 64562], "mapped", [1601, 1610]], [[64563, 64563], "mapped", [1602, 1581]], [[64564, 64564], "mapped", [1602, 1605]], [[64565, 64565], "mapped", [1602, 1609]], [[64566, 64566], "mapped", [1602, 1610]], [[64567, 64567], "mapped", [1603, 1575]], [[64568, 64568], "mapped", [1603, 1580]], [[64569, 64569], "mapped", [1603, 1581]], [[64570, 64570], "mapped", [1603, 1582]], [[64571, 64571], "mapped", [1603, 1604]], [[64572, 64572], "mapped", [1603, 1605]], [[64573, 64573], "mapped", [1603, 1609]], [[64574, 64574], "mapped", [1603, 1610]], [[64575, 64575], "mapped", [1604, 1580]], [[64576, 64576], "mapped", [1604, 1581]], [[64577, 64577], "mapped", [1604, 1582]], [[64578, 64578], "mapped", [1604, 1605]], [[64579, 64579], "mapped", [1604, 1609]], [[64580, 64580], "mapped", [1604, 1610]], [[64581, 64581], "mapped", [1605, 1580]], [[64582, 64582], "mapped", [1605, 1581]], [[64583, 64583], "mapped", [1605, 1582]], [[64584, 64584], "mapped", [1605, 1605]], [[64585, 64585], "mapped", [1605, 1609]], [[64586, 64586], "mapped", [1605, 1610]], [[64587, 64587], "mapped", [1606, 1580]], [[64588, 64588], "mapped", [1606, 1581]], [[64589, 64589], "mapped", [1606, 1582]], [[64590, 64590], "mapped", [1606, 1605]], [[64591, 64591], "mapped", [1606, 1609]], [[64592, 64592], "mapped", [1606, 1610]], [[64593, 64593], "mapped", [1607, 1580]], [[64594, 64594], "mapped", [1607, 1605]], [[64595, 64595], "mapped", [1607, 1609]], [[64596, 64596], "mapped", [1607, 1610]], [[64597, 64597], "mapped", [1610, 1580]], [[64598, 64598], "mapped", [1610, 1581]], [[64599, 64599], "mapped", [1610, 1582]], [[64600, 64600], "mapped", [1610, 1605]], [[64601, 64601], "mapped", [1610, 1609]], [[64602, 64602], "mapped", [1610, 1610]], [[64603, 64603], "mapped", [1584, 1648]], [[64604, 64604], "mapped", [1585, 1648]], [[64605, 64605], "mapped", [1609, 1648]], [[64606, 64606], "disallowed_STD3_mapped", [32, 1612, 1617]], [[64607, 64607], "disallowed_STD3_mapped", [32, 1613, 1617]], [[64608, 64608], "disallowed_STD3_mapped", [32, 1614, 1617]], [[64609, 64609], "disallowed_STD3_mapped", [32, 1615, 1617]], [[64610, 64610], "disallowed_STD3_mapped", [32, 1616, 1617]], [[64611, 64611], "disallowed_STD3_mapped", [32, 1617, 1648]], [[64612, 64612], "mapped", [1574, 1585]], [[64613, 64613], "mapped", [1574, 1586]], [[64614, 64614], "mapped", [1574, 1605]], [[64615, 64615], "mapped", [1574, 1606]], [[64616, 64616], "mapped", [1574, 1609]], [[64617, 64617], "mapped", [1574, 1610]], [[64618, 64618], "mapped", [1576, 1585]], [[64619, 64619], "mapped", [1576, 1586]], [[64620, 64620], "mapped", [1576, 1605]], [[64621, 64621], "mapped", [1576, 1606]], [[64622, 64622], "mapped", [1576, 1609]], [[64623, 64623], "mapped", [1576, 1610]], [[64624, 64624], "mapped", [1578, 1585]], [[64625, 64625], "mapped", [1578, 1586]], [[64626, 64626], "mapped", [1578, 1605]], [[64627, 64627], "mapped", [1578, 1606]], [[64628, 64628], "mapped", [1578, 1609]], [[64629, 64629], "mapped", [1578, 1610]], [[64630, 64630], "mapped", [1579, 1585]], [[64631, 64631], "mapped", [1579, 1586]], [[64632, 64632], "mapped", [1579, 1605]], [[64633, 64633], "mapped", [1579, 1606]], [[64634, 64634], "mapped", [1579, 1609]], [[64635, 64635], "mapped", [1579, 1610]], [[64636, 64636], "mapped", [1601, 1609]], [[64637, 64637], "mapped", [1601, 1610]], [[64638, 64638], "mapped", [1602, 1609]], [[64639, 64639], "mapped", [1602, 1610]], [[64640, 64640], "mapped", [1603, 1575]], [[64641, 64641], "mapped", [1603, 1604]], [[64642, 64642], "mapped", [1603, 1605]], [[64643, 64643], "mapped", [1603, 1609]], [[64644, 64644], "mapped", [1603, 1610]], [[64645, 64645], "mapped", [1604, 1605]], [[64646, 64646], "mapped", [1604, 1609]], [[64647, 64647], "mapped", [1604, 1610]], [[64648, 64648], "mapped", [1605, 1575]], [[64649, 64649], "mapped", [1605, 1605]], [[64650, 64650], "mapped", [1606, 1585]], [[64651, 64651], "mapped", [1606, 1586]], [[64652, 64652], "mapped", [1606, 1605]], [[64653, 64653], "mapped", [1606, 1606]], [[64654, 64654], "mapped", [1606, 1609]], [[64655, 64655], "mapped", [1606, 1610]], [[64656, 64656], "mapped", [1609, 1648]], [[64657, 64657], "mapped", [1610, 1585]], [[64658, 64658], "mapped", [1610, 1586]], [[64659, 64659], "mapped", [1610, 1605]], [[64660, 64660], "mapped", [1610, 1606]], [[64661, 64661], "mapped", [1610, 1609]], [[64662, 64662], "mapped", [1610, 1610]], [[64663, 64663], "mapped", [1574, 1580]], [[64664, 64664], "mapped", [1574, 1581]], [[64665, 64665], "mapped", [1574, 1582]], [[64666, 64666], "mapped", [1574, 1605]], [[64667, 64667], "mapped", [1574, 1607]], [[64668, 64668], "mapped", [1576, 1580]], [[64669, 64669], "mapped", [1576, 1581]], [[64670, 64670], "mapped", [1576, 1582]], [[64671, 64671], "mapped", [1576, 1605]], [[64672, 64672], "mapped", [1576, 1607]], [[64673, 64673], "mapped", [1578, 1580]], [[64674, 64674], "mapped", [1578, 1581]], [[64675, 64675], "mapped", [1578, 1582]], [[64676, 64676], "mapped", [1578, 1605]], [[64677, 64677], "mapped", [1578, 1607]], [[64678, 64678], "mapped", [1579, 1605]], [[64679, 64679], "mapped", [1580, 1581]], [[64680, 64680], "mapped", [1580, 1605]], [[64681, 64681], "mapped", [1581, 1580]], [[64682, 64682], "mapped", [1581, 1605]], [[64683, 64683], "mapped", [1582, 1580]], [[64684, 64684], "mapped", [1582, 1605]], [[64685, 64685], "mapped", [1587, 1580]], [[64686, 64686], "mapped", [1587, 1581]], [[64687, 64687], "mapped", [1587, 1582]], [[64688, 64688], "mapped", [1587, 1605]], [[64689, 64689], "mapped", [1589, 1581]], [[64690, 64690], "mapped", [1589, 1582]], [[64691, 64691], "mapped", [1589, 1605]], [[64692, 64692], "mapped", [1590, 1580]], [[64693, 64693], "mapped", [1590, 1581]], [[64694, 64694], "mapped", [1590, 1582]], [[64695, 64695], "mapped", [1590, 1605]], [[64696, 64696], "mapped", [1591, 1581]], [[64697, 64697], "mapped", [1592, 1605]], [[64698, 64698], "mapped", [1593, 1580]], [[64699, 64699], "mapped", [1593, 1605]], [[64700, 64700], "mapped", [1594, 1580]], [[64701, 64701], "mapped", [1594, 1605]], [[64702, 64702], "mapped", [1601, 1580]], [[64703, 64703], "mapped", [1601, 1581]], [[64704, 64704], "mapped", [1601, 1582]], [[64705, 64705], "mapped", [1601, 1605]], [[64706, 64706], "mapped", [1602, 1581]], [[64707, 64707], "mapped", [1602, 1605]], [[64708, 64708], "mapped", [1603, 1580]], [[64709, 64709], "mapped", [1603, 1581]], [[64710, 64710], "mapped", [1603, 1582]], [[64711, 64711], "mapped", [1603, 1604]], [[64712, 64712], "mapped", [1603, 1605]], [[64713, 64713], "mapped", [1604, 1580]], [[64714, 64714], "mapped", [1604, 1581]], [[64715, 64715], "mapped", [1604, 1582]], [[64716, 64716], "mapped", [1604, 1605]], [[64717, 64717], "mapped", [1604, 1607]], [[64718, 64718], "mapped", [1605, 1580]], [[64719, 64719], "mapped", [1605, 1581]], [[64720, 64720], "mapped", [1605, 1582]], [[64721, 64721], "mapped", [1605, 1605]], [[64722, 64722], "mapped", [1606, 1580]], [[64723, 64723], "mapped", [1606, 1581]], [[64724, 64724], "mapped", [1606, 1582]], [[64725, 64725], "mapped", [1606, 1605]], [[64726, 64726], "mapped", [1606, 1607]], [[64727, 64727], "mapped", [1607, 1580]], [[64728, 64728], "mapped", [1607, 1605]], [[64729, 64729], "mapped", [1607, 1648]], [[64730, 64730], "mapped", [1610, 1580]], [[64731, 64731], "mapped", [1610, 1581]], [[64732, 64732], "mapped", [1610, 1582]], [[64733, 64733], "mapped", [1610, 1605]], [[64734, 64734], "mapped", [1610, 1607]], [[64735, 64735], "mapped", [1574, 1605]], [[64736, 64736], "mapped", [1574, 1607]], [[64737, 64737], "mapped", [1576, 1605]], [[64738, 64738], "mapped", [1576, 1607]], [[64739, 64739], "mapped", [1578, 1605]], [[64740, 64740], "mapped", [1578, 1607]], [[64741, 64741], "mapped", [1579, 1605]], [[64742, 64742], "mapped", [1579, 1607]], [[64743, 64743], "mapped", [1587, 1605]], [[64744, 64744], "mapped", [1587, 1607]], [[64745, 64745], "mapped", [1588, 1605]], [[64746, 64746], "mapped", [1588, 1607]], [[64747, 64747], "mapped", [1603, 1604]], [[64748, 64748], "mapped", [1603, 1605]], [[64749, 64749], "mapped", [1604, 1605]], [[64750, 64750], "mapped", [1606, 1605]], [[64751, 64751], "mapped", [1606, 1607]], [[64752, 64752], "mapped", [1610, 1605]], [[64753, 64753], "mapped", [1610, 1607]], [[64754, 64754], "mapped", [1600, 1614, 1617]], [[64755, 64755], "mapped", [1600, 1615, 1617]], [[64756, 64756], "mapped", [1600, 1616, 1617]], [[64757, 64757], "mapped", [1591, 1609]], [[64758, 64758], "mapped", [1591, 1610]], [[64759, 64759], "mapped", [1593, 1609]], [[64760, 64760], "mapped", [1593, 1610]], [[64761, 64761], "mapped", [1594, 1609]], [[64762, 64762], "mapped", [1594, 1610]], [[64763, 64763], "mapped", [1587, 1609]], [[64764, 64764], "mapped", [1587, 1610]], [[64765, 64765], "mapped", [1588, 1609]], [[64766, 64766], "mapped", [1588, 1610]], [[64767, 64767], "mapped", [1581, 1609]], [[64768, 64768], "mapped", [1581, 1610]], [[64769, 64769], "mapped", [1580, 1609]], [[64770, 64770], "mapped", [1580, 1610]], [[64771, 64771], "mapped", [1582, 1609]], [[64772, 64772], "mapped", [1582, 1610]], [[64773, 64773], "mapped", [1589, 1609]], [[64774, 64774], "mapped", [1589, 1610]], [[64775, 64775], "mapped", [1590, 1609]], [[64776, 64776], "mapped", [1590, 1610]], [[64777, 64777], "mapped", [1588, 1580]], [[64778, 64778], "mapped", [1588, 1581]], [[64779, 64779], "mapped", [1588, 1582]], [[64780, 64780], "mapped", [1588, 1605]], [[64781, 64781], "mapped", [1588, 1585]], [[64782, 64782], "mapped", [1587, 1585]], [[64783, 64783], "mapped", [1589, 1585]], [[64784, 64784], "mapped", [1590, 1585]], [[64785, 64785], "mapped", [1591, 1609]], [[64786, 64786], "mapped", [1591, 1610]], [[64787, 64787], "mapped", [1593, 1609]], [[64788, 64788], "mapped", [1593, 1610]], [[64789, 64789], "mapped", [1594, 1609]], [[64790, 64790], "mapped", [1594, 1610]], [[64791, 64791], "mapped", [1587, 1609]], [[64792, 64792], "mapped", [1587, 1610]], [[64793, 64793], "mapped", [1588, 1609]], [[64794, 64794], "mapped", [1588, 1610]], [[64795, 64795], "mapped", [1581, 1609]], [[64796, 64796], "mapped", [1581, 1610]], [[64797, 64797], "mapped", [1580, 1609]], [[64798, 64798], "mapped", [1580, 1610]], [[64799, 64799], "mapped", [1582, 1609]], [[64800, 64800], "mapped", [1582, 1610]], [[64801, 64801], "mapped", [1589, 1609]], [[64802, 64802], "mapped", [1589, 1610]], [[64803, 64803], "mapped", [1590, 1609]], [[64804, 64804], "mapped", [1590, 1610]], [[64805, 64805], "mapped", [1588, 1580]], [[64806, 64806], "mapped", [1588, 1581]], [[64807, 64807], "mapped", [1588, 1582]], [[64808, 64808], "mapped", [1588, 1605]], [[64809, 64809], "mapped", [1588, 1585]], [[64810, 64810], "mapped", [1587, 1585]], [[64811, 64811], "mapped", [1589, 1585]], [[64812, 64812], "mapped", [1590, 1585]], [[64813, 64813], "mapped", [1588, 1580]], [[64814, 64814], "mapped", [1588, 1581]], [[64815, 64815], "mapped", [1588, 1582]], [[64816, 64816], "mapped", [1588, 1605]], [[64817, 64817], "mapped", [1587, 1607]], [[64818, 64818], "mapped", [1588, 1607]], [[64819, 64819], "mapped", [1591, 1605]], [[64820, 64820], "mapped", [1587, 1580]], [[64821, 64821], "mapped", [1587, 1581]], [[64822, 64822], "mapped", [1587, 1582]], [[64823, 64823], "mapped", [1588, 1580]], [[64824, 64824], "mapped", [1588, 1581]], [[64825, 64825], "mapped", [1588, 1582]], [[64826, 64826], "mapped", [1591, 1605]], [[64827, 64827], "mapped", [1592, 1605]], [[64828, 64829], "mapped", [1575, 1611]], [[64830, 64831], "valid", [], "NV8"], [[64832, 64847], "disallowed"], [[64848, 64848], "mapped", [1578, 1580, 1605]], [[64849, 64850], "mapped", [1578, 1581, 1580]], [[64851, 64851], "mapped", [1578, 1581, 1605]], [[64852, 64852], "mapped", [1578, 1582, 1605]], [[64853, 64853], "mapped", [1578, 1605, 1580]], [[64854, 64854], "mapped", [1578, 1605, 1581]], [[64855, 64855], "mapped", [1578, 1605, 1582]], [[64856, 64857], "mapped", [1580, 1605, 1581]], [[64858, 64858], "mapped", [1581, 1605, 1610]], [[64859, 64859], "mapped", [1581, 1605, 1609]], [[64860, 64860], "mapped", [1587, 1581, 1580]], [[64861, 64861], "mapped", [1587, 1580, 1581]], [[64862, 64862], "mapped", [1587, 1580, 1609]], [[64863, 64864], "mapped", [1587, 1605, 1581]], [[64865, 64865], "mapped", [1587, 1605, 1580]], [[64866, 64867], "mapped", [1587, 1605, 1605]], [[64868, 64869], "mapped", [1589, 1581, 1581]], [[64870, 64870], "mapped", [1589, 1605, 1605]], [[64871, 64872], "mapped", [1588, 1581, 1605]], [[64873, 64873], "mapped", [1588, 1580, 1610]], [[64874, 64875], "mapped", [1588, 1605, 1582]], [[64876, 64877], "mapped", [1588, 1605, 1605]], [[64878, 64878], "mapped", [1590, 1581, 1609]], [[64879, 64880], "mapped", [1590, 1582, 1605]], [[64881, 64882], "mapped", [1591, 1605, 1581]], [[64883, 64883], "mapped", [1591, 1605, 1605]], [[64884, 64884], "mapped", [1591, 1605, 1610]], [[64885, 64885], "mapped", [1593, 1580, 1605]], [[64886, 64887], "mapped", [1593, 1605, 1605]], [[64888, 64888], "mapped", [1593, 1605, 1609]], [[64889, 64889], "mapped", [1594, 1605, 1605]], [[64890, 64890], "mapped", [1594, 1605, 1610]], [[64891, 64891], "mapped", [1594, 1605, 1609]], [[64892, 64893], "mapped", [1601, 1582, 1605]], [[64894, 64894], "mapped", [1602, 1605, 1581]], [[64895, 64895], "mapped", [1602, 1605, 1605]], [[64896, 64896], "mapped", [1604, 1581, 1605]], [[64897, 64897], "mapped", [1604, 1581, 1610]], [[64898, 64898], "mapped", [1604, 1581, 1609]], [[64899, 64900], "mapped", [1604, 1580, 1580]], [[64901, 64902], "mapped", [1604, 1582, 1605]], [[64903, 64904], "mapped", [1604, 1605, 1581]], [[64905, 64905], "mapped", [1605, 1581, 1580]], [[64906, 64906], "mapped", [1605, 1581, 1605]], [[64907, 64907], "mapped", [1605, 1581, 1610]], [[64908, 64908], "mapped", [1605, 1580, 1581]], [[64909, 64909], "mapped", [1605, 1580, 1605]], [[64910, 64910], "mapped", [1605, 1582, 1580]], [[64911, 64911], "mapped", [1605, 1582, 1605]], [[64912, 64913], "disallowed"], [[64914, 64914], "mapped", [1605, 1580, 1582]], [[64915, 64915], "mapped", [1607, 1605, 1580]], [[64916, 64916], "mapped", [1607, 1605, 1605]], [[64917, 64917], "mapped", [1606, 1581, 1605]], [[64918, 64918], "mapped", [1606, 1581, 1609]], [[64919, 64920], "mapped", [1606, 1580, 1605]], [[64921, 64921], "mapped", [1606, 1580, 1609]], [[64922, 64922], "mapped", [1606, 1605, 1610]], [[64923, 64923], "mapped", [1606, 1605, 1609]], [[64924, 64925], "mapped", [1610, 1605, 1605]], [[64926, 64926], "mapped", [1576, 1582, 1610]], [[64927, 64927], "mapped", [1578, 1580, 1610]], [[64928, 64928], "mapped", [1578, 1580, 1609]], [[64929, 64929], "mapped", [1578, 1582, 1610]], [[64930, 64930], "mapped", [1578, 1582, 1609]], [[64931, 64931], "mapped", [1578, 1605, 1610]], [[64932, 64932], "mapped", [1578, 1605, 1609]], [[64933, 64933], "mapped", [1580, 1605, 1610]], [[64934, 64934], "mapped", [1580, 1581, 1609]], [[64935, 64935], "mapped", [1580, 1605, 1609]], [[64936, 64936], "mapped", [1587, 1582, 1609]], [[64937, 64937], "mapped", [1589, 1581, 1610]], [[64938, 64938], "mapped", [1588, 1581, 1610]], [[64939, 64939], "mapped", [1590, 1581, 1610]], [[64940, 64940], "mapped", [1604, 1580, 1610]], [[64941, 64941], "mapped", [1604, 1605, 1610]], [[64942, 64942], "mapped", [1610, 1581, 1610]], [[64943, 64943], "mapped", [1610, 1580, 1610]], [[64944, 64944], "mapped", [1610, 1605, 1610]], [[64945, 64945], "mapped", [1605, 1605, 1610]], [[64946, 64946], "mapped", [1602, 1605, 1610]], [[64947, 64947], "mapped", [1606, 1581, 1610]], [[64948, 64948], "mapped", [1602, 1605, 1581]], [[64949, 64949], "mapped", [1604, 1581, 1605]], [[64950, 64950], "mapped", [1593, 1605, 1610]], [[64951, 64951], "mapped", [1603, 1605, 1610]], [[64952, 64952], "mapped", [1606, 1580, 1581]], [[64953, 64953], "mapped", [1605, 1582, 1610]], [[64954, 64954], "mapped", [1604, 1580, 1605]], [[64955, 64955], "mapped", [1603, 1605, 1605]], [[64956, 64956], "mapped", [1604, 1580, 1605]], [[64957, 64957], "mapped", [1606, 1580, 1581]], [[64958, 64958], "mapped", [1580, 1581, 1610]], [[64959, 64959], "mapped", [1581, 1580, 1610]], [[64960, 64960], "mapped", [1605, 1580, 1610]], [[64961, 64961], "mapped", [1601, 1605, 1610]], [[64962, 64962], "mapped", [1576, 1581, 1610]], [[64963, 64963], "mapped", [1603, 1605, 1605]], [[64964, 64964], "mapped", [1593, 1580, 1605]], [[64965, 64965], "mapped", [1589, 1605, 1605]], [[64966, 64966], "mapped", [1587, 1582, 1610]], [[64967, 64967], "mapped", [1606, 1580, 1610]], [[64968, 64975], "disallowed"], [[64976, 65007], "disallowed"], [[65008, 65008], "mapped", [1589, 1604, 1746]], [[65009, 65009], "mapped", [1602, 1604, 1746]], [[65010, 65010], "mapped", [1575, 1604, 1604, 1607]], [[65011, 65011], "mapped", [1575, 1603, 1576, 1585]], [[65012, 65012], "mapped", [1605, 1581, 1605, 1583]], [[65013, 65013], "mapped", [1589, 1604, 1593, 1605]], [[65014, 65014], "mapped", [1585, 1587, 1608, 1604]], [[65015, 65015], "mapped", [1593, 1604, 1610, 1607]], [[65016, 65016], "mapped", [1608, 1587, 1604, 1605]], [[65017, 65017], "mapped", [1589, 1604, 1609]], [[65018, 65018], "disallowed_STD3_mapped", [1589, 1604, 1609, 32, 1575, 1604, 1604, 1607, 32, 1593, 1604, 1610, 1607, 32, 1608, 1587, 1604, 1605]], [[65019, 65019], "disallowed_STD3_mapped", [1580, 1604, 32, 1580, 1604, 1575, 1604, 1607]], [[65020, 65020], "mapped", [1585, 1740, 1575, 1604]], [[65021, 65021], "valid", [], "NV8"], [[65022, 65023], "disallowed"], [[65024, 65039], "ignored"], [[65040, 65040], "disallowed_STD3_mapped", [44]], [[65041, 65041], "mapped", [12289]], [[65042, 65042], "disallowed"], [[65043, 65043], "disallowed_STD3_mapped", [58]], [[65044, 65044], "disallowed_STD3_mapped", [59]], [[65045, 65045], "disallowed_STD3_mapped", [33]], [[65046, 65046], "disallowed_STD3_mapped", [63]], [[65047, 65047], "mapped", [12310]], [[65048, 65048], "mapped", [12311]], [[65049, 65049], "disallowed"], [[65050, 65055], "disallowed"], [[65056, 65059], "valid"], [[65060, 65062], "valid"], [[65063, 65069], "valid"], [[65070, 65071], "valid"], [[65072, 65072], "disallowed"], [[65073, 65073], "mapped", [8212]], [[65074, 65074], "mapped", [8211]], [[65075, 65076], "disallowed_STD3_mapped", [95]], [[65077, 65077], "disallowed_STD3_mapped", [40]], [[65078, 65078], "disallowed_STD3_mapped", [41]], [[65079, 65079], "disallowed_STD3_mapped", [123]], [[65080, 65080], "disallowed_STD3_mapped", [125]], [[65081, 65081], "mapped", [12308]], [[65082, 65082], "mapped", [12309]], [[65083, 65083], "mapped", [12304]], [[65084, 65084], "mapped", [12305]], [[65085, 65085], "mapped", [12298]], [[65086, 65086], "mapped", [12299]], [[65087, 65087], "mapped", [12296]], [[65088, 65088], "mapped", [12297]], [[65089, 65089], "mapped", [12300]], [[65090, 65090], "mapped", [12301]], [[65091, 65091], "mapped", [12302]], [[65092, 65092], "mapped", [12303]], [[65093, 65094], "valid", [], "NV8"], [[65095, 65095], "disallowed_STD3_mapped", [91]], [[65096, 65096], "disallowed_STD3_mapped", [93]], [[65097, 65100], "disallowed_STD3_mapped", [32, 773]], [[65101, 65103], "disallowed_STD3_mapped", [95]], [[65104, 65104], "disallowed_STD3_mapped", [44]], [[65105, 65105], "mapped", [12289]], [[65106, 65106], "disallowed"], [[65107, 65107], "disallowed"], [[65108, 65108], "disallowed_STD3_mapped", [59]], [[65109, 65109], "disallowed_STD3_mapped", [58]], [[65110, 65110], "disallowed_STD3_mapped", [63]], [[65111, 65111], "disallowed_STD3_mapped", [33]], [[65112, 65112], "mapped", [8212]], [[65113, 65113], "disallowed_STD3_mapped", [40]], [[65114, 65114], "disallowed_STD3_mapped", [41]], [[65115, 65115], "disallowed_STD3_mapped", [123]], [[65116, 65116], "disallowed_STD3_mapped", [125]], [[65117, 65117], "mapped", [12308]], [[65118, 65118], "mapped", [12309]], [[65119, 65119], "disallowed_STD3_mapped", [35]], [[65120, 65120], "disallowed_STD3_mapped", [38]], [[65121, 65121], "disallowed_STD3_mapped", [42]], [[65122, 65122], "disallowed_STD3_mapped", [43]], [[65123, 65123], "mapped", [45]], [[65124, 65124], "disallowed_STD3_mapped", [60]], [[65125, 65125], "disallowed_STD3_mapped", [62]], [[65126, 65126], "disallowed_STD3_mapped", [61]], [[65127, 65127], "disallowed"], [[65128, 65128], "disallowed_STD3_mapped", [92]], [[65129, 65129], "disallowed_STD3_mapped", [36]], [[65130, 65130], "disallowed_STD3_mapped", [37]], [[65131, 65131], "disallowed_STD3_mapped", [64]], [[65132, 65135], "disallowed"], [[65136, 65136], "disallowed_STD3_mapped", [32, 1611]], [[65137, 65137], "mapped", [1600, 1611]], [[65138, 65138], "disallowed_STD3_mapped", [32, 1612]], [[65139, 65139], "valid"], [[65140, 65140], "disallowed_STD3_mapped", [32, 1613]], [[65141, 65141], "disallowed"], [[65142, 65142], "disallowed_STD3_mapped", [32, 1614]], [[65143, 65143], "mapped", [1600, 1614]], [[65144, 65144], "disallowed_STD3_mapped", [32, 1615]], [[65145, 65145], "mapped", [1600, 1615]], [[65146, 65146], "disallowed_STD3_mapped", [32, 1616]], [[65147, 65147], "mapped", [1600, 1616]], [[65148, 65148], "disallowed_STD3_mapped", [32, 1617]], [[65149, 65149], "mapped", [1600, 1617]], [[65150, 65150], "disallowed_STD3_mapped", [32, 1618]], [[65151, 65151], "mapped", [1600, 1618]], [[65152, 65152], "mapped", [1569]], [[65153, 65154], "mapped", [1570]], [[65155, 65156], "mapped", [1571]], [[65157, 65158], "mapped", [1572]], [[65159, 65160], "mapped", [1573]], [[65161, 65164], "mapped", [1574]], [[65165, 65166], "mapped", [1575]], [[65167, 65170], "mapped", [1576]], [[65171, 65172], "mapped", [1577]], [[65173, 65176], "mapped", [1578]], [[65177, 65180], "mapped", [1579]], [[65181, 65184], "mapped", [1580]], [[65185, 65188], "mapped", [1581]], [[65189, 65192], "mapped", [1582]], [[65193, 65194], "mapped", [1583]], [[65195, 65196], "mapped", [1584]], [[65197, 65198], "mapped", [1585]], [[65199, 65200], "mapped", [1586]], [[65201, 65204], "mapped", [1587]], [[65205, 65208], "mapped", [1588]], [[65209, 65212], "mapped", [1589]], [[65213, 65216], "mapped", [1590]], [[65217, 65220], "mapped", [1591]], [[65221, 65224], "mapped", [1592]], [[65225, 65228], "mapped", [1593]], [[65229, 65232], "mapped", [1594]], [[65233, 65236], "mapped", [1601]], [[65237, 65240], "mapped", [1602]], [[65241, 65244], "mapped", [1603]], [[65245, 65248], "mapped", [1604]], [[65249, 65252], "mapped", [1605]], [[65253, 65256], "mapped", [1606]], [[65257, 65260], "mapped", [1607]], [[65261, 65262], "mapped", [1608]], [[65263, 65264], "mapped", [1609]], [[65265, 65268], "mapped", [1610]], [[65269, 65270], "mapped", [1604, 1570]], [[65271, 65272], "mapped", [1604, 1571]], [[65273, 65274], "mapped", [1604, 1573]], [[65275, 65276], "mapped", [1604, 1575]], [[65277, 65278], "disallowed"], [[65279, 65279], "ignored"], [[65280, 65280], "disallowed"], [[65281, 65281], "disallowed_STD3_mapped", [33]], [[65282, 65282], "disallowed_STD3_mapped", [34]], [[65283, 65283], "disallowed_STD3_mapped", [35]], [[65284, 65284], "disallowed_STD3_mapped", [36]], [[65285, 65285], "disallowed_STD3_mapped", [37]], [[65286, 65286], "disallowed_STD3_mapped", [38]], [[65287, 65287], "disallowed_STD3_mapped", [39]], [[65288, 65288], "disallowed_STD3_mapped", [40]], [[65289, 65289], "disallowed_STD3_mapped", [41]], [[65290, 65290], "disallowed_STD3_mapped", [42]], [[65291, 65291], "disallowed_STD3_mapped", [43]], [[65292, 65292], "disallowed_STD3_mapped", [44]], [[65293, 65293], "mapped", [45]], [[65294, 65294], "mapped", [46]], [[65295, 65295], "disallowed_STD3_mapped", [47]], [[65296, 65296], "mapped", [48]], [[65297, 65297], "mapped", [49]], [[65298, 65298], "mapped", [50]], [[65299, 65299], "mapped", [51]], [[65300, 65300], "mapped", [52]], [[65301, 65301], "mapped", [53]], [[65302, 65302], "mapped", [54]], [[65303, 65303], "mapped", [55]], [[65304, 65304], "mapped", [56]], [[65305, 65305], "mapped", [57]], [[65306, 65306], "disallowed_STD3_mapped", [58]], [[65307, 65307], "disallowed_STD3_mapped", [59]], [[65308, 65308], "disallowed_STD3_mapped", [60]], [[65309, 65309], "disallowed_STD3_mapped", [61]], [[65310, 65310], "disallowed_STD3_mapped", [62]], [[65311, 65311], "disallowed_STD3_mapped", [63]], [[65312, 65312], "disallowed_STD3_mapped", [64]], [[65313, 65313], "mapped", [97]], [[65314, 65314], "mapped", [98]], [[65315, 65315], "mapped", [99]], [[65316, 65316], "mapped", [100]], [[65317, 65317], "mapped", [101]], [[65318, 65318], "mapped", [102]], [[65319, 65319], "mapped", [103]], [[65320, 65320], "mapped", [104]], [[65321, 65321], "mapped", [105]], [[65322, 65322], "mapped", [106]], [[65323, 65323], "mapped", [107]], [[65324, 65324], "mapped", [108]], [[65325, 65325], "mapped", [109]], [[65326, 65326], "mapped", [110]], [[65327, 65327], "mapped", [111]], [[65328, 65328], "mapped", [112]], [[65329, 65329], "mapped", [113]], [[65330, 65330], "mapped", [114]], [[65331, 65331], "mapped", [115]], [[65332, 65332], "mapped", [116]], [[65333, 65333], "mapped", [117]], [[65334, 65334], "mapped", [118]], [[65335, 65335], "mapped", [119]], [[65336, 65336], "mapped", [120]], [[65337, 65337], "mapped", [121]], [[65338, 65338], "mapped", [122]], [[65339, 65339], "disallowed_STD3_mapped", [91]], [[65340, 65340], "disallowed_STD3_mapped", [92]], [[65341, 65341], "disallowed_STD3_mapped", [93]], [[65342, 65342], "disallowed_STD3_mapped", [94]], [[65343, 65343], "disallowed_STD3_mapped", [95]], [[65344, 65344], "disallowed_STD3_mapped", [96]], [[65345, 65345], "mapped", [97]], [[65346, 65346], "mapped", [98]], [[65347, 65347], "mapped", [99]], [[65348, 65348], "mapped", [100]], [[65349, 65349], "mapped", [101]], [[65350, 65350], "mapped", [102]], [[65351, 65351], "mapped", [103]], [[65352, 65352], "mapped", [104]], [[65353, 65353], "mapped", [105]], [[65354, 65354], "mapped", [106]], [[65355, 65355], "mapped", [107]], [[65356, 65356], "mapped", [108]], [[65357, 65357], "mapped", [109]], [[65358, 65358], "mapped", [110]], [[65359, 65359], "mapped", [111]], [[65360, 65360], "mapped", [112]], [[65361, 65361], "mapped", [113]], [[65362, 65362], "mapped", [114]], [[65363, 65363], "mapped", [115]], [[65364, 65364], "mapped", [116]], [[65365, 65365], "mapped", [117]], [[65366, 65366], "mapped", [118]], [[65367, 65367], "mapped", [119]], [[65368, 65368], "mapped", [120]], [[65369, 65369], "mapped", [121]], [[65370, 65370], "mapped", [122]], [[65371, 65371], "disallowed_STD3_mapped", [123]], [[65372, 65372], "disallowed_STD3_mapped", [124]], [[65373, 65373], "disallowed_STD3_mapped", [125]], [[65374, 65374], "disallowed_STD3_mapped", [126]], [[65375, 65375], "mapped", [10629]], [[65376, 65376], "mapped", [10630]], [[65377, 65377], "mapped", [46]], [[65378, 65378], "mapped", [12300]], [[65379, 65379], "mapped", [12301]], [[65380, 65380], "mapped", [12289]], [[65381, 65381], "mapped", [12539]], [[65382, 65382], "mapped", [12530]], [[65383, 65383], "mapped", [12449]], [[65384, 65384], "mapped", [12451]], [[65385, 65385], "mapped", [12453]], [[65386, 65386], "mapped", [12455]], [[65387, 65387], "mapped", [12457]], [[65388, 65388], "mapped", [12515]], [[65389, 65389], "mapped", [12517]], [[65390, 65390], "mapped", [12519]], [[65391, 65391], "mapped", [12483]], [[65392, 65392], "mapped", [12540]], [[65393, 65393], "mapped", [12450]], [[65394, 65394], "mapped", [12452]], [[65395, 65395], "mapped", [12454]], [[65396, 65396], "mapped", [12456]], [[65397, 65397], "mapped", [12458]], [[65398, 65398], "mapped", [12459]], [[65399, 65399], "mapped", [12461]], [[65400, 65400], "mapped", [12463]], [[65401, 65401], "mapped", [12465]], [[65402, 65402], "mapped", [12467]], [[65403, 65403], "mapped", [12469]], [[65404, 65404], "mapped", [12471]], [[65405, 65405], "mapped", [12473]], [[65406, 65406], "mapped", [12475]], [[65407, 65407], "mapped", [12477]], [[65408, 65408], "mapped", [12479]], [[65409, 65409], "mapped", [12481]], [[65410, 65410], "mapped", [12484]], [[65411, 65411], "mapped", [12486]], [[65412, 65412], "mapped", [12488]], [[65413, 65413], "mapped", [12490]], [[65414, 65414], "mapped", [12491]], [[65415, 65415], "mapped", [12492]], [[65416, 65416], "mapped", [12493]], [[65417, 65417], "mapped", [12494]], [[65418, 65418], "mapped", [12495]], [[65419, 65419], "mapped", [12498]], [[65420, 65420], "mapped", [12501]], [[65421, 65421], "mapped", [12504]], [[65422, 65422], "mapped", [12507]], [[65423, 65423], "mapped", [12510]], [[65424, 65424], "mapped", [12511]], [[65425, 65425], "mapped", [12512]], [[65426, 65426], "mapped", [12513]], [[65427, 65427], "mapped", [12514]], [[65428, 65428], "mapped", [12516]], [[65429, 65429], "mapped", [12518]], [[65430, 65430], "mapped", [12520]], [[65431, 65431], "mapped", [12521]], [[65432, 65432], "mapped", [12522]], [[65433, 65433], "mapped", [12523]], [[65434, 65434], "mapped", [12524]], [[65435, 65435], "mapped", [12525]], [[65436, 65436], "mapped", [12527]], [[65437, 65437], "mapped", [12531]], [[65438, 65438], "mapped", [12441]], [[65439, 65439], "mapped", [12442]], [[65440, 65440], "disallowed"], [[65441, 65441], "mapped", [4352]], [[65442, 65442], "mapped", [4353]], [[65443, 65443], "mapped", [4522]], [[65444, 65444], "mapped", [4354]], [[65445, 65445], "mapped", [4524]], [[65446, 65446], "mapped", [4525]], [[65447, 65447], "mapped", [4355]], [[65448, 65448], "mapped", [4356]], [[65449, 65449], "mapped", [4357]], [[65450, 65450], "mapped", [4528]], [[65451, 65451], "mapped", [4529]], [[65452, 65452], "mapped", [4530]], [[65453, 65453], "mapped", [4531]], [[65454, 65454], "mapped", [4532]], [[65455, 65455], "mapped", [4533]], [[65456, 65456], "mapped", [4378]], [[65457, 65457], "mapped", [4358]], [[65458, 65458], "mapped", [4359]], [[65459, 65459], "mapped", [4360]], [[65460, 65460], "mapped", [4385]], [[65461, 65461], "mapped", [4361]], [[65462, 65462], "mapped", [4362]], [[65463, 65463], "mapped", [4363]], [[65464, 65464], "mapped", [4364]], [[65465, 65465], "mapped", [4365]], [[65466, 65466], "mapped", [4366]], [[65467, 65467], "mapped", [4367]], [[65468, 65468], "mapped", [4368]], [[65469, 65469], "mapped", [4369]], [[65470, 65470], "mapped", [4370]], [[65471, 65473], "disallowed"], [[65474, 65474], "mapped", [4449]], [[65475, 65475], "mapped", [4450]], [[65476, 65476], "mapped", [4451]], [[65477, 65477], "mapped", [4452]], [[65478, 65478], "mapped", [4453]], [[65479, 65479], "mapped", [4454]], [[65480, 65481], "disallowed"], [[65482, 65482], "mapped", [4455]], [[65483, 65483], "mapped", [4456]], [[65484, 65484], "mapped", [4457]], [[65485, 65485], "mapped", [4458]], [[65486, 65486], "mapped", [4459]], [[65487, 65487], "mapped", [4460]], [[65488, 65489], "disallowed"], [[65490, 65490], "mapped", [4461]], [[65491, 65491], "mapped", [4462]], [[65492, 65492], "mapped", [4463]], [[65493, 65493], "mapped", [4464]], [[65494, 65494], "mapped", [4465]], [[65495, 65495], "mapped", [4466]], [[65496, 65497], "disallowed"], [[65498, 65498], "mapped", [4467]], [[65499, 65499], "mapped", [4468]], [[65500, 65500], "mapped", [4469]], [[65501, 65503], "disallowed"], [[65504, 65504], "mapped", [162]], [[65505, 65505], "mapped", [163]], [[65506, 65506], "mapped", [172]], [[65507, 65507], "disallowed_STD3_mapped", [32, 772]], [[65508, 65508], "mapped", [166]], [[65509, 65509], "mapped", [165]], [[65510, 65510], "mapped", [8361]], [[65511, 65511], "disallowed"], [[65512, 65512], "mapped", [9474]], [[65513, 65513], "mapped", [8592]], [[65514, 65514], "mapped", [8593]], [[65515, 65515], "mapped", [8594]], [[65516, 65516], "mapped", [8595]], [[65517, 65517], "mapped", [9632]], [[65518, 65518], "mapped", [9675]], [[65519, 65528], "disallowed"], [[65529, 65531], "disallowed"], [[65532, 65532], "disallowed"], [[65533, 65533], "disallowed"], [[65534, 65535], "disallowed"], [[65536, 65547], "valid"], [[65548, 65548], "disallowed"], [[65549, 65574], "valid"], [[65575, 65575], "disallowed"], [[65576, 65594], "valid"], [[65595, 65595], "disallowed"], [[65596, 65597], "valid"], [[65598, 65598], "disallowed"], [[65599, 65613], "valid"], [[65614, 65615], "disallowed"], [[65616, 65629], "valid"], [[65630, 65663], "disallowed"], [[65664, 65786], "valid"], [[65787, 65791], "disallowed"], [[65792, 65794], "valid", [], "NV8"], [[65795, 65798], "disallowed"], [[65799, 65843], "valid", [], "NV8"], [[65844, 65846], "disallowed"], [[65847, 65855], "valid", [], "NV8"], [[65856, 65930], "valid", [], "NV8"], [[65931, 65932], "valid", [], "NV8"], [[65933, 65935], "disallowed"], [[65936, 65947], "valid", [], "NV8"], [[65948, 65951], "disallowed"], [[65952, 65952], "valid", [], "NV8"], [[65953, 65999], "disallowed"], [[66e3, 66044], "valid", [], "NV8"], [[66045, 66045], "valid"], [[66046, 66175], "disallowed"], [[66176, 66204], "valid"], [[66205, 66207], "disallowed"], [[66208, 66256], "valid"], [[66257, 66271], "disallowed"], [[66272, 66272], "valid"], [[66273, 66299], "valid", [], "NV8"], [[66300, 66303], "disallowed"], [[66304, 66334], "valid"], [[66335, 66335], "valid"], [[66336, 66339], "valid", [], "NV8"], [[66340, 66351], "disallowed"], [[66352, 66368], "valid"], [[66369, 66369], "valid", [], "NV8"], [[66370, 66377], "valid"], [[66378, 66378], "valid", [], "NV8"], [[66379, 66383], "disallowed"], [[66384, 66426], "valid"], [[66427, 66431], "disallowed"], [[66432, 66461], "valid"], [[66462, 66462], "disallowed"], [[66463, 66463], "valid", [], "NV8"], [[66464, 66499], "valid"], [[66500, 66503], "disallowed"], [[66504, 66511], "valid"], [[66512, 66517], "valid", [], "NV8"], [[66518, 66559], "disallowed"], [[66560, 66560], "mapped", [66600]], [[66561, 66561], "mapped", [66601]], [[66562, 66562], "mapped", [66602]], [[66563, 66563], "mapped", [66603]], [[66564, 66564], "mapped", [66604]], [[66565, 66565], "mapped", [66605]], [[66566, 66566], "mapped", [66606]], [[66567, 66567], "mapped", [66607]], [[66568, 66568], "mapped", [66608]], [[66569, 66569], "mapped", [66609]], [[66570, 66570], "mapped", [66610]], [[66571, 66571], "mapped", [66611]], [[66572, 66572], "mapped", [66612]], [[66573, 66573], "mapped", [66613]], [[66574, 66574], "mapped", [66614]], [[66575, 66575], "mapped", [66615]], [[66576, 66576], "mapped", [66616]], [[66577, 66577], "mapped", [66617]], [[66578, 66578], "mapped", [66618]], [[66579, 66579], "mapped", [66619]], [[66580, 66580], "mapped", [66620]], [[66581, 66581], "mapped", [66621]], [[66582, 66582], "mapped", [66622]], [[66583, 66583], "mapped", [66623]], [[66584, 66584], "mapped", [66624]], [[66585, 66585], "mapped", [66625]], [[66586, 66586], "mapped", [66626]], [[66587, 66587], "mapped", [66627]], [[66588, 66588], "mapped", [66628]], [[66589, 66589], "mapped", [66629]], [[66590, 66590], "mapped", [66630]], [[66591, 66591], "mapped", [66631]], [[66592, 66592], "mapped", [66632]], [[66593, 66593], "mapped", [66633]], [[66594, 66594], "mapped", [66634]], [[66595, 66595], "mapped", [66635]], [[66596, 66596], "mapped", [66636]], [[66597, 66597], "mapped", [66637]], [[66598, 66598], "mapped", [66638]], [[66599, 66599], "mapped", [66639]], [[66600, 66637], "valid"], [[66638, 66717], "valid"], [[66718, 66719], "disallowed"], [[66720, 66729], "valid"], [[66730, 66815], "disallowed"], [[66816, 66855], "valid"], [[66856, 66863], "disallowed"], [[66864, 66915], "valid"], [[66916, 66926], "disallowed"], [[66927, 66927], "valid", [], "NV8"], [[66928, 67071], "disallowed"], [[67072, 67382], "valid"], [[67383, 67391], "disallowed"], [[67392, 67413], "valid"], [[67414, 67423], "disallowed"], [[67424, 67431], "valid"], [[67432, 67583], "disallowed"], [[67584, 67589], "valid"], [[67590, 67591], "disallowed"], [[67592, 67592], "valid"], [[67593, 67593], "disallowed"], [[67594, 67637], "valid"], [[67638, 67638], "disallowed"], [[67639, 67640], "valid"], [[67641, 67643], "disallowed"], [[67644, 67644], "valid"], [[67645, 67646], "disallowed"], [[67647, 67647], "valid"], [[67648, 67669], "valid"], [[67670, 67670], "disallowed"], [[67671, 67679], "valid", [], "NV8"], [[67680, 67702], "valid"], [[67703, 67711], "valid", [], "NV8"], [[67712, 67742], "valid"], [[67743, 67750], "disallowed"], [[67751, 67759], "valid", [], "NV8"], [[67760, 67807], "disallowed"], [[67808, 67826], "valid"], [[67827, 67827], "disallowed"], [[67828, 67829], "valid"], [[67830, 67834], "disallowed"], [[67835, 67839], "valid", [], "NV8"], [[67840, 67861], "valid"], [[67862, 67865], "valid", [], "NV8"], [[67866, 67867], "valid", [], "NV8"], [[67868, 67870], "disallowed"], [[67871, 67871], "valid", [], "NV8"], [[67872, 67897], "valid"], [[67898, 67902], "disallowed"], [[67903, 67903], "valid", [], "NV8"], [[67904, 67967], "disallowed"], [[67968, 68023], "valid"], [[68024, 68027], "disallowed"], [[68028, 68029], "valid", [], "NV8"], [[68030, 68031], "valid"], [[68032, 68047], "valid", [], "NV8"], [[68048, 68049], "disallowed"], [[68050, 68095], "valid", [], "NV8"], [[68096, 68099], "valid"], [[68100, 68100], "disallowed"], [[68101, 68102], "valid"], [[68103, 68107], "disallowed"], [[68108, 68115], "valid"], [[68116, 68116], "disallowed"], [[68117, 68119], "valid"], [[68120, 68120], "disallowed"], [[68121, 68147], "valid"], [[68148, 68151], "disallowed"], [[68152, 68154], "valid"], [[68155, 68158], "disallowed"], [[68159, 68159], "valid"], [[68160, 68167], "valid", [], "NV8"], [[68168, 68175], "disallowed"], [[68176, 68184], "valid", [], "NV8"], [[68185, 68191], "disallowed"], [[68192, 68220], "valid"], [[68221, 68223], "valid", [], "NV8"], [[68224, 68252], "valid"], [[68253, 68255], "valid", [], "NV8"], [[68256, 68287], "disallowed"], [[68288, 68295], "valid"], [[68296, 68296], "valid", [], "NV8"], [[68297, 68326], "valid"], [[68327, 68330], "disallowed"], [[68331, 68342], "valid", [], "NV8"], [[68343, 68351], "disallowed"], [[68352, 68405], "valid"], [[68406, 68408], "disallowed"], [[68409, 68415], "valid", [], "NV8"], [[68416, 68437], "valid"], [[68438, 68439], "disallowed"], [[68440, 68447], "valid", [], "NV8"], [[68448, 68466], "valid"], [[68467, 68471], "disallowed"], [[68472, 68479], "valid", [], "NV8"], [[68480, 68497], "valid"], [[68498, 68504], "disallowed"], [[68505, 68508], "valid", [], "NV8"], [[68509, 68520], "disallowed"], [[68521, 68527], "valid", [], "NV8"], [[68528, 68607], "disallowed"], [[68608, 68680], "valid"], [[68681, 68735], "disallowed"], [[68736, 68736], "mapped", [68800]], [[68737, 68737], "mapped", [68801]], [[68738, 68738], "mapped", [68802]], [[68739, 68739], "mapped", [68803]], [[68740, 68740], "mapped", [68804]], [[68741, 68741], "mapped", [68805]], [[68742, 68742], "mapped", [68806]], [[68743, 68743], "mapped", [68807]], [[68744, 68744], "mapped", [68808]], [[68745, 68745], "mapped", [68809]], [[68746, 68746], "mapped", [68810]], [[68747, 68747], "mapped", [68811]], [[68748, 68748], "mapped", [68812]], [[68749, 68749], "mapped", [68813]], [[68750, 68750], "mapped", [68814]], [[68751, 68751], "mapped", [68815]], [[68752, 68752], "mapped", [68816]], [[68753, 68753], "mapped", [68817]], [[68754, 68754], "mapped", [68818]], [[68755, 68755], "mapped", [68819]], [[68756, 68756], "mapped", [68820]], [[68757, 68757], "mapped", [68821]], [[68758, 68758], "mapped", [68822]], [[68759, 68759], "mapped", [68823]], [[68760, 68760], "mapped", [68824]], [[68761, 68761], "mapped", [68825]], [[68762, 68762], "mapped", [68826]], [[68763, 68763], "mapped", [68827]], [[68764, 68764], "mapped", [68828]], [[68765, 68765], "mapped", [68829]], [[68766, 68766], "mapped", [68830]], [[68767, 68767], "mapped", [68831]], [[68768, 68768], "mapped", [68832]], [[68769, 68769], "mapped", [68833]], [[68770, 68770], "mapped", [68834]], [[68771, 68771], "mapped", [68835]], [[68772, 68772], "mapped", [68836]], [[68773, 68773], "mapped", [68837]], [[68774, 68774], "mapped", [68838]], [[68775, 68775], "mapped", [68839]], [[68776, 68776], "mapped", [68840]], [[68777, 68777], "mapped", [68841]], [[68778, 68778], "mapped", [68842]], [[68779, 68779], "mapped", [68843]], [[68780, 68780], "mapped", [68844]], [[68781, 68781], "mapped", [68845]], [[68782, 68782], "mapped", [68846]], [[68783, 68783], "mapped", [68847]], [[68784, 68784], "mapped", [68848]], [[68785, 68785], "mapped", [68849]], [[68786, 68786], "mapped", [68850]], [[68787, 68799], "disallowed"], [[68800, 68850], "valid"], [[68851, 68857], "disallowed"], [[68858, 68863], "valid", [], "NV8"], [[68864, 69215], "disallowed"], [[69216, 69246], "valid", [], "NV8"], [[69247, 69631], "disallowed"], [[69632, 69702], "valid"], [[69703, 69709], "valid", [], "NV8"], [[69710, 69713], "disallowed"], [[69714, 69733], "valid", [], "NV8"], [[69734, 69743], "valid"], [[69744, 69758], "disallowed"], [[69759, 69759], "valid"], [[69760, 69818], "valid"], [[69819, 69820], "valid", [], "NV8"], [[69821, 69821], "disallowed"], [[69822, 69825], "valid", [], "NV8"], [[69826, 69839], "disallowed"], [[69840, 69864], "valid"], [[69865, 69871], "disallowed"], [[69872, 69881], "valid"], [[69882, 69887], "disallowed"], [[69888, 69940], "valid"], [[69941, 69941], "disallowed"], [[69942, 69951], "valid"], [[69952, 69955], "valid", [], "NV8"], [[69956, 69967], "disallowed"], [[69968, 70003], "valid"], [[70004, 70005], "valid", [], "NV8"], [[70006, 70006], "valid"], [[70007, 70015], "disallowed"], [[70016, 70084], "valid"], [[70085, 70088], "valid", [], "NV8"], [[70089, 70089], "valid", [], "NV8"], [[70090, 70092], "valid"], [[70093, 70093], "valid", [], "NV8"], [[70094, 70095], "disallowed"], [[70096, 70105], "valid"], [[70106, 70106], "valid"], [[70107, 70107], "valid", [], "NV8"], [[70108, 70108], "valid"], [[70109, 70111], "valid", [], "NV8"], [[70112, 70112], "disallowed"], [[70113, 70132], "valid", [], "NV8"], [[70133, 70143], "disallowed"], [[70144, 70161], "valid"], [[70162, 70162], "disallowed"], [[70163, 70199], "valid"], [[70200, 70205], "valid", [], "NV8"], [[70206, 70271], "disallowed"], [[70272, 70278], "valid"], [[70279, 70279], "disallowed"], [[70280, 70280], "valid"], [[70281, 70281], "disallowed"], [[70282, 70285], "valid"], [[70286, 70286], "disallowed"], [[70287, 70301], "valid"], [[70302, 70302], "disallowed"], [[70303, 70312], "valid"], [[70313, 70313], "valid", [], "NV8"], [[70314, 70319], "disallowed"], [[70320, 70378], "valid"], [[70379, 70383], "disallowed"], [[70384, 70393], "valid"], [[70394, 70399], "disallowed"], [[70400, 70400], "valid"], [[70401, 70403], "valid"], [[70404, 70404], "disallowed"], [[70405, 70412], "valid"], [[70413, 70414], "disallowed"], [[70415, 70416], "valid"], [[70417, 70418], "disallowed"], [[70419, 70440], "valid"], [[70441, 70441], "disallowed"], [[70442, 70448], "valid"], [[70449, 70449], "disallowed"], [[70450, 70451], "valid"], [[70452, 70452], "disallowed"], [[70453, 70457], "valid"], [[70458, 70459], "disallowed"], [[70460, 70468], "valid"], [[70469, 70470], "disallowed"], [[70471, 70472], "valid"], [[70473, 70474], "disallowed"], [[70475, 70477], "valid"], [[70478, 70479], "disallowed"], [[70480, 70480], "valid"], [[70481, 70486], "disallowed"], [[70487, 70487], "valid"], [[70488, 70492], "disallowed"], [[70493, 70499], "valid"], [[70500, 70501], "disallowed"], [[70502, 70508], "valid"], [[70509, 70511], "disallowed"], [[70512, 70516], "valid"], [[70517, 70783], "disallowed"], [[70784, 70853], "valid"], [[70854, 70854], "valid", [], "NV8"], [[70855, 70855], "valid"], [[70856, 70863], "disallowed"], [[70864, 70873], "valid"], [[70874, 71039], "disallowed"], [[71040, 71093], "valid"], [[71094, 71095], "disallowed"], [[71096, 71104], "valid"], [[71105, 71113], "valid", [], "NV8"], [[71114, 71127], "valid", [], "NV8"], [[71128, 71133], "valid"], [[71134, 71167], "disallowed"], [[71168, 71232], "valid"], [[71233, 71235], "valid", [], "NV8"], [[71236, 71236], "valid"], [[71237, 71247], "disallowed"], [[71248, 71257], "valid"], [[71258, 71295], "disallowed"], [[71296, 71351], "valid"], [[71352, 71359], "disallowed"], [[71360, 71369], "valid"], [[71370, 71423], "disallowed"], [[71424, 71449], "valid"], [[71450, 71452], "disallowed"], [[71453, 71467], "valid"], [[71468, 71471], "disallowed"], [[71472, 71481], "valid"], [[71482, 71487], "valid", [], "NV8"], [[71488, 71839], "disallowed"], [[71840, 71840], "mapped", [71872]], [[71841, 71841], "mapped", [71873]], [[71842, 71842], "mapped", [71874]], [[71843, 71843], "mapped", [71875]], [[71844, 71844], "mapped", [71876]], [[71845, 71845], "mapped", [71877]], [[71846, 71846], "mapped", [71878]], [[71847, 71847], "mapped", [71879]], [[71848, 71848], "mapped", [71880]], [[71849, 71849], "mapped", [71881]], [[71850, 71850], "mapped", [71882]], [[71851, 71851], "mapped", [71883]], [[71852, 71852], "mapped", [71884]], [[71853, 71853], "mapped", [71885]], [[71854, 71854], "mapped", [71886]], [[71855, 71855], "mapped", [71887]], [[71856, 71856], "mapped", [71888]], [[71857, 71857], "mapped", [71889]], [[71858, 71858], "mapped", [71890]], [[71859, 71859], "mapped", [71891]], [[71860, 71860], "mapped", [71892]], [[71861, 71861], "mapped", [71893]], [[71862, 71862], "mapped", [71894]], [[71863, 71863], "mapped", [71895]], [[71864, 71864], "mapped", [71896]], [[71865, 71865], "mapped", [71897]], [[71866, 71866], "mapped", [71898]], [[71867, 71867], "mapped", [71899]], [[71868, 71868], "mapped", [71900]], [[71869, 71869], "mapped", [71901]], [[71870, 71870], "mapped", [71902]], [[71871, 71871], "mapped", [71903]], [[71872, 71913], "valid"], [[71914, 71922], "valid", [], "NV8"], [[71923, 71934], "disallowed"], [[71935, 71935], "valid"], [[71936, 72383], "disallowed"], [[72384, 72440], "valid"], [[72441, 73727], "disallowed"], [[73728, 74606], "valid"], [[74607, 74648], "valid"], [[74649, 74649], "valid"], [[74650, 74751], "disallowed"], [[74752, 74850], "valid", [], "NV8"], [[74851, 74862], "valid", [], "NV8"], [[74863, 74863], "disallowed"], [[74864, 74867], "valid", [], "NV8"], [[74868, 74868], "valid", [], "NV8"], [[74869, 74879], "disallowed"], [[74880, 75075], "valid"], [[75076, 77823], "disallowed"], [[77824, 78894], "valid"], [[78895, 82943], "disallowed"], [[82944, 83526], "valid"], [[83527, 92159], "disallowed"], [[92160, 92728], "valid"], [[92729, 92735], "disallowed"], [[92736, 92766], "valid"], [[92767, 92767], "disallowed"], [[92768, 92777], "valid"], [[92778, 92781], "disallowed"], [[92782, 92783], "valid", [], "NV8"], [[92784, 92879], "disallowed"], [[92880, 92909], "valid"], [[92910, 92911], "disallowed"], [[92912, 92916], "valid"], [[92917, 92917], "valid", [], "NV8"], [[92918, 92927], "disallowed"], [[92928, 92982], "valid"], [[92983, 92991], "valid", [], "NV8"], [[92992, 92995], "valid"], [[92996, 92997], "valid", [], "NV8"], [[92998, 93007], "disallowed"], [[93008, 93017], "valid"], [[93018, 93018], "disallowed"], [[93019, 93025], "valid", [], "NV8"], [[93026, 93026], "disallowed"], [[93027, 93047], "valid"], [[93048, 93052], "disallowed"], [[93053, 93071], "valid"], [[93072, 93951], "disallowed"], [[93952, 94020], "valid"], [[94021, 94031], "disallowed"], [[94032, 94078], "valid"], [[94079, 94094], "disallowed"], [[94095, 94111], "valid"], [[94112, 110591], "disallowed"], [[110592, 110593], "valid"], [[110594, 113663], "disallowed"], [[113664, 113770], "valid"], [[113771, 113775], "disallowed"], [[113776, 113788], "valid"], [[113789, 113791], "disallowed"], [[113792, 113800], "valid"], [[113801, 113807], "disallowed"], [[113808, 113817], "valid"], [[113818, 113819], "disallowed"], [[113820, 113820], "valid", [], "NV8"], [[113821, 113822], "valid"], [[113823, 113823], "valid", [], "NV8"], [[113824, 113827], "ignored"], [[113828, 118783], "disallowed"], [[118784, 119029], "valid", [], "NV8"], [[119030, 119039], "disallowed"], [[119040, 119078], "valid", [], "NV8"], [[119079, 119080], "disallowed"], [[119081, 119081], "valid", [], "NV8"], [[119082, 119133], "valid", [], "NV8"], [[119134, 119134], "mapped", [119127, 119141]], [[119135, 119135], "mapped", [119128, 119141]], [[119136, 119136], "mapped", [119128, 119141, 119150]], [[119137, 119137], "mapped", [119128, 119141, 119151]], [[119138, 119138], "mapped", [119128, 119141, 119152]], [[119139, 119139], "mapped", [119128, 119141, 119153]], [[119140, 119140], "mapped", [119128, 119141, 119154]], [[119141, 119154], "valid", [], "NV8"], [[119155, 119162], "disallowed"], [[119163, 119226], "valid", [], "NV8"], [[119227, 119227], "mapped", [119225, 119141]], [[119228, 119228], "mapped", [119226, 119141]], [[119229, 119229], "mapped", [119225, 119141, 119150]], [[119230, 119230], "mapped", [119226, 119141, 119150]], [[119231, 119231], "mapped", [119225, 119141, 119151]], [[119232, 119232], "mapped", [119226, 119141, 119151]], [[119233, 119261], "valid", [], "NV8"], [[119262, 119272], "valid", [], "NV8"], [[119273, 119295], "disallowed"], [[119296, 119365], "valid", [], "NV8"], [[119366, 119551], "disallowed"], [[119552, 119638], "valid", [], "NV8"], [[119639, 119647], "disallowed"], [[119648, 119665], "valid", [], "NV8"], [[119666, 119807], "disallowed"], [[119808, 119808], "mapped", [97]], [[119809, 119809], "mapped", [98]], [[119810, 119810], "mapped", [99]], [[119811, 119811], "mapped", [100]], [[119812, 119812], "mapped", [101]], [[119813, 119813], "mapped", [102]], [[119814, 119814], "mapped", [103]], [[119815, 119815], "mapped", [104]], [[119816, 119816], "mapped", [105]], [[119817, 119817], "mapped", [106]], [[119818, 119818], "mapped", [107]], [[119819, 119819], "mapped", [108]], [[119820, 119820], "mapped", [109]], [[119821, 119821], "mapped", [110]], [[119822, 119822], "mapped", [111]], [[119823, 119823], "mapped", [112]], [[119824, 119824], "mapped", [113]], [[119825, 119825], "mapped", [114]], [[119826, 119826], "mapped", [115]], [[119827, 119827], "mapped", [116]], [[119828, 119828], "mapped", [117]], [[119829, 119829], "mapped", [118]], [[119830, 119830], "mapped", [119]], [[119831, 119831], "mapped", [120]], [[119832, 119832], "mapped", [121]], [[119833, 119833], "mapped", [122]], [[119834, 119834], "mapped", [97]], [[119835, 119835], "mapped", [98]], [[119836, 119836], "mapped", [99]], [[119837, 119837], "mapped", [100]], [[119838, 119838], "mapped", [101]], [[119839, 119839], "mapped", [102]], [[119840, 119840], "mapped", [103]], [[119841, 119841], "mapped", [104]], [[119842, 119842], "mapped", [105]], [[119843, 119843], "mapped", [106]], [[119844, 119844], "mapped", [107]], [[119845, 119845], "mapped", [108]], [[119846, 119846], "mapped", [109]], [[119847, 119847], "mapped", [110]], [[119848, 119848], "mapped", [111]], [[119849, 119849], "mapped", [112]], [[119850, 119850], "mapped", [113]], [[119851, 119851], "mapped", [114]], [[119852, 119852], "mapped", [115]], [[119853, 119853], "mapped", [116]], [[119854, 119854], "mapped", [117]], [[119855, 119855], "mapped", [118]], [[119856, 119856], "mapped", [119]], [[119857, 119857], "mapped", [120]], [[119858, 119858], "mapped", [121]], [[119859, 119859], "mapped", [122]], [[119860, 119860], "mapped", [97]], [[119861, 119861], "mapped", [98]], [[119862, 119862], "mapped", [99]], [[119863, 119863], "mapped", [100]], [[119864, 119864], "mapped", [101]], [[119865, 119865], "mapped", [102]], [[119866, 119866], "mapped", [103]], [[119867, 119867], "mapped", [104]], [[119868, 119868], "mapped", [105]], [[119869, 119869], "mapped", [106]], [[119870, 119870], "mapped", [107]], [[119871, 119871], "mapped", [108]], [[119872, 119872], "mapped", [109]], [[119873, 119873], "mapped", [110]], [[119874, 119874], "mapped", [111]], [[119875, 119875], "mapped", [112]], [[119876, 119876], "mapped", [113]], [[119877, 119877], "mapped", [114]], [[119878, 119878], "mapped", [115]], [[119879, 119879], "mapped", [116]], [[119880, 119880], "mapped", [117]], [[119881, 119881], "mapped", [118]], [[119882, 119882], "mapped", [119]], [[119883, 119883], "mapped", [120]], [[119884, 119884], "mapped", [121]], [[119885, 119885], "mapped", [122]], [[119886, 119886], "mapped", [97]], [[119887, 119887], "mapped", [98]], [[119888, 119888], "mapped", [99]], [[119889, 119889], "mapped", [100]], [[119890, 119890], "mapped", [101]], [[119891, 119891], "mapped", [102]], [[119892, 119892], "mapped", [103]], [[119893, 119893], "disallowed"], [[119894, 119894], "mapped", [105]], [[119895, 119895], "mapped", [106]], [[119896, 119896], "mapped", [107]], [[119897, 119897], "mapped", [108]], [[119898, 119898], "mapped", [109]], [[119899, 119899], "mapped", [110]], [[119900, 119900], "mapped", [111]], [[119901, 119901], "mapped", [112]], [[119902, 119902], "mapped", [113]], [[119903, 119903], "mapped", [114]], [[119904, 119904], "mapped", [115]], [[119905, 119905], "mapped", [116]], [[119906, 119906], "mapped", [117]], [[119907, 119907], "mapped", [118]], [[119908, 119908], "mapped", [119]], [[119909, 119909], "mapped", [120]], [[119910, 119910], "mapped", [121]], [[119911, 119911], "mapped", [122]], [[119912, 119912], "mapped", [97]], [[119913, 119913], "mapped", [98]], [[119914, 119914], "mapped", [99]], [[119915, 119915], "mapped", [100]], [[119916, 119916], "mapped", [101]], [[119917, 119917], "mapped", [102]], [[119918, 119918], "mapped", [103]], [[119919, 119919], "mapped", [104]], [[119920, 119920], "mapped", [105]], [[119921, 119921], "mapped", [106]], [[119922, 119922], "mapped", [107]], [[119923, 119923], "mapped", [108]], [[119924, 119924], "mapped", [109]], [[119925, 119925], "mapped", [110]], [[119926, 119926], "mapped", [111]], [[119927, 119927], "mapped", [112]], [[119928, 119928], "mapped", [113]], [[119929, 119929], "mapped", [114]], [[119930, 119930], "mapped", [115]], [[119931, 119931], "mapped", [116]], [[119932, 119932], "mapped", [117]], [[119933, 119933], "mapped", [118]], [[119934, 119934], "mapped", [119]], [[119935, 119935], "mapped", [120]], [[119936, 119936], "mapped", [121]], [[119937, 119937], "mapped", [122]], [[119938, 119938], "mapped", [97]], [[119939, 119939], "mapped", [98]], [[119940, 119940], "mapped", [99]], [[119941, 119941], "mapped", [100]], [[119942, 119942], "mapped", [101]], [[119943, 119943], "mapped", [102]], [[119944, 119944], "mapped", [103]], [[119945, 119945], "mapped", [104]], [[119946, 119946], "mapped", [105]], [[119947, 119947], "mapped", [106]], [[119948, 119948], "mapped", [107]], [[119949, 119949], "mapped", [108]], [[119950, 119950], "mapped", [109]], [[119951, 119951], "mapped", [110]], [[119952, 119952], "mapped", [111]], [[119953, 119953], "mapped", [112]], [[119954, 119954], "mapped", [113]], [[119955, 119955], "mapped", [114]], [[119956, 119956], "mapped", [115]], [[119957, 119957], "mapped", [116]], [[119958, 119958], "mapped", [117]], [[119959, 119959], "mapped", [118]], [[119960, 119960], "mapped", [119]], [[119961, 119961], "mapped", [120]], [[119962, 119962], "mapped", [121]], [[119963, 119963], "mapped", [122]], [[119964, 119964], "mapped", [97]], [[119965, 119965], "disallowed"], [[119966, 119966], "mapped", [99]], [[119967, 119967], "mapped", [100]], [[119968, 119969], "disallowed"], [[119970, 119970], "mapped", [103]], [[119971, 119972], "disallowed"], [[119973, 119973], "mapped", [106]], [[119974, 119974], "mapped", [107]], [[119975, 119976], "disallowed"], [[119977, 119977], "mapped", [110]], [[119978, 119978], "mapped", [111]], [[119979, 119979], "mapped", [112]], [[119980, 119980], "mapped", [113]], [[119981, 119981], "disallowed"], [[119982, 119982], "mapped", [115]], [[119983, 119983], "mapped", [116]], [[119984, 119984], "mapped", [117]], [[119985, 119985], "mapped", [118]], [[119986, 119986], "mapped", [119]], [[119987, 119987], "mapped", [120]], [[119988, 119988], "mapped", [121]], [[119989, 119989], "mapped", [122]], [[119990, 119990], "mapped", [97]], [[119991, 119991], "mapped", [98]], [[119992, 119992], "mapped", [99]], [[119993, 119993], "mapped", [100]], [[119994, 119994], "disallowed"], [[119995, 119995], "mapped", [102]], [[119996, 119996], "disallowed"], [[119997, 119997], "mapped", [104]], [[119998, 119998], "mapped", [105]], [[119999, 119999], "mapped", [106]], [[12e4, 12e4], "mapped", [107]], [[120001, 120001], "mapped", [108]], [[120002, 120002], "mapped", [109]], [[120003, 120003], "mapped", [110]], [[120004, 120004], "disallowed"], [[120005, 120005], "mapped", [112]], [[120006, 120006], "mapped", [113]], [[120007, 120007], "mapped", [114]], [[120008, 120008], "mapped", [115]], [[120009, 120009], "mapped", [116]], [[120010, 120010], "mapped", [117]], [[120011, 120011], "mapped", [118]], [[120012, 120012], "mapped", [119]], [[120013, 120013], "mapped", [120]], [[120014, 120014], "mapped", [121]], [[120015, 120015], "mapped", [122]], [[120016, 120016], "mapped", [97]], [[120017, 120017], "mapped", [98]], [[120018, 120018], "mapped", [99]], [[120019, 120019], "mapped", [100]], [[120020, 120020], "mapped", [101]], [[120021, 120021], "mapped", [102]], [[120022, 120022], "mapped", [103]], [[120023, 120023], "mapped", [104]], [[120024, 120024], "mapped", [105]], [[120025, 120025], "mapped", [106]], [[120026, 120026], "mapped", [107]], [[120027, 120027], "mapped", [108]], [[120028, 120028], "mapped", [109]], [[120029, 120029], "mapped", [110]], [[120030, 120030], "mapped", [111]], [[120031, 120031], "mapped", [112]], [[120032, 120032], "mapped", [113]], [[120033, 120033], "mapped", [114]], [[120034, 120034], "mapped", [115]], [[120035, 120035], "mapped", [116]], [[120036, 120036], "mapped", [117]], [[120037, 120037], "mapped", [118]], [[120038, 120038], "mapped", [119]], [[120039, 120039], "mapped", [120]], [[120040, 120040], "mapped", [121]], [[120041, 120041], "mapped", [122]], [[120042, 120042], "mapped", [97]], [[120043, 120043], "mapped", [98]], [[120044, 120044], "mapped", [99]], [[120045, 120045], "mapped", [100]], [[120046, 120046], "mapped", [101]], [[120047, 120047], "mapped", [102]], [[120048, 120048], "mapped", [103]], [[120049, 120049], "mapped", [104]], [[120050, 120050], "mapped", [105]], [[120051, 120051], "mapped", [106]], [[120052, 120052], "mapped", [107]], [[120053, 120053], "mapped", [108]], [[120054, 120054], "mapped", [109]], [[120055, 120055], "mapped", [110]], [[120056, 120056], "mapped", [111]], [[120057, 120057], "mapped", [112]], [[120058, 120058], "mapped", [113]], [[120059, 120059], "mapped", [114]], [[120060, 120060], "mapped", [115]], [[120061, 120061], "mapped", [116]], [[120062, 120062], "mapped", [117]], [[120063, 120063], "mapped", [118]], [[120064, 120064], "mapped", [119]], [[120065, 120065], "mapped", [120]], [[120066, 120066], "mapped", [121]], [[120067, 120067], "mapped", [122]], [[120068, 120068], "mapped", [97]], [[120069, 120069], "mapped", [98]], [[120070, 120070], "disallowed"], [[120071, 120071], "mapped", [100]], [[120072, 120072], "mapped", [101]], [[120073, 120073], "mapped", [102]], [[120074, 120074], "mapped", [103]], [[120075, 120076], "disallowed"], [[120077, 120077], "mapped", [106]], [[120078, 120078], "mapped", [107]], [[120079, 120079], "mapped", [108]], [[120080, 120080], "mapped", [109]], [[120081, 120081], "mapped", [110]], [[120082, 120082], "mapped", [111]], [[120083, 120083], "mapped", [112]], [[120084, 120084], "mapped", [113]], [[120085, 120085], "disallowed"], [[120086, 120086], "mapped", [115]], [[120087, 120087], "mapped", [116]], [[120088, 120088], "mapped", [117]], [[120089, 120089], "mapped", [118]], [[120090, 120090], "mapped", [119]], [[120091, 120091], "mapped", [120]], [[120092, 120092], "mapped", [121]], [[120093, 120093], "disallowed"], [[120094, 120094], "mapped", [97]], [[120095, 120095], "mapped", [98]], [[120096, 120096], "mapped", [99]], [[120097, 120097], "mapped", [100]], [[120098, 120098], "mapped", [101]], [[120099, 120099], "mapped", [102]], [[120100, 120100], "mapped", [103]], [[120101, 120101], "mapped", [104]], [[120102, 120102], "mapped", [105]], [[120103, 120103], "mapped", [106]], [[120104, 120104], "mapped", [107]], [[120105, 120105], "mapped", [108]], [[120106, 120106], "mapped", [109]], [[120107, 120107], "mapped", [110]], [[120108, 120108], "mapped", [111]], [[120109, 120109], "mapped", [112]], [[120110, 120110], "mapped", [113]], [[120111, 120111], "mapped", [114]], [[120112, 120112], "mapped", [115]], [[120113, 120113], "mapped", [116]], [[120114, 120114], "mapped", [117]], [[120115, 120115], "mapped", [118]], [[120116, 120116], "mapped", [119]], [[120117, 120117], "mapped", [120]], [[120118, 120118], "mapped", [121]], [[120119, 120119], "mapped", [122]], [[120120, 120120], "mapped", [97]], [[120121, 120121], "mapped", [98]], [[120122, 120122], "disallowed"], [[120123, 120123], "mapped", [100]], [[120124, 120124], "mapped", [101]], [[120125, 120125], "mapped", [102]], [[120126, 120126], "mapped", [103]], [[120127, 120127], "disallowed"], [[120128, 120128], "mapped", [105]], [[120129, 120129], "mapped", [106]], [[120130, 120130], "mapped", [107]], [[120131, 120131], "mapped", [108]], [[120132, 120132], "mapped", [109]], [[120133, 120133], "disallowed"], [[120134, 120134], "mapped", [111]], [[120135, 120137], "disallowed"], [[120138, 120138], "mapped", [115]], [[120139, 120139], "mapped", [116]], [[120140, 120140], "mapped", [117]], [[120141, 120141], "mapped", [118]], [[120142, 120142], "mapped", [119]], [[120143, 120143], "mapped", [120]], [[120144, 120144], "mapped", [121]], [[120145, 120145], "disallowed"], [[120146, 120146], "mapped", [97]], [[120147, 120147], "mapped", [98]], [[120148, 120148], "mapped", [99]], [[120149, 120149], "mapped", [100]], [[120150, 120150], "mapped", [101]], [[120151, 120151], "mapped", [102]], [[120152, 120152], "mapped", [103]], [[120153, 120153], "mapped", [104]], [[120154, 120154], "mapped", [105]], [[120155, 120155], "mapped", [106]], [[120156, 120156], "mapped", [107]], [[120157, 120157], "mapped", [108]], [[120158, 120158], "mapped", [109]], [[120159, 120159], "mapped", [110]], [[120160, 120160], "mapped", [111]], [[120161, 120161], "mapped", [112]], [[120162, 120162], "mapped", [113]], [[120163, 120163], "mapped", [114]], [[120164, 120164], "mapped", [115]], [[120165, 120165], "mapped", [116]], [[120166, 120166], "mapped", [117]], [[120167, 120167], "mapped", [118]], [[120168, 120168], "mapped", [119]], [[120169, 120169], "mapped", [120]], [[120170, 120170], "mapped", [121]], [[120171, 120171], "mapped", [122]], [[120172, 120172], "mapped", [97]], [[120173, 120173], "mapped", [98]], [[120174, 120174], "mapped", [99]], [[120175, 120175], "mapped", [100]], [[120176, 120176], "mapped", [101]], [[120177, 120177], "mapped", [102]], [[120178, 120178], "mapped", [103]], [[120179, 120179], "mapped", [104]], [[120180, 120180], "mapped", [105]], [[120181, 120181], "mapped", [106]], [[120182, 120182], "mapped", [107]], [[120183, 120183], "mapped", [108]], [[120184, 120184], "mapped", [109]], [[120185, 120185], "mapped", [110]], [[120186, 120186], "mapped", [111]], [[120187, 120187], "mapped", [112]], [[120188, 120188], "mapped", [113]], [[120189, 120189], "mapped", [114]], [[120190, 120190], "mapped", [115]], [[120191, 120191], "mapped", [116]], [[120192, 120192], "mapped", [117]], [[120193, 120193], "mapped", [118]], [[120194, 120194], "mapped", [119]], [[120195, 120195], "mapped", [120]], [[120196, 120196], "mapped", [121]], [[120197, 120197], "mapped", [122]], [[120198, 120198], "mapped", [97]], [[120199, 120199], "mapped", [98]], [[120200, 120200], "mapped", [99]], [[120201, 120201], "mapped", [100]], [[120202, 120202], "mapped", [101]], [[120203, 120203], "mapped", [102]], [[120204, 120204], "mapped", [103]], [[120205, 120205], "mapped", [104]], [[120206, 120206], "mapped", [105]], [[120207, 120207], "mapped", [106]], [[120208, 120208], "mapped", [107]], [[120209, 120209], "mapped", [108]], [[120210, 120210], "mapped", [109]], [[120211, 120211], "mapped", [110]], [[120212, 120212], "mapped", [111]], [[120213, 120213], "mapped", [112]], [[120214, 120214], "mapped", [113]], [[120215, 120215], "mapped", [114]], [[120216, 120216], "mapped", [115]], [[120217, 120217], "mapped", [116]], [[120218, 120218], "mapped", [117]], [[120219, 120219], "mapped", [118]], [[120220, 120220], "mapped", [119]], [[120221, 120221], "mapped", [120]], [[120222, 120222], "mapped", [121]], [[120223, 120223], "mapped", [122]], [[120224, 120224], "mapped", [97]], [[120225, 120225], "mapped", [98]], [[120226, 120226], "mapped", [99]], [[120227, 120227], "mapped", [100]], [[120228, 120228], "mapped", [101]], [[120229, 120229], "mapped", [102]], [[120230, 120230], "mapped", [103]], [[120231, 120231], "mapped", [104]], [[120232, 120232], "mapped", [105]], [[120233, 120233], "mapped", [106]], [[120234, 120234], "mapped", [107]], [[120235, 120235], "mapped", [108]], [[120236, 120236], "mapped", [109]], [[120237, 120237], "mapped", [110]], [[120238, 120238], "mapped", [111]], [[120239, 120239], "mapped", [112]], [[120240, 120240], "mapped", [113]], [[120241, 120241], "mapped", [114]], [[120242, 120242], "mapped", [115]], [[120243, 120243], "mapped", [116]], [[120244, 120244], "mapped", [117]], [[120245, 120245], "mapped", [118]], [[120246, 120246], "mapped", [119]], [[120247, 120247], "mapped", [120]], [[120248, 120248], "mapped", [121]], [[120249, 120249], "mapped", [122]], [[120250, 120250], "mapped", [97]], [[120251, 120251], "mapped", [98]], [[120252, 120252], "mapped", [99]], [[120253, 120253], "mapped", [100]], [[120254, 120254], "mapped", [101]], [[120255, 120255], "mapped", [102]], [[120256, 120256], "mapped", [103]], [[120257, 120257], "mapped", [104]], [[120258, 120258], "mapped", [105]], [[120259, 120259], "mapped", [106]], [[120260, 120260], "mapped", [107]], [[120261, 120261], "mapped", [108]], [[120262, 120262], "mapped", [109]], [[120263, 120263], "mapped", [110]], [[120264, 120264], "mapped", [111]], [[120265, 120265], "mapped", [112]], [[120266, 120266], "mapped", [113]], [[120267, 120267], "mapped", [114]], [[120268, 120268], "mapped", [115]], [[120269, 120269], "mapped", [116]], [[120270, 120270], "mapped", [117]], [[120271, 120271], "mapped", [118]], [[120272, 120272], "mapped", [119]], [[120273, 120273], "mapped", [120]], [[120274, 120274], "mapped", [121]], [[120275, 120275], "mapped", [122]], [[120276, 120276], "mapped", [97]], [[120277, 120277], "mapped", [98]], [[120278, 120278], "mapped", [99]], [[120279, 120279], "mapped", [100]], [[120280, 120280], "mapped", [101]], [[120281, 120281], "mapped", [102]], [[120282, 120282], "mapped", [103]], [[120283, 120283], "mapped", [104]], [[120284, 120284], "mapped", [105]], [[120285, 120285], "mapped", [106]], [[120286, 120286], "mapped", [107]], [[120287, 120287], "mapped", [108]], [[120288, 120288], "mapped", [109]], [[120289, 120289], "mapped", [110]], [[120290, 120290], "mapped", [111]], [[120291, 120291], "mapped", [112]], [[120292, 120292], "mapped", [113]], [[120293, 120293], "mapped", [114]], [[120294, 120294], "mapped", [115]], [[120295, 120295], "mapped", [116]], [[120296, 120296], "mapped", [117]], [[120297, 120297], "mapped", [118]], [[120298, 120298], "mapped", [119]], [[120299, 120299], "mapped", [120]], [[120300, 120300], "mapped", [121]], [[120301, 120301], "mapped", [122]], [[120302, 120302], "mapped", [97]], [[120303, 120303], "mapped", [98]], [[120304, 120304], "mapped", [99]], [[120305, 120305], "mapped", [100]], [[120306, 120306], "mapped", [101]], [[120307, 120307], "mapped", [102]], [[120308, 120308], "mapped", [103]], [[120309, 120309], "mapped", [104]], [[120310, 120310], "mapped", [105]], [[120311, 120311], "mapped", [106]], [[120312, 120312], "mapped", [107]], [[120313, 120313], "mapped", [108]], [[120314, 120314], "mapped", [109]], [[120315, 120315], "mapped", [110]], [[120316, 120316], "mapped", [111]], [[120317, 120317], "mapped", [112]], [[120318, 120318], "mapped", [113]], [[120319, 120319], "mapped", [114]], [[120320, 120320], "mapped", [115]], [[120321, 120321], "mapped", [116]], [[120322, 120322], "mapped", [117]], [[120323, 120323], "mapped", [118]], [[120324, 120324], "mapped", [119]], [[120325, 120325], "mapped", [120]], [[120326, 120326], "mapped", [121]], [[120327, 120327], "mapped", [122]], [[120328, 120328], "mapped", [97]], [[120329, 120329], "mapped", [98]], [[120330, 120330], "mapped", [99]], [[120331, 120331], "mapped", [100]], [[120332, 120332], "mapped", [101]], [[120333, 120333], "mapped", [102]], [[120334, 120334], "mapped", [103]], [[120335, 120335], "mapped", [104]], [[120336, 120336], "mapped", [105]], [[120337, 120337], "mapped", [106]], [[120338, 120338], "mapped", [107]], [[120339, 120339], "mapped", [108]], [[120340, 120340], "mapped", [109]], [[120341, 120341], "mapped", [110]], [[120342, 120342], "mapped", [111]], [[120343, 120343], "mapped", [112]], [[120344, 120344], "mapped", [113]], [[120345, 120345], "mapped", [114]], [[120346, 120346], "mapped", [115]], [[120347, 120347], "mapped", [116]], [[120348, 120348], "mapped", [117]], [[120349, 120349], "mapped", [118]], [[120350, 120350], "mapped", [119]], [[120351, 120351], "mapped", [120]], [[120352, 120352], "mapped", [121]], [[120353, 120353], "mapped", [122]], [[120354, 120354], "mapped", [97]], [[120355, 120355], "mapped", [98]], [[120356, 120356], "mapped", [99]], [[120357, 120357], "mapped", [100]], [[120358, 120358], "mapped", [101]], [[120359, 120359], "mapped", [102]], [[120360, 120360], "mapped", [103]], [[120361, 120361], "mapped", [104]], [[120362, 120362], "mapped", [105]], [[120363, 120363], "mapped", [106]], [[120364, 120364], "mapped", [107]], [[120365, 120365], "mapped", [108]], [[120366, 120366], "mapped", [109]], [[120367, 120367], "mapped", [110]], [[120368, 120368], "mapped", [111]], [[120369, 120369], "mapped", [112]], [[120370, 120370], "mapped", [113]], [[120371, 120371], "mapped", [114]], [[120372, 120372], "mapped", [115]], [[120373, 120373], "mapped", [116]], [[120374, 120374], "mapped", [117]], [[120375, 120375], "mapped", [118]], [[120376, 120376], "mapped", [119]], [[120377, 120377], "mapped", [120]], [[120378, 120378], "mapped", [121]], [[120379, 120379], "mapped", [122]], [[120380, 120380], "mapped", [97]], [[120381, 120381], "mapped", [98]], [[120382, 120382], "mapped", [99]], [[120383, 120383], "mapped", [100]], [[120384, 120384], "mapped", [101]], [[120385, 120385], "mapped", [102]], [[120386, 120386], "mapped", [103]], [[120387, 120387], "mapped", [104]], [[120388, 120388], "mapped", [105]], [[120389, 120389], "mapped", [106]], [[120390, 120390], "mapped", [107]], [[120391, 120391], "mapped", [108]], [[120392, 120392], "mapped", [109]], [[120393, 120393], "mapped", [110]], [[120394, 120394], "mapped", [111]], [[120395, 120395], "mapped", [112]], [[120396, 120396], "mapped", [113]], [[120397, 120397], "mapped", [114]], [[120398, 120398], "mapped", [115]], [[120399, 120399], "mapped", [116]], [[120400, 120400], "mapped", [117]], [[120401, 120401], "mapped", [118]], [[120402, 120402], "mapped", [119]], [[120403, 120403], "mapped", [120]], [[120404, 120404], "mapped", [121]], [[120405, 120405], "mapped", [122]], [[120406, 120406], "mapped", [97]], [[120407, 120407], "mapped", [98]], [[120408, 120408], "mapped", [99]], [[120409, 120409], "mapped", [100]], [[120410, 120410], "mapped", [101]], [[120411, 120411], "mapped", [102]], [[120412, 120412], "mapped", [103]], [[120413, 120413], "mapped", [104]], [[120414, 120414], "mapped", [105]], [[120415, 120415], "mapped", [106]], [[120416, 120416], "mapped", [107]], [[120417, 120417], "mapped", [108]], [[120418, 120418], "mapped", [109]], [[120419, 120419], "mapped", [110]], [[120420, 120420], "mapped", [111]], [[120421, 120421], "mapped", [112]], [[120422, 120422], "mapped", [113]], [[120423, 120423], "mapped", [114]], [[120424, 120424], "mapped", [115]], [[120425, 120425], "mapped", [116]], [[120426, 120426], "mapped", [117]], [[120427, 120427], "mapped", [118]], [[120428, 120428], "mapped", [119]], [[120429, 120429], "mapped", [120]], [[120430, 120430], "mapped", [121]], [[120431, 120431], "mapped", [122]], [[120432, 120432], "mapped", [97]], [[120433, 120433], "mapped", [98]], [[120434, 120434], "mapped", [99]], [[120435, 120435], "mapped", [100]], [[120436, 120436], "mapped", [101]], [[120437, 120437], "mapped", [102]], [[120438, 120438], "mapped", [103]], [[120439, 120439], "mapped", [104]], [[120440, 120440], "mapped", [105]], [[120441, 120441], "mapped", [106]], [[120442, 120442], "mapped", [107]], [[120443, 120443], "mapped", [108]], [[120444, 120444], "mapped", [109]], [[120445, 120445], "mapped", [110]], [[120446, 120446], "mapped", [111]], [[120447, 120447], "mapped", [112]], [[120448, 120448], "mapped", [113]], [[120449, 120449], "mapped", [114]], [[120450, 120450], "mapped", [115]], [[120451, 120451], "mapped", [116]], [[120452, 120452], "mapped", [117]], [[120453, 120453], "mapped", [118]], [[120454, 120454], "mapped", [119]], [[120455, 120455], "mapped", [120]], [[120456, 120456], "mapped", [121]], [[120457, 120457], "mapped", [122]], [[120458, 120458], "mapped", [97]], [[120459, 120459], "mapped", [98]], [[120460, 120460], "mapped", [99]], [[120461, 120461], "mapped", [100]], [[120462, 120462], "mapped", [101]], [[120463, 120463], "mapped", [102]], [[120464, 120464], "mapped", [103]], [[120465, 120465], "mapped", [104]], [[120466, 120466], "mapped", [105]], [[120467, 120467], "mapped", [106]], [[120468, 120468], "mapped", [107]], [[120469, 120469], "mapped", [108]], [[120470, 120470], "mapped", [109]], [[120471, 120471], "mapped", [110]], [[120472, 120472], "mapped", [111]], [[120473, 120473], "mapped", [112]], [[120474, 120474], "mapped", [113]], [[120475, 120475], "mapped", [114]], [[120476, 120476], "mapped", [115]], [[120477, 120477], "mapped", [116]], [[120478, 120478], "mapped", [117]], [[120479, 120479], "mapped", [118]], [[120480, 120480], "mapped", [119]], [[120481, 120481], "mapped", [120]], [[120482, 120482], "mapped", [121]], [[120483, 120483], "mapped", [122]], [[120484, 120484], "mapped", [305]], [[120485, 120485], "mapped", [567]], [[120486, 120487], "disallowed"], [[120488, 120488], "mapped", [945]], [[120489, 120489], "mapped", [946]], [[120490, 120490], "mapped", [947]], [[120491, 120491], "mapped", [948]], [[120492, 120492], "mapped", [949]], [[120493, 120493], "mapped", [950]], [[120494, 120494], "mapped", [951]], [[120495, 120495], "mapped", [952]], [[120496, 120496], "mapped", [953]], [[120497, 120497], "mapped", [954]], [[120498, 120498], "mapped", [955]], [[120499, 120499], "mapped", [956]], [[120500, 120500], "mapped", [957]], [[120501, 120501], "mapped", [958]], [[120502, 120502], "mapped", [959]], [[120503, 120503], "mapped", [960]], [[120504, 120504], "mapped", [961]], [[120505, 120505], "mapped", [952]], [[120506, 120506], "mapped", [963]], [[120507, 120507], "mapped", [964]], [[120508, 120508], "mapped", [965]], [[120509, 120509], "mapped", [966]], [[120510, 120510], "mapped", [967]], [[120511, 120511], "mapped", [968]], [[120512, 120512], "mapped", [969]], [[120513, 120513], "mapped", [8711]], [[120514, 120514], "mapped", [945]], [[120515, 120515], "mapped", [946]], [[120516, 120516], "mapped", [947]], [[120517, 120517], "mapped", [948]], [[120518, 120518], "mapped", [949]], [[120519, 120519], "mapped", [950]], [[120520, 120520], "mapped", [951]], [[120521, 120521], "mapped", [952]], [[120522, 120522], "mapped", [953]], [[120523, 120523], "mapped", [954]], [[120524, 120524], "mapped", [955]], [[120525, 120525], "mapped", [956]], [[120526, 120526], "mapped", [957]], [[120527, 120527], "mapped", [958]], [[120528, 120528], "mapped", [959]], [[120529, 120529], "mapped", [960]], [[120530, 120530], "mapped", [961]], [[120531, 120532], "mapped", [963]], [[120533, 120533], "mapped", [964]], [[120534, 120534], "mapped", [965]], [[120535, 120535], "mapped", [966]], [[120536, 120536], "mapped", [967]], [[120537, 120537], "mapped", [968]], [[120538, 120538], "mapped", [969]], [[120539, 120539], "mapped", [8706]], [[120540, 120540], "mapped", [949]], [[120541, 120541], "mapped", [952]], [[120542, 120542], "mapped", [954]], [[120543, 120543], "mapped", [966]], [[120544, 120544], "mapped", [961]], [[120545, 120545], "mapped", [960]], [[120546, 120546], "mapped", [945]], [[120547, 120547], "mapped", [946]], [[120548, 120548], "mapped", [947]], [[120549, 120549], "mapped", [948]], [[120550, 120550], "mapped", [949]], [[120551, 120551], "mapped", [950]], [[120552, 120552], "mapped", [951]], [[120553, 120553], "mapped", [952]], [[120554, 120554], "mapped", [953]], [[120555, 120555], "mapped", [954]], [[120556, 120556], "mapped", [955]], [[120557, 120557], "mapped", [956]], [[120558, 120558], "mapped", [957]], [[120559, 120559], "mapped", [958]], [[120560, 120560], "mapped", [959]], [[120561, 120561], "mapped", [960]], [[120562, 120562], "mapped", [961]], [[120563, 120563], "mapped", [952]], [[120564, 120564], "mapped", [963]], [[120565, 120565], "mapped", [964]], [[120566, 120566], "mapped", [965]], [[120567, 120567], "mapped", [966]], [[120568, 120568], "mapped", [967]], [[120569, 120569], "mapped", [968]], [[120570, 120570], "mapped", [969]], [[120571, 120571], "mapped", [8711]], [[120572, 120572], "mapped", [945]], [[120573, 120573], "mapped", [946]], [[120574, 120574], "mapped", [947]], [[120575, 120575], "mapped", [948]], [[120576, 120576], "mapped", [949]], [[120577, 120577], "mapped", [950]], [[120578, 120578], "mapped", [951]], [[120579, 120579], "mapped", [952]], [[120580, 120580], "mapped", [953]], [[120581, 120581], "mapped", [954]], [[120582, 120582], "mapped", [955]], [[120583, 120583], "mapped", [956]], [[120584, 120584], "mapped", [957]], [[120585, 120585], "mapped", [958]], [[120586, 120586], "mapped", [959]], [[120587, 120587], "mapped", [960]], [[120588, 120588], "mapped", [961]], [[120589, 120590], "mapped", [963]], [[120591, 120591], "mapped", [964]], [[120592, 120592], "mapped", [965]], [[120593, 120593], "mapped", [966]], [[120594, 120594], "mapped", [967]], [[120595, 120595], "mapped", [968]], [[120596, 120596], "mapped", [969]], [[120597, 120597], "mapped", [8706]], [[120598, 120598], "mapped", [949]], [[120599, 120599], "mapped", [952]], [[120600, 120600], "mapped", [954]], [[120601, 120601], "mapped", [966]], [[120602, 120602], "mapped", [961]], [[120603, 120603], "mapped", [960]], [[120604, 120604], "mapped", [945]], [[120605, 120605], "mapped", [946]], [[120606, 120606], "mapped", [947]], [[120607, 120607], "mapped", [948]], [[120608, 120608], "mapped", [949]], [[120609, 120609], "mapped", [950]], [[120610, 120610], "mapped", [951]], [[120611, 120611], "mapped", [952]], [[120612, 120612], "mapped", [953]], [[120613, 120613], "mapped", [954]], [[120614, 120614], "mapped", [955]], [[120615, 120615], "mapped", [956]], [[120616, 120616], "mapped", [957]], [[120617, 120617], "mapped", [958]], [[120618, 120618], "mapped", [959]], [[120619, 120619], "mapped", [960]], [[120620, 120620], "mapped", [961]], [[120621, 120621], "mapped", [952]], [[120622, 120622], "mapped", [963]], [[120623, 120623], "mapped", [964]], [[120624, 120624], "mapped", [965]], [[120625, 120625], "mapped", [966]], [[120626, 120626], "mapped", [967]], [[120627, 120627], "mapped", [968]], [[120628, 120628], "mapped", [969]], [[120629, 120629], "mapped", [8711]], [[120630, 120630], "mapped", [945]], [[120631, 120631], "mapped", [946]], [[120632, 120632], "mapped", [947]], [[120633, 120633], "mapped", [948]], [[120634, 120634], "mapped", [949]], [[120635, 120635], "mapped", [950]], [[120636, 120636], "mapped", [951]], [[120637, 120637], "mapped", [952]], [[120638, 120638], "mapped", [953]], [[120639, 120639], "mapped", [954]], [[120640, 120640], "mapped", [955]], [[120641, 120641], "mapped", [956]], [[120642, 120642], "mapped", [957]], [[120643, 120643], "mapped", [958]], [[120644, 120644], "mapped", [959]], [[120645, 120645], "mapped", [960]], [[120646, 120646], "mapped", [961]], [[120647, 120648], "mapped", [963]], [[120649, 120649], "mapped", [964]], [[120650, 120650], "mapped", [965]], [[120651, 120651], "mapped", [966]], [[120652, 120652], "mapped", [967]], [[120653, 120653], "mapped", [968]], [[120654, 120654], "mapped", [969]], [[120655, 120655], "mapped", [8706]], [[120656, 120656], "mapped", [949]], [[120657, 120657], "mapped", [952]], [[120658, 120658], "mapped", [954]], [[120659, 120659], "mapped", [966]], [[120660, 120660], "mapped", [961]], [[120661, 120661], "mapped", [960]], [[120662, 120662], "mapped", [945]], [[120663, 120663], "mapped", [946]], [[120664, 120664], "mapped", [947]], [[120665, 120665], "mapped", [948]], [[120666, 120666], "mapped", [949]], [[120667, 120667], "mapped", [950]], [[120668, 120668], "mapped", [951]], [[120669, 120669], "mapped", [952]], [[120670, 120670], "mapped", [953]], [[120671, 120671], "mapped", [954]], [[120672, 120672], "mapped", [955]], [[120673, 120673], "mapped", [956]], [[120674, 120674], "mapped", [957]], [[120675, 120675], "mapped", [958]], [[120676, 120676], "mapped", [959]], [[120677, 120677], "mapped", [960]], [[120678, 120678], "mapped", [961]], [[120679, 120679], "mapped", [952]], [[120680, 120680], "mapped", [963]], [[120681, 120681], "mapped", [964]], [[120682, 120682], "mapped", [965]], [[120683, 120683], "mapped", [966]], [[120684, 120684], "mapped", [967]], [[120685, 120685], "mapped", [968]], [[120686, 120686], "mapped", [969]], [[120687, 120687], "mapped", [8711]], [[120688, 120688], "mapped", [945]], [[120689, 120689], "mapped", [946]], [[120690, 120690], "mapped", [947]], [[120691, 120691], "mapped", [948]], [[120692, 120692], "mapped", [949]], [[120693, 120693], "mapped", [950]], [[120694, 120694], "mapped", [951]], [[120695, 120695], "mapped", [952]], [[120696, 120696], "mapped", [953]], [[120697, 120697], "mapped", [954]], [[120698, 120698], "mapped", [955]], [[120699, 120699], "mapped", [956]], [[120700, 120700], "mapped", [957]], [[120701, 120701], "mapped", [958]], [[120702, 120702], "mapped", [959]], [[120703, 120703], "mapped", [960]], [[120704, 120704], "mapped", [961]], [[120705, 120706], "mapped", [963]], [[120707, 120707], "mapped", [964]], [[120708, 120708], "mapped", [965]], [[120709, 120709], "mapped", [966]], [[120710, 120710], "mapped", [967]], [[120711, 120711], "mapped", [968]], [[120712, 120712], "mapped", [969]], [[120713, 120713], "mapped", [8706]], [[120714, 120714], "mapped", [949]], [[120715, 120715], "mapped", [952]], [[120716, 120716], "mapped", [954]], [[120717, 120717], "mapped", [966]], [[120718, 120718], "mapped", [961]], [[120719, 120719], "mapped", [960]], [[120720, 120720], "mapped", [945]], [[120721, 120721], "mapped", [946]], [[120722, 120722], "mapped", [947]], [[120723, 120723], "mapped", [948]], [[120724, 120724], "mapped", [949]], [[120725, 120725], "mapped", [950]], [[120726, 120726], "mapped", [951]], [[120727, 120727], "mapped", [952]], [[120728, 120728], "mapped", [953]], [[120729, 120729], "mapped", [954]], [[120730, 120730], "mapped", [955]], [[120731, 120731], "mapped", [956]], [[120732, 120732], "mapped", [957]], [[120733, 120733], "mapped", [958]], [[120734, 120734], "mapped", [959]], [[120735, 120735], "mapped", [960]], [[120736, 120736], "mapped", [961]], [[120737, 120737], "mapped", [952]], [[120738, 120738], "mapped", [963]], [[120739, 120739], "mapped", [964]], [[120740, 120740], "mapped", [965]], [[120741, 120741], "mapped", [966]], [[120742, 120742], "mapped", [967]], [[120743, 120743], "mapped", [968]], [[120744, 120744], "mapped", [969]], [[120745, 120745], "mapped", [8711]], [[120746, 120746], "mapped", [945]], [[120747, 120747], "mapped", [946]], [[120748, 120748], "mapped", [947]], [[120749, 120749], "mapped", [948]], [[120750, 120750], "mapped", [949]], [[120751, 120751], "mapped", [950]], [[120752, 120752], "mapped", [951]], [[120753, 120753], "mapped", [952]], [[120754, 120754], "mapped", [953]], [[120755, 120755], "mapped", [954]], [[120756, 120756], "mapped", [955]], [[120757, 120757], "mapped", [956]], [[120758, 120758], "mapped", [957]], [[120759, 120759], "mapped", [958]], [[120760, 120760], "mapped", [959]], [[120761, 120761], "mapped", [960]], [[120762, 120762], "mapped", [961]], [[120763, 120764], "mapped", [963]], [[120765, 120765], "mapped", [964]], [[120766, 120766], "mapped", [965]], [[120767, 120767], "mapped", [966]], [[120768, 120768], "mapped", [967]], [[120769, 120769], "mapped", [968]], [[120770, 120770], "mapped", [969]], [[120771, 120771], "mapped", [8706]], [[120772, 120772], "mapped", [949]], [[120773, 120773], "mapped", [952]], [[120774, 120774], "mapped", [954]], [[120775, 120775], "mapped", [966]], [[120776, 120776], "mapped", [961]], [[120777, 120777], "mapped", [960]], [[120778, 120779], "mapped", [989]], [[120780, 120781], "disallowed"], [[120782, 120782], "mapped", [48]], [[120783, 120783], "mapped", [49]], [[120784, 120784], "mapped", [50]], [[120785, 120785], "mapped", [51]], [[120786, 120786], "mapped", [52]], [[120787, 120787], "mapped", [53]], [[120788, 120788], "mapped", [54]], [[120789, 120789], "mapped", [55]], [[120790, 120790], "mapped", [56]], [[120791, 120791], "mapped", [57]], [[120792, 120792], "mapped", [48]], [[120793, 120793], "mapped", [49]], [[120794, 120794], "mapped", [50]], [[120795, 120795], "mapped", [51]], [[120796, 120796], "mapped", [52]], [[120797, 120797], "mapped", [53]], [[120798, 120798], "mapped", [54]], [[120799, 120799], "mapped", [55]], [[120800, 120800], "mapped", [56]], [[120801, 120801], "mapped", [57]], [[120802, 120802], "mapped", [48]], [[120803, 120803], "mapped", [49]], [[120804, 120804], "mapped", [50]], [[120805, 120805], "mapped", [51]], [[120806, 120806], "mapped", [52]], [[120807, 120807], "mapped", [53]], [[120808, 120808], "mapped", [54]], [[120809, 120809], "mapped", [55]], [[120810, 120810], "mapped", [56]], [[120811, 120811], "mapped", [57]], [[120812, 120812], "mapped", [48]], [[120813, 120813], "mapped", [49]], [[120814, 120814], "mapped", [50]], [[120815, 120815], "mapped", [51]], [[120816, 120816], "mapped", [52]], [[120817, 120817], "mapped", [53]], [[120818, 120818], "mapped", [54]], [[120819, 120819], "mapped", [55]], [[120820, 120820], "mapped", [56]], [[120821, 120821], "mapped", [57]], [[120822, 120822], "mapped", [48]], [[120823, 120823], "mapped", [49]], [[120824, 120824], "mapped", [50]], [[120825, 120825], "mapped", [51]], [[120826, 120826], "mapped", [52]], [[120827, 120827], "mapped", [53]], [[120828, 120828], "mapped", [54]], [[120829, 120829], "mapped", [55]], [[120830, 120830], "mapped", [56]], [[120831, 120831], "mapped", [57]], [[120832, 121343], "valid", [], "NV8"], [[121344, 121398], "valid"], [[121399, 121402], "valid", [], "NV8"], [[121403, 121452], "valid"], [[121453, 121460], "valid", [], "NV8"], [[121461, 121461], "valid"], [[121462, 121475], "valid", [], "NV8"], [[121476, 121476], "valid"], [[121477, 121483], "valid", [], "NV8"], [[121484, 121498], "disallowed"], [[121499, 121503], "valid"], [[121504, 121504], "disallowed"], [[121505, 121519], "valid"], [[121520, 124927], "disallowed"], [[124928, 125124], "valid"], [[125125, 125126], "disallowed"], [[125127, 125135], "valid", [], "NV8"], [[125136, 125142], "valid"], [[125143, 126463], "disallowed"], [[126464, 126464], "mapped", [1575]], [[126465, 126465], "mapped", [1576]], [[126466, 126466], "mapped", [1580]], [[126467, 126467], "mapped", [1583]], [[126468, 126468], "disallowed"], [[126469, 126469], "mapped", [1608]], [[126470, 126470], "mapped", [1586]], [[126471, 126471], "mapped", [1581]], [[126472, 126472], "mapped", [1591]], [[126473, 126473], "mapped", [1610]], [[126474, 126474], "mapped", [1603]], [[126475, 126475], "mapped", [1604]], [[126476, 126476], "mapped", [1605]], [[126477, 126477], "mapped", [1606]], [[126478, 126478], "mapped", [1587]], [[126479, 126479], "mapped", [1593]], [[126480, 126480], "mapped", [1601]], [[126481, 126481], "mapped", [1589]], [[126482, 126482], "mapped", [1602]], [[126483, 126483], "mapped", [1585]], [[126484, 126484], "mapped", [1588]], [[126485, 126485], "mapped", [1578]], [[126486, 126486], "mapped", [1579]], [[126487, 126487], "mapped", [1582]], [[126488, 126488], "mapped", [1584]], [[126489, 126489], "mapped", [1590]], [[126490, 126490], "mapped", [1592]], [[126491, 126491], "mapped", [1594]], [[126492, 126492], "mapped", [1646]], [[126493, 126493], "mapped", [1722]], [[126494, 126494], "mapped", [1697]], [[126495, 126495], "mapped", [1647]], [[126496, 126496], "disallowed"], [[126497, 126497], "mapped", [1576]], [[126498, 126498], "mapped", [1580]], [[126499, 126499], "disallowed"], [[126500, 126500], "mapped", [1607]], [[126501, 126502], "disallowed"], [[126503, 126503], "mapped", [1581]], [[126504, 126504], "disallowed"], [[126505, 126505], "mapped", [1610]], [[126506, 126506], "mapped", [1603]], [[126507, 126507], "mapped", [1604]], [[126508, 126508], "mapped", [1605]], [[126509, 126509], "mapped", [1606]], [[126510, 126510], "mapped", [1587]], [[126511, 126511], "mapped", [1593]], [[126512, 126512], "mapped", [1601]], [[126513, 126513], "mapped", [1589]], [[126514, 126514], "mapped", [1602]], [[126515, 126515], "disallowed"], [[126516, 126516], "mapped", [1588]], [[126517, 126517], "mapped", [1578]], [[126518, 126518], "mapped", [1579]], [[126519, 126519], "mapped", [1582]], [[126520, 126520], "disallowed"], [[126521, 126521], "mapped", [1590]], [[126522, 126522], "disallowed"], [[126523, 126523], "mapped", [1594]], [[126524, 126529], "disallowed"], [[126530, 126530], "mapped", [1580]], [[126531, 126534], "disallowed"], [[126535, 126535], "mapped", [1581]], [[126536, 126536], "disallowed"], [[126537, 126537], "mapped", [1610]], [[126538, 126538], "disallowed"], [[126539, 126539], "mapped", [1604]], [[126540, 126540], "disallowed"], [[126541, 126541], "mapped", [1606]], [[126542, 126542], "mapped", [1587]], [[126543, 126543], "mapped", [1593]], [[126544, 126544], "disallowed"], [[126545, 126545], "mapped", [1589]], [[126546, 126546], "mapped", [1602]], [[126547, 126547], "disallowed"], [[126548, 126548], "mapped", [1588]], [[126549, 126550], "disallowed"], [[126551, 126551], "mapped", [1582]], [[126552, 126552], "disallowed"], [[126553, 126553], "mapped", [1590]], [[126554, 126554], "disallowed"], [[126555, 126555], "mapped", [1594]], [[126556, 126556], "disallowed"], [[126557, 126557], "mapped", [1722]], [[126558, 126558], "disallowed"], [[126559, 126559], "mapped", [1647]], [[126560, 126560], "disallowed"], [[126561, 126561], "mapped", [1576]], [[126562, 126562], "mapped", [1580]], [[126563, 126563], "disallowed"], [[126564, 126564], "mapped", [1607]], [[126565, 126566], "disallowed"], [[126567, 126567], "mapped", [1581]], [[126568, 126568], "mapped", [1591]], [[126569, 126569], "mapped", [1610]], [[126570, 126570], "mapped", [1603]], [[126571, 126571], "disallowed"], [[126572, 126572], "mapped", [1605]], [[126573, 126573], "mapped", [1606]], [[126574, 126574], "mapped", [1587]], [[126575, 126575], "mapped", [1593]], [[126576, 126576], "mapped", [1601]], [[126577, 126577], "mapped", [1589]], [[126578, 126578], "mapped", [1602]], [[126579, 126579], "disallowed"], [[126580, 126580], "mapped", [1588]], [[126581, 126581], "mapped", [1578]], [[126582, 126582], "mapped", [1579]], [[126583, 126583], "mapped", [1582]], [[126584, 126584], "disallowed"], [[126585, 126585], "mapped", [1590]], [[126586, 126586], "mapped", [1592]], [[126587, 126587], "mapped", [1594]], [[126588, 126588], "mapped", [1646]], [[126589, 126589], "disallowed"], [[126590, 126590], "mapped", [1697]], [[126591, 126591], "disallowed"], [[126592, 126592], "mapped", [1575]], [[126593, 126593], "mapped", [1576]], [[126594, 126594], "mapped", [1580]], [[126595, 126595], "mapped", [1583]], [[126596, 126596], "mapped", [1607]], [[126597, 126597], "mapped", [1608]], [[126598, 126598], "mapped", [1586]], [[126599, 126599], "mapped", [1581]], [[126600, 126600], "mapped", [1591]], [[126601, 126601], "mapped", [1610]], [[126602, 126602], "disallowed"], [[126603, 126603], "mapped", [1604]], [[126604, 126604], "mapped", [1605]], [[126605, 126605], "mapped", [1606]], [[126606, 126606], "mapped", [1587]], [[126607, 126607], "mapped", [1593]], [[126608, 126608], "mapped", [1601]], [[126609, 126609], "mapped", [1589]], [[126610, 126610], "mapped", [1602]], [[126611, 126611], "mapped", [1585]], [[126612, 126612], "mapped", [1588]], [[126613, 126613], "mapped", [1578]], [[126614, 126614], "mapped", [1579]], [[126615, 126615], "mapped", [1582]], [[126616, 126616], "mapped", [1584]], [[126617, 126617], "mapped", [1590]], [[126618, 126618], "mapped", [1592]], [[126619, 126619], "mapped", [1594]], [[126620, 126624], "disallowed"], [[126625, 126625], "mapped", [1576]], [[126626, 126626], "mapped", [1580]], [[126627, 126627], "mapped", [1583]], [[126628, 126628], "disallowed"], [[126629, 126629], "mapped", [1608]], [[126630, 126630], "mapped", [1586]], [[126631, 126631], "mapped", [1581]], [[126632, 126632], "mapped", [1591]], [[126633, 126633], "mapped", [1610]], [[126634, 126634], "disallowed"], [[126635, 126635], "mapped", [1604]], [[126636, 126636], "mapped", [1605]], [[126637, 126637], "mapped", [1606]], [[126638, 126638], "mapped", [1587]], [[126639, 126639], "mapped", [1593]], [[126640, 126640], "mapped", [1601]], [[126641, 126641], "mapped", [1589]], [[126642, 126642], "mapped", [1602]], [[126643, 126643], "mapped", [1585]], [[126644, 126644], "mapped", [1588]], [[126645, 126645], "mapped", [1578]], [[126646, 126646], "mapped", [1579]], [[126647, 126647], "mapped", [1582]], [[126648, 126648], "mapped", [1584]], [[126649, 126649], "mapped", [1590]], [[126650, 126650], "mapped", [1592]], [[126651, 126651], "mapped", [1594]], [[126652, 126703], "disallowed"], [[126704, 126705], "valid", [], "NV8"], [[126706, 126975], "disallowed"], [[126976, 127019], "valid", [], "NV8"], [[127020, 127023], "disallowed"], [[127024, 127123], "valid", [], "NV8"], [[127124, 127135], "disallowed"], [[127136, 127150], "valid", [], "NV8"], [[127151, 127152], "disallowed"], [[127153, 127166], "valid", [], "NV8"], [[127167, 127167], "valid", [], "NV8"], [[127168, 127168], "disallowed"], [[127169, 127183], "valid", [], "NV8"], [[127184, 127184], "disallowed"], [[127185, 127199], "valid", [], "NV8"], [[127200, 127221], "valid", [], "NV8"], [[127222, 127231], "disallowed"], [[127232, 127232], "disallowed"], [[127233, 127233], "disallowed_STD3_mapped", [48, 44]], [[127234, 127234], "disallowed_STD3_mapped", [49, 44]], [[127235, 127235], "disallowed_STD3_mapped", [50, 44]], [[127236, 127236], "disallowed_STD3_mapped", [51, 44]], [[127237, 127237], "disallowed_STD3_mapped", [52, 44]], [[127238, 127238], "disallowed_STD3_mapped", [53, 44]], [[127239, 127239], "disallowed_STD3_mapped", [54, 44]], [[127240, 127240], "disallowed_STD3_mapped", [55, 44]], [[127241, 127241], "disallowed_STD3_mapped", [56, 44]], [[127242, 127242], "disallowed_STD3_mapped", [57, 44]], [[127243, 127244], "valid", [], "NV8"], [[127245, 127247], "disallowed"], [[127248, 127248], "disallowed_STD3_mapped", [40, 97, 41]], [[127249, 127249], "disallowed_STD3_mapped", [40, 98, 41]], [[127250, 127250], "disallowed_STD3_mapped", [40, 99, 41]], [[127251, 127251], "disallowed_STD3_mapped", [40, 100, 41]], [[127252, 127252], "disallowed_STD3_mapped", [40, 101, 41]], [[127253, 127253], "disallowed_STD3_mapped", [40, 102, 41]], [[127254, 127254], "disallowed_STD3_mapped", [40, 103, 41]], [[127255, 127255], "disallowed_STD3_mapped", [40, 104, 41]], [[127256, 127256], "disallowed_STD3_mapped", [40, 105, 41]], [[127257, 127257], "disallowed_STD3_mapped", [40, 106, 41]], [[127258, 127258], "disallowed_STD3_mapped", [40, 107, 41]], [[127259, 127259], "disallowed_STD3_mapped", [40, 108, 41]], [[127260, 127260], "disallowed_STD3_mapped", [40, 109, 41]], [[127261, 127261], "disallowed_STD3_mapped", [40, 110, 41]], [[127262, 127262], "disallowed_STD3_mapped", [40, 111, 41]], [[127263, 127263], "disallowed_STD3_mapped", [40, 112, 41]], [[127264, 127264], "disallowed_STD3_mapped", [40, 113, 41]], [[127265, 127265], "disallowed_STD3_mapped", [40, 114, 41]], [[127266, 127266], "disallowed_STD3_mapped", [40, 115, 41]], [[127267, 127267], "disallowed_STD3_mapped", [40, 116, 41]], [[127268, 127268], "disallowed_STD3_mapped", [40, 117, 41]], [[127269, 127269], "disallowed_STD3_mapped", [40, 118, 41]], [[127270, 127270], "disallowed_STD3_mapped", [40, 119, 41]], [[127271, 127271], "disallowed_STD3_mapped", [40, 120, 41]], [[127272, 127272], "disallowed_STD3_mapped", [40, 121, 41]], [[127273, 127273], "disallowed_STD3_mapped", [40, 122, 41]], [[127274, 127274], "mapped", [12308, 115, 12309]], [[127275, 127275], "mapped", [99]], [[127276, 127276], "mapped", [114]], [[127277, 127277], "mapped", [99, 100]], [[127278, 127278], "mapped", [119, 122]], [[127279, 127279], "disallowed"], [[127280, 127280], "mapped", [97]], [[127281, 127281], "mapped", [98]], [[127282, 127282], "mapped", [99]], [[127283, 127283], "mapped", [100]], [[127284, 127284], "mapped", [101]], [[127285, 127285], "mapped", [102]], [[127286, 127286], "mapped", [103]], [[127287, 127287], "mapped", [104]], [[127288, 127288], "mapped", [105]], [[127289, 127289], "mapped", [106]], [[127290, 127290], "mapped", [107]], [[127291, 127291], "mapped", [108]], [[127292, 127292], "mapped", [109]], [[127293, 127293], "mapped", [110]], [[127294, 127294], "mapped", [111]], [[127295, 127295], "mapped", [112]], [[127296, 127296], "mapped", [113]], [[127297, 127297], "mapped", [114]], [[127298, 127298], "mapped", [115]], [[127299, 127299], "mapped", [116]], [[127300, 127300], "mapped", [117]], [[127301, 127301], "mapped", [118]], [[127302, 127302], "mapped", [119]], [[127303, 127303], "mapped", [120]], [[127304, 127304], "mapped", [121]], [[127305, 127305], "mapped", [122]], [[127306, 127306], "mapped", [104, 118]], [[127307, 127307], "mapped", [109, 118]], [[127308, 127308], "mapped", [115, 100]], [[127309, 127309], "mapped", [115, 115]], [[127310, 127310], "mapped", [112, 112, 118]], [[127311, 127311], "mapped", [119, 99]], [[127312, 127318], "valid", [], "NV8"], [[127319, 127319], "valid", [], "NV8"], [[127320, 127326], "valid", [], "NV8"], [[127327, 127327], "valid", [], "NV8"], [[127328, 127337], "valid", [], "NV8"], [[127338, 127338], "mapped", [109, 99]], [[127339, 127339], "mapped", [109, 100]], [[127340, 127343], "disallowed"], [[127344, 127352], "valid", [], "NV8"], [[127353, 127353], "valid", [], "NV8"], [[127354, 127354], "valid", [], "NV8"], [[127355, 127356], "valid", [], "NV8"], [[127357, 127358], "valid", [], "NV8"], [[127359, 127359], "valid", [], "NV8"], [[127360, 127369], "valid", [], "NV8"], [[127370, 127373], "valid", [], "NV8"], [[127374, 127375], "valid", [], "NV8"], [[127376, 127376], "mapped", [100, 106]], [[127377, 127386], "valid", [], "NV8"], [[127387, 127461], "disallowed"], [[127462, 127487], "valid", [], "NV8"], [[127488, 127488], "mapped", [12411, 12363]], [[127489, 127489], "mapped", [12467, 12467]], [[127490, 127490], "mapped", [12469]], [[127491, 127503], "disallowed"], [[127504, 127504], "mapped", [25163]], [[127505, 127505], "mapped", [23383]], [[127506, 127506], "mapped", [21452]], [[127507, 127507], "mapped", [12487]], [[127508, 127508], "mapped", [20108]], [[127509, 127509], "mapped", [22810]], [[127510, 127510], "mapped", [35299]], [[127511, 127511], "mapped", [22825]], [[127512, 127512], "mapped", [20132]], [[127513, 127513], "mapped", [26144]], [[127514, 127514], "mapped", [28961]], [[127515, 127515], "mapped", [26009]], [[127516, 127516], "mapped", [21069]], [[127517, 127517], "mapped", [24460]], [[127518, 127518], "mapped", [20877]], [[127519, 127519], "mapped", [26032]], [[127520, 127520], "mapped", [21021]], [[127521, 127521], "mapped", [32066]], [[127522, 127522], "mapped", [29983]], [[127523, 127523], "mapped", [36009]], [[127524, 127524], "mapped", [22768]], [[127525, 127525], "mapped", [21561]], [[127526, 127526], "mapped", [28436]], [[127527, 127527], "mapped", [25237]], [[127528, 127528], "mapped", [25429]], [[127529, 127529], "mapped", [19968]], [[127530, 127530], "mapped", [19977]], [[127531, 127531], "mapped", [36938]], [[127532, 127532], "mapped", [24038]], [[127533, 127533], "mapped", [20013]], [[127534, 127534], "mapped", [21491]], [[127535, 127535], "mapped", [25351]], [[127536, 127536], "mapped", [36208]], [[127537, 127537], "mapped", [25171]], [[127538, 127538], "mapped", [31105]], [[127539, 127539], "mapped", [31354]], [[127540, 127540], "mapped", [21512]], [[127541, 127541], "mapped", [28288]], [[127542, 127542], "mapped", [26377]], [[127543, 127543], "mapped", [26376]], [[127544, 127544], "mapped", [30003]], [[127545, 127545], "mapped", [21106]], [[127546, 127546], "mapped", [21942]], [[127547, 127551], "disallowed"], [[127552, 127552], "mapped", [12308, 26412, 12309]], [[127553, 127553], "mapped", [12308, 19977, 12309]], [[127554, 127554], "mapped", [12308, 20108, 12309]], [[127555, 127555], "mapped", [12308, 23433, 12309]], [[127556, 127556], "mapped", [12308, 28857, 12309]], [[127557, 127557], "mapped", [12308, 25171, 12309]], [[127558, 127558], "mapped", [12308, 30423, 12309]], [[127559, 127559], "mapped", [12308, 21213, 12309]], [[127560, 127560], "mapped", [12308, 25943, 12309]], [[127561, 127567], "disallowed"], [[127568, 127568], "mapped", [24471]], [[127569, 127569], "mapped", [21487]], [[127570, 127743], "disallowed"], [[127744, 127776], "valid", [], "NV8"], [[127777, 127788], "valid", [], "NV8"], [[127789, 127791], "valid", [], "NV8"], [[127792, 127797], "valid", [], "NV8"], [[127798, 127798], "valid", [], "NV8"], [[127799, 127868], "valid", [], "NV8"], [[127869, 127869], "valid", [], "NV8"], [[127870, 127871], "valid", [], "NV8"], [[127872, 127891], "valid", [], "NV8"], [[127892, 127903], "valid", [], "NV8"], [[127904, 127940], "valid", [], "NV8"], [[127941, 127941], "valid", [], "NV8"], [[127942, 127946], "valid", [], "NV8"], [[127947, 127950], "valid", [], "NV8"], [[127951, 127955], "valid", [], "NV8"], [[127956, 127967], "valid", [], "NV8"], [[127968, 127984], "valid", [], "NV8"], [[127985, 127991], "valid", [], "NV8"], [[127992, 127999], "valid", [], "NV8"], [[128e3, 128062], "valid", [], "NV8"], [[128063, 128063], "valid", [], "NV8"], [[128064, 128064], "valid", [], "NV8"], [[128065, 128065], "valid", [], "NV8"], [[128066, 128247], "valid", [], "NV8"], [[128248, 128248], "valid", [], "NV8"], [[128249, 128252], "valid", [], "NV8"], [[128253, 128254], "valid", [], "NV8"], [[128255, 128255], "valid", [], "NV8"], [[128256, 128317], "valid", [], "NV8"], [[128318, 128319], "valid", [], "NV8"], [[128320, 128323], "valid", [], "NV8"], [[128324, 128330], "valid", [], "NV8"], [[128331, 128335], "valid", [], "NV8"], [[128336, 128359], "valid", [], "NV8"], [[128360, 128377], "valid", [], "NV8"], [[128378, 128378], "disallowed"], [[128379, 128419], "valid", [], "NV8"], [[128420, 128420], "disallowed"], [[128421, 128506], "valid", [], "NV8"], [[128507, 128511], "valid", [], "NV8"], [[128512, 128512], "valid", [], "NV8"], [[128513, 128528], "valid", [], "NV8"], [[128529, 128529], "valid", [], "NV8"], [[128530, 128532], "valid", [], "NV8"], [[128533, 128533], "valid", [], "NV8"], [[128534, 128534], "valid", [], "NV8"], [[128535, 128535], "valid", [], "NV8"], [[128536, 128536], "valid", [], "NV8"], [[128537, 128537], "valid", [], "NV8"], [[128538, 128538], "valid", [], "NV8"], [[128539, 128539], "valid", [], "NV8"], [[128540, 128542], "valid", [], "NV8"], [[128543, 128543], "valid", [], "NV8"], [[128544, 128549], "valid", [], "NV8"], [[128550, 128551], "valid", [], "NV8"], [[128552, 128555], "valid", [], "NV8"], [[128556, 128556], "valid", [], "NV8"], [[128557, 128557], "valid", [], "NV8"], [[128558, 128559], "valid", [], "NV8"], [[128560, 128563], "valid", [], "NV8"], [[128564, 128564], "valid", [], "NV8"], [[128565, 128576], "valid", [], "NV8"], [[128577, 128578], "valid", [], "NV8"], [[128579, 128580], "valid", [], "NV8"], [[128581, 128591], "valid", [], "NV8"], [[128592, 128639], "valid", [], "NV8"], [[128640, 128709], "valid", [], "NV8"], [[128710, 128719], "valid", [], "NV8"], [[128720, 128720], "valid", [], "NV8"], [[128721, 128735], "disallowed"], [[128736, 128748], "valid", [], "NV8"], [[128749, 128751], "disallowed"], [[128752, 128755], "valid", [], "NV8"], [[128756, 128767], "disallowed"], [[128768, 128883], "valid", [], "NV8"], [[128884, 128895], "disallowed"], [[128896, 128980], "valid", [], "NV8"], [[128981, 129023], "disallowed"], [[129024, 129035], "valid", [], "NV8"], [[129036, 129039], "disallowed"], [[129040, 129095], "valid", [], "NV8"], [[129096, 129103], "disallowed"], [[129104, 129113], "valid", [], "NV8"], [[129114, 129119], "disallowed"], [[129120, 129159], "valid", [], "NV8"], [[129160, 129167], "disallowed"], [[129168, 129197], "valid", [], "NV8"], [[129198, 129295], "disallowed"], [[129296, 129304], "valid", [], "NV8"], [[129305, 129407], "disallowed"], [[129408, 129412], "valid", [], "NV8"], [[129413, 129471], "disallowed"], [[129472, 129472], "valid", [], "NV8"], [[129473, 131069], "disallowed"], [[131070, 131071], "disallowed"], [[131072, 173782], "valid"], [[173783, 173823], "disallowed"], [[173824, 177972], "valid"], [[177973, 177983], "disallowed"], [[177984, 178205], "valid"], [[178206, 178207], "disallowed"], [[178208, 183969], "valid"], [[183970, 194559], "disallowed"], [[194560, 194560], "mapped", [20029]], [[194561, 194561], "mapped", [20024]], [[194562, 194562], "mapped", [20033]], [[194563, 194563], "mapped", [131362]], [[194564, 194564], "mapped", [20320]], [[194565, 194565], "mapped", [20398]], [[194566, 194566], "mapped", [20411]], [[194567, 194567], "mapped", [20482]], [[194568, 194568], "mapped", [20602]], [[194569, 194569], "mapped", [20633]], [[194570, 194570], "mapped", [20711]], [[194571, 194571], "mapped", [20687]], [[194572, 194572], "mapped", [13470]], [[194573, 194573], "mapped", [132666]], [[194574, 194574], "mapped", [20813]], [[194575, 194575], "mapped", [20820]], [[194576, 194576], "mapped", [20836]], [[194577, 194577], "mapped", [20855]], [[194578, 194578], "mapped", [132380]], [[194579, 194579], "mapped", [13497]], [[194580, 194580], "mapped", [20839]], [[194581, 194581], "mapped", [20877]], [[194582, 194582], "mapped", [132427]], [[194583, 194583], "mapped", [20887]], [[194584, 194584], "mapped", [20900]], [[194585, 194585], "mapped", [20172]], [[194586, 194586], "mapped", [20908]], [[194587, 194587], "mapped", [20917]], [[194588, 194588], "mapped", [168415]], [[194589, 194589], "mapped", [20981]], [[194590, 194590], "mapped", [20995]], [[194591, 194591], "mapped", [13535]], [[194592, 194592], "mapped", [21051]], [[194593, 194593], "mapped", [21062]], [[194594, 194594], "mapped", [21106]], [[194595, 194595], "mapped", [21111]], [[194596, 194596], "mapped", [13589]], [[194597, 194597], "mapped", [21191]], [[194598, 194598], "mapped", [21193]], [[194599, 194599], "mapped", [21220]], [[194600, 194600], "mapped", [21242]], [[194601, 194601], "mapped", [21253]], [[194602, 194602], "mapped", [21254]], [[194603, 194603], "mapped", [21271]], [[194604, 194604], "mapped", [21321]], [[194605, 194605], "mapped", [21329]], [[194606, 194606], "mapped", [21338]], [[194607, 194607], "mapped", [21363]], [[194608, 194608], "mapped", [21373]], [[194609, 194611], "mapped", [21375]], [[194612, 194612], "mapped", [133676]], [[194613, 194613], "mapped", [28784]], [[194614, 194614], "mapped", [21450]], [[194615, 194615], "mapped", [21471]], [[194616, 194616], "mapped", [133987]], [[194617, 194617], "mapped", [21483]], [[194618, 194618], "mapped", [21489]], [[194619, 194619], "mapped", [21510]], [[194620, 194620], "mapped", [21662]], [[194621, 194621], "mapped", [21560]], [[194622, 194622], "mapped", [21576]], [[194623, 194623], "mapped", [21608]], [[194624, 194624], "mapped", [21666]], [[194625, 194625], "mapped", [21750]], [[194626, 194626], "mapped", [21776]], [[194627, 194627], "mapped", [21843]], [[194628, 194628], "mapped", [21859]], [[194629, 194630], "mapped", [21892]], [[194631, 194631], "mapped", [21913]], [[194632, 194632], "mapped", [21931]], [[194633, 194633], "mapped", [21939]], [[194634, 194634], "mapped", [21954]], [[194635, 194635], "mapped", [22294]], [[194636, 194636], "mapped", [22022]], [[194637, 194637], "mapped", [22295]], [[194638, 194638], "mapped", [22097]], [[194639, 194639], "mapped", [22132]], [[194640, 194640], "mapped", [20999]], [[194641, 194641], "mapped", [22766]], [[194642, 194642], "mapped", [22478]], [[194643, 194643], "mapped", [22516]], [[194644, 194644], "mapped", [22541]], [[194645, 194645], "mapped", [22411]], [[194646, 194646], "mapped", [22578]], [[194647, 194647], "mapped", [22577]], [[194648, 194648], "mapped", [22700]], [[194649, 194649], "mapped", [136420]], [[194650, 194650], "mapped", [22770]], [[194651, 194651], "mapped", [22775]], [[194652, 194652], "mapped", [22790]], [[194653, 194653], "mapped", [22810]], [[194654, 194654], "mapped", [22818]], [[194655, 194655], "mapped", [22882]], [[194656, 194656], "mapped", [136872]], [[194657, 194657], "mapped", [136938]], [[194658, 194658], "mapped", [23020]], [[194659, 194659], "mapped", [23067]], [[194660, 194660], "mapped", [23079]], [[194661, 194661], "mapped", [23e3]], [[194662, 194662], "mapped", [23142]], [[194663, 194663], "mapped", [14062]], [[194664, 194664], "disallowed"], [[194665, 194665], "mapped", [23304]], [[194666, 194667], "mapped", [23358]], [[194668, 194668], "mapped", [137672]], [[194669, 194669], "mapped", [23491]], [[194670, 194670], "mapped", [23512]], [[194671, 194671], "mapped", [23527]], [[194672, 194672], "mapped", [23539]], [[194673, 194673], "mapped", [138008]], [[194674, 194674], "mapped", [23551]], [[194675, 194675], "mapped", [23558]], [[194676, 194676], "disallowed"], [[194677, 194677], "mapped", [23586]], [[194678, 194678], "mapped", [14209]], [[194679, 194679], "mapped", [23648]], [[194680, 194680], "mapped", [23662]], [[194681, 194681], "mapped", [23744]], [[194682, 194682], "mapped", [23693]], [[194683, 194683], "mapped", [138724]], [[194684, 194684], "mapped", [23875]], [[194685, 194685], "mapped", [138726]], [[194686, 194686], "mapped", [23918]], [[194687, 194687], "mapped", [23915]], [[194688, 194688], "mapped", [23932]], [[194689, 194689], "mapped", [24033]], [[194690, 194690], "mapped", [24034]], [[194691, 194691], "mapped", [14383]], [[194692, 194692], "mapped", [24061]], [[194693, 194693], "mapped", [24104]], [[194694, 194694], "mapped", [24125]], [[194695, 194695], "mapped", [24169]], [[194696, 194696], "mapped", [14434]], [[194697, 194697], "mapped", [139651]], [[194698, 194698], "mapped", [14460]], [[194699, 194699], "mapped", [24240]], [[194700, 194700], "mapped", [24243]], [[194701, 194701], "mapped", [24246]], [[194702, 194702], "mapped", [24266]], [[194703, 194703], "mapped", [172946]], [[194704, 194704], "mapped", [24318]], [[194705, 194706], "mapped", [140081]], [[194707, 194707], "mapped", [33281]], [[194708, 194709], "mapped", [24354]], [[194710, 194710], "mapped", [14535]], [[194711, 194711], "mapped", [144056]], [[194712, 194712], "mapped", [156122]], [[194713, 194713], "mapped", [24418]], [[194714, 194714], "mapped", [24427]], [[194715, 194715], "mapped", [14563]], [[194716, 194716], "mapped", [24474]], [[194717, 194717], "mapped", [24525]], [[194718, 194718], "mapped", [24535]], [[194719, 194719], "mapped", [24569]], [[194720, 194720], "mapped", [24705]], [[194721, 194721], "mapped", [14650]], [[194722, 194722], "mapped", [14620]], [[194723, 194723], "mapped", [24724]], [[194724, 194724], "mapped", [141012]], [[194725, 194725], "mapped", [24775]], [[194726, 194726], "mapped", [24904]], [[194727, 194727], "mapped", [24908]], [[194728, 194728], "mapped", [24910]], [[194729, 194729], "mapped", [24908]], [[194730, 194730], "mapped", [24954]], [[194731, 194731], "mapped", [24974]], [[194732, 194732], "mapped", [25010]], [[194733, 194733], "mapped", [24996]], [[194734, 194734], "mapped", [25007]], [[194735, 194735], "mapped", [25054]], [[194736, 194736], "mapped", [25074]], [[194737, 194737], "mapped", [25078]], [[194738, 194738], "mapped", [25104]], [[194739, 194739], "mapped", [25115]], [[194740, 194740], "mapped", [25181]], [[194741, 194741], "mapped", [25265]], [[194742, 194742], "mapped", [25300]], [[194743, 194743], "mapped", [25424]], [[194744, 194744], "mapped", [142092]], [[194745, 194745], "mapped", [25405]], [[194746, 194746], "mapped", [25340]], [[194747, 194747], "mapped", [25448]], [[194748, 194748], "mapped", [25475]], [[194749, 194749], "mapped", [25572]], [[194750, 194750], "mapped", [142321]], [[194751, 194751], "mapped", [25634]], [[194752, 194752], "mapped", [25541]], [[194753, 194753], "mapped", [25513]], [[194754, 194754], "mapped", [14894]], [[194755, 194755], "mapped", [25705]], [[194756, 194756], "mapped", [25726]], [[194757, 194757], "mapped", [25757]], [[194758, 194758], "mapped", [25719]], [[194759, 194759], "mapped", [14956]], [[194760, 194760], "mapped", [25935]], [[194761, 194761], "mapped", [25964]], [[194762, 194762], "mapped", [143370]], [[194763, 194763], "mapped", [26083]], [[194764, 194764], "mapped", [26360]], [[194765, 194765], "mapped", [26185]], [[194766, 194766], "mapped", [15129]], [[194767, 194767], "mapped", [26257]], [[194768, 194768], "mapped", [15112]], [[194769, 194769], "mapped", [15076]], [[194770, 194770], "mapped", [20882]], [[194771, 194771], "mapped", [20885]], [[194772, 194772], "mapped", [26368]], [[194773, 194773], "mapped", [26268]], [[194774, 194774], "mapped", [32941]], [[194775, 194775], "mapped", [17369]], [[194776, 194776], "mapped", [26391]], [[194777, 194777], "mapped", [26395]], [[194778, 194778], "mapped", [26401]], [[194779, 194779], "mapped", [26462]], [[194780, 194780], "mapped", [26451]], [[194781, 194781], "mapped", [144323]], [[194782, 194782], "mapped", [15177]], [[194783, 194783], "mapped", [26618]], [[194784, 194784], "mapped", [26501]], [[194785, 194785], "mapped", [26706]], [[194786, 194786], "mapped", [26757]], [[194787, 194787], "mapped", [144493]], [[194788, 194788], "mapped", [26766]], [[194789, 194789], "mapped", [26655]], [[194790, 194790], "mapped", [26900]], [[194791, 194791], "mapped", [15261]], [[194792, 194792], "mapped", [26946]], [[194793, 194793], "mapped", [27043]], [[194794, 194794], "mapped", [27114]], [[194795, 194795], "mapped", [27304]], [[194796, 194796], "mapped", [145059]], [[194797, 194797], "mapped", [27355]], [[194798, 194798], "mapped", [15384]], [[194799, 194799], "mapped", [27425]], [[194800, 194800], "mapped", [145575]], [[194801, 194801], "mapped", [27476]], [[194802, 194802], "mapped", [15438]], [[194803, 194803], "mapped", [27506]], [[194804, 194804], "mapped", [27551]], [[194805, 194805], "mapped", [27578]], [[194806, 194806], "mapped", [27579]], [[194807, 194807], "mapped", [146061]], [[194808, 194808], "mapped", [138507]], [[194809, 194809], "mapped", [146170]], [[194810, 194810], "mapped", [27726]], [[194811, 194811], "mapped", [146620]], [[194812, 194812], "mapped", [27839]], [[194813, 194813], "mapped", [27853]], [[194814, 194814], "mapped", [27751]], [[194815, 194815], "mapped", [27926]], [[194816, 194816], "mapped", [27966]], [[194817, 194817], "mapped", [28023]], [[194818, 194818], "mapped", [27969]], [[194819, 194819], "mapped", [28009]], [[194820, 194820], "mapped", [28024]], [[194821, 194821], "mapped", [28037]], [[194822, 194822], "mapped", [146718]], [[194823, 194823], "mapped", [27956]], [[194824, 194824], "mapped", [28207]], [[194825, 194825], "mapped", [28270]], [[194826, 194826], "mapped", [15667]], [[194827, 194827], "mapped", [28363]], [[194828, 194828], "mapped", [28359]], [[194829, 194829], "mapped", [147153]], [[194830, 194830], "mapped", [28153]], [[194831, 194831], "mapped", [28526]], [[194832, 194832], "mapped", [147294]], [[194833, 194833], "mapped", [147342]], [[194834, 194834], "mapped", [28614]], [[194835, 194835], "mapped", [28729]], [[194836, 194836], "mapped", [28702]], [[194837, 194837], "mapped", [28699]], [[194838, 194838], "mapped", [15766]], [[194839, 194839], "mapped", [28746]], [[194840, 194840], "mapped", [28797]], [[194841, 194841], "mapped", [28791]], [[194842, 194842], "mapped", [28845]], [[194843, 194843], "mapped", [132389]], [[194844, 194844], "mapped", [28997]], [[194845, 194845], "mapped", [148067]], [[194846, 194846], "mapped", [29084]], [[194847, 194847], "disallowed"], [[194848, 194848], "mapped", [29224]], [[194849, 194849], "mapped", [29237]], [[194850, 194850], "mapped", [29264]], [[194851, 194851], "mapped", [149e3]], [[194852, 194852], "mapped", [29312]], [[194853, 194853], "mapped", [29333]], [[194854, 194854], "mapped", [149301]], [[194855, 194855], "mapped", [149524]], [[194856, 194856], "mapped", [29562]], [[194857, 194857], "mapped", [29579]], [[194858, 194858], "mapped", [16044]], [[194859, 194859], "mapped", [29605]], [[194860, 194861], "mapped", [16056]], [[194862, 194862], "mapped", [29767]], [[194863, 194863], "mapped", [29788]], [[194864, 194864], "mapped", [29809]], [[194865, 194865], "mapped", [29829]], [[194866, 194866], "mapped", [29898]], [[194867, 194867], "mapped", [16155]], [[194868, 194868], "mapped", [29988]], [[194869, 194869], "mapped", [150582]], [[194870, 194870], "mapped", [30014]], [[194871, 194871], "mapped", [150674]], [[194872, 194872], "mapped", [30064]], [[194873, 194873], "mapped", [139679]], [[194874, 194874], "mapped", [30224]], [[194875, 194875], "mapped", [151457]], [[194876, 194876], "mapped", [151480]], [[194877, 194877], "mapped", [151620]], [[194878, 194878], "mapped", [16380]], [[194879, 194879], "mapped", [16392]], [[194880, 194880], "mapped", [30452]], [[194881, 194881], "mapped", [151795]], [[194882, 194882], "mapped", [151794]], [[194883, 194883], "mapped", [151833]], [[194884, 194884], "mapped", [151859]], [[194885, 194885], "mapped", [30494]], [[194886, 194887], "mapped", [30495]], [[194888, 194888], "mapped", [30538]], [[194889, 194889], "mapped", [16441]], [[194890, 194890], "mapped", [30603]], [[194891, 194891], "mapped", [16454]], [[194892, 194892], "mapped", [16534]], [[194893, 194893], "mapped", [152605]], [[194894, 194894], "mapped", [30798]], [[194895, 194895], "mapped", [30860]], [[194896, 194896], "mapped", [30924]], [[194897, 194897], "mapped", [16611]], [[194898, 194898], "mapped", [153126]], [[194899, 194899], "mapped", [31062]], [[194900, 194900], "mapped", [153242]], [[194901, 194901], "mapped", [153285]], [[194902, 194902], "mapped", [31119]], [[194903, 194903], "mapped", [31211]], [[194904, 194904], "mapped", [16687]], [[194905, 194905], "mapped", [31296]], [[194906, 194906], "mapped", [31306]], [[194907, 194907], "mapped", [31311]], [[194908, 194908], "mapped", [153980]], [[194909, 194910], "mapped", [154279]], [[194911, 194911], "disallowed"], [[194912, 194912], "mapped", [16898]], [[194913, 194913], "mapped", [154539]], [[194914, 194914], "mapped", [31686]], [[194915, 194915], "mapped", [31689]], [[194916, 194916], "mapped", [16935]], [[194917, 194917], "mapped", [154752]], [[194918, 194918], "mapped", [31954]], [[194919, 194919], "mapped", [17056]], [[194920, 194920], "mapped", [31976]], [[194921, 194921], "mapped", [31971]], [[194922, 194922], "mapped", [32e3]], [[194923, 194923], "mapped", [155526]], [[194924, 194924], "mapped", [32099]], [[194925, 194925], "mapped", [17153]], [[194926, 194926], "mapped", [32199]], [[194927, 194927], "mapped", [32258]], [[194928, 194928], "mapped", [32325]], [[194929, 194929], "mapped", [17204]], [[194930, 194930], "mapped", [156200]], [[194931, 194931], "mapped", [156231]], [[194932, 194932], "mapped", [17241]], [[194933, 194933], "mapped", [156377]], [[194934, 194934], "mapped", [32634]], [[194935, 194935], "mapped", [156478]], [[194936, 194936], "mapped", [32661]], [[194937, 194937], "mapped", [32762]], [[194938, 194938], "mapped", [32773]], [[194939, 194939], "mapped", [156890]], [[194940, 194940], "mapped", [156963]], [[194941, 194941], "mapped", [32864]], [[194942, 194942], "mapped", [157096]], [[194943, 194943], "mapped", [32880]], [[194944, 194944], "mapped", [144223]], [[194945, 194945], "mapped", [17365]], [[194946, 194946], "mapped", [32946]], [[194947, 194947], "mapped", [33027]], [[194948, 194948], "mapped", [17419]], [[194949, 194949], "mapped", [33086]], [[194950, 194950], "mapped", [23221]], [[194951, 194951], "mapped", [157607]], [[194952, 194952], "mapped", [157621]], [[194953, 194953], "mapped", [144275]], [[194954, 194954], "mapped", [144284]], [[194955, 194955], "mapped", [33281]], [[194956, 194956], "mapped", [33284]], [[194957, 194957], "mapped", [36766]], [[194958, 194958], "mapped", [17515]], [[194959, 194959], "mapped", [33425]], [[194960, 194960], "mapped", [33419]], [[194961, 194961], "mapped", [33437]], [[194962, 194962], "mapped", [21171]], [[194963, 194963], "mapped", [33457]], [[194964, 194964], "mapped", [33459]], [[194965, 194965], "mapped", [33469]], [[194966, 194966], "mapped", [33510]], [[194967, 194967], "mapped", [158524]], [[194968, 194968], "mapped", [33509]], [[194969, 194969], "mapped", [33565]], [[194970, 194970], "mapped", [33635]], [[194971, 194971], "mapped", [33709]], [[194972, 194972], "mapped", [33571]], [[194973, 194973], "mapped", [33725]], [[194974, 194974], "mapped", [33767]], [[194975, 194975], "mapped", [33879]], [[194976, 194976], "mapped", [33619]], [[194977, 194977], "mapped", [33738]], [[194978, 194978], "mapped", [33740]], [[194979, 194979], "mapped", [33756]], [[194980, 194980], "mapped", [158774]], [[194981, 194981], "mapped", [159083]], [[194982, 194982], "mapped", [158933]], [[194983, 194983], "mapped", [17707]], [[194984, 194984], "mapped", [34033]], [[194985, 194985], "mapped", [34035]], [[194986, 194986], "mapped", [34070]], [[194987, 194987], "mapped", [160714]], [[194988, 194988], "mapped", [34148]], [[194989, 194989], "mapped", [159532]], [[194990, 194990], "mapped", [17757]], [[194991, 194991], "mapped", [17761]], [[194992, 194992], "mapped", [159665]], [[194993, 194993], "mapped", [159954]], [[194994, 194994], "mapped", [17771]], [[194995, 194995], "mapped", [34384]], [[194996, 194996], "mapped", [34396]], [[194997, 194997], "mapped", [34407]], [[194998, 194998], "mapped", [34409]], [[194999, 194999], "mapped", [34473]], [[195e3, 195e3], "mapped", [34440]], [[195001, 195001], "mapped", [34574]], [[195002, 195002], "mapped", [34530]], [[195003, 195003], "mapped", [34681]], [[195004, 195004], "mapped", [34600]], [[195005, 195005], "mapped", [34667]], [[195006, 195006], "mapped", [34694]], [[195007, 195007], "disallowed"], [[195008, 195008], "mapped", [34785]], [[195009, 195009], "mapped", [34817]], [[195010, 195010], "mapped", [17913]], [[195011, 195011], "mapped", [34912]], [[195012, 195012], "mapped", [34915]], [[195013, 195013], "mapped", [161383]], [[195014, 195014], "mapped", [35031]], [[195015, 195015], "mapped", [35038]], [[195016, 195016], "mapped", [17973]], [[195017, 195017], "mapped", [35066]], [[195018, 195018], "mapped", [13499]], [[195019, 195019], "mapped", [161966]], [[195020, 195020], "mapped", [162150]], [[195021, 195021], "mapped", [18110]], [[195022, 195022], "mapped", [18119]], [[195023, 195023], "mapped", [35488]], [[195024, 195024], "mapped", [35565]], [[195025, 195025], "mapped", [35722]], [[195026, 195026], "mapped", [35925]], [[195027, 195027], "mapped", [162984]], [[195028, 195028], "mapped", [36011]], [[195029, 195029], "mapped", [36033]], [[195030, 195030], "mapped", [36123]], [[195031, 195031], "mapped", [36215]], [[195032, 195032], "mapped", [163631]], [[195033, 195033], "mapped", [133124]], [[195034, 195034], "mapped", [36299]], [[195035, 195035], "mapped", [36284]], [[195036, 195036], "mapped", [36336]], [[195037, 195037], "mapped", [133342]], [[195038, 195038], "mapped", [36564]], [[195039, 195039], "mapped", [36664]], [[195040, 195040], "mapped", [165330]], [[195041, 195041], "mapped", [165357]], [[195042, 195042], "mapped", [37012]], [[195043, 195043], "mapped", [37105]], [[195044, 195044], "mapped", [37137]], [[195045, 195045], "mapped", [165678]], [[195046, 195046], "mapped", [37147]], [[195047, 195047], "mapped", [37432]], [[195048, 195048], "mapped", [37591]], [[195049, 195049], "mapped", [37592]], [[195050, 195050], "mapped", [37500]], [[195051, 195051], "mapped", [37881]], [[195052, 195052], "mapped", [37909]], [[195053, 195053], "mapped", [166906]], [[195054, 195054], "mapped", [38283]], [[195055, 195055], "mapped", [18837]], [[195056, 195056], "mapped", [38327]], [[195057, 195057], "mapped", [167287]], [[195058, 195058], "mapped", [18918]], [[195059, 195059], "mapped", [38595]], [[195060, 195060], "mapped", [23986]], [[195061, 195061], "mapped", [38691]], [[195062, 195062], "mapped", [168261]], [[195063, 195063], "mapped", [168474]], [[195064, 195064], "mapped", [19054]], [[195065, 195065], "mapped", [19062]], [[195066, 195066], "mapped", [38880]], [[195067, 195067], "mapped", [168970]], [[195068, 195068], "mapped", [19122]], [[195069, 195069], "mapped", [169110]], [[195070, 195071], "mapped", [38923]], [[195072, 195072], "mapped", [38953]], [[195073, 195073], "mapped", [169398]], [[195074, 195074], "mapped", [39138]], [[195075, 195075], "mapped", [19251]], [[195076, 195076], "mapped", [39209]], [[195077, 195077], "mapped", [39335]], [[195078, 195078], "mapped", [39362]], [[195079, 195079], "mapped", [39422]], [[195080, 195080], "mapped", [19406]], [[195081, 195081], "mapped", [170800]], [[195082, 195082], "mapped", [39698]], [[195083, 195083], "mapped", [4e4]], [[195084, 195084], "mapped", [40189]], [[195085, 195085], "mapped", [19662]], [[195086, 195086], "mapped", [19693]], [[195087, 195087], "mapped", [40295]], [[195088, 195088], "mapped", [172238]], [[195089, 195089], "mapped", [19704]], [[195090, 195090], "mapped", [172293]], [[195091, 195091], "mapped", [172558]], [[195092, 195092], "mapped", [172689]], [[195093, 195093], "mapped", [40635]], [[195094, 195094], "mapped", [19798]], [[195095, 195095], "mapped", [40697]], [[195096, 195096], "mapped", [40702]], [[195097, 195097], "mapped", [40709]], [[195098, 195098], "mapped", [40719]], [[195099, 195099], "mapped", [40726]], [[195100, 195100], "mapped", [40763]], [[195101, 195101], "mapped", [173568]], [[195102, 196605], "disallowed"], [[196606, 196607], "disallowed"], [[196608, 262141], "disallowed"], [[262142, 262143], "disallowed"], [[262144, 327677], "disallowed"], [[327678, 327679], "disallowed"], [[327680, 393213], "disallowed"], [[393214, 393215], "disallowed"], [[393216, 458749], "disallowed"], [[458750, 458751], "disallowed"], [[458752, 524285], "disallowed"], [[524286, 524287], "disallowed"], [[524288, 589821], "disallowed"], [[589822, 589823], "disallowed"], [[589824, 655357], "disallowed"], [[655358, 655359], "disallowed"], [[655360, 720893], "disallowed"], [[720894, 720895], "disallowed"], [[720896, 786429], "disallowed"], [[786430, 786431], "disallowed"], [[786432, 851965], "disallowed"], [[851966, 851967], "disallowed"], [[851968, 917501], "disallowed"], [[917502, 917503], "disallowed"], [[917504, 917504], "disallowed"], [[917505, 917505], "disallowed"], [[917506, 917535], "disallowed"], [[917536, 917631], "disallowed"], [[917632, 917759], "disallowed"], [[917760, 917999], "ignored"], [[918e3, 983037], "disallowed"], [[983038, 983039], "disallowed"], [[983040, 1048573], "disallowed"], [[1048574, 1048575], "disallowed"], [[1048576, 1114109], "disallowed"], [[1114110, 1114111], "disallowed"]]; + } +}); + +// node_modules/tr46/index.js +var require_tr46 = __commonJS({ + "node_modules/tr46/index.js"(exports, module) { + "use strict"; + var punycode = __require("punycode"); + var mappingTable = require_mappingTable(); + var PROCESSING_OPTIONS = { + TRANSITIONAL: 0, + NONTRANSITIONAL: 1 + }; + function normalize(str2) { + return str2.split("\0").map(function(s) { + return s.normalize("NFC"); + }).join("\0"); + } + function findStatus(val) { + var start = 0; + var end = mappingTable.length - 1; + while (start <= end) { + var mid = Math.floor((start + end) / 2); + var target = mappingTable[mid]; + if (target[0][0] <= val && target[0][1] >= val) { + return target; + } else if (target[0][0] > val) { + end = mid - 1; + } else { + start = mid + 1; + } + } + return null; + } + var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + function countSymbols(string) { + return string.replace(regexAstralSymbols, "_").length; + } + function mapChars(domain_name, useSTD3, processing_option) { + var hasError = false; + var processed = ""; + var len = countSymbols(domain_name); + for (var i = 0; i < len; ++i) { + var codePoint = domain_name.codePointAt(i); + var status = findStatus(codePoint); + switch (status[1]) { + case "disallowed": + hasError = true; + processed += String.fromCodePoint(codePoint); + break; + case "ignored": + break; + case "mapped": + processed += String.fromCodePoint.apply(String, status[2]); + break; + case "deviation": + if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL) { + processed += String.fromCodePoint.apply(String, status[2]); + } else { + processed += String.fromCodePoint(codePoint); + } + break; + case "valid": + processed += String.fromCodePoint(codePoint); + break; + case "disallowed_STD3_mapped": + if (useSTD3) { + hasError = true; + processed += String.fromCodePoint(codePoint); + } else { + processed += String.fromCodePoint.apply(String, status[2]); + } + break; + case "disallowed_STD3_valid": + if (useSTD3) { + hasError = true; + } + processed += String.fromCodePoint(codePoint); + break; + } + } + return { + string: processed, + error: hasError + }; + } + var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/; + function validateLabel(label, processing_option) { + if (label.substr(0, 4) === "xn--") { + label = punycode.toUnicode(label); + processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL; + } + var error2 = false; + if (normalize(label) !== label || label[3] === "-" && label[4] === "-" || label[0] === "-" || label[label.length - 1] === "-" || label.indexOf(".") !== -1 || label.search(combiningMarksRegex) === 0) { + error2 = true; + } + var len = countSymbols(label); + for (var i = 0; i < len; ++i) { + var status = findStatus(label.codePointAt(i)); + if (processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid" || processing === PROCESSING_OPTIONS.NONTRANSITIONAL && status[1] !== "valid" && status[1] !== "deviation") { + error2 = true; + break; + } + } + return { + label, + error: error2 + }; + } + function processing(domain_name, useSTD3, processing_option) { + var result = mapChars(domain_name, useSTD3, processing_option); + result.string = normalize(result.string); + var labels = result.string.split("."); + for (var i = 0; i < labels.length; ++i) { + try { + var validation = validateLabel(labels[i]); + labels[i] = validation.label; + result.error = result.error || validation.error; + } catch (e2) { + result.error = true; + } + } + return { + string: labels.join("."), + error: result.error + }; + } + module.exports.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) { + var result = processing(domain_name, useSTD3, processing_option); + var labels = result.string.split("."); + labels = labels.map(function(l) { + try { + return punycode.toASCII(l); + } catch (e2) { + result.error = true; + return l; + } + }); + if (verifyDnsLength) { + var total = labels.slice(0, labels.length - 1).join(".").length; + if (total.length > 253 || total.length === 0) { + result.error = true; + } + for (var i = 0; i < labels.length; ++i) { + if (labels.length > 63 || labels.length === 0) { + result.error = true; + break; + } + } + } + if (result.error) return null; + return labels.join("."); + }; + module.exports.toUnicode = function(domain_name, useSTD3) { + var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL); + return { + domain: result.string, + error: result.error + }; + }; + module.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS; + } +}); + +// node_modules/whatwg-url/lib/url-state-machine.js +var require_url_state_machine = __commonJS({ + "node_modules/whatwg-url/lib/url-state-machine.js"(exports, module) { + "use strict"; + var punycode = __require("punycode"); + var tr46 = require_tr46(); + var specialSchemes = { + ftp: 21, + file: null, + gopher: 70, + http: 80, + https: 443, + ws: 80, + wss: 443 + }; + var failure = /* @__PURE__ */ Symbol("failure"); + function countSymbols(str2) { + return punycode.ucs2.decode(str2).length; + } + function at(input, idx) { + const c = input[idx]; + return isNaN(c) ? void 0 : String.fromCodePoint(c); + } + function isASCIIDigit(c) { + return c >= 48 && c <= 57; + } + function isASCIIAlpha(c) { + return c >= 65 && c <= 90 || c >= 97 && c <= 122; + } + function isASCIIAlphanumeric(c) { + return isASCIIAlpha(c) || isASCIIDigit(c); + } + function isASCIIHex(c) { + return isASCIIDigit(c) || c >= 65 && c <= 70 || c >= 97 && c <= 102; + } + function isSingleDot(buffer) { + return buffer === "." || buffer.toLowerCase() === "%2e"; + } + function isDoubleDot(buffer) { + buffer = buffer.toLowerCase(); + return buffer === ".." || buffer === "%2e." || buffer === ".%2e" || buffer === "%2e%2e"; + } + function isWindowsDriveLetterCodePoints(cp1, cp2) { + return isASCIIAlpha(cp1) && (cp2 === 58 || cp2 === 124); + } + function isWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && (string[1] === ":" || string[1] === "|"); + } + function isNormalizedWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && string[1] === ":"; + } + function containsForbiddenHostCodePoint(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|%|\/|:|\?|@|\[|\\|\]/) !== -1; + } + function containsForbiddenHostCodePointExcludingPercent(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|\/|:|\?|@|\[|\\|\]/) !== -1; + } + function isSpecialScheme(scheme) { + return specialSchemes[scheme] !== void 0; + } + function isSpecial(url) { + return isSpecialScheme(url.scheme); + } + function defaultPort(scheme) { + return specialSchemes[scheme]; + } + function percentEncode(c) { + let hex = c.toString(16).toUpperCase(); + if (hex.length === 1) { + hex = "0" + hex; + } + return "%" + hex; + } + function utf8PercentEncode(c) { + const buf2 = new Buffer(c); + let str2 = ""; + for (let i = 0; i < buf2.length; ++i) { + str2 += percentEncode(buf2[i]); + } + return str2; + } + function utf8PercentDecode(str2) { + const input = new Buffer(str2); + const output = []; + for (let i = 0; i < input.length; ++i) { + if (input[i] !== 37) { + output.push(input[i]); + } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) { + output.push(parseInt(input.slice(i + 1, i + 3).toString(), 16)); + i += 2; + } else { + output.push(input[i]); + } + } + return new Buffer(output).toString(); + } + function isC0ControlPercentEncode(c) { + return c <= 31 || c > 126; + } + var extraPathPercentEncodeSet = /* @__PURE__ */ new Set([32, 34, 35, 60, 62, 63, 96, 123, 125]); + function isPathPercentEncode(c) { + return isC0ControlPercentEncode(c) || extraPathPercentEncodeSet.has(c); + } + var extraUserinfoPercentEncodeSet = /* @__PURE__ */ new Set([47, 58, 59, 61, 64, 91, 92, 93, 94, 124]); + function isUserinfoPercentEncode(c) { + return isPathPercentEncode(c) || extraUserinfoPercentEncodeSet.has(c); + } + function percentEncodeChar(c, encodeSetPredicate) { + const cStr = String.fromCodePoint(c); + if (encodeSetPredicate(c)) { + return utf8PercentEncode(cStr); + } + return cStr; + } + function parseIPv4Number(input) { + let R = 10; + if (input.length >= 2 && input.charAt(0) === "0" && input.charAt(1).toLowerCase() === "x") { + input = input.substring(2); + R = 16; + } else if (input.length >= 2 && input.charAt(0) === "0") { + input = input.substring(1); + R = 8; + } + if (input === "") { + return 0; + } + const regex = R === 10 ? /[^0-9]/ : R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/; + if (regex.test(input)) { + return failure; + } + return parseInt(input, R); + } + function parseIPv4(input) { + const parts = input.split("."); + if (parts[parts.length - 1] === "") { + if (parts.length > 1) { + parts.pop(); + } + } + if (parts.length > 4) { + return input; + } + const numbers = []; + for (const part of parts) { + if (part === "") { + return input; + } + const n = parseIPv4Number(part); + if (n === failure) { + return input; + } + numbers.push(n); + } + for (let i = 0; i < numbers.length - 1; ++i) { + if (numbers[i] > 255) { + return failure; + } + } + if (numbers[numbers.length - 1] >= Math.pow(256, 5 - numbers.length)) { + return failure; + } + let ipv4 = numbers.pop(); + let counter = 0; + for (const n of numbers) { + ipv4 += n * Math.pow(256, 3 - counter); + ++counter; + } + return ipv4; + } + function serializeIPv4(address) { + let output = ""; + let n = address; + for (let i = 1; i <= 4; ++i) { + output = String(n % 256) + output; + if (i !== 4) { + output = "." + output; + } + n = Math.floor(n / 256); + } + return output; + } + function parseIPv6(input) { + const address = [0, 0, 0, 0, 0, 0, 0, 0]; + let pieceIndex = 0; + let compress = null; + let pointer = 0; + input = punycode.ucs2.decode(input); + if (input[pointer] === 58) { + if (input[pointer + 1] !== 58) { + return failure; + } + pointer += 2; + ++pieceIndex; + compress = pieceIndex; + } + while (pointer < input.length) { + if (pieceIndex === 8) { + return failure; + } + if (input[pointer] === 58) { + if (compress !== null) { + return failure; + } + ++pointer; + ++pieceIndex; + compress = pieceIndex; + continue; + } + let value = 0; + let length = 0; + while (length < 4 && isASCIIHex(input[pointer])) { + value = value * 16 + parseInt(at(input, pointer), 16); + ++pointer; + ++length; + } + if (input[pointer] === 46) { + if (length === 0) { + return failure; + } + pointer -= length; + if (pieceIndex > 6) { + return failure; + } + let numbersSeen = 0; + while (input[pointer] !== void 0) { + let ipv4Piece = null; + if (numbersSeen > 0) { + if (input[pointer] === 46 && numbersSeen < 4) { + ++pointer; + } else { + return failure; + } + } + if (!isASCIIDigit(input[pointer])) { + return failure; + } + while (isASCIIDigit(input[pointer])) { + const number = parseInt(at(input, pointer)); + if (ipv4Piece === null) { + ipv4Piece = number; + } else if (ipv4Piece === 0) { + return failure; + } else { + ipv4Piece = ipv4Piece * 10 + number; + } + if (ipv4Piece > 255) { + return failure; + } + ++pointer; + } + address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; + ++numbersSeen; + if (numbersSeen === 2 || numbersSeen === 4) { + ++pieceIndex; + } + } + if (numbersSeen !== 4) { + return failure; + } + break; + } else if (input[pointer] === 58) { + ++pointer; + if (input[pointer] === void 0) { + return failure; + } + } else if (input[pointer] !== void 0) { + return failure; + } + address[pieceIndex] = value; + ++pieceIndex; + } + if (compress !== null) { + let swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex !== 0 && swaps > 0) { + const temp = address[compress + swaps - 1]; + address[compress + swaps - 1] = address[pieceIndex]; + address[pieceIndex] = temp; + --pieceIndex; + --swaps; + } + } else if (compress === null && pieceIndex !== 8) { + return failure; + } + return address; + } + function serializeIPv6(address) { + let output = ""; + const seqResult = findLongestZeroSequence(address); + const compress = seqResult.idx; + let ignore0 = false; + for (let pieceIndex = 0; pieceIndex <= 7; ++pieceIndex) { + if (ignore0 && address[pieceIndex] === 0) { + continue; + } else if (ignore0) { + ignore0 = false; + } + if (compress === pieceIndex) { + const separator = pieceIndex === 0 ? "::" : ":"; + output += separator; + ignore0 = true; + continue; + } + output += address[pieceIndex].toString(16); + if (pieceIndex !== 7) { + output += ":"; + } + } + return output; + } + function parseHost(input, isSpecialArg) { + if (input[0] === "[") { + if (input[input.length - 1] !== "]") { + return failure; + } + return parseIPv6(input.substring(1, input.length - 1)); + } + if (!isSpecialArg) { + return parseOpaqueHost(input); + } + const domain = utf8PercentDecode(input); + const asciiDomain = tr46.toASCII(domain, false, tr46.PROCESSING_OPTIONS.NONTRANSITIONAL, false); + if (asciiDomain === null) { + return failure; + } + if (containsForbiddenHostCodePoint(asciiDomain)) { + return failure; + } + const ipv4Host = parseIPv4(asciiDomain); + if (typeof ipv4Host === "number" || ipv4Host === failure) { + return ipv4Host; + } + return asciiDomain; + } + function parseOpaqueHost(input) { + if (containsForbiddenHostCodePointExcludingPercent(input)) { + return failure; + } + let output = ""; + const decoded = punycode.ucs2.decode(input); + for (let i = 0; i < decoded.length; ++i) { + output += percentEncodeChar(decoded[i], isC0ControlPercentEncode); + } + return output; + } + function findLongestZeroSequence(arr) { + let maxIdx = null; + let maxLen = 1; + let currStart = null; + let currLen = 0; + for (let i = 0; i < arr.length; ++i) { + if (arr[i] !== 0) { + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + currStart = null; + currLen = 0; + } else { + if (currStart === null) { + currStart = i; + } + ++currLen; + } + } + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + return { + idx: maxIdx, + len: maxLen + }; + } + function serializeHost(host) { + if (typeof host === "number") { + return serializeIPv4(host); + } + if (host instanceof Array) { + return "[" + serializeIPv6(host) + "]"; + } + return host; + } + function trimControlChars(url) { + return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, ""); + } + function trimTabAndNewline(url) { + return url.replace(/\u0009|\u000A|\u000D/g, ""); + } + function shortenPath(url) { + const path7 = url.path; + if (path7.length === 0) { + return; + } + if (url.scheme === "file" && path7.length === 1 && isNormalizedWindowsDriveLetter(path7[0])) { + return; + } + path7.pop(); + } + function includesCredentials(url) { + return url.username !== "" || url.password !== ""; + } + function cannotHaveAUsernamePasswordPort(url) { + return url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file"; + } + function isNormalizedWindowsDriveLetter(string) { + return /^[A-Za-z]:$/.test(string); + } + function URLStateMachine(input, base, encodingOverride, url, stateOverride) { + this.pointer = 0; + this.input = input; + this.base = base || null; + this.encodingOverride = encodingOverride || "utf-8"; + this.stateOverride = stateOverride; + this.url = url; + this.failure = false; + this.parseError = false; + if (!this.url) { + this.url = { + scheme: "", + username: "", + password: "", + host: null, + port: null, + path: [], + query: null, + fragment: null, + cannotBeABaseURL: false + }; + const res2 = trimControlChars(this.input); + if (res2 !== this.input) { + this.parseError = true; + } + this.input = res2; + } + const res = trimTabAndNewline(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + this.state = stateOverride || "scheme start"; + this.buffer = ""; + this.atFlag = false; + this.arrFlag = false; + this.passwordTokenSeenFlag = false; + this.input = punycode.ucs2.decode(this.input); + for (; this.pointer <= this.input.length; ++this.pointer) { + const c = this.input[this.pointer]; + const cStr = isNaN(c) ? void 0 : String.fromCodePoint(c); + const ret = this["parse " + this.state](c, cStr); + if (!ret) { + break; + } else if (ret === failure) { + this.failure = true; + break; + } + } + } + URLStateMachine.prototype["parse scheme start"] = function parseSchemeStart(c, cStr) { + if (isASCIIAlpha(c)) { + this.buffer += cStr.toLowerCase(); + this.state = "scheme"; + } else if (!this.stateOverride) { + this.state = "no scheme"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + return true; + }; + URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) { + if (isASCIIAlphanumeric(c) || c === 43 || c === 45 || c === 46) { + this.buffer += cStr.toLowerCase(); + } else if (c === 58) { + if (this.stateOverride) { + if (isSpecial(this.url) && !isSpecialScheme(this.buffer)) { + return false; + } + if (!isSpecial(this.url) && isSpecialScheme(this.buffer)) { + return false; + } + if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file") { + return false; + } + if (this.url.scheme === "file" && (this.url.host === "" || this.url.host === null)) { + return false; + } + } + this.url.scheme = this.buffer; + this.buffer = ""; + if (this.stateOverride) { + return false; + } + if (this.url.scheme === "file") { + if (this.input[this.pointer + 1] !== 47 || this.input[this.pointer + 2] !== 47) { + this.parseError = true; + } + this.state = "file"; + } else if (isSpecial(this.url) && this.base !== null && this.base.scheme === this.url.scheme) { + this.state = "special relative or authority"; + } else if (isSpecial(this.url)) { + this.state = "special authority slashes"; + } else if (this.input[this.pointer + 1] === 47) { + this.state = "path or authority"; + ++this.pointer; + } else { + this.url.cannotBeABaseURL = true; + this.url.path.push(""); + this.state = "cannot-be-a-base-URL path"; + } + } else if (!this.stateOverride) { + this.buffer = ""; + this.state = "no scheme"; + this.pointer = -1; + } else { + this.parseError = true; + return failure; + } + return true; + }; + URLStateMachine.prototype["parse no scheme"] = function parseNoScheme(c) { + if (this.base === null || this.base.cannotBeABaseURL && c !== 35) { + return failure; + } else if (this.base.cannotBeABaseURL && c === 35) { + this.url.scheme = this.base.scheme; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.url.cannotBeABaseURL = true; + this.state = "fragment"; + } else if (this.base.scheme === "file") { + this.state = "file"; + --this.pointer; + } else { + this.state = "relative"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special relative or authority"] = function parseSpecialRelativeOrAuthority(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "relative"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse path or authority"] = function parsePathOrAuthority(c) { + if (c === 47) { + this.state = "authority"; + } else { + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse relative"] = function parseRelative(c) { + this.url.scheme = this.base.scheme; + if (isNaN(c)) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 47) { + this.state = "relative slash"; + } else if (c === 63) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else if (isSpecial(this.url) && c === 92) { + this.parseError = true; + this.state = "relative slash"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(0, this.base.path.length - 1); + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse relative slash"] = function parseRelativeSlash(c) { + if (isSpecial(this.url) && (c === 47 || c === 92)) { + if (c === 92) { + this.parseError = true; + } + this.state = "special authority ignore slashes"; + } else if (c === 47) { + this.state = "authority"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special authority slashes"] = function parseSpecialAuthoritySlashes(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "special authority ignore slashes"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special authority ignore slashes"] = function parseSpecialAuthorityIgnoreSlashes(c) { + if (c !== 47 && c !== 92) { + this.state = "authority"; + --this.pointer; + } else { + this.parseError = true; + } + return true; + }; + URLStateMachine.prototype["parse authority"] = function parseAuthority(c, cStr) { + if (c === 64) { + this.parseError = true; + if (this.atFlag) { + this.buffer = "%40" + this.buffer; + } + this.atFlag = true; + const len = countSymbols(this.buffer); + for (let pointer = 0; pointer < len; ++pointer) { + const codePoint = this.buffer.codePointAt(pointer); + if (codePoint === 58 && !this.passwordTokenSeenFlag) { + this.passwordTokenSeenFlag = true; + continue; + } + const encodedCodePoints = percentEncodeChar(codePoint, isUserinfoPercentEncode); + if (this.passwordTokenSeenFlag) { + this.url.password += encodedCodePoints; + } else { + this.url.username += encodedCodePoints; + } + } + this.buffer = ""; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92) { + if (this.atFlag && this.buffer === "") { + this.parseError = true; + return failure; + } + this.pointer -= countSymbols(this.buffer) + 1; + this.buffer = ""; + this.state = "host"; + } else { + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse hostname"] = URLStateMachine.prototype["parse host"] = function parseHostName(c, cStr) { + if (this.stateOverride && this.url.scheme === "file") { + --this.pointer; + this.state = "file host"; + } else if (c === 58 && !this.arrFlag) { + if (this.buffer === "") { + this.parseError = true; + return failure; + } + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + this.url.host = host; + this.buffer = ""; + this.state = "port"; + if (this.stateOverride === "hostname") { + return false; + } + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92) { + --this.pointer; + if (isSpecial(this.url) && this.buffer === "") { + this.parseError = true; + return failure; + } else if (this.stateOverride && this.buffer === "" && (includesCredentials(this.url) || this.url.port !== null)) { + this.parseError = true; + return false; + } + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + this.url.host = host; + this.buffer = ""; + this.state = "path start"; + if (this.stateOverride) { + return false; + } + } else { + if (c === 91) { + this.arrFlag = true; + } else if (c === 93) { + this.arrFlag = false; + } + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) { + if (isASCIIDigit(c)) { + this.buffer += cStr; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92 || this.stateOverride) { + if (this.buffer !== "") { + const port = parseInt(this.buffer); + if (port > Math.pow(2, 16) - 1) { + this.parseError = true; + return failure; + } + this.url.port = port === defaultPort(this.url.scheme) ? null : port; + this.buffer = ""; + } + if (this.stateOverride) { + return false; + } + this.state = "path start"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + return true; + }; + var fileOtherwiseCodePoints = /* @__PURE__ */ new Set([47, 92, 63, 35]); + URLStateMachine.prototype["parse file"] = function parseFile(c) { + this.url.scheme = "file"; + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file slash"; + } else if (this.base !== null && this.base.scheme === "file") { + if (isNaN(c)) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 63) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else { + if (this.input.length - this.pointer - 1 === 0 || // remaining consists of 0 code points + !isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) || this.input.length - this.pointer - 1 >= 2 && // remaining has at least 2 code points + !fileOtherwiseCodePoints.has(this.input[this.pointer + 2])) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + shortenPath(this.url); + } else { + this.parseError = true; + } + this.state = "path"; + --this.pointer; + } + } else { + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) { + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file host"; + } else { + if (this.base !== null && this.base.scheme === "file") { + if (isNormalizedWindowsDriveLetterString(this.base.path[0])) { + this.url.path.push(this.base.path[0]); + } else { + this.url.host = this.base.host; + } + } + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse file host"] = function parseFileHost(c, cStr) { + if (isNaN(c) || c === 47 || c === 92 || c === 63 || c === 35) { + --this.pointer; + if (!this.stateOverride && isWindowsDriveLetterString(this.buffer)) { + this.parseError = true; + this.state = "path"; + } else if (this.buffer === "") { + this.url.host = ""; + if (this.stateOverride) { + return false; + } + this.state = "path start"; + } else { + let host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + if (host === "localhost") { + host = ""; + } + this.url.host = host; + if (this.stateOverride) { + return false; + } + this.buffer = ""; + this.state = "path start"; + } + } else { + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse path start"] = function parsePathStart(c) { + if (isSpecial(this.url)) { + if (c === 92) { + this.parseError = true; + } + this.state = "path"; + if (c !== 47 && c !== 92) { + --this.pointer; + } + } else if (!this.stateOverride && c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (!this.stateOverride && c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (c !== void 0) { + this.state = "path"; + if (c !== 47) { + --this.pointer; + } + } + return true; + }; + URLStateMachine.prototype["parse path"] = function parsePath(c) { + if (isNaN(c) || c === 47 || isSpecial(this.url) && c === 92 || !this.stateOverride && (c === 63 || c === 35)) { + if (isSpecial(this.url) && c === 92) { + this.parseError = true; + } + if (isDoubleDot(this.buffer)) { + shortenPath(this.url); + if (c !== 47 && !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } + } else if (isSingleDot(this.buffer) && c !== 47 && !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } else if (!isSingleDot(this.buffer)) { + if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) { + if (this.url.host !== "" && this.url.host !== null) { + this.parseError = true; + this.url.host = ""; + } + this.buffer = this.buffer[0] + ":"; + } + this.url.path.push(this.buffer); + } + this.buffer = ""; + if (this.url.scheme === "file" && (c === void 0 || c === 63 || c === 35)) { + while (this.url.path.length > 1 && this.url.path[0] === "") { + this.parseError = true; + this.url.path.shift(); + } + } + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.buffer += percentEncodeChar(c, isPathPercentEncode); + } + return true; + }; + URLStateMachine.prototype["parse cannot-be-a-base-URL path"] = function parseCannotBeABaseURLPath(c) { + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else { + if (!isNaN(c) && c !== 37) { + this.parseError = true; + } + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + if (!isNaN(c)) { + this.url.path[0] = this.url.path[0] + percentEncodeChar(c, isC0ControlPercentEncode); + } + } + return true; + }; + URLStateMachine.prototype["parse query"] = function parseQuery(c, cStr) { + if (isNaN(c) || !this.stateOverride && c === 35) { + if (!isSpecial(this.url) || this.url.scheme === "ws" || this.url.scheme === "wss") { + this.encodingOverride = "utf-8"; + } + const buffer = new Buffer(this.buffer); + for (let i = 0; i < buffer.length; ++i) { + if (buffer[i] < 33 || buffer[i] > 126 || buffer[i] === 34 || buffer[i] === 35 || buffer[i] === 60 || buffer[i] === 62) { + this.url.query += percentEncode(buffer[i]); + } else { + this.url.query += String.fromCodePoint(buffer[i]); + } + } + this.buffer = ""; + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse fragment"] = function parseFragment(c) { + if (isNaN(c)) { + } else if (c === 0) { + this.parseError = true; + } else { + if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.url.fragment += percentEncodeChar(c, isC0ControlPercentEncode); + } + return true; + }; + function serializeURL(url, excludeFragment) { + let output = url.scheme + ":"; + if (url.host !== null) { + output += "//"; + if (url.username !== "" || url.password !== "") { + output += url.username; + if (url.password !== "") { + output += ":" + url.password; + } + output += "@"; + } + output += serializeHost(url.host); + if (url.port !== null) { + output += ":" + url.port; + } + } else if (url.host === null && url.scheme === "file") { + output += "//"; + } + if (url.cannotBeABaseURL) { + output += url.path[0]; + } else { + for (const string of url.path) { + output += "/" + string; + } + } + if (url.query !== null) { + output += "?" + url.query; + } + if (!excludeFragment && url.fragment !== null) { + output += "#" + url.fragment; + } + return output; + } + function serializeOrigin(tuple) { + let result = tuple.scheme + "://"; + result += serializeHost(tuple.host); + if (tuple.port !== null) { + result += ":" + tuple.port; + } + return result; + } + module.exports.serializeURL = serializeURL; + module.exports.serializeURLOrigin = function(url) { + switch (url.scheme) { + case "blob": + try { + return module.exports.serializeURLOrigin(module.exports.parseURL(url.path[0])); + } catch (e2) { + return "null"; + } + case "ftp": + case "gopher": + case "http": + case "https": + case "ws": + case "wss": + return serializeOrigin({ + scheme: url.scheme, + host: url.host, + port: url.port + }); + case "file": + return "file://"; + default: + return "null"; + } + }; + module.exports.basicURLParse = function(input, options) { + if (options === void 0) { + options = {}; + } + const usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride); + if (usm.failure) { + return "failure"; + } + return usm.url; + }; + module.exports.setTheUsername = function(url, username) { + url.username = ""; + const decoded = punycode.ucs2.decode(username); + for (let i = 0; i < decoded.length; ++i) { + url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } + }; + module.exports.setThePassword = function(url, password) { + url.password = ""; + const decoded = punycode.ucs2.decode(password); + for (let i = 0; i < decoded.length; ++i) { + url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } + }; + module.exports.serializeHost = serializeHost; + module.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort; + module.exports.serializeInteger = function(integer) { + return String(integer); + }; + module.exports.parseURL = function(input, options) { + if (options === void 0) { + options = {}; + } + return module.exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride }); + }; + } +}); + +// node_modules/whatwg-url/lib/URL-impl.js +var require_URL_impl = __commonJS({ + "node_modules/whatwg-url/lib/URL-impl.js"(exports) { + "use strict"; + var usm = require_url_state_machine(); + exports.implementation = class URLImpl { + constructor(constructorArgs) { + const url = constructorArgs[0]; + const base = constructorArgs[1]; + let parsedBase = null; + if (base !== void 0) { + parsedBase = usm.basicURLParse(base); + if (parsedBase === "failure") { + throw new TypeError("Invalid base URL"); + } + } + const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase }); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + this._url = parsedURL; + } + get href() { + return usm.serializeURL(this._url); + } + set href(v) { + const parsedURL = usm.basicURLParse(v); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + this._url = parsedURL; + } + get origin() { + return usm.serializeURLOrigin(this._url); + } + get protocol() { + return this._url.scheme + ":"; + } + set protocol(v) { + usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" }); + } + get username() { + return this._url.username; + } + set username(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + usm.setTheUsername(this._url, v); + } + get password() { + return this._url.password; + } + set password(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + usm.setThePassword(this._url, v); + } + get host() { + const url = this._url; + if (url.host === null) { + return ""; + } + if (url.port === null) { + return usm.serializeHost(url.host); + } + return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port); + } + set host(v) { + if (this._url.cannotBeABaseURL) { + return; + } + usm.basicURLParse(v, { url: this._url, stateOverride: "host" }); + } + get hostname() { + if (this._url.host === null) { + return ""; + } + return usm.serializeHost(this._url.host); + } + set hostname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" }); + } + get port() { + if (this._url.port === null) { + return ""; + } + return usm.serializeInteger(this._url.port); + } + set port(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + if (v === "") { + this._url.port = null; + } else { + usm.basicURLParse(v, { url: this._url, stateOverride: "port" }); + } + } + get pathname() { + if (this._url.cannotBeABaseURL) { + return this._url.path[0]; + } + if (this._url.path.length === 0) { + return ""; + } + return "/" + this._url.path.join("/"); + } + set pathname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + this._url.path = []; + usm.basicURLParse(v, { url: this._url, stateOverride: "path start" }); + } + get search() { + if (this._url.query === null || this._url.query === "") { + return ""; + } + return "?" + this._url.query; + } + set search(v) { + const url = this._url; + if (v === "") { + url.query = null; + return; + } + const input = v[0] === "?" ? v.substring(1) : v; + url.query = ""; + usm.basicURLParse(input, { url, stateOverride: "query" }); + } + get hash() { + if (this._url.fragment === null || this._url.fragment === "") { + return ""; + } + return "#" + this._url.fragment; + } + set hash(v) { + if (v === "") { + this._url.fragment = null; + return; + } + const input = v[0] === "#" ? v.substring(1) : v; + this._url.fragment = ""; + usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" }); + } + toJSON() { + return this.href; + } + }; + } +}); + +// node_modules/whatwg-url/lib/URL.js +var require_URL = __commonJS({ + "node_modules/whatwg-url/lib/URL.js"(exports, module) { + "use strict"; + var conversions = require_lib(); + var utils = require_utils2(); + var Impl = require_URL_impl(); + var impl = utils.implSymbol; + function URL3(url) { + if (!this || this[impl] || !(this instanceof URL3)) { + throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function."); + } + if (arguments.length < 1) { + throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present."); + } + const args = []; + for (let i = 0; i < arguments.length && i < 2; ++i) { + args[i] = arguments[i]; + } + args[0] = conversions["USVString"](args[0]); + if (args[1] !== void 0) { + args[1] = conversions["USVString"](args[1]); + } + module.exports.setup(this, args); + } + URL3.prototype.toJSON = function toJSON() { + if (!this || !module.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + const args = []; + for (let i = 0; i < arguments.length && i < 0; ++i) { + args[i] = arguments[i]; + } + return this[impl].toJSON.apply(this[impl], args); + }; + Object.defineProperty(URL3.prototype, "href", { + get() { + return this[impl].href; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].href = V; + }, + enumerable: true, + configurable: true + }); + URL3.prototype.toString = function() { + if (!this || !module.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + return this.href; + }; + Object.defineProperty(URL3.prototype, "origin", { + get() { + return this[impl].origin; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "protocol", { + get() { + return this[impl].protocol; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].protocol = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "username", { + get() { + return this[impl].username; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].username = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "password", { + get() { + return this[impl].password; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].password = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "host", { + get() { + return this[impl].host; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].host = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "hostname", { + get() { + return this[impl].hostname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hostname = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "port", { + get() { + return this[impl].port; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].port = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "pathname", { + get() { + return this[impl].pathname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].pathname = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "search", { + get() { + return this[impl].search; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].search = V; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(URL3.prototype, "hash", { + get() { + return this[impl].hash; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hash = V; + }, + enumerable: true, + configurable: true + }); + module.exports = { + is(obj) { + return !!obj && obj[impl] instanceof Impl.implementation; + }, + create(constructorArgs, privateData) { + let obj = Object.create(URL3.prototype); + this.setup(obj, constructorArgs, privateData); + return obj; + }, + setup(obj, constructorArgs, privateData) { + if (!privateData) privateData = {}; + privateData.wrapper = obj; + obj[impl] = new Impl.implementation(constructorArgs, privateData); + obj[impl][utils.wrapperSymbol] = obj; + }, + interface: URL3, + expose: { + Window: { URL: URL3 }, + Worker: { URL: URL3 } + } + }; + } +}); + +// node_modules/whatwg-url/lib/public-api.js +var require_public_api = __commonJS({ + "node_modules/whatwg-url/lib/public-api.js"(exports) { + "use strict"; + exports.URL = require_URL().interface; + exports.serializeURL = require_url_state_machine().serializeURL; + exports.serializeURLOrigin = require_url_state_machine().serializeURLOrigin; + exports.basicURLParse = require_url_state_machine().basicURLParse; + exports.setTheUsername = require_url_state_machine().setTheUsername; + exports.setThePassword = require_url_state_machine().setThePassword; + exports.serializeHost = require_url_state_machine().serializeHost; + exports.serializeInteger = require_url_state_machine().serializeInteger; + exports.parseURL = require_url_state_machine().parseURL; + } +}); + +// node_modules/node-fetch/lib/index.js +var require_lib2 = __commonJS({ + "node_modules/node-fetch/lib/index.js"(exports, module) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + function _interopDefault(ex) { + return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex; + } + var Stream = _interopDefault(__require("stream")); + var http2 = _interopDefault(__require("http")); + var Url = _interopDefault(__require("url")); + var whatwgUrl = _interopDefault(require_public_api()); + var https2 = _interopDefault(__require("https")); + var zlib = _interopDefault(__require("zlib")); + var Readable = Stream.Readable; + var BUFFER = /* @__PURE__ */ Symbol("buffer"); + var TYPE = /* @__PURE__ */ Symbol("type"); + var Blob2 = class _Blob { + constructor() { + this[TYPE] = ""; + const blobParts = arguments[0]; + const options = arguments[1]; + const buffers = []; + let size = 0; + if (blobParts) { + const a = blobParts; + const length = Number(a.length); + for (let i = 0; i < length; i++) { + const element = a[i]; + let buffer; + if (element instanceof Buffer) { + buffer = element; + } else if (ArrayBuffer.isView(element)) { + buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength); + } else if (element instanceof ArrayBuffer) { + buffer = Buffer.from(element); + } else if (element instanceof _Blob) { + buffer = element[BUFFER]; + } else { + buffer = Buffer.from(typeof element === "string" ? element : String(element)); + } + size += buffer.length; + buffers.push(buffer); + } + } + this[BUFFER] = Buffer.concat(buffers); + let type2 = options && options.type !== void 0 && String(options.type).toLowerCase(); + if (type2 && !/[^\u0020-\u007E]/.test(type2)) { + this[TYPE] = type2; + } + } + get size() { + return this[BUFFER].length; + } + get type() { + return this[TYPE]; + } + text() { + return Promise.resolve(this[BUFFER].toString()); + } + arrayBuffer() { + const buf2 = this[BUFFER]; + const ab = buf2.buffer.slice(buf2.byteOffset, buf2.byteOffset + buf2.byteLength); + return Promise.resolve(ab); + } + stream() { + const readable = new Readable(); + readable._read = function() { + }; + readable.push(this[BUFFER]); + readable.push(null); + return readable; + } + toString() { + return "[object Blob]"; + } + slice() { + const size = this.size; + const start = arguments[0]; + const end = arguments[1]; + let relativeStart, relativeEnd; + if (start === void 0) { + relativeStart = 0; + } else if (start < 0) { + relativeStart = Math.max(size + start, 0); + } else { + relativeStart = Math.min(start, size); + } + if (end === void 0) { + relativeEnd = size; + } else if (end < 0) { + relativeEnd = Math.max(size + end, 0); + } else { + relativeEnd = Math.min(end, size); + } + const span = Math.max(relativeEnd - relativeStart, 0); + const buffer = this[BUFFER]; + const slicedBuffer = buffer.slice(relativeStart, relativeStart + span); + const blob = new _Blob([], { type: arguments[2] }); + blob[BUFFER] = slicedBuffer; + return blob; + } + }; + Object.defineProperties(Blob2.prototype, { + size: { enumerable: true }, + type: { enumerable: true }, + slice: { enumerable: true } + }); + Object.defineProperty(Blob2.prototype, Symbol.toStringTag, { + value: "Blob", + writable: false, + enumerable: false, + configurable: true + }); + function FetchError2(message, type2, systemError) { + Error.call(this, message); + this.message = message; + this.type = type2; + if (systemError) { + this.code = this.errno = systemError.code; + } + Error.captureStackTrace(this, this.constructor); + } + FetchError2.prototype = Object.create(Error.prototype); + FetchError2.prototype.constructor = FetchError2; + FetchError2.prototype.name = "FetchError"; + var convert; + try { + convert = __require("encoding").convert; + } catch (e2) { + } + var INTERNALS = /* @__PURE__ */ Symbol("Body internals"); + var PassThrough = Stream.PassThrough; + function Body(body) { + var _this = this; + var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref$size = _ref.size; + let size = _ref$size === void 0 ? 0 : _ref$size; + var _ref$timeout = _ref.timeout; + let timeout = _ref$timeout === void 0 ? 0 : _ref$timeout; + if (body == null) { + body = null; + } else if (isURLSearchParams(body)) { + body = Buffer.from(body.toString()); + } else if (isBlob(body)) ; + else if (Buffer.isBuffer(body)) ; + else if (Object.prototype.toString.call(body) === "[object ArrayBuffer]") { + body = Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof Stream) ; + else { + body = Buffer.from(String(body)); + } + this[INTERNALS] = { + body, + disturbed: false, + error: null + }; + this.size = size; + this.timeout = timeout; + if (body instanceof Stream) { + body.on("error", function(err) { + const error2 = err.name === "AbortError" ? err : new FetchError2(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, "system", err); + _this[INTERNALS].error = error2; + }); + } + } + Body.prototype = { + get body() { + return this[INTERNALS].body; + }, + get bodyUsed() { + return this[INTERNALS].disturbed; + }, + /** + * Decode response as ArrayBuffer + * + * @return Promise + */ + arrayBuffer() { + return consumeBody.call(this).then(function(buf2) { + return buf2.buffer.slice(buf2.byteOffset, buf2.byteOffset + buf2.byteLength); + }); + }, + /** + * Return raw response as Blob + * + * @return Promise + */ + blob() { + let ct = this.headers && this.headers.get("content-type") || ""; + return consumeBody.call(this).then(function(buf2) { + return Object.assign( + // Prevent copying + new Blob2([], { + type: ct.toLowerCase() + }), + { + [BUFFER]: buf2 + } + ); + }); + }, + /** + * Decode response as json + * + * @return Promise + */ + json() { + var _this2 = this; + return consumeBody.call(this).then(function(buffer) { + try { + return JSON.parse(buffer.toString()); + } catch (err) { + return Body.Promise.reject(new FetchError2(`invalid json response body at ${_this2.url} reason: ${err.message}`, "invalid-json")); + } + }); + }, + /** + * Decode response as text + * + * @return Promise + */ + text() { + return consumeBody.call(this).then(function(buffer) { + return buffer.toString(); + }); + }, + /** + * Decode response as buffer (non-spec api) + * + * @return Promise + */ + buffer() { + return consumeBody.call(this); + }, + /** + * Decode response as text, while automatically detecting the encoding and + * trying to decode to UTF-8 (non-spec api) + * + * @return Promise + */ + textConverted() { + var _this3 = this; + return consumeBody.call(this).then(function(buffer) { + return convertBody(buffer, _this3.headers); + }); + } + }; + Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true } + }); + Body.mixIn = function(proto) { + for (const name of Object.getOwnPropertyNames(Body.prototype)) { + if (!(name in proto)) { + const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); + Object.defineProperty(proto, name, desc); + } + } + }; + function consumeBody() { + var _this4 = this; + if (this[INTERNALS].disturbed) { + return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); + } + this[INTERNALS].disturbed = true; + if (this[INTERNALS].error) { + return Body.Promise.reject(this[INTERNALS].error); + } + let body = this.body; + if (body === null) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + if (isBlob(body)) { + body = body.stream(); + } + if (Buffer.isBuffer(body)) { + return Body.Promise.resolve(body); + } + if (!(body instanceof Stream)) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + let accum = []; + let accumBytes = 0; + let abort = false; + return new Body.Promise(function(resolve2, reject) { + let resTimeout; + if (_this4.timeout) { + resTimeout = setTimeout(function() { + abort = true; + reject(new FetchError2(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, "body-timeout")); + }, _this4.timeout); + } + body.on("error", function(err) { + if (err.name === "AbortError") { + abort = true; + reject(err); + } else { + reject(new FetchError2(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, "system", err)); + } + }); + body.on("data", function(chunk) { + if (abort || chunk === null) { + return; + } + if (_this4.size && accumBytes + chunk.length > _this4.size) { + abort = true; + reject(new FetchError2(`content size at ${_this4.url} over limit: ${_this4.size}`, "max-size")); + return; + } + accumBytes += chunk.length; + accum.push(chunk); + }); + body.on("end", function() { + if (abort) { + return; + } + clearTimeout(resTimeout); + try { + resolve2(Buffer.concat(accum, accumBytes)); + } catch (err) { + reject(new FetchError2(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err)); + } + }); + }); + } + function convertBody(buffer, headers2) { + if (typeof convert !== "function") { + throw new Error("The package `encoding` must be installed to use the textConverted() function"); + } + const ct = headers2.get("content-type"); + let charset = "utf-8"; + let res, str2; + if (ct) { + res = /charset=([^;]*)/i.exec(ct); + } + str2 = buffer.slice(0, 1024).toString(); + if (!res && str2) { + res = / 0 && arguments[0] !== void 0 ? arguments[0] : void 0; + this[MAP] = /* @__PURE__ */ Object.create(null); + if (init instanceof _Headers) { + const rawHeaders = init.raw(); + const headerNames = Object.keys(rawHeaders); + for (const headerName of headerNames) { + for (const value of rawHeaders[headerName]) { + this.append(headerName, value); + } + } + return; + } + if (init == null) ; + else if (typeof init === "object") { + const method = init[Symbol.iterator]; + if (method != null) { + if (typeof method !== "function") { + throw new TypeError("Header pairs must be iterable"); + } + const pairs2 = []; + for (const pair of init) { + if (typeof pair !== "object" || typeof pair[Symbol.iterator] !== "function") { + throw new TypeError("Each header pair must be iterable"); + } + pairs2.push(Array.from(pair)); + } + for (const pair of pairs2) { + if (pair.length !== 2) { + throw new TypeError("Each header pair must be a name/value tuple"); + } + this.append(pair[0], pair[1]); + } + } else { + for (const key of Object.keys(init)) { + const value = init[key]; + this.append(key, value); + } + } + } else { + throw new TypeError("Provided initializer must be an object"); + } + } + /** + * Return combined header value given name + * + * @param String name Header name + * @return Mixed + */ + get(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key === void 0) { + return null; + } + return this[MAP][key].join(", "); + } + /** + * Iterate over all headers + * + * @param Function callback Executed for each item with parameters (value, name, thisArg) + * @param Boolean thisArg `this` context for callback function + * @return Void + */ + forEach(callback) { + let thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0; + let pairs2 = getHeaders(this); + let i = 0; + while (i < pairs2.length) { + var _pairs$i = pairs2[i]; + const name = _pairs$i[0], value = _pairs$i[1]; + callback.call(thisArg, value, name, this); + pairs2 = getHeaders(this); + i++; + } + } + /** + * Overwrite header values given name + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + set(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + this[MAP][key !== void 0 ? key : name] = [value]; + } + /** + * Append a value onto existing header + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + append(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + if (key !== void 0) { + this[MAP][key].push(value); + } else { + this[MAP][name] = [value]; + } + } + /** + * Check for header name existence + * + * @param String name Header name + * @return Boolean + */ + has(name) { + name = `${name}`; + validateName(name); + return find(this[MAP], name) !== void 0; + } + /** + * Delete all header values given name + * + * @param String name Header name + * @return Void + */ + delete(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key !== void 0) { + delete this[MAP][key]; + } + } + /** + * Return raw headers (non-spec api) + * + * @return Object + */ + raw() { + return this[MAP]; + } + /** + * Get an iterator on keys. + * + * @return Iterator + */ + keys() { + return createHeadersIterator(this, "key"); + } + /** + * Get an iterator on values. + * + * @return Iterator + */ + values() { + return createHeadersIterator(this, "value"); + } + /** + * Get an iterator on entries. + * + * This is the default iterator of the Headers object. + * + * @return Iterator + */ + [Symbol.iterator]() { + return createHeadersIterator(this, "key+value"); + } + }; + Headers4.prototype.entries = Headers4.prototype[Symbol.iterator]; + Object.defineProperty(Headers4.prototype, Symbol.toStringTag, { + value: "Headers", + writable: false, + enumerable: false, + configurable: true + }); + Object.defineProperties(Headers4.prototype, { + get: { enumerable: true }, + forEach: { enumerable: true }, + set: { enumerable: true }, + append: { enumerable: true }, + has: { enumerable: true }, + delete: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true } + }); + function getHeaders(headers2) { + let kind = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "key+value"; + const keys = Object.keys(headers2[MAP]).sort(); + return keys.map(kind === "key" ? function(k) { + return k.toLowerCase(); + } : kind === "value" ? function(k) { + return headers2[MAP][k].join(", "); + } : function(k) { + return [k.toLowerCase(), headers2[MAP][k].join(", ")]; + }); + } + var INTERNAL = /* @__PURE__ */ Symbol("internal"); + function createHeadersIterator(target, kind) { + const iterator = Object.create(HeadersIteratorPrototype); + iterator[INTERNAL] = { + target, + kind, + index: 0 + }; + return iterator; + } + var HeadersIteratorPrototype = Object.setPrototypeOf({ + next() { + if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { + throw new TypeError("Value of `this` is not a HeadersIterator"); + } + var _INTERNAL = this[INTERNAL]; + const target = _INTERNAL.target, kind = _INTERNAL.kind, index2 = _INTERNAL.index; + const values = getHeaders(target, kind); + const len = values.length; + if (index2 >= len) { + return { + value: void 0, + done: true + }; + } + this[INTERNAL].index = index2 + 1; + return { + value: values[index2], + done: false + }; + } + }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); + Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { + value: "HeadersIterator", + writable: false, + enumerable: false, + configurable: true + }); + function exportNodeCompatibleHeaders(headers2) { + const obj = Object.assign({ __proto__: null }, headers2[MAP]); + const hostHeaderKey = find(headers2[MAP], "Host"); + if (hostHeaderKey !== void 0) { + obj[hostHeaderKey] = obj[hostHeaderKey][0]; + } + return obj; + } + function createHeadersLenient(obj) { + const headers2 = new Headers4(); + for (const name of Object.keys(obj)) { + if (invalidTokenRegex.test(name)) { + continue; + } + if (Array.isArray(obj[name])) { + for (const val of obj[name]) { + if (invalidHeaderCharRegex.test(val)) { + continue; + } + if (headers2[MAP][name] === void 0) { + headers2[MAP][name] = [val]; + } else { + headers2[MAP][name].push(val); + } + } + } else if (!invalidHeaderCharRegex.test(obj[name])) { + headers2[MAP][name] = [obj[name]]; + } + } + return headers2; + } + var INTERNALS$1 = /* @__PURE__ */ Symbol("Response internals"); + var STATUS_CODES2 = http2.STATUS_CODES; + var Response2 = class _Response { + constructor() { + let body = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + Body.call(this, body, opts); + const status = opts.status || 200; + const headers2 = new Headers4(opts.headers); + if (body != null && !headers2.has("Content-Type")) { + const contentType = extractContentType(body); + if (contentType) { + headers2.append("Content-Type", contentType); + } + } + this[INTERNALS$1] = { + url: opts.url, + status, + statusText: opts.statusText || STATUS_CODES2[status], + headers: headers2, + counter: opts.counter + }; + } + get url() { + return this[INTERNALS$1].url || ""; + } + get status() { + return this[INTERNALS$1].status; + } + /** + * Convenience property representing if the request ended normally + */ + get ok() { + return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; + } + get redirected() { + return this[INTERNALS$1].counter > 0; + } + get statusText() { + return this[INTERNALS$1].statusText; + } + get headers() { + return this[INTERNALS$1].headers; + } + /** + * Clone this response + * + * @return Response + */ + clone() { + return new _Response(clone(this), { + url: this.url, + status: this.status, + statusText: this.statusText, + headers: this.headers, + ok: this.ok, + redirected: this.redirected + }); + } + }; + Body.mixIn(Response2.prototype); + Object.defineProperties(Response2.prototype, { + url: { enumerable: true }, + status: { enumerable: true }, + ok: { enumerable: true }, + redirected: { enumerable: true }, + statusText: { enumerable: true }, + headers: { enumerable: true }, + clone: { enumerable: true } + }); + Object.defineProperty(Response2.prototype, Symbol.toStringTag, { + value: "Response", + writable: false, + enumerable: false, + configurable: true + }); + var INTERNALS$2 = /* @__PURE__ */ Symbol("Request internals"); + var URL3 = Url.URL || whatwgUrl.URL; + var parse_url = Url.parse; + var format_url = Url.format; + function parseURL(urlStr) { + if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(urlStr)) { + urlStr = new URL3(urlStr).toString(); + } + return parse_url(urlStr); + } + var streamDestructionSupported = "destroy" in Stream.Readable.prototype; + function isRequest(input) { + return typeof input === "object" && typeof input[INTERNALS$2] === "object"; + } + function isAbortSignal(signal3) { + const proto = signal3 && typeof signal3 === "object" && Object.getPrototypeOf(signal3); + return !!(proto && proto.constructor.name === "AbortSignal"); + } + var Request2 = class _Request { + constructor(input) { + let init = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + let parsedURL; + if (!isRequest(input)) { + if (input && input.href) { + parsedURL = parseURL(input.href); + } else { + parsedURL = parseURL(`${input}`); + } + input = {}; + } else { + parsedURL = parseURL(input.url); + } + let method = init.method || input.method || "GET"; + method = method.toUpperCase(); + if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body"); + } + let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; + Body.call(this, inputBody, { + timeout: init.timeout || input.timeout || 0, + size: init.size || input.size || 0 + }); + const headers2 = new Headers4(init.headers || input.headers || {}); + if (inputBody != null && !headers2.has("Content-Type")) { + const contentType = extractContentType(inputBody); + if (contentType) { + headers2.append("Content-Type", contentType); + } + } + let signal3 = isRequest(input) ? input.signal : null; + if ("signal" in init) signal3 = init.signal; + if (signal3 != null && !isAbortSignal(signal3)) { + throw new TypeError("Expected signal to be an instanceof AbortSignal"); + } + this[INTERNALS$2] = { + method, + redirect: init.redirect || input.redirect || "follow", + headers: headers2, + parsedURL, + signal: signal3 + }; + this.follow = init.follow !== void 0 ? init.follow : input.follow !== void 0 ? input.follow : 20; + this.compress = init.compress !== void 0 ? init.compress : input.compress !== void 0 ? input.compress : true; + this.counter = init.counter || input.counter || 0; + this.agent = init.agent || input.agent; + } + get method() { + return this[INTERNALS$2].method; + } + get url() { + return format_url(this[INTERNALS$2].parsedURL); + } + get headers() { + return this[INTERNALS$2].headers; + } + get redirect() { + return this[INTERNALS$2].redirect; + } + get signal() { + return this[INTERNALS$2].signal; + } + /** + * Clone this request + * + * @return Request + */ + clone() { + return new _Request(this); + } + }; + Body.mixIn(Request2.prototype); + Object.defineProperty(Request2.prototype, Symbol.toStringTag, { + value: "Request", + writable: false, + enumerable: false, + configurable: true + }); + Object.defineProperties(Request2.prototype, { + method: { enumerable: true }, + url: { enumerable: true }, + headers: { enumerable: true }, + redirect: { enumerable: true }, + clone: { enumerable: true }, + signal: { enumerable: true } + }); + function getNodeRequestOptions(request) { + const parsedURL = request[INTERNALS$2].parsedURL; + const headers2 = new Headers4(request[INTERNALS$2].headers); + if (!headers2.has("Accept")) { + headers2.set("Accept", "*/*"); + } + if (!parsedURL.protocol || !parsedURL.hostname) { + throw new TypeError("Only absolute URLs are supported"); + } + if (!/^https?:$/.test(parsedURL.protocol)) { + throw new TypeError("Only HTTP(S) protocols are supported"); + } + if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) { + throw new Error("Cancellation of streamed requests with AbortSignal is not supported in node < 8"); + } + let contentLengthValue = null; + if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { + contentLengthValue = "0"; + } + if (request.body != null) { + const totalBytes = getTotalBytes(request); + if (typeof totalBytes === "number") { + contentLengthValue = String(totalBytes); + } + } + if (contentLengthValue) { + headers2.set("Content-Length", contentLengthValue); + } + if (!headers2.has("User-Agent")) { + headers2.set("User-Agent", "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)"); + } + if (request.compress && !headers2.has("Accept-Encoding")) { + headers2.set("Accept-Encoding", "gzip,deflate"); + } + let agent = request.agent; + if (typeof agent === "function") { + agent = agent(parsedURL); + } + return Object.assign({}, parsedURL, { + method: request.method, + headers: exportNodeCompatibleHeaders(headers2), + agent + }); + } + function AbortError2(message) { + Error.call(this, message); + this.type = "aborted"; + this.message = message; + Error.captureStackTrace(this, this.constructor); + } + AbortError2.prototype = Object.create(Error.prototype); + AbortError2.prototype.constructor = AbortError2; + AbortError2.prototype.name = "AbortError"; + var URL$1 = Url.URL || whatwgUrl.URL; + var PassThrough$1 = Stream.PassThrough; + var isDomainOrSubdomain = function isDomainOrSubdomain2(destination, original) { + const orig = new URL$1(original).hostname; + const dest = new URL$1(destination).hostname; + return orig === dest || orig[orig.length - dest.length - 1] === "." && orig.endsWith(dest); + }; + var isSameProtocol = function isSameProtocol2(destination, original) { + const orig = new URL$1(original).protocol; + const dest = new URL$1(destination).protocol; + return orig === dest; + }; + function fetch7(url, opts) { + if (!fetch7.Promise) { + throw new Error("native promise missing, set fetch.Promise to your favorite alternative"); + } + Body.Promise = fetch7.Promise; + return new fetch7.Promise(function(resolve2, reject) { + const request = new Request2(url, opts); + const options = getNodeRequestOptions(request); + const send = (options.protocol === "https:" ? https2 : http2).request; + const signal3 = request.signal; + let response = null; + const abort = function abort2() { + let error2 = new AbortError2("The user aborted a request."); + reject(error2); + if (request.body && request.body instanceof Stream.Readable) { + destroyStream(request.body, error2); + } + if (!response || !response.body) return; + response.body.emit("error", error2); + }; + if (signal3 && signal3.aborted) { + abort(); + return; + } + const abortAndFinalize = function abortAndFinalize2() { + abort(); + finalize(); + }; + const req = send(options); + let reqTimeout; + if (signal3) { + signal3.addEventListener("abort", abortAndFinalize); + } + function finalize() { + req.abort(); + if (signal3) signal3.removeEventListener("abort", abortAndFinalize); + clearTimeout(reqTimeout); + } + if (request.timeout) { + req.once("socket", function(socket) { + reqTimeout = setTimeout(function() { + reject(new FetchError2(`network timeout at: ${request.url}`, "request-timeout")); + finalize(); + }, request.timeout); + }); + } + req.on("error", function(err) { + reject(new FetchError2(`request to ${request.url} failed, reason: ${err.message}`, "system", err)); + if (response && response.body) { + destroyStream(response.body, err); + } + finalize(); + }); + fixResponseChunkedTransferBadEnding(req, function(err) { + if (signal3 && signal3.aborted) { + return; + } + if (response && response.body) { + destroyStream(response.body, err); + } + }); + if (parseInt(process.version.substring(1)) < 14) { + req.on("socket", function(s) { + s.addListener("close", function(hadError) { + const hasDataListener = s.listenerCount("data") > 0; + if (response && hasDataListener && !hadError && !(signal3 && signal3.aborted)) { + const err = new Error("Premature close"); + err.code = "ERR_STREAM_PREMATURE_CLOSE"; + response.body.emit("error", err); + } + }); + }); + } + req.on("response", function(res) { + clearTimeout(reqTimeout); + const headers2 = createHeadersLenient(res.headers); + if (fetch7.isRedirect(res.statusCode)) { + const location = headers2.get("Location"); + let locationURL = null; + try { + locationURL = location === null ? null : new URL$1(location, request.url).toString(); + } catch (err) { + if (request.redirect !== "manual") { + reject(new FetchError2(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect")); + finalize(); + return; + } + } + switch (request.redirect) { + case "error": + reject(new FetchError2(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect")); + finalize(); + return; + case "manual": + if (locationURL !== null) { + try { + headers2.set("Location", locationURL); + } catch (err) { + reject(err); + } + } + break; + case "follow": + if (locationURL === null) { + break; + } + if (request.counter >= request.follow) { + reject(new FetchError2(`maximum redirect reached at: ${request.url}`, "max-redirect")); + finalize(); + return; + } + const requestOpts = { + headers: new Headers4(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout, + size: request.size + }; + if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) { + for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) { + requestOpts.headers.delete(name); + } + } + if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { + reject(new FetchError2("Cannot follow redirect with body being a readable stream", "unsupported-redirect")); + finalize(); + return; + } + if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === "POST") { + requestOpts.method = "GET"; + requestOpts.body = void 0; + requestOpts.headers.delete("content-length"); + } + resolve2(fetch7(new Request2(locationURL, requestOpts))); + finalize(); + return; + } + } + res.once("end", function() { + if (signal3) signal3.removeEventListener("abort", abortAndFinalize); + }); + let body = res.pipe(new PassThrough$1()); + const response_options = { + url: request.url, + status: res.statusCode, + statusText: res.statusMessage, + headers: headers2, + size: request.size, + timeout: request.timeout, + counter: request.counter + }; + const codings = headers2.get("Content-Encoding"); + if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) { + response = new Response2(body, response_options); + resolve2(response); + return; + } + const zlibOptions = { + flush: zlib.Z_SYNC_FLUSH, + finishFlush: zlib.Z_SYNC_FLUSH + }; + if (codings == "gzip" || codings == "x-gzip") { + body = body.pipe(zlib.createGunzip(zlibOptions)); + response = new Response2(body, response_options); + resolve2(response); + return; + } + if (codings == "deflate" || codings == "x-deflate") { + const raw = res.pipe(new PassThrough$1()); + raw.once("data", function(chunk) { + if ((chunk[0] & 15) === 8) { + body = body.pipe(zlib.createInflate()); + } else { + body = body.pipe(zlib.createInflateRaw()); + } + response = new Response2(body, response_options); + resolve2(response); + }); + raw.on("end", function() { + if (!response) { + response = new Response2(body, response_options); + resolve2(response); + } + }); + return; + } + if (codings == "br" && typeof zlib.createBrotliDecompress === "function") { + body = body.pipe(zlib.createBrotliDecompress()); + response = new Response2(body, response_options); + resolve2(response); + return; + } + response = new Response2(body, response_options); + resolve2(response); + }); + writeToStream(req, request); + }); + } + function fixResponseChunkedTransferBadEnding(request, errorCallback) { + let socket; + request.on("socket", function(s) { + socket = s; + }); + request.on("response", function(response) { + const headers2 = response.headers; + if (headers2["transfer-encoding"] === "chunked" && !headers2["content-length"]) { + response.once("close", function(hadError) { + const hasDataListener = socket && socket.listenerCount("data") > 0; + if (hasDataListener && !hadError) { + const err = new Error("Premature close"); + err.code = "ERR_STREAM_PREMATURE_CLOSE"; + errorCallback(err); + } + }); + } + }); + } + function destroyStream(stream, err) { + if (stream.destroy) { + stream.destroy(err); + } else { + stream.emit("error", err); + stream.end(); + } + } + fetch7.isRedirect = function(code) { + return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; + }; + fetch7.Promise = global.Promise; + module.exports = exports = fetch7; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = exports; + exports.Headers = Headers4; + exports.Request = Request2; + exports.Response = Response2; + exports.FetchError = FetchError2; + exports.AbortError = AbortError2; + } +}); + +// node_modules/smart-buffer/build/utils.js +var require_utils3 = __commonJS({ + "node_modules/smart-buffer/build/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var buffer_1 = __require("buffer"); + var ERRORS = { + INVALID_ENCODING: "Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.", + INVALID_SMARTBUFFER_SIZE: "Invalid size provided. Size must be a valid integer greater than zero.", + INVALID_SMARTBUFFER_BUFFER: "Invalid Buffer provided in SmartBufferOptions.", + INVALID_SMARTBUFFER_OBJECT: "Invalid SmartBufferOptions object supplied to SmartBuffer constructor or factory methods.", + INVALID_OFFSET: "An invalid offset value was provided.", + INVALID_OFFSET_NON_NUMBER: "An invalid offset value was provided. A numeric value is required.", + INVALID_LENGTH: "An invalid length value was provided.", + INVALID_LENGTH_NON_NUMBER: "An invalid length value was provived. A numeric value is required.", + INVALID_TARGET_OFFSET: "Target offset is beyond the bounds of the internal SmartBuffer data.", + INVALID_TARGET_LENGTH: "Specified length value moves cursor beyong the bounds of the internal SmartBuffer data.", + INVALID_READ_BEYOND_BOUNDS: "Attempted to read beyond the bounds of the managed data.", + INVALID_WRITE_BEYOND_BOUNDS: "Attempted to write beyond the bounds of the managed data." + }; + exports.ERRORS = ERRORS; + function checkEncoding(encoding) { + if (!buffer_1.Buffer.isEncoding(encoding)) { + throw new Error(ERRORS.INVALID_ENCODING); + } + } + exports.checkEncoding = checkEncoding; + function isFiniteInteger(value) { + return typeof value === "number" && isFinite(value) && isInteger2(value); + } + exports.isFiniteInteger = isFiniteInteger; + function checkOffsetOrLengthValue(value, offset) { + if (typeof value === "number") { + if (!isFiniteInteger(value) || value < 0) { + throw new Error(offset ? ERRORS.INVALID_OFFSET : ERRORS.INVALID_LENGTH); + } + } else { + throw new Error(offset ? ERRORS.INVALID_OFFSET_NON_NUMBER : ERRORS.INVALID_LENGTH_NON_NUMBER); + } + } + function checkLengthValue(length) { + checkOffsetOrLengthValue(length, false); + } + exports.checkLengthValue = checkLengthValue; + function checkOffsetValue(offset) { + checkOffsetOrLengthValue(offset, true); + } + exports.checkOffsetValue = checkOffsetValue; + function checkTargetOffset(offset, buff) { + if (offset < 0 || offset > buff.length) { + throw new Error(ERRORS.INVALID_TARGET_OFFSET); + } + } + exports.checkTargetOffset = checkTargetOffset; + function isInteger2(value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value; + } + function bigIntAndBufferInt64Check(bufferMethod) { + if (typeof BigInt === "undefined") { + throw new Error("Platform does not support JS BigInt type."); + } + if (typeof buffer_1.Buffer.prototype[bufferMethod] === "undefined") { + throw new Error(`Platform does not support Buffer.prototype.${bufferMethod}.`); + } + } + exports.bigIntAndBufferInt64Check = bigIntAndBufferInt64Check; + } +}); + +// node_modules/smart-buffer/build/smartbuffer.js +var require_smartbuffer = __commonJS({ + "node_modules/smart-buffer/build/smartbuffer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var utils_1 = require_utils3(); + var DEFAULT_SMARTBUFFER_SIZE = 4096; + var DEFAULT_SMARTBUFFER_ENCODING = "utf8"; + var SmartBuffer = class _SmartBuffer { + /** + * Creates a new SmartBuffer instance. + * + * @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance. + */ + constructor(options) { + this.length = 0; + this._encoding = DEFAULT_SMARTBUFFER_ENCODING; + this._writeOffset = 0; + this._readOffset = 0; + if (_SmartBuffer.isSmartBufferOptions(options)) { + if (options.encoding) { + utils_1.checkEncoding(options.encoding); + this._encoding = options.encoding; + } + if (options.size) { + if (utils_1.isFiniteInteger(options.size) && options.size > 0) { + this._buff = Buffer.allocUnsafe(options.size); + } else { + throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE); + } + } else if (options.buff) { + if (Buffer.isBuffer(options.buff)) { + this._buff = options.buff; + this.length = options.buff.length; + } else { + throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER); + } + } else { + this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + } + } else { + if (typeof options !== "undefined") { + throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT); + } + this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + } + } + /** + * Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding. + * + * @param size { Number } The size of the internal Buffer. + * @param encoding { String } The BufferEncoding to use for strings. + * + * @return { SmartBuffer } + */ + static fromSize(size, encoding) { + return new this({ + size, + encoding + }); + } + /** + * Creates a new SmartBuffer instance with the provided Buffer and optional encoding. + * + * @param buffer { Buffer } The Buffer to use as the internal Buffer value. + * @param encoding { String } The BufferEncoding to use for strings. + * + * @return { SmartBuffer } + */ + static fromBuffer(buff, encoding) { + return new this({ + buff, + encoding + }); + } + /** + * Creates a new SmartBuffer instance with the provided SmartBufferOptions options. + * + * @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance. + */ + static fromOptions(options) { + return new this(options); + } + /** + * Type checking function that determines if an object is a SmartBufferOptions object. + */ + static isSmartBufferOptions(options) { + const castOptions = options; + return castOptions && (castOptions.encoding !== void 0 || castOptions.size !== void 0 || castOptions.buff !== void 0); + } + // Signed integers + /** + * Reads an Int8 value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt8(offset) { + return this._readNumberValue(Buffer.prototype.readInt8, 1, offset); + } + /** + * Reads an Int16BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt16BE(offset) { + return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset); + } + /** + * Reads an Int16LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt16LE(offset) { + return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset); + } + /** + * Reads an Int32BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt32BE(offset) { + return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset); + } + /** + * Reads an Int32LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt32LE(offset) { + return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset); + } + /** + * Reads a BigInt64BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigInt64BE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigInt64BE"); + return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset); + } + /** + * Reads a BigInt64LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigInt64LE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigInt64LE"); + return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset); + } + /** + * Writes an Int8 value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt8(value, offset) { + this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset); + return this; + } + /** + * Inserts an Int8 value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt8(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset); + } + /** + * Writes an Int16BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt16BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); + } + /** + * Inserts an Int16BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt16BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); + } + /** + * Writes an Int16LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt16LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); + } + /** + * Inserts an Int16LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt16LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); + } + /** + * Writes an Int32BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt32BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); + } + /** + * Inserts an Int32BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt32BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); + } + /** + * Writes an Int32LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt32LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); + } + /** + * Inserts an Int32LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt32LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); + } + /** + * Writes a BigInt64BE value to the current write position (or at optional offset). + * + * @param value { BigInt } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64BE"); + return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset); + } + /** + * Inserts a BigInt64BE value at the given offset value. + * + * @param value { BigInt } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64BE"); + return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset); + } + /** + * Writes a BigInt64LE value to the current write position (or at optional offset). + * + * @param value { BigInt } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64LE"); + return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset); + } + /** + * Inserts a Int64LE value at the given offset value. + * + * @param value { BigInt } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64LE"); + return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset); + } + // Unsigned Integers + /** + * Reads an UInt8 value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt8(offset) { + return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset); + } + /** + * Reads an UInt16BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt16BE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset); + } + /** + * Reads an UInt16LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt16LE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset); + } + /** + * Reads an UInt32BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt32BE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset); + } + /** + * Reads an UInt32LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt32LE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset); + } + /** + * Reads a BigUInt64BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigUInt64BE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigUInt64BE"); + return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset); + } + /** + * Reads a BigUInt64LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigUInt64LE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigUInt64LE"); + return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset); + } + /** + * Writes an UInt8 value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt8(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); + } + /** + * Inserts an UInt8 value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt8(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); + } + /** + * Writes an UInt16BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt16BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); + } + /** + * Inserts an UInt16BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt16BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); + } + /** + * Writes an UInt16LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt16LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); + } + /** + * Inserts an UInt16LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt16LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); + } + /** + * Writes an UInt32BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt32BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); + } + /** + * Inserts an UInt32BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt32BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); + } + /** + * Writes an UInt32LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt32LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); + } + /** + * Inserts an UInt32LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt32LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); + } + /** + * Writes a BigUInt64BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigUInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE"); + return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset); + } + /** + * Inserts a BigUInt64BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigUInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE"); + return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset); + } + /** + * Writes a BigUInt64LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigUInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE"); + return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset); + } + /** + * Inserts a BigUInt64LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigUInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE"); + return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset); + } + // Floating Point + /** + * Reads an FloatBE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readFloatBE(offset) { + return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset); + } + /** + * Reads an FloatLE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readFloatLE(offset) { + return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset); + } + /** + * Writes a FloatBE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeFloatBE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); + } + /** + * Inserts a FloatBE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertFloatBE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); + } + /** + * Writes a FloatLE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeFloatLE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); + } + /** + * Inserts a FloatLE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertFloatLE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); + } + // Double Floating Point + /** + * Reads an DoublEBE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readDoubleBE(offset) { + return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset); + } + /** + * Reads an DoubleLE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readDoubleLE(offset) { + return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset); + } + /** + * Writes a DoubleBE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeDoubleBE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); + } + /** + * Inserts a DoubleBE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertDoubleBE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); + } + /** + * Writes a DoubleLE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeDoubleLE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); + } + /** + * Inserts a DoubleLE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertDoubleLE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); + } + // Strings + /** + * Reads a String from the current read position. + * + * @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for + * the string (Defaults to instance level encoding). + * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). + * + * @return { String } + */ + readString(arg1, encoding) { + let lengthVal; + if (typeof arg1 === "number") { + utils_1.checkLengthValue(arg1); + lengthVal = Math.min(arg1, this.length - this._readOffset); + } else { + encoding = arg1; + lengthVal = this.length - this._readOffset; + } + if (typeof encoding !== "undefined") { + utils_1.checkEncoding(encoding); + } + const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding); + this._readOffset += lengthVal; + return value; + } + /** + * Inserts a String + * + * @param value { String } The String value to insert. + * @param offset { Number } The offset to insert the string at. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + insertString(value, offset, encoding) { + utils_1.checkOffsetValue(offset); + return this._handleString(value, true, offset, encoding); + } + /** + * Writes a String + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + writeString(value, arg2, encoding) { + return this._handleString(value, false, arg2, encoding); + } + /** + * Reads a null-terminated String from the current read position. + * + * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). + * + * @return { String } + */ + readStringNT(encoding) { + if (typeof encoding !== "undefined") { + utils_1.checkEncoding(encoding); + } + let nullPos = this.length; + for (let i = this._readOffset; i < this.length; i++) { + if (this._buff[i] === 0) { + nullPos = i; + break; + } + } + const value = this._buff.slice(this._readOffset, nullPos); + this._readOffset = nullPos + 1; + return value.toString(encoding || this._encoding); + } + /** + * Inserts a null-terminated String. + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + insertStringNT(value, offset, encoding) { + utils_1.checkOffsetValue(offset); + this.insertString(value, offset, encoding); + this.insertUInt8(0, offset + value.length); + return this; + } + /** + * Writes a null-terminated String. + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + writeStringNT(value, arg2, encoding) { + this.writeString(value, arg2, encoding); + this.writeUInt8(0, typeof arg2 === "number" ? arg2 + value.length : this.writeOffset); + return this; + } + // Buffers + /** + * Reads a Buffer from the internal read position. + * + * @param length { Number } The length of data to read as a Buffer. + * + * @return { Buffer } + */ + readBuffer(length) { + if (typeof length !== "undefined") { + utils_1.checkLengthValue(length); + } + const lengthVal = typeof length === "number" ? length : this.length; + const endPoint = Math.min(this.length, this._readOffset + lengthVal); + const value = this._buff.slice(this._readOffset, endPoint); + this._readOffset = endPoint; + return value; + } + /** + * Writes a Buffer to the current write position. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + insertBuffer(value, offset) { + utils_1.checkOffsetValue(offset); + return this._handleBuffer(value, true, offset); + } + /** + * Writes a Buffer to the current write position. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + writeBuffer(value, offset) { + return this._handleBuffer(value, false, offset); + } + /** + * Reads a null-terminated Buffer from the current read poisiton. + * + * @return { Buffer } + */ + readBufferNT() { + let nullPos = this.length; + for (let i = this._readOffset; i < this.length; i++) { + if (this._buff[i] === 0) { + nullPos = i; + break; + } + } + const value = this._buff.slice(this._readOffset, nullPos); + this._readOffset = nullPos + 1; + return value; + } + /** + * Inserts a null-terminated Buffer. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + insertBufferNT(value, offset) { + utils_1.checkOffsetValue(offset); + this.insertBuffer(value, offset); + this.insertUInt8(0, offset + value.length); + return this; + } + /** + * Writes a null-terminated Buffer. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + writeBufferNT(value, offset) { + if (typeof offset !== "undefined") { + utils_1.checkOffsetValue(offset); + } + this.writeBuffer(value, offset); + this.writeUInt8(0, typeof offset === "number" ? offset + value.length : this._writeOffset); + return this; + } + /** + * Clears the SmartBuffer instance to its original empty state. + */ + clear() { + this._writeOffset = 0; + this._readOffset = 0; + this.length = 0; + return this; + } + /** + * Gets the remaining data left to be read from the SmartBuffer instance. + * + * @return { Number } + */ + remaining() { + return this.length - this._readOffset; + } + /** + * Gets the current read offset value of the SmartBuffer instance. + * + * @return { Number } + */ + get readOffset() { + return this._readOffset; + } + /** + * Sets the read offset value of the SmartBuffer instance. + * + * @param offset { Number } - The offset value to set. + */ + set readOffset(offset) { + utils_1.checkOffsetValue(offset); + utils_1.checkTargetOffset(offset, this); + this._readOffset = offset; + } + /** + * Gets the current write offset value of the SmartBuffer instance. + * + * @return { Number } + */ + get writeOffset() { + return this._writeOffset; + } + /** + * Sets the write offset value of the SmartBuffer instance. + * + * @param offset { Number } - The offset value to set. + */ + set writeOffset(offset) { + utils_1.checkOffsetValue(offset); + utils_1.checkTargetOffset(offset, this); + this._writeOffset = offset; + } + /** + * Gets the currently set string encoding of the SmartBuffer instance. + * + * @return { BufferEncoding } The string Buffer encoding currently set. + */ + get encoding() { + return this._encoding; + } + /** + * Sets the string encoding of the SmartBuffer instance. + * + * @param encoding { BufferEncoding } The string Buffer encoding to set. + */ + set encoding(encoding) { + utils_1.checkEncoding(encoding); + this._encoding = encoding; + } + /** + * Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer) + * + * @return { Buffer } The Buffer value. + */ + get internalBuffer() { + return this._buff; + } + /** + * Gets the value of the internal managed Buffer (Includes managed data only) + * + * @param { Buffer } + */ + toBuffer() { + return this._buff.slice(0, this.length); + } + /** + * Gets the String value of the internal managed Buffer + * + * @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding). + */ + toString(encoding) { + const encodingVal = typeof encoding === "string" ? encoding : this._encoding; + utils_1.checkEncoding(encodingVal); + return this._buff.toString(encodingVal, 0, this.length); + } + /** + * Destroys the SmartBuffer instance. + */ + destroy() { + this.clear(); + return this; + } + /** + * Handles inserting and writing strings. + * + * @param value { String } The String value to insert. + * @param isInsert { Boolean } True if inserting a string, false if writing. + * @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + */ + _handleString(value, isInsert, arg3, encoding) { + let offsetVal = this._writeOffset; + let encodingVal = this._encoding; + if (typeof arg3 === "number") { + offsetVal = arg3; + } else if (typeof arg3 === "string") { + utils_1.checkEncoding(arg3); + encodingVal = arg3; + } + if (typeof encoding === "string") { + utils_1.checkEncoding(encoding); + encodingVal = encoding; + } + const byteLength = Buffer.byteLength(value, encodingVal); + if (isInsert) { + this.ensureInsertable(byteLength, offsetVal); + } else { + this._ensureWriteable(byteLength, offsetVal); + } + this._buff.write(value, offsetVal, byteLength, encodingVal); + if (isInsert) { + this._writeOffset += byteLength; + } else { + if (typeof arg3 === "number") { + this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength); + } else { + this._writeOffset += byteLength; + } + } + return this; + } + /** + * Handles writing or insert of a Buffer. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + */ + _handleBuffer(value, isInsert, offset) { + const offsetVal = typeof offset === "number" ? offset : this._writeOffset; + if (isInsert) { + this.ensureInsertable(value.length, offsetVal); + } else { + this._ensureWriteable(value.length, offsetVal); + } + value.copy(this._buff, offsetVal); + if (isInsert) { + this._writeOffset += value.length; + } else { + if (typeof offset === "number") { + this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length); + } else { + this._writeOffset += value.length; + } + } + return this; + } + /** + * Ensures that the internal Buffer is large enough to read data. + * + * @param length { Number } The length of the data that needs to be read. + * @param offset { Number } The offset of the data that needs to be read. + */ + ensureReadable(length, offset) { + let offsetVal = this._readOffset; + if (typeof offset !== "undefined") { + utils_1.checkOffsetValue(offset); + offsetVal = offset; + } + if (offsetVal < 0 || offsetVal + length > this.length) { + throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS); + } + } + /** + * Ensures that the internal Buffer is large enough to insert data. + * + * @param dataLength { Number } The length of the data that needs to be written. + * @param offset { Number } The offset of the data to be written. + */ + ensureInsertable(dataLength, offset) { + utils_1.checkOffsetValue(offset); + this._ensureCapacity(this.length + dataLength); + if (offset < this.length) { + this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length); + } + if (offset + dataLength > this.length) { + this.length = offset + dataLength; + } else { + this.length += dataLength; + } + } + /** + * Ensures that the internal Buffer is large enough to write data. + * + * @param dataLength { Number } The length of the data that needs to be written. + * @param offset { Number } The offset of the data to be written (defaults to writeOffset). + */ + _ensureWriteable(dataLength, offset) { + const offsetVal = typeof offset === "number" ? offset : this._writeOffset; + this._ensureCapacity(offsetVal + dataLength); + if (offsetVal + dataLength > this.length) { + this.length = offsetVal + dataLength; + } + } + /** + * Ensures that the internal Buffer is large enough to write at least the given amount of data. + * + * @param minLength { Number } The minimum length of the data needs to be written. + */ + _ensureCapacity(minLength) { + const oldLength = this._buff.length; + if (minLength > oldLength) { + let data = this._buff; + let newLength = oldLength * 3 / 2 + 1; + if (newLength < minLength) { + newLength = minLength; + } + this._buff = Buffer.allocUnsafe(newLength); + data.copy(this._buff, 0, 0, oldLength); + } + } + /** + * Reads a numeric number value using the provided function. + * + * @typeparam T { number | bigint } The type of the value to be read + * + * @param func { Function(offset: number) => number } The function to read data on the internal Buffer with. + * @param byteSize { Number } The number of bytes read. + * @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead. + * + * @returns { T } the number value + */ + _readNumberValue(func, byteSize, offset) { + this.ensureReadable(byteSize, offset); + const value = func.call(this._buff, typeof offset === "number" ? offset : this._readOffset); + if (typeof offset === "undefined") { + this._readOffset += byteSize; + } + return value; + } + /** + * Inserts a numeric number value based on the given offset and value. + * + * @typeparam T { number | bigint } The type of the value to be written + * + * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. + * @param byteSize { Number } The number of bytes written. + * @param value { T } The number value to write. + * @param offset { Number } the offset to write the number at (REQUIRED). + * + * @returns SmartBuffer this buffer + */ + _insertNumberValue(func, byteSize, value, offset) { + utils_1.checkOffsetValue(offset); + this.ensureInsertable(byteSize, offset); + func.call(this._buff, value, offset); + this._writeOffset += byteSize; + return this; + } + /** + * Writes a numeric number value based on the given offset and value. + * + * @typeparam T { number | bigint } The type of the value to be written + * + * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. + * @param byteSize { Number } The number of bytes written. + * @param value { T } The number value to write. + * @param offset { Number } the offset to write the number at (REQUIRED). + * + * @returns SmartBuffer this buffer + */ + _writeNumberValue(func, byteSize, value, offset) { + if (typeof offset === "number") { + if (offset < 0) { + throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS); + } + utils_1.checkOffsetValue(offset); + } + const offsetVal = typeof offset === "number" ? offset : this._writeOffset; + this._ensureWriteable(byteSize, offsetVal); + func.call(this._buff, value, offsetVal); + if (typeof offset === "number") { + this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize); + } else { + this._writeOffset += byteSize; + } + return this; + } + }; + exports.SmartBuffer = SmartBuffer; + } +}); + +// node_modules/socks/build/common/constants.js +var require_constants6 = __commonJS({ + "node_modules/socks/build/common/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SOCKS5_NO_ACCEPTABLE_AUTH = exports.SOCKS5_CUSTOM_AUTH_END = exports.SOCKS5_CUSTOM_AUTH_START = exports.SOCKS_INCOMING_PACKET_SIZES = exports.SocksClientState = exports.Socks5Response = exports.Socks5HostType = exports.Socks5Auth = exports.Socks4Response = exports.SocksCommand = exports.ERRORS = exports.DEFAULT_TIMEOUT = void 0; + var DEFAULT_TIMEOUT = 3e4; + exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT; + var ERRORS = { + InvalidSocksCommand: "An invalid SOCKS command was provided. Valid options are connect, bind, and associate.", + InvalidSocksCommandForOperation: "An invalid SOCKS command was provided. Only a subset of commands are supported for this operation.", + InvalidSocksCommandChain: "An invalid SOCKS command was provided. Chaining currently only supports the connect command.", + InvalidSocksClientOptionsDestination: "An invalid destination host was provided.", + InvalidSocksClientOptionsExistingSocket: "An invalid existing socket was provided. This should be an instance of stream.Duplex.", + InvalidSocksClientOptionsProxy: "Invalid SOCKS proxy details were provided.", + InvalidSocksClientOptionsTimeout: "An invalid timeout value was provided. Please enter a value above 0 (in ms).", + InvalidSocksClientOptionsProxiesLength: "At least two socks proxies must be provided for chaining.", + InvalidSocksClientOptionsCustomAuthRange: "Custom auth must be a value between 0x80 and 0xFE.", + InvalidSocksClientOptionsCustomAuthOptions: "When a custom_auth_method is provided, custom_auth_request_handler, custom_auth_response_size, and custom_auth_response_handler must also be provided and valid.", + NegotiationError: "Negotiation error", + SocketClosed: "Socket closed", + ProxyConnectionTimedOut: "Proxy connection timed out", + InternalError: "SocksClient internal error (this should not happen)", + InvalidSocks4HandshakeResponse: "Received invalid Socks4 handshake response", + Socks4ProxyRejectedConnection: "Socks4 Proxy rejected connection", + InvalidSocks4IncomingConnectionResponse: "Socks4 invalid incoming connection response", + Socks4ProxyRejectedIncomingBoundConnection: "Socks4 Proxy rejected incoming bound connection", + InvalidSocks5InitialHandshakeResponse: "Received invalid Socks5 initial handshake response", + InvalidSocks5IntiailHandshakeSocksVersion: "Received invalid Socks5 initial handshake (invalid socks version)", + InvalidSocks5InitialHandshakeNoAcceptedAuthType: "Received invalid Socks5 initial handshake (no accepted authentication type)", + InvalidSocks5InitialHandshakeUnknownAuthType: "Received invalid Socks5 initial handshake (unknown authentication type)", + Socks5AuthenticationFailed: "Socks5 Authentication failed", + InvalidSocks5FinalHandshake: "Received invalid Socks5 final handshake response", + InvalidSocks5FinalHandshakeRejected: "Socks5 proxy rejected connection", + InvalidSocks5IncomingConnectionResponse: "Received invalid Socks5 incoming connection response", + Socks5ProxyRejectedIncomingBoundConnection: "Socks5 Proxy rejected incoming bound connection" + }; + exports.ERRORS = ERRORS; + var SOCKS_INCOMING_PACKET_SIZES = { + Socks5InitialHandshakeResponse: 2, + Socks5UserPassAuthenticationResponse: 2, + // Command response + incoming connection (bind) + Socks5ResponseHeader: 5, + // We need at least 5 to read the hostname length, then we wait for the address+port information. + Socks5ResponseIPv4: 10, + // 4 header + 4 ip + 2 port + Socks5ResponseIPv6: 22, + // 4 header + 16 ip + 2 port + Socks5ResponseHostname: (hostNameLength) => hostNameLength + 7, + // 4 header + 1 host length + host + 2 port + // Command response + incoming connection (bind) + Socks4Response: 8 + // 2 header + 2 port + 4 ip + }; + exports.SOCKS_INCOMING_PACKET_SIZES = SOCKS_INCOMING_PACKET_SIZES; + var SocksCommand; + (function(SocksCommand2) { + SocksCommand2[SocksCommand2["connect"] = 1] = "connect"; + SocksCommand2[SocksCommand2["bind"] = 2] = "bind"; + SocksCommand2[SocksCommand2["associate"] = 3] = "associate"; + })(SocksCommand || (exports.SocksCommand = SocksCommand = {})); + var Socks4Response; + (function(Socks4Response2) { + Socks4Response2[Socks4Response2["Granted"] = 90] = "Granted"; + Socks4Response2[Socks4Response2["Failed"] = 91] = "Failed"; + Socks4Response2[Socks4Response2["Rejected"] = 92] = "Rejected"; + Socks4Response2[Socks4Response2["RejectedIdent"] = 93] = "RejectedIdent"; + })(Socks4Response || (exports.Socks4Response = Socks4Response = {})); + var Socks5Auth; + (function(Socks5Auth2) { + Socks5Auth2[Socks5Auth2["NoAuth"] = 0] = "NoAuth"; + Socks5Auth2[Socks5Auth2["GSSApi"] = 1] = "GSSApi"; + Socks5Auth2[Socks5Auth2["UserPass"] = 2] = "UserPass"; + })(Socks5Auth || (exports.Socks5Auth = Socks5Auth = {})); + var SOCKS5_CUSTOM_AUTH_START = 128; + exports.SOCKS5_CUSTOM_AUTH_START = SOCKS5_CUSTOM_AUTH_START; + var SOCKS5_CUSTOM_AUTH_END = 254; + exports.SOCKS5_CUSTOM_AUTH_END = SOCKS5_CUSTOM_AUTH_END; + var SOCKS5_NO_ACCEPTABLE_AUTH = 255; + exports.SOCKS5_NO_ACCEPTABLE_AUTH = SOCKS5_NO_ACCEPTABLE_AUTH; + var Socks5Response; + (function(Socks5Response2) { + Socks5Response2[Socks5Response2["Granted"] = 0] = "Granted"; + Socks5Response2[Socks5Response2["Failure"] = 1] = "Failure"; + Socks5Response2[Socks5Response2["NotAllowed"] = 2] = "NotAllowed"; + Socks5Response2[Socks5Response2["NetworkUnreachable"] = 3] = "NetworkUnreachable"; + Socks5Response2[Socks5Response2["HostUnreachable"] = 4] = "HostUnreachable"; + Socks5Response2[Socks5Response2["ConnectionRefused"] = 5] = "ConnectionRefused"; + Socks5Response2[Socks5Response2["TTLExpired"] = 6] = "TTLExpired"; + Socks5Response2[Socks5Response2["CommandNotSupported"] = 7] = "CommandNotSupported"; + Socks5Response2[Socks5Response2["AddressNotSupported"] = 8] = "AddressNotSupported"; + })(Socks5Response || (exports.Socks5Response = Socks5Response = {})); + var Socks5HostType; + (function(Socks5HostType2) { + Socks5HostType2[Socks5HostType2["IPv4"] = 1] = "IPv4"; + Socks5HostType2[Socks5HostType2["Hostname"] = 3] = "Hostname"; + Socks5HostType2[Socks5HostType2["IPv6"] = 4] = "IPv6"; + })(Socks5HostType || (exports.Socks5HostType = Socks5HostType = {})); + var SocksClientState; + (function(SocksClientState2) { + SocksClientState2[SocksClientState2["Created"] = 0] = "Created"; + SocksClientState2[SocksClientState2["Connecting"] = 1] = "Connecting"; + SocksClientState2[SocksClientState2["Connected"] = 2] = "Connected"; + SocksClientState2[SocksClientState2["SentInitialHandshake"] = 3] = "SentInitialHandshake"; + SocksClientState2[SocksClientState2["ReceivedInitialHandshakeResponse"] = 4] = "ReceivedInitialHandshakeResponse"; + SocksClientState2[SocksClientState2["SentAuthentication"] = 5] = "SentAuthentication"; + SocksClientState2[SocksClientState2["ReceivedAuthenticationResponse"] = 6] = "ReceivedAuthenticationResponse"; + SocksClientState2[SocksClientState2["SentFinalHandshake"] = 7] = "SentFinalHandshake"; + SocksClientState2[SocksClientState2["ReceivedFinalResponse"] = 8] = "ReceivedFinalResponse"; + SocksClientState2[SocksClientState2["BoundWaitingForConnection"] = 9] = "BoundWaitingForConnection"; + SocksClientState2[SocksClientState2["Established"] = 10] = "Established"; + SocksClientState2[SocksClientState2["Disconnected"] = 11] = "Disconnected"; + SocksClientState2[SocksClientState2["Error"] = 99] = "Error"; + })(SocksClientState || (exports.SocksClientState = SocksClientState = {})); + } +}); + +// node_modules/socks/build/common/util.js +var require_util9 = __commonJS({ + "node_modules/socks/build/common/util.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.shuffleArray = exports.SocksClientError = void 0; + var SocksClientError = class extends Error { + constructor(message, options) { + super(message); + this.options = options; + } + }; + exports.SocksClientError = SocksClientError; + function shuffleArray(array) { + for (let i = array.length - 1; i > 0; i--) { + const j = Math.floor(Math.random() * (i + 1)); + [array[i], array[j]] = [array[j], array[i]]; + } + } + exports.shuffleArray = shuffleArray; + } +}); + +// node_modules/ip-address/dist/common.js +var require_common = __commonJS({ + "node_modules/ip-address/dist/common.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isInSubnet = isInSubnet; + exports.isCorrect = isCorrect; + exports.numberToPaddedHex = numberToPaddedHex; + exports.stringToPaddedHex = stringToPaddedHex; + exports.testBit = testBit; + function isInSubnet(address) { + if (this.subnetMask < address.subnetMask) { + return false; + } + if (this.mask(address.subnetMask) === address.mask()) { + return true; + } + return false; + } + function isCorrect(defaultBits) { + return function() { + if (this.addressMinusSuffix !== this.correctForm()) { + return false; + } + if (this.subnetMask === defaultBits && !this.parsedSubnet) { + return true; + } + return this.parsedSubnet === String(this.subnetMask); + }; + } + function numberToPaddedHex(number) { + return number.toString(16).padStart(2, "0"); + } + function stringToPaddedHex(numberString) { + return numberToPaddedHex(parseInt(numberString, 10)); + } + function testBit(binaryValue, position) { + const { length } = binaryValue; + if (position > length) { + return false; + } + const positionInString = length - position; + return binaryValue.substring(positionInString, positionInString + 1) === "1"; + } + } +}); + +// node_modules/ip-address/dist/v4/constants.js +var require_constants7 = __commonJS({ + "node_modules/ip-address/dist/v4/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0; + exports.BITS = 32; + exports.GROUPS = 4; + exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g; + exports.RE_SUBNET_STRING = /\/\d{1,2}$/; + } +}); + +// node_modules/ip-address/dist/address-error.js +var require_address_error = __commonJS({ + "node_modules/ip-address/dist/address-error.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AddressError = void 0; + var AddressError = class extends Error { + constructor(message, parseMessage) { + super(message); + this.name = "AddressError"; + this.parseMessage = parseMessage; + } + }; + exports.AddressError = AddressError; + } +}); + +// node_modules/ip-address/dist/ipv4.js +var require_ipv4 = __commonJS({ + "node_modules/ip-address/dist/ipv4.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Address4 = void 0; + var common2 = __importStar(require_common()); + var constants3 = __importStar(require_constants7()); + var address_error_1 = require_address_error(); + var Address4 = class _Address4 { + constructor(address) { + this.groups = constants3.GROUPS; + this.parsedAddress = []; + this.parsedSubnet = ""; + this.subnet = "/32"; + this.subnetMask = 32; + this.v4 = true; + this.isCorrect = common2.isCorrect(constants3.BITS); + this.isInSubnet = common2.isInSubnet; + this.address = address; + const subnet = constants3.RE_SUBNET_STRING.exec(address); + if (subnet) { + this.parsedSubnet = subnet[0].replace("/", ""); + this.subnetMask = parseInt(this.parsedSubnet, 10); + this.subnet = `/${this.subnetMask}`; + if (this.subnetMask < 0 || this.subnetMask > constants3.BITS) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + address = address.replace(constants3.RE_SUBNET_STRING, ""); + } + this.addressMinusSuffix = address; + this.parsedAddress = this.parse(address); + } + static isValid(address) { + try { + new _Address4(address); + return true; + } catch (e2) { + return false; + } + } + /* + * Parses a v4 address + */ + parse(address) { + const groups = address.split("."); + if (!address.match(constants3.RE_ADDRESS)) { + throw new address_error_1.AddressError("Invalid IPv4 address."); + } + return groups; + } + /** + * Returns the correct form of an address + * @memberof Address4 + * @instance + * @returns {String} + */ + correctForm() { + return this.parsedAddress.map((part) => parseInt(part, 10)).join("."); + } + /** + * Converts a hex string to an IPv4 address object + * @memberof Address4 + * @static + * @param {string} hex - a hex string to convert + * @returns {Address4} + */ + static fromHex(hex) { + const padded = hex.replace(/:/g, "").padStart(8, "0"); + const groups = []; + let i; + for (i = 0; i < 8; i += 2) { + const h = padded.slice(i, i + 2); + groups.push(parseInt(h, 16)); + } + return new _Address4(groups.join(".")); + } + /** + * Converts an integer into a IPv4 address object + * @memberof Address4 + * @static + * @param {integer} integer - a number to convert + * @returns {Address4} + */ + static fromInteger(integer) { + return _Address4.fromHex(integer.toString(16)); + } + /** + * Return an address from in-addr.arpa form + * @memberof Address4 + * @static + * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address + * @returns {Adress4} + * @example + * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.) + * address.correctForm(); // '192.0.2.42' + */ + static fromArpa(arpaFormAddress) { + const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, ""); + const address = leader.split(".").reverse().join("."); + return new _Address4(address); + } + /** + * Converts an IPv4 address object to a hex string + * @memberof Address4 + * @instance + * @returns {String} + */ + toHex() { + return this.parsedAddress.map((part) => common2.stringToPaddedHex(part)).join(":"); + } + /** + * Converts an IPv4 address object to an array of bytes + * @memberof Address4 + * @instance + * @returns {Array} + */ + toArray() { + return this.parsedAddress.map((part) => parseInt(part, 10)); + } + /** + * Converts an IPv4 address object to an IPv6 address group + * @memberof Address4 + * @instance + * @returns {String} + */ + toGroup6() { + const output = []; + let i; + for (i = 0; i < constants3.GROUPS; i += 2) { + output.push(`${common2.stringToPaddedHex(this.parsedAddress[i])}${common2.stringToPaddedHex(this.parsedAddress[i + 1])}`); + } + return output.join(":"); + } + /** + * Returns the address as a `bigint` + * @memberof Address4 + * @instance + * @returns {bigint} + */ + bigInt() { + return BigInt(`0x${this.parsedAddress.map((n) => common2.stringToPaddedHex(n)).join("")}`); + } + /** + * Helper function getting start address. + * @memberof Address4 + * @instance + * @returns {bigint} + */ + _startAddress() { + return BigInt(`0b${this.mask() + "0".repeat(constants3.BITS - this.subnetMask)}`); + } + /** + * The first address in the range given by this address' subnet. + * Often referred to as the Network Address. + * @memberof Address4 + * @instance + * @returns {Address4} + */ + startAddress() { + return _Address4.fromBigInt(this._startAddress()); + } + /** + * The first host address in the range given by this address's subnet ie + * the first address after the Network Address + * @memberof Address4 + * @instance + * @returns {Address4} + */ + startAddressExclusive() { + const adjust = BigInt("1"); + return _Address4.fromBigInt(this._startAddress() + adjust); + } + /** + * Helper function getting end address. + * @memberof Address4 + * @instance + * @returns {bigint} + */ + _endAddress() { + return BigInt(`0b${this.mask() + "1".repeat(constants3.BITS - this.subnetMask)}`); + } + /** + * The last address in the range given by this address' subnet + * Often referred to as the Broadcast + * @memberof Address4 + * @instance + * @returns {Address4} + */ + endAddress() { + return _Address4.fromBigInt(this._endAddress()); + } + /** + * The last host address in the range given by this address's subnet ie + * the last address prior to the Broadcast Address + * @memberof Address4 + * @instance + * @returns {Address4} + */ + endAddressExclusive() { + const adjust = BigInt("1"); + return _Address4.fromBigInt(this._endAddress() - adjust); + } + /** + * Converts a BigInt to a v4 address object + * @memberof Address4 + * @static + * @param {bigint} bigInt - a BigInt to convert + * @returns {Address4} + */ + static fromBigInt(bigInt) { + return _Address4.fromHex(bigInt.toString(16)); + } + /** + * Convert a byte array to an Address4 object + * @memberof Address4 + * @static + * @param {Array} bytes - an array of 4 bytes (0-255) + * @returns {Address4} + */ + static fromByteArray(bytes) { + if (bytes.length !== 4) { + throw new address_error_1.AddressError("IPv4 addresses require exactly 4 bytes"); + } + for (let i = 0; i < bytes.length; i++) { + if (!Number.isInteger(bytes[i]) || bytes[i] < 0 || bytes[i] > 255) { + throw new address_error_1.AddressError("All bytes must be integers between 0 and 255"); + } + } + return this.fromUnsignedByteArray(bytes); + } + /** + * Convert an unsigned byte array to an Address4 object + * @memberof Address4 + * @static + * @param {Array} bytes - an array of 4 unsigned bytes (0-255) + * @returns {Address4} + */ + static fromUnsignedByteArray(bytes) { + if (bytes.length !== 4) { + throw new address_error_1.AddressError("IPv4 addresses require exactly 4 bytes"); + } + const address = bytes.join("."); + return new _Address4(address); + } + /** + * Returns the first n bits of the address, defaulting to the + * subnet mask + * @memberof Address4 + * @instance + * @returns {String} + */ + mask(mask) { + if (mask === void 0) { + mask = this.subnetMask; + } + return this.getBitsBase2(0, mask); + } + /** + * Returns the bits in the given range as a base-2 string + * @memberof Address4 + * @instance + * @returns {string} + */ + getBitsBase2(start, end) { + return this.binaryZeroPad().slice(start, end); + } + /** + * Return the reversed ip6.arpa form of the address + * @memberof Address4 + * @param {Object} options + * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix + * @instance + * @returns {String} + */ + reverseForm(options) { + if (!options) { + options = {}; + } + const reversed = this.correctForm().split(".").reverse().join("."); + if (options.omitSuffix) { + return reversed; + } + return `${reversed}.in-addr.arpa.`; + } + /** + * Returns true if the given address is a multicast address + * @memberof Address4 + * @instance + * @returns {boolean} + */ + isMulticast() { + return this.isInSubnet(new _Address4("224.0.0.0/4")); + } + /** + * Returns a zero-padded base-2 string representation of the address + * @memberof Address4 + * @instance + * @returns {string} + */ + binaryZeroPad() { + return this.bigInt().toString(2).padStart(constants3.BITS, "0"); + } + /** + * Groups an IPv4 address for inclusion at the end of an IPv6 address + * @returns {String} + */ + groupForV6() { + const segments = this.parsedAddress; + return this.address.replace(constants3.RE_ADDRESS, `${segments.slice(0, 2).join(".")}.${segments.slice(2, 4).join(".")}`); + } + }; + exports.Address4 = Address4; + } +}); + +// node_modules/ip-address/dist/v6/constants.js +var require_constants8 = __commonJS({ + "node_modules/ip-address/dist/v6/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0; + exports.BITS = 128; + exports.GROUPS = 8; + exports.SCOPES = { + 0: "Reserved", + 1: "Interface local", + 2: "Link local", + 4: "Admin local", + 5: "Site local", + 8: "Organization local", + 14: "Global", + 15: "Reserved" + }; + exports.TYPES = { + "ff01::1/128": "Multicast (All nodes on this interface)", + "ff01::2/128": "Multicast (All routers on this interface)", + "ff02::1/128": "Multicast (All nodes on this link)", + "ff02::2/128": "Multicast (All routers on this link)", + "ff05::2/128": "Multicast (All routers in this site)", + "ff02::5/128": "Multicast (OSPFv3 AllSPF routers)", + "ff02::6/128": "Multicast (OSPFv3 AllDR routers)", + "ff02::9/128": "Multicast (RIP routers)", + "ff02::a/128": "Multicast (EIGRP routers)", + "ff02::d/128": "Multicast (PIM routers)", + "ff02::16/128": "Multicast (MLDv2 reports)", + "ff01::fb/128": "Multicast (mDNSv6)", + "ff02::fb/128": "Multicast (mDNSv6)", + "ff05::fb/128": "Multicast (mDNSv6)", + "ff02::1:2/128": "Multicast (All DHCP servers and relay agents on this link)", + "ff05::1:2/128": "Multicast (All DHCP servers and relay agents in this site)", + "ff02::1:3/128": "Multicast (All DHCP servers on this link)", + "ff05::1:3/128": "Multicast (All DHCP servers in this site)", + "::/128": "Unspecified", + "::1/128": "Loopback", + "ff00::/8": "Multicast", + "fe80::/10": "Link-local unicast" + }; + exports.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi; + exports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi; + exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/; + exports.RE_ZONE_STRING = /%.*$/; + exports.RE_URL = /^\[{0,1}([0-9a-f:]+)\]{0,1}/; + exports.RE_URL_WITH_PORT = /\[([0-9a-f:]+)\]:([0-9]{1,5})/; + } +}); + +// node_modules/ip-address/dist/v6/helpers.js +var require_helpers = __commonJS({ + "node_modules/ip-address/dist/v6/helpers.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.spanAllZeroes = spanAllZeroes; + exports.spanAll = spanAll; + exports.spanLeadingZeroes = spanLeadingZeroes; + exports.simpleGroup = simpleGroup; + function spanAllZeroes(s) { + return s.replace(/(0+)/g, '$1'); + } + function spanAll(s, offset = 0) { + const letters = s.split(""); + return letters.map((n, i) => `${spanAllZeroes(n)}`).join(""); + } + function spanLeadingZeroesSimple(group) { + return group.replace(/^(0+)/, '$1'); + } + function spanLeadingZeroes(address) { + const groups = address.split(":"); + return groups.map((g) => spanLeadingZeroesSimple(g)).join(":"); + } + function simpleGroup(addressString, offset = 0) { + const groups = addressString.split(":"); + return groups.map((g, i) => { + if (/group-v4/.test(g)) { + return g; + } + return `${spanLeadingZeroesSimple(g)}`; + }); + } + } +}); + +// node_modules/ip-address/dist/v6/regular-expressions.js +var require_regular_expressions = __commonJS({ + "node_modules/ip-address/dist/v6/regular-expressions.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ADDRESS_BOUNDARY = void 0; + exports.groupPossibilities = groupPossibilities; + exports.padGroup = padGroup; + exports.simpleRegularExpression = simpleRegularExpression; + exports.possibleElisions = possibleElisions; + var v6 = __importStar(require_constants8()); + function groupPossibilities(possibilities) { + return `(${possibilities.join("|")})`; + } + function padGroup(group) { + if (group.length < 4) { + return `0{0,${4 - group.length}}${group}`; + } + return group; + } + exports.ADDRESS_BOUNDARY = "[^A-Fa-f0-9:]"; + function simpleRegularExpression(groups) { + const zeroIndexes = []; + groups.forEach((group, i) => { + const groupInteger = parseInt(group, 16); + if (groupInteger === 0) { + zeroIndexes.push(i); + } + }); + const possibilities = zeroIndexes.map((zeroIndex) => groups.map((group, i) => { + if (i === zeroIndex) { + const elision = i === 0 || i === v6.GROUPS - 1 ? ":" : ""; + return groupPossibilities([padGroup(group), elision]); + } + return padGroup(group); + }).join(":")); + possibilities.push(groups.map(padGroup).join(":")); + return groupPossibilities(possibilities); + } + function possibleElisions(elidedGroups, moreLeft, moreRight) { + const left = moreLeft ? "" : ":"; + const right = moreRight ? "" : ":"; + const possibilities = []; + if (!moreLeft && !moreRight) { + possibilities.push("::"); + } + if (moreLeft && moreRight) { + possibilities.push(""); + } + if (moreRight && !moreLeft || !moreRight && moreLeft) { + possibilities.push(":"); + } + possibilities.push(`${left}(:0{1,4}){1,${elidedGroups - 1}}`); + possibilities.push(`(0{1,4}:){1,${elidedGroups - 1}}${right}`); + possibilities.push(`(0{1,4}:){${elidedGroups - 1}}0{1,4}`); + for (let groups = 1; groups < elidedGroups - 1; groups++) { + for (let position = 1; position < elidedGroups - groups; position++) { + possibilities.push(`(0{1,4}:){${position}}:(0{1,4}:){${elidedGroups - position - groups - 1}}0{1,4}`); + } + } + return groupPossibilities(possibilities); + } + } +}); + +// node_modules/ip-address/dist/ipv6.js +var require_ipv6 = __commonJS({ + "node_modules/ip-address/dist/ipv6.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Address6 = void 0; + var common2 = __importStar(require_common()); + var constants4 = __importStar(require_constants7()); + var constants6 = __importStar(require_constants8()); + var helpers = __importStar(require_helpers()); + var ipv4_1 = require_ipv4(); + var regular_expressions_1 = require_regular_expressions(); + var address_error_1 = require_address_error(); + var common_1 = require_common(); + function assert(condition) { + if (!condition) { + throw new Error("Assertion failed."); + } + } + function addCommas(number) { + const r = /(\d+)(\d{3})/; + while (r.test(number)) { + number = number.replace(r, "$1,$2"); + } + return number; + } + function spanLeadingZeroes4(n) { + n = n.replace(/^(0{1,})([1-9]+)$/, '$1$2'); + n = n.replace(/^(0{1,})(0)$/, '$1$2'); + return n; + } + function compact(address, slice) { + const s1 = []; + const s2 = []; + let i; + for (i = 0; i < address.length; i++) { + if (i < slice[0]) { + s1.push(address[i]); + } else if (i > slice[1]) { + s2.push(address[i]); + } + } + return s1.concat(["compact"]).concat(s2); + } + function paddedHex(octet) { + return parseInt(octet, 16).toString(16).padStart(4, "0"); + } + function unsignByte(b) { + return b & 255; + } + var Address6 = class _Address6 { + constructor(address, optionalGroups) { + this.addressMinusSuffix = ""; + this.parsedSubnet = ""; + this.subnet = "/128"; + this.subnetMask = 128; + this.v4 = false; + this.zone = ""; + this.isInSubnet = common2.isInSubnet; + this.isCorrect = common2.isCorrect(constants6.BITS); + if (optionalGroups === void 0) { + this.groups = constants6.GROUPS; + } else { + this.groups = optionalGroups; + } + this.address = address; + const subnet = constants6.RE_SUBNET_STRING.exec(address); + if (subnet) { + this.parsedSubnet = subnet[0].replace("/", ""); + this.subnetMask = parseInt(this.parsedSubnet, 10); + this.subnet = `/${this.subnetMask}`; + if (Number.isNaN(this.subnetMask) || this.subnetMask < 0 || this.subnetMask > constants6.BITS) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + address = address.replace(constants6.RE_SUBNET_STRING, ""); + } else if (/\//.test(address)) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + const zone = constants6.RE_ZONE_STRING.exec(address); + if (zone) { + this.zone = zone[0]; + address = address.replace(constants6.RE_ZONE_STRING, ""); + } + this.addressMinusSuffix = address; + this.parsedAddress = this.parse(this.addressMinusSuffix); + } + static isValid(address) { + try { + new _Address6(address); + return true; + } catch (e2) { + return false; + } + } + /** + * Convert a BigInt to a v6 address object + * @memberof Address6 + * @static + * @param {bigint} bigInt - a BigInt to convert + * @returns {Address6} + * @example + * var bigInt = BigInt('1000000000000'); + * var address = Address6.fromBigInt(bigInt); + * address.correctForm(); // '::e8:d4a5:1000' + */ + static fromBigInt(bigInt) { + const hex = bigInt.toString(16).padStart(32, "0"); + const groups = []; + let i; + for (i = 0; i < constants6.GROUPS; i++) { + groups.push(hex.slice(i * 4, (i + 1) * 4)); + } + return new _Address6(groups.join(":")); + } + /** + * Convert a URL (with optional port number) to an address object + * @memberof Address6 + * @static + * @param {string} url - a URL with optional port number + * @example + * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/'); + * addressAndPort.address.correctForm(); // 'ffff::' + * addressAndPort.port; // 8080 + */ + static fromURL(url) { + let host; + let port = null; + let result; + if (url.indexOf("[") !== -1 && url.indexOf("]:") !== -1) { + result = constants6.RE_URL_WITH_PORT.exec(url); + if (result === null) { + return { + error: "failed to parse address with port", + address: null, + port: null + }; + } + host = result[1]; + port = result[2]; + } else if (url.indexOf("/") !== -1) { + url = url.replace(/^[a-z0-9]+:\/\//, ""); + result = constants6.RE_URL.exec(url); + if (result === null) { + return { + error: "failed to parse address from URL", + address: null, + port: null + }; + } + host = result[1]; + } else { + host = url; + } + if (port) { + port = parseInt(port, 10); + if (port < 0 || port > 65536) { + port = null; + } + } else { + port = null; + } + return { + address: new _Address6(host), + port + }; + } + /** + * Create an IPv6-mapped address given an IPv4 address + * @memberof Address6 + * @static + * @param {string} address - An IPv4 address string + * @returns {Address6} + * @example + * var address = Address6.fromAddress4('192.168.0.1'); + * address.correctForm(); // '::ffff:c0a8:1' + * address.to4in6(); // '::ffff:192.168.0.1' + */ + static fromAddress4(address) { + const address4 = new ipv4_1.Address4(address); + const mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask); + return new _Address6(`::ffff:${address4.correctForm()}/${mask6}`); + } + /** + * Return an address from ip6.arpa form + * @memberof Address6 + * @static + * @param {string} arpaFormAddress - an 'ip6.arpa' form address + * @returns {Adress6} + * @example + * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.) + * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe' + */ + static fromArpa(arpaFormAddress) { + let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, ""); + const semicolonAmount = 7; + if (address.length !== 63) { + throw new address_error_1.AddressError("Invalid 'ip6.arpa' form."); + } + const parts = address.split(".").reverse(); + for (let i = semicolonAmount; i > 0; i--) { + const insertIndex = i * 4; + parts.splice(insertIndex, 0, ":"); + } + address = parts.join(""); + return new _Address6(address); + } + /** + * Return the Microsoft UNC transcription of the address + * @memberof Address6 + * @instance + * @returns {String} the Microsoft UNC transcription of the address + */ + microsoftTranscription() { + return `${this.correctForm().replace(/:/g, "-")}.ipv6-literal.net`; + } + /** + * Return the first n bits of the address, defaulting to the subnet mask + * @memberof Address6 + * @instance + * @param {number} [mask=subnet] - the number of bits to mask + * @returns {String} the first n bits of the address as a string + */ + mask(mask = this.subnetMask) { + return this.getBitsBase2(0, mask); + } + /** + * Return the number of possible subnets of a given size in the address + * @memberof Address6 + * @instance + * @param {number} [subnetSize=128] - the subnet size + * @returns {String} + */ + // TODO: probably useful to have a numeric version of this too + possibleSubnets(subnetSize = 128) { + const availableBits = constants6.BITS - this.subnetMask; + const subnetBits = Math.abs(subnetSize - constants6.BITS); + const subnetPowers = availableBits - subnetBits; + if (subnetPowers < 0) { + return "0"; + } + return addCommas((BigInt("2") ** BigInt(subnetPowers)).toString(10)); + } + /** + * Helper function getting start address. + * @memberof Address6 + * @instance + * @returns {bigint} + */ + _startAddress() { + return BigInt(`0b${this.mask() + "0".repeat(constants6.BITS - this.subnetMask)}`); + } + /** + * The first address in the range given by this address' subnet + * Often referred to as the Network Address. + * @memberof Address6 + * @instance + * @returns {Address6} + */ + startAddress() { + return _Address6.fromBigInt(this._startAddress()); + } + /** + * The first host address in the range given by this address's subnet ie + * the first address after the Network Address + * @memberof Address6 + * @instance + * @returns {Address6} + */ + startAddressExclusive() { + const adjust = BigInt("1"); + return _Address6.fromBigInt(this._startAddress() + adjust); + } + /** + * Helper function getting end address. + * @memberof Address6 + * @instance + * @returns {bigint} + */ + _endAddress() { + return BigInt(`0b${this.mask() + "1".repeat(constants6.BITS - this.subnetMask)}`); + } + /** + * The last address in the range given by this address' subnet + * Often referred to as the Broadcast + * @memberof Address6 + * @instance + * @returns {Address6} + */ + endAddress() { + return _Address6.fromBigInt(this._endAddress()); + } + /** + * The last host address in the range given by this address's subnet ie + * the last address prior to the Broadcast Address + * @memberof Address6 + * @instance + * @returns {Address6} + */ + endAddressExclusive() { + const adjust = BigInt("1"); + return _Address6.fromBigInt(this._endAddress() - adjust); + } + /** + * Return the scope of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + getScope() { + let scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)]; + if (this.getType() === "Global unicast" && scope !== "Link local") { + scope = "Global"; + } + return scope || "Unknown"; + } + /** + * Return the type of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + getType() { + for (const subnet of Object.keys(constants6.TYPES)) { + if (this.isInSubnet(new _Address6(subnet))) { + return constants6.TYPES[subnet]; + } + } + return "Global unicast"; + } + /** + * Return the bits in the given range as a BigInt + * @memberof Address6 + * @instance + * @returns {bigint} + */ + getBits(start, end) { + return BigInt(`0b${this.getBitsBase2(start, end)}`); + } + /** + * Return the bits in the given range as a base-2 string + * @memberof Address6 + * @instance + * @returns {String} + */ + getBitsBase2(start, end) { + return this.binaryZeroPad().slice(start, end); + } + /** + * Return the bits in the given range as a base-16 string + * @memberof Address6 + * @instance + * @returns {String} + */ + getBitsBase16(start, end) { + const length = end - start; + if (length % 4 !== 0) { + throw new Error("Length of bits to retrieve must be divisible by four"); + } + return this.getBits(start, end).toString(16).padStart(length / 4, "0"); + } + /** + * Return the bits that are set past the subnet mask length + * @memberof Address6 + * @instance + * @returns {String} + */ + getBitsPastSubnet() { + return this.getBitsBase2(this.subnetMask, constants6.BITS); + } + /** + * Return the reversed ip6.arpa form of the address + * @memberof Address6 + * @param {Object} options + * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix + * @instance + * @returns {String} + */ + reverseForm(options) { + if (!options) { + options = {}; + } + const characters = Math.floor(this.subnetMask / 4); + const reversed = this.canonicalForm().replace(/:/g, "").split("").slice(0, characters).reverse().join("."); + if (characters > 0) { + if (options.omitSuffix) { + return reversed; + } + return `${reversed}.ip6.arpa.`; + } + if (options.omitSuffix) { + return ""; + } + return "ip6.arpa."; + } + /** + * Return the correct form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + correctForm() { + let i; + let groups = []; + let zeroCounter = 0; + const zeroes = []; + for (i = 0; i < this.parsedAddress.length; i++) { + const value = parseInt(this.parsedAddress[i], 16); + if (value === 0) { + zeroCounter++; + } + if (value !== 0 && zeroCounter > 0) { + if (zeroCounter > 1) { + zeroes.push([i - zeroCounter, i - 1]); + } + zeroCounter = 0; + } + } + if (zeroCounter > 1) { + zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]); + } + const zeroLengths = zeroes.map((n) => n[1] - n[0] + 1); + if (zeroes.length > 0) { + const index2 = zeroLengths.indexOf(Math.max(...zeroLengths)); + groups = compact(this.parsedAddress, zeroes[index2]); + } else { + groups = this.parsedAddress; + } + for (i = 0; i < groups.length; i++) { + if (groups[i] !== "compact") { + groups[i] = parseInt(groups[i], 16).toString(16); + } + } + let correct = groups.join(":"); + correct = correct.replace(/^compact$/, "::"); + correct = correct.replace(/(^compact)|(compact$)/, ":"); + correct = correct.replace(/compact/, ""); + return correct; + } + /** + * Return a zero-padded base-2 string representation of the address + * @memberof Address6 + * @instance + * @returns {String} + * @example + * var address = new Address6('2001:4860:4001:803::1011'); + * address.binaryZeroPad(); + * // '0010000000000001010010000110000001000000000000010000100000000011 + * // 0000000000000000000000000000000000000000000000000001000000010001' + */ + binaryZeroPad() { + return this.bigInt().toString(2).padStart(constants6.BITS, "0"); + } + // TODO: Improve the semantics of this helper function + parse4in6(address) { + const groups = address.split(":"); + const lastGroup = groups.slice(-1)[0]; + const address4 = lastGroup.match(constants4.RE_ADDRESS); + if (address4) { + this.parsedAddress4 = address4[0]; + this.address4 = new ipv4_1.Address4(this.parsedAddress4); + for (let i = 0; i < this.address4.groups; i++) { + if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) { + throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join("."))); + } + } + this.v4 = true; + groups[groups.length - 1] = this.address4.toGroup6(); + address = groups.join(":"); + } + return address; + } + // TODO: Make private? + parse(address) { + address = this.parse4in6(address); + const badCharacters = address.match(constants6.RE_BAD_CHARACTERS); + if (badCharacters) { + throw new address_error_1.AddressError(`Bad character${badCharacters.length > 1 ? "s" : ""} detected in address: ${badCharacters.join("")}`, address.replace(constants6.RE_BAD_CHARACTERS, '$1')); + } + const badAddress = address.match(constants6.RE_BAD_ADDRESS); + if (badAddress) { + throw new address_error_1.AddressError(`Address failed regex: ${badAddress.join("")}`, address.replace(constants6.RE_BAD_ADDRESS, '$1')); + } + let groups = []; + const halves = address.split("::"); + if (halves.length === 2) { + let first = halves[0].split(":"); + let last = halves[1].split(":"); + if (first.length === 1 && first[0] === "") { + first = []; + } + if (last.length === 1 && last[0] === "") { + last = []; + } + const remaining = this.groups - (first.length + last.length); + if (!remaining) { + throw new address_error_1.AddressError("Error parsing groups"); + } + this.elidedGroups = remaining; + this.elisionBegin = first.length; + this.elisionEnd = first.length + this.elidedGroups; + groups = groups.concat(first); + for (let i = 0; i < remaining; i++) { + groups.push("0"); + } + groups = groups.concat(last); + } else if (halves.length === 1) { + groups = address.split(":"); + this.elidedGroups = 0; + } else { + throw new address_error_1.AddressError("Too many :: groups found"); + } + groups = groups.map((group) => parseInt(group, 16).toString(16)); + if (groups.length !== this.groups) { + throw new address_error_1.AddressError("Incorrect number of groups found"); + } + return groups; + } + /** + * Return the canonical form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + canonicalForm() { + return this.parsedAddress.map(paddedHex).join(":"); + } + /** + * Return the decimal form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + decimal() { + return this.parsedAddress.map((n) => parseInt(n, 16).toString(10).padStart(5, "0")).join(":"); + } + /** + * Return the address as a BigInt + * @memberof Address6 + * @instance + * @returns {bigint} + */ + bigInt() { + return BigInt(`0x${this.parsedAddress.map(paddedHex).join("")}`); + } + /** + * Return the last two groups of this address as an IPv4 address string + * @memberof Address6 + * @instance + * @returns {Address4} + * @example + * var address = new Address6('2001:4860:4001::1825:bf11'); + * address.to4().correctForm(); // '24.37.191.17' + */ + to4() { + const binary2 = this.binaryZeroPad().split(""); + return ipv4_1.Address4.fromHex(BigInt(`0b${binary2.slice(96, 128).join("")}`).toString(16)); + } + /** + * Return the v4-in-v6 form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + to4in6() { + const address4 = this.to4(); + const address6 = new _Address6(this.parsedAddress.slice(0, 6).join(":"), 6); + const correct = address6.correctForm(); + let infix = ""; + if (!/:$/.test(correct)) { + infix = ":"; + } + return correct + infix + address4.address; + } + /** + * Return an object containing the Teredo properties of the address + * @memberof Address6 + * @instance + * @returns {Object} + */ + inspectTeredo() { + const prefix = this.getBitsBase16(0, 32); + const bitsForUdpPort = this.getBits(80, 96); + const udpPort = (bitsForUdpPort ^ BigInt("0xffff")).toString(); + const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64)); + const bitsForClient4 = this.getBits(96, 128); + const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt("0xffffffff")).toString(16)); + const flagsBase2 = this.getBitsBase2(64, 80); + const coneNat = (0, common_1.testBit)(flagsBase2, 15); + const reserved = (0, common_1.testBit)(flagsBase2, 14); + const groupIndividual = (0, common_1.testBit)(flagsBase2, 8); + const universalLocal = (0, common_1.testBit)(flagsBase2, 9); + const nonce = BigInt(`0b${flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16)}`).toString(10); + return { + prefix: `${prefix.slice(0, 4)}:${prefix.slice(4, 8)}`, + server4: server4.address, + client4: client4.address, + flags: flagsBase2, + coneNat, + microsoft: { + reserved, + universalLocal, + groupIndividual, + nonce + }, + udpPort + }; + } + /** + * Return an object containing the 6to4 properties of the address + * @memberof Address6 + * @instance + * @returns {Object} + */ + inspect6to4() { + const prefix = this.getBitsBase16(0, 16); + const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48)); + return { + prefix: prefix.slice(0, 4), + gateway: gateway.address + }; + } + /** + * Return a v6 6to4 address from a v6 v4inv6 address + * @memberof Address6 + * @instance + * @returns {Address6} + */ + to6to4() { + if (!this.is4()) { + return null; + } + const addr6to4 = [ + "2002", + this.getBitsBase16(96, 112), + this.getBitsBase16(112, 128), + "", + "/16" + ].join(":"); + return new _Address6(addr6to4); + } + /** + * Return a byte array + * @memberof Address6 + * @instance + * @returns {Array} + */ + toByteArray() { + const valueWithoutPadding = this.bigInt().toString(16); + const leadingPad = "0".repeat(valueWithoutPadding.length % 2); + const value = `${leadingPad}${valueWithoutPadding}`; + const bytes = []; + for (let i = 0, length = value.length; i < length; i += 2) { + bytes.push(parseInt(value.substring(i, i + 2), 16)); + } + return bytes; + } + /** + * Return an unsigned byte array + * @memberof Address6 + * @instance + * @returns {Array} + */ + toUnsignedByteArray() { + return this.toByteArray().map(unsignByte); + } + /** + * Convert a byte array to an Address6 object + * @memberof Address6 + * @static + * @returns {Address6} + */ + static fromByteArray(bytes) { + return this.fromUnsignedByteArray(bytes.map(unsignByte)); + } + /** + * Convert an unsigned byte array to an Address6 object + * @memberof Address6 + * @static + * @returns {Address6} + */ + static fromUnsignedByteArray(bytes) { + const BYTE_MAX = BigInt("256"); + let result = BigInt("0"); + let multiplier = BigInt("1"); + for (let i = bytes.length - 1; i >= 0; i--) { + result += multiplier * BigInt(bytes[i].toString(10)); + multiplier *= BYTE_MAX; + } + return _Address6.fromBigInt(result); + } + /** + * Returns true if the address is in the canonical form, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isCanonical() { + return this.addressMinusSuffix === this.canonicalForm(); + } + /** + * Returns true if the address is a link local address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isLinkLocal() { + if (this.getBitsBase2(0, 64) === "1111111010000000000000000000000000000000000000000000000000000000") { + return true; + } + return false; + } + /** + * Returns true if the address is a multicast address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isMulticast() { + return this.getType() === "Multicast"; + } + /** + * Returns true if the address is a v4-in-v6 address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + is4() { + return this.v4; + } + /** + * Returns true if the address is a Teredo address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isTeredo() { + return this.isInSubnet(new _Address6("2001::/32")); + } + /** + * Returns true if the address is a 6to4 address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + is6to4() { + return this.isInSubnet(new _Address6("2002::/16")); + } + /** + * Returns true if the address is a loopback address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isLoopback() { + return this.getType() === "Loopback"; + } + // #endregion + // #region HTML + /** + * @returns {String} the address in link form with a default port of 80 + */ + href(optionalPort) { + if (optionalPort === void 0) { + optionalPort = ""; + } else { + optionalPort = `:${optionalPort}`; + } + return `http://[${this.correctForm()}]${optionalPort}/`; + } + /** + * @returns {String} a link suitable for conveying the address via a URL hash + */ + link(options) { + if (!options) { + options = {}; + } + if (options.className === void 0) { + options.className = ""; + } + if (options.prefix === void 0) { + options.prefix = "/#address="; + } + if (options.v4 === void 0) { + options.v4 = false; + } + let formFunction = this.correctForm; + if (options.v4) { + formFunction = this.to4in6; + } + const form = formFunction.call(this); + if (options.className) { + return `${form}`; + } + return `${form}`; + } + /** + * Groups an address + * @returns {String} + */ + group() { + if (this.elidedGroups === 0) { + return helpers.simpleGroup(this.address).join(":"); + } + assert(typeof this.elidedGroups === "number"); + assert(typeof this.elisionBegin === "number"); + const output = []; + const [left, right] = this.address.split("::"); + if (left.length) { + output.push(...helpers.simpleGroup(left)); + } else { + output.push(""); + } + const classes = ["hover-group"]; + for (let i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) { + classes.push(`group-${i}`); + } + output.push(``); + if (right.length) { + output.push(...helpers.simpleGroup(right, this.elisionEnd)); + } else { + output.push(""); + } + if (this.is4()) { + assert(this.address4 instanceof ipv4_1.Address4); + output.pop(); + output.push(this.address4.groupForV6()); + } + return output.join(":"); + } + // #endregion + // #region Regular expressions + /** + * Generate a regular expression string that can be used to find or validate + * all variations of this address + * @memberof Address6 + * @instance + * @param {boolean} substringSearch + * @returns {string} + */ + regularExpressionString(substringSearch = false) { + let output = []; + const address6 = new _Address6(this.correctForm()); + if (address6.elidedGroups === 0) { + output.push((0, regular_expressions_1.simpleRegularExpression)(address6.parsedAddress)); + } else if (address6.elidedGroups === constants6.GROUPS) { + output.push((0, regular_expressions_1.possibleElisions)(constants6.GROUPS)); + } else { + const halves = address6.address.split("::"); + if (halves[0].length) { + output.push((0, regular_expressions_1.simpleRegularExpression)(halves[0].split(":"))); + } + assert(typeof address6.elidedGroups === "number"); + output.push((0, regular_expressions_1.possibleElisions)(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0)); + if (halves[1].length) { + output.push((0, regular_expressions_1.simpleRegularExpression)(halves[1].split(":"))); + } + output = [output.join(":")]; + } + if (!substringSearch) { + output = [ + "(?=^|", + regular_expressions_1.ADDRESS_BOUNDARY, + "|[^\\w\\:])(", + ...output, + ")(?=[^\\w\\:]|", + regular_expressions_1.ADDRESS_BOUNDARY, + "|$)" + ]; + } + return output.join(""); + } + /** + * Generate a regular expression that can be used to find or validate all + * variations of this address. + * @memberof Address6 + * @instance + * @param {boolean} substringSearch + * @returns {RegExp} + */ + regularExpression(substringSearch = false) { + return new RegExp(this.regularExpressionString(substringSearch), "i"); + } + }; + exports.Address6 = Address6; + } +}); + +// node_modules/ip-address/dist/ip-address.js +var require_ip_address = __commonJS({ + "node_modules/ip-address/dist/ip-address.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.v6 = exports.AddressError = exports.Address6 = exports.Address4 = void 0; + var ipv4_1 = require_ipv4(); + Object.defineProperty(exports, "Address4", { enumerable: true, get: function() { + return ipv4_1.Address4; + } }); + var ipv6_1 = require_ipv6(); + Object.defineProperty(exports, "Address6", { enumerable: true, get: function() { + return ipv6_1.Address6; + } }); + var address_error_1 = require_address_error(); + Object.defineProperty(exports, "AddressError", { enumerable: true, get: function() { + return address_error_1.AddressError; + } }); + var helpers = __importStar(require_helpers()); + exports.v6 = { helpers }; + } +}); + +// node_modules/socks/build/common/helpers.js +var require_helpers2 = __commonJS({ + "node_modules/socks/build/common/helpers.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ipToBuffer = exports.int32ToIpv4 = exports.ipv4ToInt32 = exports.validateSocksClientChainOptions = exports.validateSocksClientOptions = void 0; + var util_1 = require_util9(); + var constants_1 = require_constants6(); + var stream = __require("stream"); + var ip_address_1 = require_ip_address(); + var net2 = __require("net"); + function validateSocksClientOptions(options, acceptedCommands = ["connect", "bind", "associate"]) { + if (!constants_1.SocksCommand[options.command]) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommand, options); + } + if (acceptedCommands.indexOf(options.command) === -1) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandForOperation, options); + } + if (!isValidSocksRemoteHost(options.destination)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options); + } + if (!isValidSocksProxy(options.proxy)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options); + } + validateCustomProxyAuth(options.proxy, options); + if (options.timeout && !isValidTimeoutValue(options.timeout)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options); + } + if (options.existing_socket && !(options.existing_socket instanceof stream.Duplex)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsExistingSocket, options); + } + } + exports.validateSocksClientOptions = validateSocksClientOptions; + function validateSocksClientChainOptions(options) { + if (options.command !== "connect") { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandChain, options); + } + if (!isValidSocksRemoteHost(options.destination)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options); + } + if (!(options.proxies && Array.isArray(options.proxies) && options.proxies.length >= 2)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxiesLength, options); + } + options.proxies.forEach((proxy) => { + if (!isValidSocksProxy(proxy)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options); + } + validateCustomProxyAuth(proxy, options); + }); + if (options.timeout && !isValidTimeoutValue(options.timeout)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options); + } + } + exports.validateSocksClientChainOptions = validateSocksClientChainOptions; + function validateCustomProxyAuth(proxy, options) { + if (proxy.custom_auth_method !== void 0) { + if (proxy.custom_auth_method < constants_1.SOCKS5_CUSTOM_AUTH_START || proxy.custom_auth_method > constants_1.SOCKS5_CUSTOM_AUTH_END) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthRange, options); + } + if (proxy.custom_auth_request_handler === void 0 || typeof proxy.custom_auth_request_handler !== "function") { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options); + } + if (proxy.custom_auth_response_size === void 0) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options); + } + if (proxy.custom_auth_response_handler === void 0 || typeof proxy.custom_auth_response_handler !== "function") { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options); + } + } + } + function isValidSocksRemoteHost(remoteHost) { + return remoteHost && typeof remoteHost.host === "string" && Buffer.byteLength(remoteHost.host) < 256 && typeof remoteHost.port === "number" && remoteHost.port >= 0 && remoteHost.port <= 65535; + } + function isValidSocksProxy(proxy) { + return proxy && (typeof proxy.host === "string" || typeof proxy.ipaddress === "string") && typeof proxy.port === "number" && proxy.port >= 0 && proxy.port <= 65535 && (proxy.type === 4 || proxy.type === 5); + } + function isValidTimeoutValue(value) { + return typeof value === "number" && value > 0; + } + function ipv4ToInt32(ip) { + const address = new ip_address_1.Address4(ip); + return address.toArray().reduce((acc, part) => (acc << 8) + part, 0) >>> 0; + } + exports.ipv4ToInt32 = ipv4ToInt32; + function int32ToIpv4(int32) { + const octet1 = int32 >>> 24 & 255; + const octet2 = int32 >>> 16 & 255; + const octet3 = int32 >>> 8 & 255; + const octet4 = int32 & 255; + return [octet1, octet2, octet3, octet4].join("."); + } + exports.int32ToIpv4 = int32ToIpv4; + function ipToBuffer(ip) { + if (net2.isIPv4(ip)) { + const address = new ip_address_1.Address4(ip); + return Buffer.from(address.toArray()); + } else if (net2.isIPv6(ip)) { + const address = new ip_address_1.Address6(ip); + return Buffer.from(address.canonicalForm().split(":").map((segment) => segment.padStart(4, "0")).join(""), "hex"); + } else { + throw new Error("Invalid IP address format"); + } + } + exports.ipToBuffer = ipToBuffer; + } +}); + +// node_modules/socks/build/common/receivebuffer.js +var require_receivebuffer = __commonJS({ + "node_modules/socks/build/common/receivebuffer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ReceiveBuffer = void 0; + var ReceiveBuffer = class { + constructor(size = 4096) { + this.buffer = Buffer.allocUnsafe(size); + this.offset = 0; + this.originalSize = size; + } + get length() { + return this.offset; + } + append(data) { + if (!Buffer.isBuffer(data)) { + throw new Error("Attempted to append a non-buffer instance to ReceiveBuffer."); + } + if (this.offset + data.length >= this.buffer.length) { + const tmp = this.buffer; + this.buffer = Buffer.allocUnsafe(Math.max(this.buffer.length + this.originalSize, this.buffer.length + data.length)); + tmp.copy(this.buffer); + } + data.copy(this.buffer, this.offset); + return this.offset += data.length; + } + peek(length) { + if (length > this.offset) { + throw new Error("Attempted to read beyond the bounds of the managed internal data."); + } + return this.buffer.slice(0, length); + } + get(length) { + if (length > this.offset) { + throw new Error("Attempted to read beyond the bounds of the managed internal data."); + } + const value = Buffer.allocUnsafe(length); + this.buffer.slice(0, length).copy(value); + this.buffer.copyWithin(0, length, length + this.offset - length); + this.offset -= length; + return value; + } + }; + exports.ReceiveBuffer = ReceiveBuffer; + } +}); + +// node_modules/socks/build/client/socksclient.js +var require_socksclient = __commonJS({ + "node_modules/socks/build/client/socksclient.js"(exports) { + "use strict"; + var __awaiter6 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve2) { + resolve2(value); + }); + } + return new (P || (P = Promise))(function(resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e2) { + reject(e2); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e2) { + reject(e2); + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SocksClientError = exports.SocksClient = void 0; + var events_1 = __require("events"); + var net2 = __require("net"); + var smart_buffer_1 = require_smartbuffer(); + var constants_1 = require_constants6(); + var helpers_1 = require_helpers2(); + var receivebuffer_1 = require_receivebuffer(); + var util_1 = require_util9(); + Object.defineProperty(exports, "SocksClientError", { enumerable: true, get: function() { + return util_1.SocksClientError; + } }); + var ip_address_1 = require_ip_address(); + var SocksClient = class _SocksClient extends events_1.EventEmitter { + constructor(options) { + super(); + this.options = Object.assign({}, options); + (0, helpers_1.validateSocksClientOptions)(options); + this.setState(constants_1.SocksClientState.Created); + } + /** + * Creates a new SOCKS connection. + * + * Note: Supports callbacks and promises. Only supports the connect command. + * @param options { SocksClientOptions } Options. + * @param callback { Function } An optional callback function. + * @returns { Promise } + */ + static createConnection(options, callback) { + return new Promise((resolve2, reject) => { + try { + (0, helpers_1.validateSocksClientOptions)(options, ["connect"]); + } catch (err) { + if (typeof callback === "function") { + callback(err); + return resolve2(err); + } else { + return reject(err); + } + } + const client = new _SocksClient(options); + client.connect(options.existing_socket); + client.once("established", (info) => { + client.removeAllListeners(); + if (typeof callback === "function") { + callback(null, info); + resolve2(info); + } else { + resolve2(info); + } + }); + client.once("error", (err) => { + client.removeAllListeners(); + if (typeof callback === "function") { + callback(err); + resolve2(err); + } else { + reject(err); + } + }); + }); + } + /** + * Creates a new SOCKS connection chain to a destination host through 2 or more SOCKS proxies. + * + * Note: Supports callbacks and promises. Only supports the connect method. + * Note: Implemented via createConnection() factory function. + * @param options { SocksClientChainOptions } Options + * @param callback { Function } An optional callback function. + * @returns { Promise } + */ + static createConnectionChain(options, callback) { + return new Promise((resolve2, reject) => __awaiter6(this, void 0, void 0, function* () { + try { + (0, helpers_1.validateSocksClientChainOptions)(options); + } catch (err) { + if (typeof callback === "function") { + callback(err); + return resolve2(err); + } else { + return reject(err); + } + } + if (options.randomizeChain) { + (0, util_1.shuffleArray)(options.proxies); + } + try { + let sock; + for (let i = 0; i < options.proxies.length; i++) { + const nextProxy = options.proxies[i]; + const nextDestination = i === options.proxies.length - 1 ? options.destination : { + host: options.proxies[i + 1].host || options.proxies[i + 1].ipaddress, + port: options.proxies[i + 1].port + }; + const result = yield _SocksClient.createConnection({ + command: "connect", + proxy: nextProxy, + destination: nextDestination, + existing_socket: sock + }); + sock = sock || result.socket; + } + if (typeof callback === "function") { + callback(null, { socket: sock }); + resolve2({ socket: sock }); + } else { + resolve2({ socket: sock }); + } + } catch (err) { + if (typeof callback === "function") { + callback(err); + resolve2(err); + } else { + reject(err); + } + } + })); + } + /** + * Creates a SOCKS UDP Frame. + * @param options + */ + static createUDPFrame(options) { + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt16BE(0); + buff.writeUInt8(options.frameNumber || 0); + if (net2.isIPv4(options.remoteHost.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv4); + buff.writeUInt32BE((0, helpers_1.ipv4ToInt32)(options.remoteHost.host)); + } else if (net2.isIPv6(options.remoteHost.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv6); + buff.writeBuffer((0, helpers_1.ipToBuffer)(options.remoteHost.host)); + } else { + buff.writeUInt8(constants_1.Socks5HostType.Hostname); + buff.writeUInt8(Buffer.byteLength(options.remoteHost.host)); + buff.writeString(options.remoteHost.host); + } + buff.writeUInt16BE(options.remoteHost.port); + buff.writeBuffer(options.data); + return buff.toBuffer(); + } + /** + * Parses a SOCKS UDP frame. + * @param data + */ + static parseUDPFrame(data) { + const buff = smart_buffer_1.SmartBuffer.fromBuffer(data); + buff.readOffset = 2; + const frameNumber = buff.readUInt8(); + const hostType = buff.readUInt8(); + let remoteHost; + if (hostType === constants_1.Socks5HostType.IPv4) { + remoteHost = (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()); + } else if (hostType === constants_1.Socks5HostType.IPv6) { + remoteHost = ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(); + } else { + remoteHost = buff.readString(buff.readUInt8()); + } + const remotePort = buff.readUInt16BE(); + return { + frameNumber, + remoteHost: { + host: remoteHost, + port: remotePort + }, + data: buff.readBuffer() + }; + } + /** + * Internal state setter. If the SocksClient is in an error state, it cannot be changed to a non error state. + */ + setState(newState) { + if (this.state !== constants_1.SocksClientState.Error) { + this.state = newState; + } + } + /** + * Starts the connection establishment to the proxy and destination. + * @param existingSocket Connected socket to use instead of creating a new one (internal use). + */ + connect(existingSocket) { + this.onDataReceived = (data) => this.onDataReceivedHandler(data); + this.onClose = () => this.onCloseHandler(); + this.onError = (err) => this.onErrorHandler(err); + this.onConnect = () => this.onConnectHandler(); + const timer = setTimeout(() => this.onEstablishedTimeout(), this.options.timeout || constants_1.DEFAULT_TIMEOUT); + if (timer.unref && typeof timer.unref === "function") { + timer.unref(); + } + if (existingSocket) { + this.socket = existingSocket; + } else { + this.socket = new net2.Socket(); + } + this.socket.once("close", this.onClose); + this.socket.once("error", this.onError); + this.socket.once("connect", this.onConnect); + this.socket.on("data", this.onDataReceived); + this.setState(constants_1.SocksClientState.Connecting); + this.receiveBuffer = new receivebuffer_1.ReceiveBuffer(); + if (existingSocket) { + this.socket.emit("connect"); + } else { + this.socket.connect(this.getSocketOptions()); + if (this.options.set_tcp_nodelay !== void 0 && this.options.set_tcp_nodelay !== null) { + this.socket.setNoDelay(!!this.options.set_tcp_nodelay); + } + } + this.prependOnceListener("established", (info) => { + setImmediate(() => { + if (this.receiveBuffer.length > 0) { + const excessData = this.receiveBuffer.get(this.receiveBuffer.length); + info.socket.emit("data", excessData); + } + info.socket.resume(); + }); + }); + } + // Socket options (defaults host/port to options.proxy.host/options.proxy.port) + getSocketOptions() { + return Object.assign(Object.assign({}, this.options.socket_options), { host: this.options.proxy.host || this.options.proxy.ipaddress, port: this.options.proxy.port }); + } + /** + * Handles internal Socks timeout callback. + * Note: If the Socks client is not BoundWaitingForConnection or Established, the connection will be closed. + */ + onEstablishedTimeout() { + if (this.state !== constants_1.SocksClientState.Established && this.state !== constants_1.SocksClientState.BoundWaitingForConnection) { + this.closeSocket(constants_1.ERRORS.ProxyConnectionTimedOut); + } + } + /** + * Handles Socket connect event. + */ + onConnectHandler() { + this.setState(constants_1.SocksClientState.Connected); + if (this.options.proxy.type === 4) { + this.sendSocks4InitialHandshake(); + } else { + this.sendSocks5InitialHandshake(); + } + this.setState(constants_1.SocksClientState.SentInitialHandshake); + } + /** + * Handles Socket data event. + * @param data + */ + onDataReceivedHandler(data) { + this.receiveBuffer.append(data); + this.processData(); + } + /** + * Handles processing of the data we have received. + */ + processData() { + while (this.state !== constants_1.SocksClientState.Established && this.state !== constants_1.SocksClientState.Error && this.receiveBuffer.length >= this.nextRequiredPacketBufferSize) { + if (this.state === constants_1.SocksClientState.SentInitialHandshake) { + if (this.options.proxy.type === 4) { + this.handleSocks4FinalHandshakeResponse(); + } else { + this.handleInitialSocks5HandshakeResponse(); + } + } else if (this.state === constants_1.SocksClientState.SentAuthentication) { + this.handleInitialSocks5AuthenticationHandshakeResponse(); + } else if (this.state === constants_1.SocksClientState.SentFinalHandshake) { + this.handleSocks5FinalHandshakeResponse(); + } else if (this.state === constants_1.SocksClientState.BoundWaitingForConnection) { + if (this.options.proxy.type === 4) { + this.handleSocks4IncomingConnectionResponse(); + } else { + this.handleSocks5IncomingConnectionResponse(); + } + } else { + this.closeSocket(constants_1.ERRORS.InternalError); + break; + } + } + } + /** + * Handles Socket close event. + * @param had_error + */ + onCloseHandler() { + this.closeSocket(constants_1.ERRORS.SocketClosed); + } + /** + * Handles Socket error event. + * @param err + */ + onErrorHandler(err) { + this.closeSocket(err.message); + } + /** + * Removes internal event listeners on the underlying Socket. + */ + removeInternalSocketHandlers() { + this.socket.pause(); + this.socket.removeListener("data", this.onDataReceived); + this.socket.removeListener("close", this.onClose); + this.socket.removeListener("error", this.onError); + this.socket.removeListener("connect", this.onConnect); + } + /** + * Closes and destroys the underlying Socket. Emits an error event. + * @param err { String } An error string to include in error event. + */ + closeSocket(err) { + if (this.state !== constants_1.SocksClientState.Error) { + this.setState(constants_1.SocksClientState.Error); + this.socket.destroy(); + this.removeInternalSocketHandlers(); + this.emit("error", new util_1.SocksClientError(err, this.options)); + } + } + /** + * Sends initial Socks v4 handshake request. + */ + sendSocks4InitialHandshake() { + const userId = this.options.proxy.userId || ""; + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt8(4); + buff.writeUInt8(constants_1.SocksCommand[this.options.command]); + buff.writeUInt16BE(this.options.destination.port); + if (net2.isIPv4(this.options.destination.host)) { + buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host)); + buff.writeStringNT(userId); + } else { + buff.writeUInt8(0); + buff.writeUInt8(0); + buff.writeUInt8(0); + buff.writeUInt8(1); + buff.writeStringNT(userId); + buff.writeStringNT(this.options.destination.host); + } + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks4Response; + this.socket.write(buff.toBuffer()); + } + /** + * Handles Socks v4 handshake response. + * @param data + */ + handleSocks4FinalHandshakeResponse() { + const data = this.receiveBuffer.get(8); + if (data[1] !== constants_1.Socks4Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedConnection} - (${constants_1.Socks4Response[data[1]]})`); + } else { + if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) { + const buff = smart_buffer_1.SmartBuffer.fromBuffer(data); + buff.readOffset = 2; + const remoteHost = { + port: buff.readUInt16BE(), + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()) + }; + if (remoteHost.host === "0.0.0.0") { + remoteHost.host = this.options.proxy.ipaddress; + } + this.setState(constants_1.SocksClientState.BoundWaitingForConnection); + this.emit("bound", { remoteHost, socket: this.socket }); + } else { + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { socket: this.socket }); + } + } + } + /** + * Handles Socks v4 incoming connection request (BIND) + * @param data + */ + handleSocks4IncomingConnectionResponse() { + const data = this.receiveBuffer.get(8); + if (data[1] !== constants_1.Socks4Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedIncomingBoundConnection} - (${constants_1.Socks4Response[data[1]]})`); + } else { + const buff = smart_buffer_1.SmartBuffer.fromBuffer(data); + buff.readOffset = 2; + const remoteHost = { + port: buff.readUInt16BE(), + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()) + }; + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { remoteHost, socket: this.socket }); + } + } + /** + * Sends initial Socks v5 handshake request. + */ + sendSocks5InitialHandshake() { + const buff = new smart_buffer_1.SmartBuffer(); + const supportedAuthMethods = [constants_1.Socks5Auth.NoAuth]; + if (this.options.proxy.userId || this.options.proxy.password) { + supportedAuthMethods.push(constants_1.Socks5Auth.UserPass); + } + if (this.options.proxy.custom_auth_method !== void 0) { + supportedAuthMethods.push(this.options.proxy.custom_auth_method); + } + buff.writeUInt8(5); + buff.writeUInt8(supportedAuthMethods.length); + for (const authMethod of supportedAuthMethods) { + buff.writeUInt8(authMethod); + } + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5InitialHandshakeResponse; + this.socket.write(buff.toBuffer()); + this.setState(constants_1.SocksClientState.SentInitialHandshake); + } + /** + * Handles initial Socks v5 handshake response. + * @param data + */ + handleInitialSocks5HandshakeResponse() { + const data = this.receiveBuffer.get(2); + if (data[0] !== 5) { + this.closeSocket(constants_1.ERRORS.InvalidSocks5IntiailHandshakeSocksVersion); + } else if (data[1] === constants_1.SOCKS5_NO_ACCEPTABLE_AUTH) { + this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeNoAcceptedAuthType); + } else { + if (data[1] === constants_1.Socks5Auth.NoAuth) { + this.socks5ChosenAuthType = constants_1.Socks5Auth.NoAuth; + this.sendSocks5CommandRequest(); + } else if (data[1] === constants_1.Socks5Auth.UserPass) { + this.socks5ChosenAuthType = constants_1.Socks5Auth.UserPass; + this.sendSocks5UserPassAuthentication(); + } else if (data[1] === this.options.proxy.custom_auth_method) { + this.socks5ChosenAuthType = this.options.proxy.custom_auth_method; + this.sendSocks5CustomAuthentication(); + } else { + this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeUnknownAuthType); + } + } + } + /** + * Sends Socks v5 user & password auth handshake. + * + * Note: No auth and user/pass are currently supported. + */ + sendSocks5UserPassAuthentication() { + const userId = this.options.proxy.userId || ""; + const password = this.options.proxy.password || ""; + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt8(1); + buff.writeUInt8(Buffer.byteLength(userId)); + buff.writeString(userId); + buff.writeUInt8(Buffer.byteLength(password)); + buff.writeString(password); + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5UserPassAuthenticationResponse; + this.socket.write(buff.toBuffer()); + this.setState(constants_1.SocksClientState.SentAuthentication); + } + sendSocks5CustomAuthentication() { + return __awaiter6(this, void 0, void 0, function* () { + this.nextRequiredPacketBufferSize = this.options.proxy.custom_auth_response_size; + this.socket.write(yield this.options.proxy.custom_auth_request_handler()); + this.setState(constants_1.SocksClientState.SentAuthentication); + }); + } + handleSocks5CustomAuthHandshakeResponse(data) { + return __awaiter6(this, void 0, void 0, function* () { + return yield this.options.proxy.custom_auth_response_handler(data); + }); + } + handleSocks5AuthenticationNoAuthHandshakeResponse(data) { + return __awaiter6(this, void 0, void 0, function* () { + return data[1] === 0; + }); + } + handleSocks5AuthenticationUserPassHandshakeResponse(data) { + return __awaiter6(this, void 0, void 0, function* () { + return data[1] === 0; + }); + } + /** + * Handles Socks v5 auth handshake response. + * @param data + */ + handleInitialSocks5AuthenticationHandshakeResponse() { + return __awaiter6(this, void 0, void 0, function* () { + this.setState(constants_1.SocksClientState.ReceivedAuthenticationResponse); + let authResult = false; + if (this.socks5ChosenAuthType === constants_1.Socks5Auth.NoAuth) { + authResult = yield this.handleSocks5AuthenticationNoAuthHandshakeResponse(this.receiveBuffer.get(2)); + } else if (this.socks5ChosenAuthType === constants_1.Socks5Auth.UserPass) { + authResult = yield this.handleSocks5AuthenticationUserPassHandshakeResponse(this.receiveBuffer.get(2)); + } else if (this.socks5ChosenAuthType === this.options.proxy.custom_auth_method) { + authResult = yield this.handleSocks5CustomAuthHandshakeResponse(this.receiveBuffer.get(this.options.proxy.custom_auth_response_size)); + } + if (!authResult) { + this.closeSocket(constants_1.ERRORS.Socks5AuthenticationFailed); + } else { + this.sendSocks5CommandRequest(); + } + }); + } + /** + * Sends Socks v5 final handshake request. + */ + sendSocks5CommandRequest() { + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt8(5); + buff.writeUInt8(constants_1.SocksCommand[this.options.command]); + buff.writeUInt8(0); + if (net2.isIPv4(this.options.destination.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv4); + buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host)); + } else if (net2.isIPv6(this.options.destination.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv6); + buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host)); + } else { + buff.writeUInt8(constants_1.Socks5HostType.Hostname); + buff.writeUInt8(this.options.destination.host.length); + buff.writeString(this.options.destination.host); + } + buff.writeUInt16BE(this.options.destination.port); + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader; + this.socket.write(buff.toBuffer()); + this.setState(constants_1.SocksClientState.SentFinalHandshake); + } + /** + * Handles Socks v5 final handshake response. + * @param data + */ + handleSocks5FinalHandshakeResponse() { + const header = this.receiveBuffer.peek(5); + if (header[0] !== 5 || header[1] !== constants_1.Socks5Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.InvalidSocks5FinalHandshakeRejected} - ${constants_1.Socks5Response[header[1]]}`); + } else { + const addressType = header[3]; + let remoteHost; + let buff; + if (addressType === constants_1.Socks5HostType.IPv4) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()), + port: buff.readUInt16BE() + }; + if (remoteHost.host === "0.0.0.0") { + remoteHost.host = this.options.proxy.ipaddress; + } + } else if (addressType === constants_1.Socks5HostType.Hostname) { + const hostLength = header[4]; + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5)); + remoteHost = { + host: buff.readString(hostLength), + port: buff.readUInt16BE() + }; + } else if (addressType === constants_1.Socks5HostType.IPv6) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(), + port: buff.readUInt16BE() + }; + } + this.setState(constants_1.SocksClientState.ReceivedFinalResponse); + if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.connect) { + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { remoteHost, socket: this.socket }); + } else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) { + this.setState(constants_1.SocksClientState.BoundWaitingForConnection); + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader; + this.emit("bound", { remoteHost, socket: this.socket }); + } else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.associate) { + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { + remoteHost, + socket: this.socket + }); + } + } + } + /** + * Handles Socks v5 incoming connection request (BIND). + */ + handleSocks5IncomingConnectionResponse() { + const header = this.receiveBuffer.peek(5); + if (header[0] !== 5 || header[1] !== constants_1.Socks5Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.Socks5ProxyRejectedIncomingBoundConnection} - ${constants_1.Socks5Response[header[1]]}`); + } else { + const addressType = header[3]; + let remoteHost; + let buff; + if (addressType === constants_1.Socks5HostType.IPv4) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()), + port: buff.readUInt16BE() + }; + if (remoteHost.host === "0.0.0.0") { + remoteHost.host = this.options.proxy.ipaddress; + } + } else if (addressType === constants_1.Socks5HostType.Hostname) { + const hostLength = header[4]; + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5)); + remoteHost = { + host: buff.readString(hostLength), + port: buff.readUInt16BE() + }; + } else if (addressType === constants_1.Socks5HostType.IPv6) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(), + port: buff.readUInt16BE() + }; + } + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { remoteHost, socket: this.socket }); + } + } + get socksClientOptions() { + return Object.assign({}, this.options); + } + }; + exports.SocksClient = SocksClient; + } +}); + +// node_modules/socks/build/index.js +var require_build = __commonJS({ + "node_modules/socks/build/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar(require_socksclient(), exports); + } +}); + +// node_modules/agent-base/dist/helpers.js +var require_helpers3 = __commonJS({ + "node_modules/agent-base/dist/helpers.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.req = exports.json = exports.toBuffer = void 0; + var http2 = __importStar(__require("http")); + var https2 = __importStar(__require("https")); + async function toBuffer(stream) { + let length = 0; + const chunks = []; + for await (const chunk of stream) { + length += chunk.length; + chunks.push(chunk); + } + return Buffer.concat(chunks, length); + } + exports.toBuffer = toBuffer; + async function json2(stream) { + const buf2 = await toBuffer(stream); + const str2 = buf2.toString("utf8"); + try { + return JSON.parse(str2); + } catch (_err) { + const err = _err; + err.message += ` (input: ${str2})`; + throw err; + } + } + exports.json = json2; + function req(url, opts = {}) { + const href = typeof url === "string" ? url : url.href; + const req2 = (href.startsWith("https:") ? https2 : http2).request(url, opts); + const promise = new Promise((resolve2, reject) => { + req2.once("response", resolve2).once("error", reject).end(); + }); + req2.then = promise.then.bind(promise); + return req2; + } + exports.req = req; + } +}); + +// node_modules/agent-base/dist/index.js +var require_dist = __commonJS({ + "node_modules/agent-base/dist/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Agent = void 0; + var net2 = __importStar(__require("net")); + var http2 = __importStar(__require("http")); + var https_1 = __require("https"); + __exportStar(require_helpers3(), exports); + var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState"); + var Agent = class extends http2.Agent { + constructor(opts) { + super(opts); + this[INTERNAL] = {}; + } + /** + * Determine whether this is an `http` or `https` request. + */ + isSecureEndpoint(options) { + if (options) { + if (typeof options.secureEndpoint === "boolean") { + return options.secureEndpoint; + } + if (typeof options.protocol === "string") { + return options.protocol === "https:"; + } + } + const { stack } = new Error(); + if (typeof stack !== "string") + return false; + return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1); + } + // In order to support async signatures in `connect()` and Node's native + // connection pooling in `http.Agent`, the array of sockets for each origin + // has to be updated synchronously. This is so the length of the array is + // accurate when `addRequest()` is next called. We achieve this by creating a + // fake socket and adding it to `sockets[origin]` and incrementing + // `totalSocketCount`. + incrementSockets(name) { + if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) { + return null; + } + if (!this.sockets[name]) { + this.sockets[name] = []; + } + const fakeSocket = new net2.Socket({ writable: false }); + this.sockets[name].push(fakeSocket); + this.totalSocketCount++; + return fakeSocket; + } + decrementSockets(name, socket) { + if (!this.sockets[name] || socket === null) { + return; + } + const sockets = this.sockets[name]; + const index2 = sockets.indexOf(socket); + if (index2 !== -1) { + sockets.splice(index2, 1); + this.totalSocketCount--; + if (sockets.length === 0) { + delete this.sockets[name]; + } + } + } + // In order to properly update the socket pool, we need to call `getName()` on + // the core `https.Agent` if it is a secureEndpoint. + getName(options) { + const secureEndpoint = this.isSecureEndpoint(options); + if (secureEndpoint) { + return https_1.Agent.prototype.getName.call(this, options); + } + return super.getName(options); + } + createSocket(req, options, cb) { + const connectOpts = { + ...options, + secureEndpoint: this.isSecureEndpoint(options) + }; + const name = this.getName(connectOpts); + const fakeSocket = this.incrementSockets(name); + Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => { + this.decrementSockets(name, fakeSocket); + if (socket instanceof http2.Agent) { + try { + return socket.addRequest(req, connectOpts); + } catch (err) { + return cb(err); + } + } + this[INTERNAL].currentSocket = socket; + super.createSocket(req, options, cb); + }, (err) => { + this.decrementSockets(name, fakeSocket); + cb(err); + }); + } + createConnection() { + const socket = this[INTERNAL].currentSocket; + this[INTERNAL].currentSocket = void 0; + if (!socket) { + throw new Error("No socket was returned in the `connect()` function"); + } + return socket; + } + get defaultPort() { + return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80); + } + set defaultPort(v) { + if (this[INTERNAL]) { + this[INTERNAL].defaultPort = v; + } + } + get protocol() { + return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:"); + } + set protocol(v) { + if (this[INTERNAL]) { + this[INTERNAL].protocol = v; + } + } + }; + exports.Agent = Agent; + } +}); + +// 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 type2 = typeof val; + if (type2 === "string" && val.length > 0) { + return parse2(val); + } else if (type2 === "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 parse2(str2) { + str2 = String(str2); + if (str2.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( + str2 + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type2 = (match[2] || "ms").toLowerCase(); + switch (type2) { + 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_common2 = __commonJS({ + "node_modules/debug/src/common.js"(exports, module) { + 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(); + createDebug.destroy = destroy; + Object.keys(env).forEach((key) => { + createDebug[key] = env[key]; + }); + createDebug.names = []; + createDebug.skips = []; + createDebug.formatters = {}; + function selectColor(namespace) { + let hash = 0; + for (let 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) { + let prevTime; + let enableOverride = null; + let namespacesCache; + let enabledCache; + function debug2(...args) { + if (!debug2.enabled) { + return; + } + const self = debug2; + const curr = Number(/* @__PURE__ */ new Date()); + const ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== "string") { + args.unshift("%O"); + } + let index2 = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format2) => { + if (match === "%%") { + return "%"; + } + index2++; + const formatter = createDebug.formatters[format2]; + if (typeof formatter === "function") { + const val = args[index2]; + match = formatter.call(self, val); + args.splice(index2, 1); + index2--; + } + return match; + }); + createDebug.formatArgs.call(self, args); + const logFn = self.log || createDebug.log; + logFn.apply(self, args); + } + debug2.namespace = namespace; + debug2.useColors = createDebug.useColors(); + debug2.color = createDebug.selectColor(namespace); + debug2.extend = extend3; + debug2.destroy = createDebug.destroy; + Object.defineProperty(debug2, "enabled", { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + return enabledCache; + }, + set: (v) => { + enableOverride = v; + } + }); + if (typeof createDebug.init === "function") { + createDebug.init(debug2); + } + return debug2; + } + function extend3(namespace, delimiter2) { + const newDebug = createDebug(this.namespace + (typeof delimiter2 === "undefined" ? ":" : delimiter2) + namespace); + newDebug.log = this.log; + return newDebug; + } + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + createDebug.names = []; + createDebug.skips = []; + const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean); + for (const ns of split) { + if (ns[0] === "-") { + createDebug.skips.push(ns.slice(1)); + } else { + createDebug.names.push(ns); + } + } + } + function matchesTemplate(search, template) { + let searchIndex = 0; + let templateIndex = 0; + let starIndex = -1; + let matchIndex = 0; + while (searchIndex < search.length) { + if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) { + if (template[templateIndex] === "*") { + starIndex = templateIndex; + matchIndex = searchIndex; + templateIndex++; + } else { + searchIndex++; + templateIndex++; + } + } else if (starIndex !== -1) { + templateIndex = starIndex + 1; + matchIndex++; + searchIndex = matchIndex; + } else { + return false; + } + } + while (templateIndex < template.length && template[templateIndex] === "*") { + templateIndex++; + } + return templateIndex === template.length; + } + function disable() { + const namespaces = [ + ...createDebug.names, + ...createDebug.skips.map((namespace) => "-" + namespace) + ].join(","); + createDebug.enable(""); + return namespaces; + } + function enabled(name) { + for (const skip of createDebug.skips) { + if (matchesTemplate(name, skip)) { + return false; + } + } + for (const ns of createDebug.names) { + if (matchesTemplate(name, ns)) { + return true; + } + } + return false; + } + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + function destroy() { + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + 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) { + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load2; + exports.useColors = useColors; + exports.storage = localstorage(); + exports.destroy = /* @__PURE__ */ (() => { + let warned = false; + return () => { + if (!warned) { + warned = true; + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + }; + })(); + 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; + } + let m; + 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 && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[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; + } + const c = "color: " + this.color; + args.splice(1, 0, c, "color: inherit"); + let index2 = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, (match) => { + if (match === "%%") { + return; + } + index2++; + if (match === "%c") { + lastC = index2; + } + }); + args.splice(lastC, 0, c); + } + exports.log = console.debug || console.log || (() => { + }); + function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem("debug", namespaces); + } else { + exports.storage.removeItem("debug"); + } + } catch (error2) { + } + } + function load2() { + let r; + try { + r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG"); + } catch (error2) { + } + if (!r && typeof process !== "undefined" && "env" in process) { + r = process.env.DEBUG; + } + return r; + } + function localstorage() { + try { + return localStorage; + } catch (error2) { + } + } + module.exports = require_common2()(exports); + var { formatters } = module.exports; + formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (error2) { + return "[UnexpectedJSONParseError]: " + error2.message; + } + }; + } +}); + +// node_modules/debug/src/node.js +var require_node = __commonJS({ + "node_modules/debug/src/node.js"(exports, module) { + var tty = __require("tty"); + var util2 = __require("util"); + exports.init = init; + exports.log = log; + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load2; + exports.useColors = useColors; + exports.destroy = util2.deprecate( + () => { + }, + "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`." + ); + exports.colors = [6, 2, 3, 4, 5, 1]; + try { + const supportsColor = __require("supports-color"); + if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) { + exports.colors = [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 + ]; + } + } catch (error2) { + } + exports.inspectOpts = Object.keys(process.env).filter((key) => { + return /^debug_/i.test(key); + }).reduce((obj, key) => { + const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => { + return k.toUpperCase(); + }); + let val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) { + val = true; + } else if (/^(no|off|false|disabled)$/i.test(val)) { + val = false; + } else if (val === "null") { + val = null; + } else { + val = Number(val); + } + obj[prop] = val; + return obj; + }, {}); + function useColors() { + return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd); + } + function formatArgs(args) { + const { namespace: name, useColors: useColors2 } = this; + if (useColors2) { + const c = this.color; + const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c); + const prefix = ` ${colorCode};1m${name} \x1B[0m`; + args[0] = prefix + args[0].split("\n").join("\n" + prefix); + args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m"); + } else { + args[0] = getDate() + name + " " + args[0]; + } + } + function getDate() { + if (exports.inspectOpts.hideDate) { + return ""; + } + return (/* @__PURE__ */ new Date()).toISOString() + " "; + } + function log(...args) { + return process.stderr.write(util2.formatWithOptions(exports.inspectOpts, ...args) + "\n"); + } + function save(namespaces) { + if (namespaces) { + process.env.DEBUG = namespaces; + } else { + delete process.env.DEBUG; + } + } + function load2() { + return process.env.DEBUG; + } + function init(debug2) { + debug2.inspectOpts = {}; + const keys = Object.keys(exports.inspectOpts); + for (let i = 0; i < keys.length; i++) { + debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; + } + } + module.exports = require_common2()(exports); + var { formatters } = module.exports; + formatters.o = function(v) { + this.inspectOpts.colors = this.useColors; + return util2.inspect(v, this.inspectOpts).split("\n").map((str2) => str2.trim()).join(" "); + }; + formatters.O = function(v) { + this.inspectOpts.colors = this.useColors; + return util2.inspect(v, this.inspectOpts); + }; + } +}); + +// node_modules/debug/src/index.js +var require_src = __commonJS({ + "node_modules/debug/src/index.js"(exports, module) { + if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) { + module.exports = require_browser(); + } else { + module.exports = require_node(); + } + } +}); + +// node_modules/socks-proxy-agent/dist/index.js +var require_dist2 = __commonJS({ + "node_modules/socks-proxy-agent/dist/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod2) { + if (mod2 && mod2.__esModule) return mod2; + var result = {}; + if (mod2 != null) { + for (var k in mod2) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k)) __createBinding(result, mod2, k); + } + __setModuleDefault(result, mod2); + return result; + }; + var __importDefault = exports && exports.__importDefault || function(mod2) { + return mod2 && mod2.__esModule ? mod2 : { "default": mod2 }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SocksProxyAgent = void 0; + var socks_1 = require_build(); + var agent_base_1 = require_dist(); + var debug_1 = __importDefault(require_src()); + var dns = __importStar(__require("dns")); + var net2 = __importStar(__require("net")); + var tls = __importStar(__require("tls")); + var url_1 = __require("url"); + var debug2 = (0, debug_1.default)("socks-proxy-agent"); + var setServernameFromNonIpHost = (options) => { + if (options.servername === void 0 && options.host && !net2.isIP(options.host)) { + return { + ...options, + servername: options.host + }; + } + return options; + }; + function parseSocksURL(url) { + let lookup = false; + let type2 = 5; + const host = url.hostname; + const port = parseInt(url.port, 10) || 1080; + switch (url.protocol.replace(":", "")) { + case "socks4": + lookup = true; + type2 = 4; + break; + // pass through + case "socks4a": + type2 = 4; + break; + case "socks5": + lookup = true; + type2 = 5; + break; + // pass through + case "socks": + type2 = 5; + break; + case "socks5h": + type2 = 5; + break; + default: + throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`); + } + const proxy = { + host, + port, + type: type2 + }; + if (url.username) { + Object.defineProperty(proxy, "userId", { + value: decodeURIComponent(url.username), + enumerable: false + }); + } + if (url.password != null) { + Object.defineProperty(proxy, "password", { + value: decodeURIComponent(url.password), + enumerable: false + }); + } + return { lookup, proxy }; + } + var SocksProxyAgent2 = class extends agent_base_1.Agent { + constructor(uri, opts) { + super(opts); + const url = typeof uri === "string" ? new url_1.URL(uri) : uri; + const { proxy, lookup } = parseSocksURL(url); + this.shouldLookup = lookup; + this.proxy = proxy; + this.timeout = opts?.timeout ?? null; + this.socketOptions = opts?.socketOptions ?? null; + } + /** + * Initiates a SOCKS connection to the specified SOCKS proxy server, + * which in turn connects to the specified remote host and port. + */ + async connect(req, opts) { + const { shouldLookup, proxy, timeout } = this; + if (!opts.host) { + throw new Error("No `host` defined!"); + } + let { host } = opts; + const { port, lookup: lookupFn = dns.lookup } = opts; + if (shouldLookup) { + host = await new Promise((resolve2, reject) => { + lookupFn(host, {}, (err, res) => { + if (err) { + reject(err); + } else { + resolve2(res); + } + }); + }); + } + const socksOpts = { + proxy, + destination: { + host, + port: typeof port === "number" ? port : parseInt(port, 10) + }, + command: "connect", + timeout: timeout ?? void 0, + // @ts-expect-error the type supplied by socks for socket_options is wider + // than necessary since socks will always override the host and port + socket_options: this.socketOptions ?? void 0 + }; + const cleanup = (tlsSocket) => { + req.destroy(); + socket.destroy(); + if (tlsSocket) + tlsSocket.destroy(); + }; + debug2("Creating socks proxy connection: %o", socksOpts); + const { socket } = await socks_1.SocksClient.createConnection(socksOpts); + debug2("Successfully created socks proxy connection"); + if (timeout !== null) { + socket.setTimeout(timeout); + socket.on("timeout", () => cleanup()); + } + if (opts.secureEndpoint) { + debug2("Upgrading socket connection to TLS"); + const tlsSocket = tls.connect({ + ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"), + socket + }); + tlsSocket.once("error", (error2) => { + debug2("Socket TLS error", error2.message); + cleanup(tlsSocket); + }); + return tlsSocket; + } + return socket; + } + }; + SocksProxyAgent2.protocols = [ + "socks", + "socks4", + "socks4a", + "socks5", + "socks5h" + ]; + exports.SocksProxyAgent = SocksProxyAgent2; + function omit(obj, ...keys) { + const ret = {}; + let key; + for (key in obj) { + if (!keys.includes(key)) { + ret[key] = obj[key]; + } + } + return ret; + } + } +}); + +// node_modules/hpagent/index.js +var require_hpagent = __commonJS({ + "node_modules/hpagent/index.js"(exports, module) { + "use strict"; + var https2 = __require("https"); + var http2 = __require("http"); + var { URL: URL3 } = __require("url"); + var HttpProxyAgent2 = class extends http2.Agent { + constructor(options) { + const { proxy, proxyRequestOptions, ...opts } = options; + super(opts); + this.proxy = typeof proxy === "string" ? new URL3(proxy) : proxy; + this.proxyRequestOptions = proxyRequestOptions || {}; + } + createConnection(options, callback) { + const requestOptions = { + ...this.proxyRequestOptions, + method: "CONNECT", + host: this.proxy.hostname, + port: this.proxy.port, + path: `${options.host}:${options.port}`, + setHost: false, + headers: { ...this.proxyRequestOptions.headers, connection: this.keepAlive ? "keep-alive" : "close", host: `${options.host}:${options.port}` }, + agent: false, + timeout: options.timeout || 0 + }; + if (this.proxy.username || this.proxy.password) { + const base64 = Buffer.from(`${decodeURIComponent(this.proxy.username || "")}:${decodeURIComponent(this.proxy.password || "")}`).toString("base64"); + requestOptions.headers["proxy-authorization"] = `Basic ${base64}`; + } + if (this.proxy.protocol === "https:") { + requestOptions.servername = this.proxy.hostname; + } + const request = (this.proxy.protocol === "http:" ? http2 : https2).request(requestOptions); + request.once("connect", (response, socket, head) => { + request.removeAllListeners(); + socket.removeAllListeners(); + if (response.statusCode === 200) { + callback(null, socket); + } else { + socket.destroy(); + callback(new Error(`Bad response: ${response.statusCode}`), null); + } + }); + request.once("timeout", () => { + request.destroy(new Error("Proxy timeout")); + }); + request.once("error", (err) => { + request.removeAllListeners(); + callback(err, null); + }); + request.end(); + } + }; + var HttpsProxyAgent2 = class extends https2.Agent { + constructor(options) { + const { proxy, proxyRequestOptions, ...opts } = options; + super(opts); + this.proxy = typeof proxy === "string" ? new URL3(proxy) : proxy; + this.proxyRequestOptions = proxyRequestOptions || {}; + } + createConnection(options, callback) { + const requestOptions = { + ...this.proxyRequestOptions, + method: "CONNECT", + host: this.proxy.hostname, + port: this.proxy.port, + path: `${options.host}:${options.port}`, + setHost: false, + headers: { ...this.proxyRequestOptions.headers, connection: this.keepAlive ? "keep-alive" : "close", host: `${options.host}:${options.port}` }, + agent: false, + timeout: options.timeout || 0 + }; + if (this.proxy.username || this.proxy.password) { + const base64 = Buffer.from(`${decodeURIComponent(this.proxy.username || "")}:${decodeURIComponent(this.proxy.password || "")}`).toString("base64"); + requestOptions.headers["proxy-authorization"] = `Basic ${base64}`; + } + if (this.proxy.protocol === "https:") { + requestOptions.servername = this.proxy.hostname; + } + const request = (this.proxy.protocol === "http:" ? http2 : https2).request(requestOptions); + request.once("connect", (response, socket, head) => { + request.removeAllListeners(); + socket.removeAllListeners(); + if (response.statusCode === 200) { + const secureSocket = super.createConnection({ ...options, socket }); + callback(null, secureSocket); + } else { + socket.destroy(); + callback(new Error(`Bad response: ${response.statusCode}`), null); + } + }); + request.once("timeout", () => { + request.destroy(new Error("Proxy timeout")); + }); + request.once("error", (err) => { + request.removeAllListeners(); + callback(err, null); + }); + request.end(); + } + }; + module.exports = { + HttpProxyAgent: HttpProxyAgent2, + HttpsProxyAgent: HttpsProxyAgent2 + }; + } +}); + +// node_modules/ws/lib/constants.js +var require_constants9 = __commonJS({ + "node_modules/ws/lib/constants.js"(exports, module) { + "use strict"; + var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"]; + var hasBlob = typeof Blob !== "undefined"; + if (hasBlob) BINARY_TYPES.push("blob"); + module.exports = { + BINARY_TYPES, + CLOSE_TIMEOUT: 3e4, + EMPTY_BUFFER: Buffer.alloc(0), + GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", + hasBlob, + kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"), + kListener: /* @__PURE__ */ Symbol("kListener"), + kStatusCode: /* @__PURE__ */ Symbol("status-code"), + kWebSocket: /* @__PURE__ */ Symbol("websocket"), + NOOP: () => { + } + }; + } +}); + +// node_modules/ws/lib/buffer-util.js +var require_buffer_util = __commonJS({ + "node_modules/ws/lib/buffer-util.js"(exports, module) { + "use strict"; + var { EMPTY_BUFFER } = require_constants9(); + var FastBuffer = Buffer[Symbol.species]; + function concat(list, totalLength) { + if (list.length === 0) return EMPTY_BUFFER; + if (list.length === 1) return list[0]; + const target = Buffer.allocUnsafe(totalLength); + let offset = 0; + for (let i = 0; i < list.length; i++) { + const buf2 = list[i]; + target.set(buf2, offset); + offset += buf2.length; + } + if (offset < totalLength) { + return new FastBuffer(target.buffer, target.byteOffset, offset); + } + return target; + } + function _mask(source, mask, output, offset, length) { + for (let i = 0; i < length; i++) { + output[offset + i] = source[i] ^ mask[i & 3]; + } + } + function _unmask(buffer, mask) { + for (let i = 0; i < buffer.length; i++) { + buffer[i] ^= mask[i & 3]; + } + } + function toArrayBuffer(buf2) { + if (buf2.length === buf2.buffer.byteLength) { + return buf2.buffer; + } + return buf2.buffer.slice(buf2.byteOffset, buf2.byteOffset + buf2.length); + } + function toBuffer(data) { + toBuffer.readOnly = true; + if (Buffer.isBuffer(data)) return data; + let buf2; + if (data instanceof ArrayBuffer) { + buf2 = new FastBuffer(data); + } else if (ArrayBuffer.isView(data)) { + buf2 = new FastBuffer(data.buffer, data.byteOffset, data.byteLength); + } else { + buf2 = Buffer.from(data); + toBuffer.readOnly = false; + } + return buf2; + } + module.exports = { + concat, + mask: _mask, + toArrayBuffer, + toBuffer, + unmask: _unmask + }; + if (!process.env.WS_NO_BUFFER_UTIL) { + try { + const bufferUtil = __require("bufferutil"); + module.exports.mask = function(source, mask, output, offset, length) { + if (length < 48) _mask(source, mask, output, offset, length); + else bufferUtil.mask(source, mask, output, offset, length); + }; + module.exports.unmask = function(buffer, mask) { + if (buffer.length < 32) _unmask(buffer, mask); + else bufferUtil.unmask(buffer, mask); + }; + } catch (e2) { + } + } + } +}); + +// node_modules/ws/lib/limiter.js +var require_limiter = __commonJS({ + "node_modules/ws/lib/limiter.js"(exports, module) { + "use strict"; + var kDone = /* @__PURE__ */ Symbol("kDone"); + var kRun = /* @__PURE__ */ Symbol("kRun"); + var Limiter = class { + /** + * Creates a new `Limiter`. + * + * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed + * to run concurrently + */ + constructor(concurrency) { + this[kDone] = () => { + this.pending--; + this[kRun](); + }; + this.concurrency = concurrency || Infinity; + this.jobs = []; + this.pending = 0; + } + /** + * Adds a job to the queue. + * + * @param {Function} job The job to run + * @public + */ + add(job) { + this.jobs.push(job); + this[kRun](); + } + /** + * Removes a job from the queue and runs it if possible. + * + * @private + */ + [kRun]() { + if (this.pending === this.concurrency) return; + if (this.jobs.length) { + const job = this.jobs.shift(); + this.pending++; + job(this[kDone]); + } + } + }; + module.exports = Limiter; + } +}); + +// node_modules/ws/lib/permessage-deflate.js +var require_permessage_deflate2 = __commonJS({ + "node_modules/ws/lib/permessage-deflate.js"(exports, module) { + "use strict"; + var zlib = __require("zlib"); + var bufferUtil = require_buffer_util(); + var Limiter = require_limiter(); + var { kStatusCode } = require_constants9(); + var FastBuffer = Buffer[Symbol.species]; + var TRAILER = Buffer.from([0, 0, 255, 255]); + var kPerMessageDeflate = /* @__PURE__ */ Symbol("permessage-deflate"); + var kTotalLength = /* @__PURE__ */ Symbol("total-length"); + var kCallback = /* @__PURE__ */ Symbol("callback"); + var kBuffers = /* @__PURE__ */ Symbol("buffers"); + var kError = /* @__PURE__ */ Symbol("error"); + var zlibLimiter; + var PerMessageDeflate = class { + /** + * Creates a PerMessageDeflate instance. + * + * @param {Object} [options] Configuration options + * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support + * for, or request, a custom client window size + * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/ + * acknowledge disabling of client context takeover + * @param {Number} [options.concurrencyLimit=10] The number of concurrent + * calls to zlib + * @param {Boolean} [options.isServer=false] Create the instance in either + * server or client mode + * @param {Number} [options.maxPayload=0] The maximum allowed message length + * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the + * use of a custom server window size + * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept + * disabling of server context takeover + * @param {Number} [options.threshold=1024] Size (in bytes) below which + * messages should not be compressed if context takeover is disabled + * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on + * deflate + * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on + * inflate + */ + constructor(options) { + this._options = options || {}; + this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024; + this._maxPayload = this._options.maxPayload | 0; + this._isServer = !!this._options.isServer; + this._deflate = null; + this._inflate = null; + this.params = null; + if (!zlibLimiter) { + const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10; + zlibLimiter = new Limiter(concurrency); + } + } + /** + * @type {String} + */ + static get extensionName() { + return "permessage-deflate"; + } + /** + * Create an extension negotiation offer. + * + * @return {Object} Extension parameters + * @public + */ + offer() { + const params = {}; + if (this._options.serverNoContextTakeover) { + params.server_no_context_takeover = true; + } + if (this._options.clientNoContextTakeover) { + params.client_no_context_takeover = true; + } + if (this._options.serverMaxWindowBits) { + params.server_max_window_bits = this._options.serverMaxWindowBits; + } + if (this._options.clientMaxWindowBits) { + params.client_max_window_bits = this._options.clientMaxWindowBits; + } else if (this._options.clientMaxWindowBits == null) { + params.client_max_window_bits = true; + } + return params; + } + /** + * Accept an extension negotiation offer/response. + * + * @param {Array} configurations The extension negotiation offers/reponse + * @return {Object} Accepted configuration + * @public + */ + accept(configurations) { + configurations = this.normalizeParams(configurations); + this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations); + return this.params; + } + /** + * Releases all resources used by the extension. + * + * @public + */ + cleanup() { + if (this._inflate) { + this._inflate.close(); + this._inflate = null; + } + if (this._deflate) { + const callback = this._deflate[kCallback]; + this._deflate.close(); + this._deflate = null; + if (callback) { + callback( + new Error( + "The deflate stream was closed while data was being processed" + ) + ); + } + } + } + /** + * Accept an extension negotiation offer. + * + * @param {Array} offers The extension negotiation offers + * @return {Object} Accepted configuration + * @private + */ + acceptAsServer(offers) { + const opts = this._options; + const accepted = offers.find((params) => { + if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) { + return false; + } + return true; + }); + if (!accepted) { + throw new Error("None of the extension offers can be accepted"); + } + if (opts.serverNoContextTakeover) { + accepted.server_no_context_takeover = true; + } + if (opts.clientNoContextTakeover) { + accepted.client_no_context_takeover = true; + } + if (typeof opts.serverMaxWindowBits === "number") { + accepted.server_max_window_bits = opts.serverMaxWindowBits; + } + if (typeof opts.clientMaxWindowBits === "number") { + accepted.client_max_window_bits = opts.clientMaxWindowBits; + } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) { + delete accepted.client_max_window_bits; + } + return accepted; + } + /** + * Accept the extension negotiation response. + * + * @param {Array} response The extension negotiation response + * @return {Object} Accepted configuration + * @private + */ + acceptAsClient(response) { + const params = response[0]; + if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) { + throw new Error('Unexpected parameter "client_no_context_takeover"'); + } + if (!params.client_max_window_bits) { + if (typeof this._options.clientMaxWindowBits === "number") { + params.client_max_window_bits = this._options.clientMaxWindowBits; + } + } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) { + throw new Error( + 'Unexpected or invalid parameter "client_max_window_bits"' + ); + } + return params; + } + /** + * Normalize parameters. + * + * @param {Array} configurations The extension negotiation offers/reponse + * @return {Array} The offers/response with normalized parameters + * @private + */ + normalizeParams(configurations) { + configurations.forEach((params) => { + Object.keys(params).forEach((key) => { + let value = params[key]; + if (value.length > 1) { + throw new Error(`Parameter "${key}" must have only a single value`); + } + value = value[0]; + if (key === "client_max_window_bits") { + if (value !== true) { + const num = +value; + if (!Number.isInteger(num) || num < 8 || num > 15) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + value = num; + } else if (!this._isServer) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + } else if (key === "server_max_window_bits") { + const num = +value; + if (!Number.isInteger(num) || num < 8 || num > 15) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + value = num; + } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") { + if (value !== true) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + } else { + throw new Error(`Unknown parameter "${key}"`); + } + params[key] = value; + }); + }); + return configurations; + } + /** + * Decompress data. Concurrency limited. + * + * @param {Buffer} data Compressed data + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @public + */ + decompress(data, fin, callback) { + zlibLimiter.add((done) => { + this._decompress(data, fin, (err, result) => { + done(); + callback(err, result); + }); + }); + } + /** + * Compress data. Concurrency limited. + * + * @param {(Buffer|String)} data Data to compress + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @public + */ + compress(data, fin, callback) { + zlibLimiter.add((done) => { + this._compress(data, fin, (err, result) => { + done(); + callback(err, result); + }); + }); + } + /** + * Decompress data. + * + * @param {Buffer} data Compressed data + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @private + */ + _decompress(data, fin, callback) { + const endpoint = this._isServer ? "client" : "server"; + if (!this._inflate) { + const key = `${endpoint}_max_window_bits`; + const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key]; + this._inflate = zlib.createInflateRaw({ + ...this._options.zlibInflateOptions, + windowBits + }); + this._inflate[kPerMessageDeflate] = this; + this._inflate[kTotalLength] = 0; + this._inflate[kBuffers] = []; + this._inflate.on("error", inflateOnError); + this._inflate.on("data", inflateOnData); + } + this._inflate[kCallback] = callback; + this._inflate.write(data); + if (fin) this._inflate.write(TRAILER); + this._inflate.flush(() => { + const err = this._inflate[kError]; + if (err) { + this._inflate.close(); + this._inflate = null; + callback(err); + return; + } + const data2 = bufferUtil.concat( + this._inflate[kBuffers], + this._inflate[kTotalLength] + ); + if (this._inflate._readableState.endEmitted) { + this._inflate.close(); + this._inflate = null; + } else { + this._inflate[kTotalLength] = 0; + this._inflate[kBuffers] = []; + if (fin && this.params[`${endpoint}_no_context_takeover`]) { + this._inflate.reset(); + } + } + callback(null, data2); + }); + } + /** + * Compress data. + * + * @param {(Buffer|String)} data Data to compress + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @private + */ + _compress(data, fin, callback) { + const endpoint = this._isServer ? "server" : "client"; + if (!this._deflate) { + const key = `${endpoint}_max_window_bits`; + const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key]; + this._deflate = zlib.createDeflateRaw({ + ...this._options.zlibDeflateOptions, + windowBits + }); + this._deflate[kTotalLength] = 0; + this._deflate[kBuffers] = []; + this._deflate.on("data", deflateOnData); + } + this._deflate[kCallback] = callback; + this._deflate.write(data); + this._deflate.flush(zlib.Z_SYNC_FLUSH, () => { + if (!this._deflate) { + return; + } + let data2 = bufferUtil.concat( + this._deflate[kBuffers], + this._deflate[kTotalLength] + ); + if (fin) { + data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4); + } + this._deflate[kCallback] = null; + this._deflate[kTotalLength] = 0; + this._deflate[kBuffers] = []; + if (fin && this.params[`${endpoint}_no_context_takeover`]) { + this._deflate.reset(); + } + callback(null, data2); + }); + } + }; + module.exports = PerMessageDeflate; + function deflateOnData(chunk) { + this[kBuffers].push(chunk); + this[kTotalLength] += chunk.length; + } + function inflateOnData(chunk) { + this[kTotalLength] += chunk.length; + if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) { + this[kBuffers].push(chunk); + return; + } + this[kError] = new RangeError("Max payload size exceeded"); + this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"; + this[kError][kStatusCode] = 1009; + this.removeListener("data", inflateOnData); + this.reset(); + } + function inflateOnError(err) { + this[kPerMessageDeflate]._inflate = null; + if (this[kError]) { + this[kCallback](this[kError]); + return; + } + err[kStatusCode] = 1007; + this[kCallback](err); + } + } +}); + +// node_modules/ws/lib/validation.js +var require_validation = __commonJS({ + "node_modules/ws/lib/validation.js"(exports, module) { + "use strict"; + var { isUtf8 } = __require("buffer"); + var { hasBlob } = require_constants9(); + var tokenChars = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + // 0 - 15 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + // 16 - 31 + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + // 32 - 47 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + // 48 - 63 + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + // 64 - 79 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + // 80 - 95 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + // 96 - 111 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0 + // 112 - 127 + ]; + function isValidStatusCode(code) { + return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999; + } + function _isValidUTF8(buf2) { + const len = buf2.length; + let i = 0; + while (i < len) { + if ((buf2[i] & 128) === 0) { + i++; + } else if ((buf2[i] & 224) === 192) { + if (i + 1 === len || (buf2[i + 1] & 192) !== 128 || (buf2[i] & 254) === 192) { + return false; + } + i += 2; + } else if ((buf2[i] & 240) === 224) { + if (i + 2 >= len || (buf2[i + 1] & 192) !== 128 || (buf2[i + 2] & 192) !== 128 || buf2[i] === 224 && (buf2[i + 1] & 224) === 128 || // Overlong + buf2[i] === 237 && (buf2[i + 1] & 224) === 160) { + return false; + } + i += 3; + } else if ((buf2[i] & 248) === 240) { + if (i + 3 >= len || (buf2[i + 1] & 192) !== 128 || (buf2[i + 2] & 192) !== 128 || (buf2[i + 3] & 192) !== 128 || buf2[i] === 240 && (buf2[i + 1] & 240) === 128 || // Overlong + buf2[i] === 244 && buf2[i + 1] > 143 || buf2[i] > 244) { + return false; + } + i += 4; + } else { + return false; + } + } + return true; + } + function isBlob(value) { + return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File"); + } + module.exports = { + isBlob, + isValidStatusCode, + isValidUTF8: _isValidUTF8, + tokenChars + }; + if (isUtf8) { + module.exports.isValidUTF8 = function(buf2) { + return buf2.length < 24 ? _isValidUTF8(buf2) : isUtf8(buf2); + }; + } else if (!process.env.WS_NO_UTF_8_VALIDATE) { + try { + const isValidUTF8 = __require("utf-8-validate"); + module.exports.isValidUTF8 = function(buf2) { + return buf2.length < 32 ? _isValidUTF8(buf2) : isValidUTF8(buf2); + }; + } catch (e2) { + } + } + } +}); + +// node_modules/ws/lib/receiver.js +var require_receiver2 = __commonJS({ + "node_modules/ws/lib/receiver.js"(exports, module) { + "use strict"; + var { Writable } = __require("stream"); + var PerMessageDeflate = require_permessage_deflate2(); + var { + BINARY_TYPES, + EMPTY_BUFFER, + kStatusCode, + kWebSocket + } = require_constants9(); + var { concat, toArrayBuffer, unmask } = require_buffer_util(); + var { isValidStatusCode, isValidUTF8 } = require_validation(); + var FastBuffer = Buffer[Symbol.species]; + var GET_INFO = 0; + var GET_PAYLOAD_LENGTH_16 = 1; + var GET_PAYLOAD_LENGTH_64 = 2; + var GET_MASK = 3; + var GET_DATA = 4; + var INFLATING = 5; + var DEFER_EVENT = 6; + var Receiver = class extends Writable { + /** + * Creates a Receiver instance. + * + * @param {Object} [options] Options object + * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {String} [options.binaryType=nodebuffer] The type for binary data + * @param {Object} [options.extensions] An object containing the negotiated + * extensions + * @param {Boolean} [options.isServer=false] Specifies whether to operate in + * client or server mode + * @param {Number} [options.maxPayload=0] The maximum allowed message length + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + */ + constructor(options = {}) { + super(); + this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true; + this._binaryType = options.binaryType || BINARY_TYPES[0]; + this._extensions = options.extensions || {}; + this._isServer = !!options.isServer; + this._maxPayload = options.maxPayload | 0; + this._skipUTF8Validation = !!options.skipUTF8Validation; + this[kWebSocket] = void 0; + this._bufferedBytes = 0; + this._buffers = []; + this._compressed = false; + this._payloadLength = 0; + this._mask = void 0; + this._fragmented = 0; + this._masked = false; + this._fin = false; + this._opcode = 0; + this._totalPayloadLength = 0; + this._messageLength = 0; + this._fragments = []; + this._errored = false; + this._loop = false; + this._state = GET_INFO; + } + /** + * Implements `Writable.prototype._write()`. + * + * @param {Buffer} chunk The chunk of data to write + * @param {String} encoding The character encoding of `chunk` + * @param {Function} cb Callback + * @private + */ + _write(chunk, encoding, cb) { + if (this._opcode === 8 && this._state == GET_INFO) return cb(); + this._bufferedBytes += chunk.length; + this._buffers.push(chunk); + this.startLoop(cb); + } + /** + * Consumes `n` bytes from the buffered data. + * + * @param {Number} n The number of bytes to consume + * @return {Buffer} The consumed bytes + * @private + */ + consume(n) { + this._bufferedBytes -= n; + if (n === this._buffers[0].length) return this._buffers.shift(); + if (n < this._buffers[0].length) { + const buf2 = this._buffers[0]; + this._buffers[0] = new FastBuffer( + buf2.buffer, + buf2.byteOffset + n, + buf2.length - n + ); + return new FastBuffer(buf2.buffer, buf2.byteOffset, n); + } + const dst = Buffer.allocUnsafe(n); + do { + const buf2 = this._buffers[0]; + const offset = dst.length - n; + if (n >= buf2.length) { + dst.set(this._buffers.shift(), offset); + } else { + dst.set(new Uint8Array(buf2.buffer, buf2.byteOffset, n), offset); + this._buffers[0] = new FastBuffer( + buf2.buffer, + buf2.byteOffset + n, + buf2.length - n + ); + } + n -= buf2.length; + } while (n > 0); + return dst; + } + /** + * Starts the parsing loop. + * + * @param {Function} cb Callback + * @private + */ + startLoop(cb) { + this._loop = true; + do { + switch (this._state) { + case GET_INFO: + this.getInfo(cb); + break; + case GET_PAYLOAD_LENGTH_16: + this.getPayloadLength16(cb); + break; + case GET_PAYLOAD_LENGTH_64: + this.getPayloadLength64(cb); + break; + case GET_MASK: + this.getMask(); + break; + case GET_DATA: + this.getData(cb); + break; + case INFLATING: + case DEFER_EVENT: + this._loop = false; + return; + } + } while (this._loop); + if (!this._errored) cb(); + } + /** + * Reads the first two bytes of a frame. + * + * @param {Function} cb Callback + * @private + */ + getInfo(cb) { + if (this._bufferedBytes < 2) { + this._loop = false; + return; + } + const buf2 = this.consume(2); + if ((buf2[0] & 48) !== 0) { + const error2 = this.createError( + RangeError, + "RSV2 and RSV3 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_2_3" + ); + cb(error2); + return; + } + const compressed = (buf2[0] & 64) === 64; + if (compressed && !this._extensions[PerMessageDeflate.extensionName]) { + const error2 = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error2); + return; + } + this._fin = (buf2[0] & 128) === 128; + this._opcode = buf2[0] & 15; + this._payloadLength = buf2[1] & 127; + if (this._opcode === 0) { + if (compressed) { + const error2 = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error2); + return; + } + if (!this._fragmented) { + const error2 = this.createError( + RangeError, + "invalid opcode 0", + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error2); + return; + } + this._opcode = this._fragmented; + } else if (this._opcode === 1 || this._opcode === 2) { + if (this._fragmented) { + const error2 = this.createError( + RangeError, + `invalid opcode ${this._opcode}`, + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error2); + return; + } + this._compressed = compressed; + } else if (this._opcode > 7 && this._opcode < 11) { + if (!this._fin) { + const error2 = this.createError( + RangeError, + "FIN must be set", + true, + 1002, + "WS_ERR_EXPECTED_FIN" + ); + cb(error2); + return; + } + if (compressed) { + const error2 = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error2); + return; + } + if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) { + const error2 = this.createError( + RangeError, + `invalid payload length ${this._payloadLength}`, + true, + 1002, + "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH" + ); + cb(error2); + return; + } + } else { + const error2 = this.createError( + RangeError, + `invalid opcode ${this._opcode}`, + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error2); + return; + } + if (!this._fin && !this._fragmented) this._fragmented = this._opcode; + this._masked = (buf2[1] & 128) === 128; + if (this._isServer) { + if (!this._masked) { + const error2 = this.createError( + RangeError, + "MASK must be set", + true, + 1002, + "WS_ERR_EXPECTED_MASK" + ); + cb(error2); + return; + } + } else if (this._masked) { + const error2 = this.createError( + RangeError, + "MASK must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_MASK" + ); + cb(error2); + return; + } + if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16; + else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64; + else this.haveLength(cb); + } + /** + * Gets extended payload length (7+16). + * + * @param {Function} cb Callback + * @private + */ + getPayloadLength16(cb) { + if (this._bufferedBytes < 2) { + this._loop = false; + return; + } + this._payloadLength = this.consume(2).readUInt16BE(0); + this.haveLength(cb); + } + /** + * Gets extended payload length (7+64). + * + * @param {Function} cb Callback + * @private + */ + getPayloadLength64(cb) { + if (this._bufferedBytes < 8) { + this._loop = false; + return; + } + const buf2 = this.consume(8); + const num = buf2.readUInt32BE(0); + if (num > Math.pow(2, 53 - 32) - 1) { + const error2 = this.createError( + RangeError, + "Unsupported WebSocket frame: payload length > 2^53 - 1", + false, + 1009, + "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH" + ); + cb(error2); + return; + } + this._payloadLength = num * Math.pow(2, 32) + buf2.readUInt32BE(4); + this.haveLength(cb); + } + /** + * Payload length has been read. + * + * @param {Function} cb Callback + * @private + */ + haveLength(cb) { + if (this._payloadLength && this._opcode < 8) { + this._totalPayloadLength += this._payloadLength; + if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) { + const error2 = this.createError( + RangeError, + "Max payload size exceeded", + false, + 1009, + "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" + ); + cb(error2); + return; + } + } + if (this._masked) this._state = GET_MASK; + else this._state = GET_DATA; + } + /** + * Reads mask bytes. + * + * @private + */ + getMask() { + if (this._bufferedBytes < 4) { + this._loop = false; + return; + } + this._mask = this.consume(4); + this._state = GET_DATA; + } + /** + * Reads data bytes. + * + * @param {Function} cb Callback + * @private + */ + getData(cb) { + let data = EMPTY_BUFFER; + if (this._payloadLength) { + if (this._bufferedBytes < this._payloadLength) { + this._loop = false; + return; + } + data = this.consume(this._payloadLength); + if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) { + unmask(data, this._mask); + } + } + if (this._opcode > 7) { + this.controlMessage(data, cb); + return; + } + if (this._compressed) { + this._state = INFLATING; + this.decompress(data, cb); + return; + } + if (data.length) { + this._messageLength = this._totalPayloadLength; + this._fragments.push(data); + } + this.dataMessage(cb); + } + /** + * Decompresses data. + * + * @param {Buffer} data Compressed data + * @param {Function} cb Callback + * @private + */ + decompress(data, cb) { + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + perMessageDeflate.decompress(data, this._fin, (err, buf2) => { + if (err) return cb(err); + if (buf2.length) { + this._messageLength += buf2.length; + if (this._messageLength > this._maxPayload && this._maxPayload > 0) { + const error2 = this.createError( + RangeError, + "Max payload size exceeded", + false, + 1009, + "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" + ); + cb(error2); + return; + } + this._fragments.push(buf2); + } + this.dataMessage(cb); + if (this._state === GET_INFO) this.startLoop(cb); + }); + } + /** + * Handles a data message. + * + * @param {Function} cb Callback + * @private + */ + dataMessage(cb) { + if (!this._fin) { + this._state = GET_INFO; + return; + } + const messageLength = this._messageLength; + const fragments = this._fragments; + this._totalPayloadLength = 0; + this._messageLength = 0; + this._fragmented = 0; + this._fragments = []; + if (this._opcode === 2) { + let data; + if (this._binaryType === "nodebuffer") { + data = concat(fragments, messageLength); + } else if (this._binaryType === "arraybuffer") { + data = toArrayBuffer(concat(fragments, messageLength)); + } else if (this._binaryType === "blob") { + data = new Blob(fragments); + } else { + data = fragments; + } + if (this._allowSynchronousEvents) { + this.emit("message", data, true); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit("message", data, true); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } else { + const buf2 = concat(fragments, messageLength); + if (!this._skipUTF8Validation && !isValidUTF8(buf2)) { + const error2 = this.createError( + Error, + "invalid UTF-8 sequence", + true, + 1007, + "WS_ERR_INVALID_UTF8" + ); + cb(error2); + return; + } + if (this._state === INFLATING || this._allowSynchronousEvents) { + this.emit("message", buf2, false); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit("message", buf2, false); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } + } + /** + * Handles a control message. + * + * @param {Buffer} data Data to handle + * @return {(Error|RangeError|undefined)} A possible error + * @private + */ + controlMessage(data, cb) { + if (this._opcode === 8) { + if (data.length === 0) { + this._loop = false; + this.emit("conclude", 1005, EMPTY_BUFFER); + this.end(); + } else { + const code = data.readUInt16BE(0); + if (!isValidStatusCode(code)) { + const error2 = this.createError( + RangeError, + `invalid status code ${code}`, + true, + 1002, + "WS_ERR_INVALID_CLOSE_CODE" + ); + cb(error2); + return; + } + const buf2 = new FastBuffer( + data.buffer, + data.byteOffset + 2, + data.length - 2 + ); + if (!this._skipUTF8Validation && !isValidUTF8(buf2)) { + const error2 = this.createError( + Error, + "invalid UTF-8 sequence", + true, + 1007, + "WS_ERR_INVALID_UTF8" + ); + cb(error2); + return; + } + this._loop = false; + this.emit("conclude", code, buf2); + this.end(); + } + this._state = GET_INFO; + return; + } + if (this._allowSynchronousEvents) { + this.emit(this._opcode === 9 ? "ping" : "pong", data); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit(this._opcode === 9 ? "ping" : "pong", data); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } + /** + * Builds an error object. + * + * @param {function(new:Error|RangeError)} ErrorCtor The error constructor + * @param {String} message The error message + * @param {Boolean} prefix Specifies whether or not to add a default prefix to + * `message` + * @param {Number} statusCode The status code + * @param {String} errorCode The exposed error code + * @return {(Error|RangeError)} The error + * @private + */ + createError(ErrorCtor, message, prefix, statusCode, errorCode) { + this._loop = false; + this._errored = true; + const err = new ErrorCtor( + prefix ? `Invalid WebSocket frame: ${message}` : message + ); + Error.captureStackTrace(err, this.createError); + err.code = errorCode; + err[kStatusCode] = statusCode; + return err; + } + }; + module.exports = Receiver; + } +}); + +// node_modules/ws/lib/sender.js +var require_sender2 = __commonJS({ + "node_modules/ws/lib/sender.js"(exports, module) { + "use strict"; + var { Duplex } = __require("stream"); + var { randomFillSync } = __require("crypto"); + var PerMessageDeflate = require_permessage_deflate2(); + var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants9(); + var { isBlob, isValidStatusCode } = require_validation(); + var { mask: applyMask, toBuffer } = require_buffer_util(); + var kByteLength = /* @__PURE__ */ Symbol("kByteLength"); + var maskBuffer = Buffer.alloc(4); + var RANDOM_POOL_SIZE = 8 * 1024; + var randomPool; + var randomPoolPointer = RANDOM_POOL_SIZE; + var DEFAULT = 0; + var DEFLATING = 1; + var GET_BLOB_DATA = 2; + var Sender = class _Sender { + /** + * Creates a Sender instance. + * + * @param {Duplex} socket The connection socket + * @param {Object} [extensions] An object containing the negotiated extensions + * @param {Function} [generateMask] The function used to generate the masking + * key + */ + constructor(socket, extensions, generateMask) { + this._extensions = extensions || {}; + if (generateMask) { + this._generateMask = generateMask; + this._maskBuffer = Buffer.alloc(4); + } + this._socket = socket; + this._firstFragment = true; + this._compress = false; + this._bufferedBytes = 0; + this._queue = []; + this._state = DEFAULT; + this.onerror = NOOP; + this[kWebSocket] = void 0; + } + /** + * Frames a piece of data according to the HyBi WebSocket protocol. + * + * @param {(Buffer|String)} data The data to frame + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @return {(Buffer|String)[]} The framed data + * @public + */ + static frame(data, options) { + let mask; + let merge2 = false; + let offset = 2; + let skipMasking = false; + if (options.mask) { + mask = options.maskBuffer || maskBuffer; + if (options.generateMask) { + options.generateMask(mask); + } else { + if (randomPoolPointer === RANDOM_POOL_SIZE) { + if (randomPool === void 0) { + randomPool = Buffer.alloc(RANDOM_POOL_SIZE); + } + randomFillSync(randomPool, 0, RANDOM_POOL_SIZE); + randomPoolPointer = 0; + } + mask[0] = randomPool[randomPoolPointer++]; + mask[1] = randomPool[randomPoolPointer++]; + mask[2] = randomPool[randomPoolPointer++]; + mask[3] = randomPool[randomPoolPointer++]; + } + skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0; + offset = 6; + } + let dataLength; + if (typeof data === "string") { + if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) { + dataLength = options[kByteLength]; + } else { + data = Buffer.from(data); + dataLength = data.length; + } + } else { + dataLength = data.length; + merge2 = options.mask && options.readOnly && !skipMasking; + } + let payloadLength = dataLength; + if (dataLength >= 65536) { + offset += 8; + payloadLength = 127; + } else if (dataLength > 125) { + offset += 2; + payloadLength = 126; + } + const target = Buffer.allocUnsafe(merge2 ? dataLength + offset : offset); + target[0] = options.fin ? options.opcode | 128 : options.opcode; + if (options.rsv1) target[0] |= 64; + target[1] = payloadLength; + if (payloadLength === 126) { + target.writeUInt16BE(dataLength, 2); + } else if (payloadLength === 127) { + target[2] = target[3] = 0; + target.writeUIntBE(dataLength, 4, 6); + } + if (!options.mask) return [target, data]; + target[1] |= 128; + target[offset - 4] = mask[0]; + target[offset - 3] = mask[1]; + target[offset - 2] = mask[2]; + target[offset - 1] = mask[3]; + if (skipMasking) return [target, data]; + if (merge2) { + applyMask(data, mask, target, offset, dataLength); + return [target]; + } + applyMask(data, mask, data, 0, dataLength); + return [target, data]; + } + /** + * Sends a close message to the other peer. + * + * @param {Number} [code] The status code component of the body + * @param {(String|Buffer)} [data] The message component of the body + * @param {Boolean} [mask=false] Specifies whether or not to mask the message + * @param {Function} [cb] Callback + * @public + */ + close(code, data, mask, cb) { + let buf2; + if (code === void 0) { + buf2 = EMPTY_BUFFER; + } else if (typeof code !== "number" || !isValidStatusCode(code)) { + throw new TypeError("First argument must be a valid error code number"); + } else if (data === void 0 || !data.length) { + buf2 = Buffer.allocUnsafe(2); + buf2.writeUInt16BE(code, 0); + } else { + const length = Buffer.byteLength(data); + if (length > 123) { + throw new RangeError("The message must not be greater than 123 bytes"); + } + buf2 = Buffer.allocUnsafe(2 + length); + buf2.writeUInt16BE(code, 0); + if (typeof data === "string") { + buf2.write(data, 2); + } else { + buf2.set(data, 2); + } + } + const options = { + [kByteLength]: buf2.length, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 8, + readOnly: false, + rsv1: false + }; + if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, buf2, false, options, cb]); + } else { + this.sendFrame(_Sender.frame(buf2, options), cb); + } + } + /** + * Sends a ping message to the other peer. + * + * @param {*} data The message to send + * @param {Boolean} [mask=false] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback + * @public + */ + ping(data, mask, cb) { + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (byteLength > 125) { + throw new RangeError("The data size must not be greater than 125 bytes"); + } + const options = { + [kByteLength]: byteLength, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 9, + readOnly, + rsv1: false + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, false, options, cb]); + } else { + this.getBlobData(data, false, options, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, false, options, cb]); + } else { + this.sendFrame(_Sender.frame(data, options), cb); + } + } + /** + * Sends a pong message to the other peer. + * + * @param {*} data The message to send + * @param {Boolean} [mask=false] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback + * @public + */ + pong(data, mask, cb) { + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (byteLength > 125) { + throw new RangeError("The data size must not be greater than 125 bytes"); + } + const options = { + [kByteLength]: byteLength, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 10, + readOnly, + rsv1: false + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, false, options, cb]); + } else { + this.getBlobData(data, false, options, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, false, options, cb]); + } else { + this.sendFrame(_Sender.frame(data, options), cb); + } + } + /** + * Sends a data message to the other peer. + * + * @param {*} data The message to send + * @param {Object} options Options object + * @param {Boolean} [options.binary=false] Specifies whether `data` is binary + * or text + * @param {Boolean} [options.compress=false] Specifies whether or not to + * compress `data` + * @param {Boolean} [options.fin=false] Specifies whether the fragment is the + * last one + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Function} [cb] Callback + * @public + */ + send(data, options, cb) { + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + let opcode = options.binary ? 2 : 1; + let rsv1 = options.compress; + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (this._firstFragment) { + this._firstFragment = false; + if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) { + rsv1 = byteLength >= perMessageDeflate._threshold; + } + this._compress = rsv1; + } else { + rsv1 = false; + opcode = 0; + } + if (options.fin) this._firstFragment = true; + const opts = { + [kByteLength]: byteLength, + fin: options.fin, + generateMask: this._generateMask, + mask: options.mask, + maskBuffer: this._maskBuffer, + opcode, + readOnly, + rsv1 + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, this._compress, opts, cb]); + } else { + this.getBlobData(data, this._compress, opts, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, this._compress, opts, cb]); + } else { + this.dispatch(data, this._compress, opts, cb); + } + } + /** + * Gets the contents of a blob as binary data. + * + * @param {Blob} blob The blob + * @param {Boolean} [compress=false] Specifies whether or not to compress + * the data + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @param {Function} [cb] Callback + * @private + */ + getBlobData(blob, compress, options, cb) { + this._bufferedBytes += options[kByteLength]; + this._state = GET_BLOB_DATA; + blob.arrayBuffer().then((arrayBuffer) => { + if (this._socket.destroyed) { + const err = new Error( + "The socket was closed while the blob was being read" + ); + process.nextTick(callCallbacks, this, err, cb); + return; + } + this._bufferedBytes -= options[kByteLength]; + const data = toBuffer(arrayBuffer); + if (!compress) { + this._state = DEFAULT; + this.sendFrame(_Sender.frame(data, options), cb); + this.dequeue(); + } else { + this.dispatch(data, compress, options, cb); + } + }).catch((err) => { + process.nextTick(onError, this, err, cb); + }); + } + /** + * Dispatches a message. + * + * @param {(Buffer|String)} data The message to send + * @param {Boolean} [compress=false] Specifies whether or not to compress + * `data` + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @param {Function} [cb] Callback + * @private + */ + dispatch(data, compress, options, cb) { + if (!compress) { + this.sendFrame(_Sender.frame(data, options), cb); + return; + } + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + this._bufferedBytes += options[kByteLength]; + this._state = DEFLATING; + perMessageDeflate.compress(data, options.fin, (_, buf2) => { + if (this._socket.destroyed) { + const err = new Error( + "The socket was closed while data was being compressed" + ); + callCallbacks(this, err, cb); + return; + } + this._bufferedBytes -= options[kByteLength]; + this._state = DEFAULT; + options.readOnly = false; + this.sendFrame(_Sender.frame(buf2, options), cb); + this.dequeue(); + }); + } + /** + * Executes queued send operations. + * + * @private + */ + dequeue() { + while (this._state === DEFAULT && this._queue.length) { + const params = this._queue.shift(); + this._bufferedBytes -= params[3][kByteLength]; + Reflect.apply(params[0], this, params.slice(1)); + } + } + /** + * Enqueues a send operation. + * + * @param {Array} params Send operation parameters. + * @private + */ + enqueue(params) { + this._bufferedBytes += params[3][kByteLength]; + this._queue.push(params); + } + /** + * Sends a frame. + * + * @param {(Buffer | String)[]} list The frame to send + * @param {Function} [cb] Callback + * @private + */ + sendFrame(list, cb) { + if (list.length === 2) { + this._socket.cork(); + this._socket.write(list[0]); + this._socket.write(list[1], cb); + this._socket.uncork(); + } else { + this._socket.write(list[0], cb); + } + } + }; + module.exports = Sender; + function callCallbacks(sender, err, cb) { + if (typeof cb === "function") cb(err); + for (let i = 0; i < sender._queue.length; i++) { + const params = sender._queue[i]; + const callback = params[params.length - 1]; + if (typeof callback === "function") callback(err); + } + } + function onError(sender, err, cb) { + callCallbacks(sender, err, cb); + sender.onerror(err); + } + } +}); + +// node_modules/ws/lib/event-target.js +var require_event_target = __commonJS({ + "node_modules/ws/lib/event-target.js"(exports, module) { + "use strict"; + var { kForOnEventAttribute, kListener } = require_constants9(); + var kCode = /* @__PURE__ */ Symbol("kCode"); + var kData = /* @__PURE__ */ Symbol("kData"); + var kError = /* @__PURE__ */ Symbol("kError"); + var kMessage = /* @__PURE__ */ Symbol("kMessage"); + var kReason = /* @__PURE__ */ Symbol("kReason"); + var kTarget = /* @__PURE__ */ Symbol("kTarget"); + var kType = /* @__PURE__ */ Symbol("kType"); + var kWasClean = /* @__PURE__ */ Symbol("kWasClean"); + var Event2 = class { + /** + * Create a new `Event`. + * + * @param {String} type The name of the event + * @throws {TypeError} If the `type` argument is not specified + */ + constructor(type2) { + this[kTarget] = null; + this[kType] = type2; + } + /** + * @type {*} + */ + get target() { + return this[kTarget]; + } + /** + * @type {String} + */ + get type() { + return this[kType]; + } + }; + Object.defineProperty(Event2.prototype, "target", { enumerable: true }); + Object.defineProperty(Event2.prototype, "type", { enumerable: true }); + var CloseEvent = class extends Event2 { + /** + * Create a new `CloseEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {Number} [options.code=0] The status code explaining why the + * connection was closed + * @param {String} [options.reason=''] A human-readable string explaining why + * the connection was closed + * @param {Boolean} [options.wasClean=false] Indicates whether or not the + * connection was cleanly closed + */ + constructor(type2, options = {}) { + super(type2); + this[kCode] = options.code === void 0 ? 0 : options.code; + this[kReason] = options.reason === void 0 ? "" : options.reason; + this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean; + } + /** + * @type {Number} + */ + get code() { + return this[kCode]; + } + /** + * @type {String} + */ + get reason() { + return this[kReason]; + } + /** + * @type {Boolean} + */ + get wasClean() { + return this[kWasClean]; + } + }; + Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true }); + Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true }); + Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true }); + var ErrorEvent = class extends Event2 { + /** + * Create a new `ErrorEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {*} [options.error=null] The error that generated this event + * @param {String} [options.message=''] The error message + */ + constructor(type2, options = {}) { + super(type2); + this[kError] = options.error === void 0 ? null : options.error; + this[kMessage] = options.message === void 0 ? "" : options.message; + } + /** + * @type {*} + */ + get error() { + return this[kError]; + } + /** + * @type {String} + */ + get message() { + return this[kMessage]; + } + }; + Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true }); + Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true }); + var MessageEvent = class extends Event2 { + /** + * Create a new `MessageEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {*} [options.data=null] The message content + */ + constructor(type2, options = {}) { + super(type2); + this[kData] = options.data === void 0 ? null : options.data; + } + /** + * @type {*} + */ + get data() { + return this[kData]; + } + }; + Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true }); + var EventTarget2 = { + /** + * Register an event listener. + * + * @param {String} type A string representing the event type to listen for + * @param {(Function|Object)} handler The listener to add + * @param {Object} [options] An options object specifies characteristics about + * the event listener + * @param {Boolean} [options.once=false] A `Boolean` indicating that the + * listener should be invoked at most once after being added. If `true`, + * the listener would be automatically removed when invoked. + * @public + */ + addEventListener(type2, handler, options = {}) { + for (const listener of this.listeners(type2)) { + if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) { + return; + } + } + let wrapper; + if (type2 === "message") { + wrapper = function onMessage(data, isBinary2) { + const event = new MessageEvent("message", { + data: isBinary2 ? data : data.toString() + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type2 === "close") { + wrapper = function onClose(code, message) { + const event = new CloseEvent("close", { + code, + reason: message.toString(), + wasClean: this._closeFrameReceived && this._closeFrameSent + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type2 === "error") { + wrapper = function onError(error2) { + const event = new ErrorEvent("error", { + error: error2, + message: error2.message + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type2 === "open") { + wrapper = function onOpen() { + const event = new Event2("open"); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else { + return; + } + wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute]; + wrapper[kListener] = handler; + if (options.once) { + this.once(type2, wrapper); + } else { + this.on(type2, wrapper); + } + }, + /** + * Remove an event listener. + * + * @param {String} type A string representing the event type to remove + * @param {(Function|Object)} handler The listener to remove + * @public + */ + removeEventListener(type2, handler) { + for (const listener of this.listeners(type2)) { + if (listener[kListener] === handler && !listener[kForOnEventAttribute]) { + this.removeListener(type2, listener); + break; + } + } + } + }; + module.exports = { + CloseEvent, + ErrorEvent, + Event: Event2, + EventTarget: EventTarget2, + MessageEvent + }; + function callListener(listener, thisArg, event) { + if (typeof listener === "object" && listener.handleEvent) { + listener.handleEvent.call(listener, event); + } else { + listener.call(thisArg, event); + } + } + } +}); + +// node_modules/ws/lib/extension.js +var require_extension = __commonJS({ + "node_modules/ws/lib/extension.js"(exports, module) { + "use strict"; + var { tokenChars } = require_validation(); + function push2(dest, name, elem) { + if (dest[name] === void 0) dest[name] = [elem]; + else dest[name].push(elem); + } + function parse2(header) { + const offers = /* @__PURE__ */ Object.create(null); + let params = /* @__PURE__ */ Object.create(null); + let mustUnescape = false; + let isEscaping = false; + let inQuotes = false; + let extensionName; + let paramName; + let start = -1; + let code = -1; + let end = -1; + let i = 0; + for (; i < header.length; i++) { + code = header.charCodeAt(i); + if (extensionName === void 0) { + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (i !== 0 && (code === 32 || code === 9)) { + if (end === -1 && start !== -1) end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + const name = header.slice(start, end); + if (code === 44) { + push2(offers, name, params); + params = /* @__PURE__ */ Object.create(null); + } else { + extensionName = name; + } + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else if (paramName === void 0) { + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (code === 32 || code === 9) { + if (end === -1 && start !== -1) end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + push2(params, header.slice(start, end), true); + if (code === 44) { + push2(offers, extensionName, params); + params = /* @__PURE__ */ Object.create(null); + extensionName = void 0; + } + start = end = -1; + } else if (code === 61 && start !== -1 && end === -1) { + paramName = header.slice(start, i); + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else { + if (isEscaping) { + if (tokenChars[code] !== 1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (start === -1) start = i; + else if (!mustUnescape) mustUnescape = true; + isEscaping = false; + } else if (inQuotes) { + if (tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (code === 34 && start !== -1) { + inQuotes = false; + end = i; + } else if (code === 92) { + isEscaping = true; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else if (code === 34 && header.charCodeAt(i - 1) === 61) { + inQuotes = true; + } else if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (start !== -1 && (code === 32 || code === 9)) { + if (end === -1) end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + let value = header.slice(start, end); + if (mustUnescape) { + value = value.replace(/\\/g, ""); + mustUnescape = false; + } + push2(params, paramName, value); + if (code === 44) { + push2(offers, extensionName, params); + params = /* @__PURE__ */ Object.create(null); + extensionName = void 0; + } + paramName = void 0; + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } + } + if (start === -1 || inQuotes || code === 32 || code === 9) { + throw new SyntaxError("Unexpected end of input"); + } + if (end === -1) end = i; + const token = header.slice(start, end); + if (extensionName === void 0) { + push2(offers, token, params); + } else { + if (paramName === void 0) { + push2(params, token, true); + } else if (mustUnescape) { + push2(params, paramName, token.replace(/\\/g, "")); + } else { + push2(params, paramName, token); + } + push2(offers, extensionName, params); + } + return offers; + } + function format2(extensions) { + return Object.keys(extensions).map((extension) => { + let configurations = extensions[extension]; + if (!Array.isArray(configurations)) configurations = [configurations]; + return configurations.map((params) => { + return [extension].concat( + Object.keys(params).map((k) => { + let values = params[k]; + if (!Array.isArray(values)) values = [values]; + return values.map((v) => v === true ? k : `${k}=${v}`).join("; "); + }) + ).join("; "); + }).join(", "); + }).join(", "); + } + module.exports = { format: format2, parse: parse2 }; + } +}); + +// node_modules/ws/lib/websocket.js +var require_websocket2 = __commonJS({ + "node_modules/ws/lib/websocket.js"(exports, module) { + "use strict"; + var EventEmitter2 = __require("events"); + var https2 = __require("https"); + var http2 = __require("http"); + var net2 = __require("net"); + var tls = __require("tls"); + var { randomBytes, createHash } = __require("crypto"); + var { Duplex, Readable } = __require("stream"); + var { URL: URL3 } = __require("url"); + var PerMessageDeflate = require_permessage_deflate2(); + var Receiver = require_receiver2(); + var Sender = require_sender2(); + var { isBlob } = require_validation(); + var { + BINARY_TYPES, + CLOSE_TIMEOUT, + EMPTY_BUFFER, + GUID, + kForOnEventAttribute, + kListener, + kStatusCode, + kWebSocket, + NOOP + } = require_constants9(); + var { + EventTarget: { addEventListener, removeEventListener } + } = require_event_target(); + var { format: format2, parse: parse2 } = require_extension(); + var { toBuffer } = require_buffer_util(); + var kAborted = /* @__PURE__ */ Symbol("kAborted"); + var protocolVersions = [8, 13]; + var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"]; + var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/; + var WebSocket2 = class _WebSocket extends EventEmitter2 { + /** + * Create a new `WebSocket`. + * + * @param {(String|URL)} address The URL to which to connect + * @param {(String|String[])} [protocols] The subprotocols + * @param {Object} [options] Connection options + */ + constructor(address, protocols2, options) { + super(); + this._binaryType = BINARY_TYPES[0]; + this._closeCode = 1006; + this._closeFrameReceived = false; + this._closeFrameSent = false; + this._closeMessage = EMPTY_BUFFER; + this._closeTimer = null; + this._errorEmitted = false; + this._extensions = {}; + this._paused = false; + this._protocol = ""; + this._readyState = _WebSocket.CONNECTING; + this._receiver = null; + this._sender = null; + this._socket = null; + if (address !== null) { + this._bufferedAmount = 0; + this._isServer = false; + this._redirects = 0; + if (protocols2 === void 0) { + protocols2 = []; + } else if (!Array.isArray(protocols2)) { + if (typeof protocols2 === "object" && protocols2 !== null) { + options = protocols2; + protocols2 = []; + } else { + protocols2 = [protocols2]; + } + } + initAsClient(this, address, protocols2, options); + } else { + this._autoPong = options.autoPong; + this._closeTimeout = options.closeTimeout; + this._isServer = true; + } + } + /** + * For historical reasons, the custom "nodebuffer" type is used by the default + * instead of "blob". + * + * @type {String} + */ + get binaryType() { + return this._binaryType; + } + set binaryType(type2) { + if (!BINARY_TYPES.includes(type2)) return; + this._binaryType = type2; + if (this._receiver) this._receiver._binaryType = type2; + } + /** + * @type {Number} + */ + get bufferedAmount() { + if (!this._socket) return this._bufferedAmount; + return this._socket._writableState.length + this._sender._bufferedBytes; + } + /** + * @type {String} + */ + get extensions() { + return Object.keys(this._extensions).join(); + } + /** + * @type {Boolean} + */ + get isPaused() { + return this._paused; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onclose() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onerror() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onopen() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onmessage() { + return null; + } + /** + * @type {String} + */ + get protocol() { + return this._protocol; + } + /** + * @type {Number} + */ + get readyState() { + return this._readyState; + } + /** + * @type {String} + */ + get url() { + return this._url; + } + /** + * Set up the socket and the internal resources. + * + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Object} options Options object + * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Number} [options.maxPayload=0] The maximum allowed message size + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + * @private + */ + setSocket(socket, head, options) { + const receiver = new Receiver({ + allowSynchronousEvents: options.allowSynchronousEvents, + binaryType: this.binaryType, + extensions: this._extensions, + isServer: this._isServer, + maxPayload: options.maxPayload, + skipUTF8Validation: options.skipUTF8Validation + }); + const sender = new Sender(socket, this._extensions, options.generateMask); + this._receiver = receiver; + this._sender = sender; + this._socket = socket; + receiver[kWebSocket] = this; + sender[kWebSocket] = this; + socket[kWebSocket] = this; + receiver.on("conclude", receiverOnConclude); + receiver.on("drain", receiverOnDrain); + receiver.on("error", receiverOnError); + receiver.on("message", receiverOnMessage); + receiver.on("ping", receiverOnPing); + receiver.on("pong", receiverOnPong); + sender.onerror = senderOnError; + if (socket.setTimeout) socket.setTimeout(0); + if (socket.setNoDelay) socket.setNoDelay(); + if (head.length > 0) socket.unshift(head); + socket.on("close", socketOnClose); + socket.on("data", socketOnData); + socket.on("end", socketOnEnd); + socket.on("error", socketOnError); + this._readyState = _WebSocket.OPEN; + this.emit("open"); + } + /** + * Emit the `'close'` event. + * + * @private + */ + emitClose() { + if (!this._socket) { + this._readyState = _WebSocket.CLOSED; + this.emit("close", this._closeCode, this._closeMessage); + return; + } + if (this._extensions[PerMessageDeflate.extensionName]) { + this._extensions[PerMessageDeflate.extensionName].cleanup(); + } + this._receiver.removeAllListeners(); + this._readyState = _WebSocket.CLOSED; + this.emit("close", this._closeCode, this._closeMessage); + } + /** + * Start a closing handshake. + * + * +----------+ +-----------+ +----------+ + * - - -|ws.close()|-->|close frame|-->|ws.close()|- - - + * | +----------+ +-----------+ +----------+ | + * +----------+ +-----------+ | + * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING + * +----------+ +-----------+ | + * | | | +---+ | + * +------------------------+-->|fin| - - - - + * | +---+ | +---+ + * - - - - -|fin|<---------------------+ + * +---+ + * + * @param {Number} [code] Status code explaining why the connection is closing + * @param {(String|Buffer)} [data] The reason why the connection is + * closing + * @public + */ + close(code, data) { + if (this.readyState === _WebSocket.CLOSED) return; + if (this.readyState === _WebSocket.CONNECTING) { + const msg = "WebSocket was closed before the connection was established"; + abortHandshake(this, this._req, msg); + return; + } + if (this.readyState === _WebSocket.CLOSING) { + if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) { + this._socket.end(); + } + return; + } + this._readyState = _WebSocket.CLOSING; + this._sender.close(code, data, !this._isServer, (err) => { + if (err) return; + this._closeFrameSent = true; + if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) { + this._socket.end(); + } + }); + setCloseTimer(this); + } + /** + * Pause the socket. + * + * @public + */ + pause() { + if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) { + return; + } + this._paused = true; + this._socket.pause(); + } + /** + * Send a ping. + * + * @param {*} [data] The data to send + * @param {Boolean} [mask] Indicates whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when the ping is sent + * @public + */ + ping(data, mask, cb) { + if (this.readyState === _WebSocket.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof data === "function") { + cb = data; + data = mask = void 0; + } else if (typeof mask === "function") { + cb = mask; + mask = void 0; + } + if (typeof data === "number") data = data.toString(); + if (this.readyState !== _WebSocket.OPEN) { + sendAfterClose(this, data, cb); + return; + } + if (mask === void 0) mask = !this._isServer; + this._sender.ping(data || EMPTY_BUFFER, mask, cb); + } + /** + * Send a pong. + * + * @param {*} [data] The data to send + * @param {Boolean} [mask] Indicates whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when the pong is sent + * @public + */ + pong(data, mask, cb) { + if (this.readyState === _WebSocket.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof data === "function") { + cb = data; + data = mask = void 0; + } else if (typeof mask === "function") { + cb = mask; + mask = void 0; + } + if (typeof data === "number") data = data.toString(); + if (this.readyState !== _WebSocket.OPEN) { + sendAfterClose(this, data, cb); + return; + } + if (mask === void 0) mask = !this._isServer; + this._sender.pong(data || EMPTY_BUFFER, mask, cb); + } + /** + * Resume the socket. + * + * @public + */ + resume() { + if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) { + return; + } + this._paused = false; + if (!this._receiver._writableState.needDrain) this._socket.resume(); + } + /** + * Send a data message. + * + * @param {*} data The message to send + * @param {Object} [options] Options object + * @param {Boolean} [options.binary] Specifies whether `data` is binary or + * text + * @param {Boolean} [options.compress] Specifies whether or not to compress + * `data` + * @param {Boolean} [options.fin=true] Specifies whether the fragment is the + * last one + * @param {Boolean} [options.mask] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when data is written out + * @public + */ + send(data, options, cb) { + if (this.readyState === _WebSocket.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof options === "function") { + cb = options; + options = {}; + } + if (typeof data === "number") data = data.toString(); + if (this.readyState !== _WebSocket.OPEN) { + sendAfterClose(this, data, cb); + return; + } + const opts = { + binary: typeof data !== "string", + mask: !this._isServer, + compress: true, + fin: true, + ...options + }; + if (!this._extensions[PerMessageDeflate.extensionName]) { + opts.compress = false; + } + this._sender.send(data || EMPTY_BUFFER, opts, cb); + } + /** + * Forcibly close the connection. + * + * @public + */ + terminate() { + if (this.readyState === _WebSocket.CLOSED) return; + if (this.readyState === _WebSocket.CONNECTING) { + const msg = "WebSocket was closed before the connection was established"; + abortHandshake(this, this._req, msg); + return; + } + if (this._socket) { + this._readyState = _WebSocket.CLOSING; + this._socket.destroy(); + } + } + }; + Object.defineProperty(WebSocket2, "CONNECTING", { + enumerable: true, + value: readyStates.indexOf("CONNECTING") + }); + Object.defineProperty(WebSocket2.prototype, "CONNECTING", { + enumerable: true, + value: readyStates.indexOf("CONNECTING") + }); + Object.defineProperty(WebSocket2, "OPEN", { + enumerable: true, + value: readyStates.indexOf("OPEN") + }); + Object.defineProperty(WebSocket2.prototype, "OPEN", { + enumerable: true, + value: readyStates.indexOf("OPEN") + }); + Object.defineProperty(WebSocket2, "CLOSING", { + enumerable: true, + value: readyStates.indexOf("CLOSING") + }); + Object.defineProperty(WebSocket2.prototype, "CLOSING", { + enumerable: true, + value: readyStates.indexOf("CLOSING") + }); + Object.defineProperty(WebSocket2, "CLOSED", { + enumerable: true, + value: readyStates.indexOf("CLOSED") + }); + Object.defineProperty(WebSocket2.prototype, "CLOSED", { + enumerable: true, + value: readyStates.indexOf("CLOSED") + }); + [ + "binaryType", + "bufferedAmount", + "extensions", + "isPaused", + "protocol", + "readyState", + "url" + ].forEach((property) => { + Object.defineProperty(WebSocket2.prototype, property, { enumerable: true }); + }); + ["open", "error", "close", "message"].forEach((method) => { + Object.defineProperty(WebSocket2.prototype, `on${method}`, { + enumerable: true, + get() { + for (const listener of this.listeners(method)) { + if (listener[kForOnEventAttribute]) return listener[kListener]; + } + return null; + }, + set(handler) { + for (const listener of this.listeners(method)) { + if (listener[kForOnEventAttribute]) { + this.removeListener(method, listener); + break; + } + } + if (typeof handler !== "function") return; + this.addEventListener(method, handler, { + [kForOnEventAttribute]: true + }); + } + }); + }); + WebSocket2.prototype.addEventListener = addEventListener; + WebSocket2.prototype.removeEventListener = removeEventListener; + module.exports = WebSocket2; + function initAsClient(websocket, address, protocols2, options) { + const opts = { + allowSynchronousEvents: true, + autoPong: true, + closeTimeout: CLOSE_TIMEOUT, + protocolVersion: protocolVersions[1], + maxPayload: 100 * 1024 * 1024, + skipUTF8Validation: false, + perMessageDeflate: true, + followRedirects: false, + maxRedirects: 10, + ...options, + socketPath: void 0, + hostname: void 0, + protocol: void 0, + timeout: void 0, + method: "GET", + host: void 0, + path: void 0, + port: void 0 + }; + websocket._autoPong = opts.autoPong; + websocket._closeTimeout = opts.closeTimeout; + if (!protocolVersions.includes(opts.protocolVersion)) { + throw new RangeError( + `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})` + ); + } + let parsedUrl; + if (address instanceof URL3) { + parsedUrl = address; + } else { + try { + parsedUrl = new URL3(address); + } catch { + throw new SyntaxError(`Invalid URL: ${address}`); + } + } + if (parsedUrl.protocol === "http:") { + parsedUrl.protocol = "ws:"; + } else if (parsedUrl.protocol === "https:") { + parsedUrl.protocol = "wss:"; + } + websocket._url = parsedUrl.href; + const isSecure = parsedUrl.protocol === "wss:"; + const isIpcUrl = parsedUrl.protocol === "ws+unix:"; + let invalidUrlMessage; + if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) { + invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`; + } else if (isIpcUrl && !parsedUrl.pathname) { + invalidUrlMessage = "The URL's pathname is empty"; + } else if (parsedUrl.hash) { + invalidUrlMessage = "The URL contains a fragment identifier"; + } + if (invalidUrlMessage) { + const err = new SyntaxError(invalidUrlMessage); + if (websocket._redirects === 0) { + throw err; + } else { + emitErrorAndClose(websocket, err); + return; + } + } + const defaultPort = isSecure ? 443 : 80; + const key = randomBytes(16).toString("base64"); + const request = isSecure ? https2.request : http2.request; + const protocolSet = /* @__PURE__ */ new Set(); + let perMessageDeflate; + opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect); + opts.defaultPort = opts.defaultPort || defaultPort; + opts.port = parsedUrl.port || defaultPort; + opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname; + opts.headers = { + ...opts.headers, + "Sec-WebSocket-Version": opts.protocolVersion, + "Sec-WebSocket-Key": key, + Connection: "Upgrade", + Upgrade: "websocket" + }; + opts.path = parsedUrl.pathname + parsedUrl.search; + opts.timeout = opts.handshakeTimeout; + if (opts.perMessageDeflate) { + perMessageDeflate = new PerMessageDeflate({ + ...opts.perMessageDeflate, + isServer: false, + maxPayload: opts.maxPayload + }); + opts.headers["Sec-WebSocket-Extensions"] = format2({ + [PerMessageDeflate.extensionName]: perMessageDeflate.offer() + }); + } + if (protocols2.length) { + for (const protocol of protocols2) { + if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) { + throw new SyntaxError( + "An invalid or duplicated subprotocol was specified" + ); + } + protocolSet.add(protocol); + } + opts.headers["Sec-WebSocket-Protocol"] = protocols2.join(","); + } + if (opts.origin) { + if (opts.protocolVersion < 13) { + opts.headers["Sec-WebSocket-Origin"] = opts.origin; + } else { + opts.headers.Origin = opts.origin; + } + } + if (parsedUrl.username || parsedUrl.password) { + opts.auth = `${parsedUrl.username}:${parsedUrl.password}`; + } + if (isIpcUrl) { + const parts = opts.path.split(":"); + opts.socketPath = parts[0]; + opts.path = parts[1]; + } + let req; + if (opts.followRedirects) { + if (websocket._redirects === 0) { + websocket._originalIpc = isIpcUrl; + websocket._originalSecure = isSecure; + websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host; + const headers2 = options && options.headers; + options = { ...options, headers: {} }; + if (headers2) { + for (const [key2, value] of Object.entries(headers2)) { + options.headers[key2.toLowerCase()] = value; + } + } + } else if (websocket.listenerCount("redirect") === 0) { + const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath; + if (!isSameHost || websocket._originalSecure && !isSecure) { + delete opts.headers.authorization; + delete opts.headers.cookie; + if (!isSameHost) delete opts.headers.host; + opts.auth = void 0; + } + } + if (opts.auth && !options.headers.authorization) { + options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64"); + } + req = websocket._req = request(opts); + if (websocket._redirects) { + websocket.emit("redirect", websocket.url, req); + } + } else { + req = websocket._req = request(opts); + } + if (opts.timeout) { + req.on("timeout", () => { + abortHandshake(websocket, req, "Opening handshake has timed out"); + }); + } + req.on("error", (err) => { + if (req === null || req[kAborted]) return; + req = websocket._req = null; + emitErrorAndClose(websocket, err); + }); + req.on("response", (res) => { + const location = res.headers.location; + const statusCode = res.statusCode; + if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) { + if (++websocket._redirects > opts.maxRedirects) { + abortHandshake(websocket, req, "Maximum redirects exceeded"); + return; + } + req.abort(); + let addr; + try { + addr = new URL3(location, address); + } catch (e2) { + const err = new SyntaxError(`Invalid URL: ${location}`); + emitErrorAndClose(websocket, err); + return; + } + initAsClient(websocket, addr, protocols2, options); + } else if (!websocket.emit("unexpected-response", req, res)) { + abortHandshake( + websocket, + req, + `Unexpected server response: ${res.statusCode}` + ); + } + }); + req.on("upgrade", (res, socket, head) => { + websocket.emit("upgrade", res); + if (websocket.readyState !== WebSocket2.CONNECTING) return; + req = websocket._req = null; + const upgrade = res.headers.upgrade; + if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") { + abortHandshake(websocket, socket, "Invalid Upgrade header"); + return; + } + const digest = createHash("sha1").update(key + GUID).digest("base64"); + if (res.headers["sec-websocket-accept"] !== digest) { + abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header"); + return; + } + const serverProt = res.headers["sec-websocket-protocol"]; + let protError; + if (serverProt !== void 0) { + if (!protocolSet.size) { + protError = "Server sent a subprotocol but none was requested"; + } else if (!protocolSet.has(serverProt)) { + protError = "Server sent an invalid subprotocol"; + } + } else if (protocolSet.size) { + protError = "Server sent no subprotocol"; + } + if (protError) { + abortHandshake(websocket, socket, protError); + return; + } + if (serverProt) websocket._protocol = serverProt; + const secWebSocketExtensions = res.headers["sec-websocket-extensions"]; + if (secWebSocketExtensions !== void 0) { + if (!perMessageDeflate) { + const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested"; + abortHandshake(websocket, socket, message); + return; + } + let extensions; + try { + extensions = parse2(secWebSocketExtensions); + } catch (err) { + const message = "Invalid Sec-WebSocket-Extensions header"; + abortHandshake(websocket, socket, message); + return; + } + const extensionNames = Object.keys(extensions); + if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) { + const message = "Server indicated an extension that was not requested"; + abortHandshake(websocket, socket, message); + return; + } + try { + perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]); + } catch (err) { + const message = "Invalid Sec-WebSocket-Extensions header"; + abortHandshake(websocket, socket, message); + return; + } + websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate; + } + websocket.setSocket(socket, head, { + allowSynchronousEvents: opts.allowSynchronousEvents, + generateMask: opts.generateMask, + maxPayload: opts.maxPayload, + skipUTF8Validation: opts.skipUTF8Validation + }); + }); + if (opts.finishRequest) { + opts.finishRequest(req, websocket); + } else { + req.end(); + } + } + function emitErrorAndClose(websocket, err) { + websocket._readyState = WebSocket2.CLOSING; + websocket._errorEmitted = true; + websocket.emit("error", err); + websocket.emitClose(); + } + function netConnect(options) { + options.path = options.socketPath; + return net2.connect(options); + } + function tlsConnect(options) { + options.path = void 0; + if (!options.servername && options.servername !== "") { + options.servername = net2.isIP(options.host) ? "" : options.host; + } + return tls.connect(options); + } + function abortHandshake(websocket, stream, message) { + websocket._readyState = WebSocket2.CLOSING; + const err = new Error(message); + Error.captureStackTrace(err, abortHandshake); + if (stream.setHeader) { + stream[kAborted] = true; + stream.abort(); + if (stream.socket && !stream.socket.destroyed) { + stream.socket.destroy(); + } + process.nextTick(emitErrorAndClose, websocket, err); + } else { + stream.destroy(err); + stream.once("error", websocket.emit.bind(websocket, "error")); + stream.once("close", websocket.emitClose.bind(websocket)); + } + } + function sendAfterClose(websocket, data, cb) { + if (data) { + const length = isBlob(data) ? data.size : toBuffer(data).length; + if (websocket._socket) websocket._sender._bufferedBytes += length; + else websocket._bufferedAmount += length; + } + if (cb) { + const err = new Error( + `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})` + ); + process.nextTick(cb, err); + } + } + function receiverOnConclude(code, reason) { + const websocket = this[kWebSocket]; + websocket._closeFrameReceived = true; + websocket._closeMessage = reason; + websocket._closeCode = code; + if (websocket._socket[kWebSocket] === void 0) return; + websocket._socket.removeListener("data", socketOnData); + process.nextTick(resume, websocket._socket); + if (code === 1005) websocket.close(); + else websocket.close(code, reason); + } + function receiverOnDrain() { + const websocket = this[kWebSocket]; + if (!websocket.isPaused) websocket._socket.resume(); + } + function receiverOnError(err) { + const websocket = this[kWebSocket]; + if (websocket._socket[kWebSocket] !== void 0) { + websocket._socket.removeListener("data", socketOnData); + process.nextTick(resume, websocket._socket); + websocket.close(err[kStatusCode]); + } + if (!websocket._errorEmitted) { + websocket._errorEmitted = true; + websocket.emit("error", err); + } + } + function receiverOnFinish() { + this[kWebSocket].emitClose(); + } + function receiverOnMessage(data, isBinary2) { + this[kWebSocket].emit("message", data, isBinary2); + } + function receiverOnPing(data) { + const websocket = this[kWebSocket]; + if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP); + websocket.emit("ping", data); + } + function receiverOnPong(data) { + this[kWebSocket].emit("pong", data); + } + function resume(stream) { + stream.resume(); + } + function senderOnError(err) { + const websocket = this[kWebSocket]; + if (websocket.readyState === WebSocket2.CLOSED) return; + if (websocket.readyState === WebSocket2.OPEN) { + websocket._readyState = WebSocket2.CLOSING; + setCloseTimer(websocket); + } + this._socket.end(); + if (!websocket._errorEmitted) { + websocket._errorEmitted = true; + websocket.emit("error", err); + } + } + function setCloseTimer(websocket) { + websocket._closeTimer = setTimeout( + websocket._socket.destroy.bind(websocket._socket), + websocket._closeTimeout + ); + } + function socketOnClose() { + const websocket = this[kWebSocket]; + this.removeListener("close", socketOnClose); + this.removeListener("data", socketOnData); + this.removeListener("end", socketOnEnd); + websocket._readyState = WebSocket2.CLOSING; + if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) { + const chunk = this.read(this._readableState.length); + websocket._receiver.write(chunk); + } + websocket._receiver.end(); + this[kWebSocket] = void 0; + clearTimeout(websocket._closeTimer); + if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) { + websocket.emitClose(); + } else { + websocket._receiver.on("error", receiverOnFinish); + websocket._receiver.on("finish", receiverOnFinish); + } + } + function socketOnData(chunk) { + if (!this[kWebSocket]._receiver.write(chunk)) { + this.pause(); + } + } + function socketOnEnd() { + const websocket = this[kWebSocket]; + websocket._readyState = WebSocket2.CLOSING; + websocket._receiver.end(); + this.end(); + } + function socketOnError() { + const websocket = this[kWebSocket]; + this.removeListener("error", socketOnError); + this.on("error", NOOP); + if (websocket) { + websocket._readyState = WebSocket2.CLOSING; + this.destroy(); + } + } + } +}); + +// node_modules/ws/lib/stream.js +var require_stream = __commonJS({ + "node_modules/ws/lib/stream.js"(exports, module) { + "use strict"; + var WebSocket2 = require_websocket2(); + var { Duplex } = __require("stream"); + function emitClose(stream) { + stream.emit("close"); + } + function duplexOnEnd() { + if (!this.destroyed && this._writableState.finished) { + this.destroy(); + } + } + function duplexOnError(err) { + this.removeListener("error", duplexOnError); + this.destroy(); + if (this.listenerCount("error") === 0) { + this.emit("error", err); + } + } + function createWebSocketStream(ws, options) { + let terminateOnDestroy = true; + const duplex = new Duplex({ + ...options, + autoDestroy: false, + emitClose: false, + objectMode: false, + writableObjectMode: false + }); + ws.on("message", function message(msg, isBinary2) { + const data = !isBinary2 && duplex._readableState.objectMode ? msg.toString() : msg; + if (!duplex.push(data)) ws.pause(); + }); + ws.once("error", function error2(err) { + if (duplex.destroyed) return; + terminateOnDestroy = false; + duplex.destroy(err); + }); + ws.once("close", function close() { + if (duplex.destroyed) return; + duplex.push(null); + }); + duplex._destroy = function(err, callback) { + if (ws.readyState === ws.CLOSED) { + callback(err); + process.nextTick(emitClose, duplex); + return; + } + let called = false; + ws.once("error", function error2(err2) { + called = true; + callback(err2); + }); + ws.once("close", function close() { + if (!called) callback(err); + process.nextTick(emitClose, duplex); + }); + if (terminateOnDestroy) ws.terminate(); + }; + duplex._final = function(callback) { + if (ws.readyState === ws.CONNECTING) { + ws.once("open", function open2() { + duplex._final(callback); + }); + return; + } + if (ws._socket === null) return; + if (ws._socket._writableState.finished) { + callback(); + if (duplex._readableState.endEmitted) duplex.destroy(); + } else { + ws._socket.once("finish", function finish() { + callback(); + }); + ws.close(); + } + }; + duplex._read = function() { + if (ws.isPaused) ws.resume(); + }; + duplex._write = function(chunk, encoding, callback) { + if (ws.readyState === ws.CONNECTING) { + ws.once("open", function open2() { + duplex._write(chunk, encoding, callback); + }); + return; + } + ws.send(chunk, callback); + }; + duplex.on("end", duplexOnEnd); + duplex.on("error", duplexOnError); + return duplex; + } + module.exports = createWebSocketStream; + } +}); + +// node_modules/ws/lib/subprotocol.js +var require_subprotocol = __commonJS({ + "node_modules/ws/lib/subprotocol.js"(exports, module) { + "use strict"; + var { tokenChars } = require_validation(); + function parse2(header) { + const protocols2 = /* @__PURE__ */ new Set(); + let start = -1; + let end = -1; + let i = 0; + for (i; i < header.length; i++) { + const code = header.charCodeAt(i); + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (i !== 0 && (code === 32 || code === 9)) { + if (end === -1 && start !== -1) end = i; + } else if (code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + const protocol2 = header.slice(start, end); + if (protocols2.has(protocol2)) { + throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`); + } + protocols2.add(protocol2); + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } + if (start === -1 || end !== -1) { + throw new SyntaxError("Unexpected end of input"); + } + const protocol = header.slice(start, i); + if (protocols2.has(protocol)) { + throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`); + } + protocols2.add(protocol); + return protocols2; + } + module.exports = { parse: parse2 }; + } +}); + +// node_modules/ws/lib/websocket-server.js +var require_websocket_server = __commonJS({ + "node_modules/ws/lib/websocket-server.js"(exports, module) { + "use strict"; + var EventEmitter2 = __require("events"); + var http2 = __require("http"); + var { Duplex } = __require("stream"); + var { createHash } = __require("crypto"); + var extension = require_extension(); + var PerMessageDeflate = require_permessage_deflate2(); + var subprotocol = require_subprotocol(); + var WebSocket2 = require_websocket2(); + var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants9(); + var keyRegex = /^[+/0-9A-Za-z]{22}==$/; + var RUNNING = 0; + var CLOSING = 1; + var CLOSED = 2; + var WebSocketServer = class extends EventEmitter2 { + /** + * Create a `WebSocketServer` instance. + * + * @param {Object} options Configuration options + * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {Boolean} [options.autoPong=true] Specifies whether or not to + * automatically send a pong in response to a ping + * @param {Number} [options.backlog=511] The maximum length of the queue of + * pending connections + * @param {Boolean} [options.clientTracking=true] Specifies whether or not to + * track clients + * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to + * wait for the closing handshake to finish after `websocket.close()` is + * called + * @param {Function} [options.handleProtocols] A hook to handle protocols + * @param {String} [options.host] The hostname where to bind the server + * @param {Number} [options.maxPayload=104857600] The maximum allowed message + * size + * @param {Boolean} [options.noServer=false] Enable no server mode + * @param {String} [options.path] Accept only connections matching this path + * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable + * permessage-deflate + * @param {Number} [options.port] The port where to bind the server + * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S + * server to use + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + * @param {Function} [options.verifyClient] A hook to reject connections + * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket` + * class to use. It must be the `WebSocket` class or class that extends it + * @param {Function} [callback] A listener for the `listening` event + */ + constructor(options, callback) { + super(); + options = { + allowSynchronousEvents: true, + autoPong: true, + maxPayload: 100 * 1024 * 1024, + skipUTF8Validation: false, + perMessageDeflate: false, + handleProtocols: null, + clientTracking: true, + closeTimeout: CLOSE_TIMEOUT, + verifyClient: null, + noServer: false, + backlog: null, + // use default (511 as implemented in net.js) + server: null, + host: null, + path: null, + port: null, + WebSocket: WebSocket2, + ...options + }; + if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) { + throw new TypeError( + 'One and only one of the "port", "server", or "noServer" options must be specified' + ); + } + if (options.port != null) { + this._server = http2.createServer((req, res) => { + const body = http2.STATUS_CODES[426]; + res.writeHead(426, { + "Content-Length": body.length, + "Content-Type": "text/plain" + }); + res.end(body); + }); + this._server.listen( + options.port, + options.host, + options.backlog, + callback + ); + } else if (options.server) { + this._server = options.server; + } + if (this._server) { + const emitConnection = this.emit.bind(this, "connection"); + this._removeListeners = addListeners(this._server, { + listening: this.emit.bind(this, "listening"), + error: this.emit.bind(this, "error"), + upgrade: (req, socket, head) => { + this.handleUpgrade(req, socket, head, emitConnection); + } + }); + } + if (options.perMessageDeflate === true) options.perMessageDeflate = {}; + if (options.clientTracking) { + this.clients = /* @__PURE__ */ new Set(); + this._shouldEmitClose = false; + } + this.options = options; + this._state = RUNNING; + } + /** + * Returns the bound address, the address family name, and port of the server + * as reported by the operating system if listening on an IP socket. + * If the server is listening on a pipe or UNIX domain socket, the name is + * returned as a string. + * + * @return {(Object|String|null)} The address of the server + * @public + */ + address() { + if (this.options.noServer) { + throw new Error('The server is operating in "noServer" mode'); + } + if (!this._server) return null; + return this._server.address(); + } + /** + * Stop the server from accepting new connections and emit the `'close'` event + * when all existing connections are closed. + * + * @param {Function} [cb] A one-time listener for the `'close'` event + * @public + */ + close(cb) { + if (this._state === CLOSED) { + if (cb) { + this.once("close", () => { + cb(new Error("The server is not running")); + }); + } + process.nextTick(emitClose, this); + return; + } + if (cb) this.once("close", cb); + if (this._state === CLOSING) return; + this._state = CLOSING; + if (this.options.noServer || this.options.server) { + if (this._server) { + this._removeListeners(); + this._removeListeners = this._server = null; + } + if (this.clients) { + if (!this.clients.size) { + process.nextTick(emitClose, this); + } else { + this._shouldEmitClose = true; + } + } else { + process.nextTick(emitClose, this); + } + } else { + const server = this._server; + this._removeListeners(); + this._removeListeners = this._server = null; + server.close(() => { + emitClose(this); + }); + } + } + /** + * See if a given request should be handled by this server instance. + * + * @param {http.IncomingMessage} req Request object to inspect + * @return {Boolean} `true` if the request is valid, else `false` + * @public + */ + shouldHandle(req) { + if (this.options.path) { + const index2 = req.url.indexOf("?"); + const pathname = index2 !== -1 ? req.url.slice(0, index2) : req.url; + if (pathname !== this.options.path) return false; + } + return true; + } + /** + * Handle a HTTP Upgrade request. + * + * @param {http.IncomingMessage} req The request object + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Function} cb Callback + * @public + */ + handleUpgrade(req, socket, head, cb) { + socket.on("error", socketOnError); + const key = req.headers["sec-websocket-key"]; + const upgrade = req.headers.upgrade; + const version = +req.headers["sec-websocket-version"]; + if (req.method !== "GET") { + const message = "Invalid HTTP method"; + abortHandshakeOrEmitwsClientError(this, req, socket, 405, message); + return; + } + if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") { + const message = "Invalid Upgrade header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (key === void 0 || !keyRegex.test(key)) { + const message = "Missing or invalid Sec-WebSocket-Key header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (version !== 13 && version !== 8) { + const message = "Missing or invalid Sec-WebSocket-Version header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, { + "Sec-WebSocket-Version": "13, 8" + }); + return; + } + if (!this.shouldHandle(req)) { + abortHandshake(socket, 400); + return; + } + const secWebSocketProtocol = req.headers["sec-websocket-protocol"]; + let protocols2 = /* @__PURE__ */ new Set(); + if (secWebSocketProtocol !== void 0) { + try { + protocols2 = subprotocol.parse(secWebSocketProtocol); + } catch (err) { + const message = "Invalid Sec-WebSocket-Protocol header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + } + const secWebSocketExtensions = req.headers["sec-websocket-extensions"]; + const extensions = {}; + if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) { + const perMessageDeflate = new PerMessageDeflate({ + ...this.options.perMessageDeflate, + isServer: true, + maxPayload: this.options.maxPayload + }); + try { + const offers = extension.parse(secWebSocketExtensions); + if (offers[PerMessageDeflate.extensionName]) { + perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]); + extensions[PerMessageDeflate.extensionName] = perMessageDeflate; + } + } catch (err) { + const message = "Invalid or unacceptable Sec-WebSocket-Extensions header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + } + if (this.options.verifyClient) { + const info = { + origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`], + secure: !!(req.socket.authorized || req.socket.encrypted), + req + }; + if (this.options.verifyClient.length === 2) { + this.options.verifyClient(info, (verified, code, message, headers2) => { + if (!verified) { + return abortHandshake(socket, code || 401, message, headers2); + } + this.completeUpgrade( + extensions, + key, + protocols2, + req, + socket, + head, + cb + ); + }); + return; + } + if (!this.options.verifyClient(info)) return abortHandshake(socket, 401); + } + this.completeUpgrade(extensions, key, protocols2, req, socket, head, cb); + } + /** + * Upgrade the connection to WebSocket. + * + * @param {Object} extensions The accepted extensions + * @param {String} key The value of the `Sec-WebSocket-Key` header + * @param {Set} protocols The subprotocols + * @param {http.IncomingMessage} req The request object + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Function} cb Callback + * @throws {Error} If called more than once with the same socket + * @private + */ + completeUpgrade(extensions, key, protocols2, req, socket, head, cb) { + if (!socket.readable || !socket.writable) return socket.destroy(); + if (socket[kWebSocket]) { + throw new Error( + "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration" + ); + } + if (this._state > RUNNING) return abortHandshake(socket, 503); + const digest = createHash("sha1").update(key + GUID).digest("base64"); + const headers2 = [ + "HTTP/1.1 101 Switching Protocols", + "Upgrade: websocket", + "Connection: Upgrade", + `Sec-WebSocket-Accept: ${digest}` + ]; + const ws = new this.options.WebSocket(null, void 0, this.options); + if (protocols2.size) { + const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols2, req) : protocols2.values().next().value; + if (protocol) { + headers2.push(`Sec-WebSocket-Protocol: ${protocol}`); + ws._protocol = protocol; + } + } + if (extensions[PerMessageDeflate.extensionName]) { + const params = extensions[PerMessageDeflate.extensionName].params; + const value = extension.format({ + [PerMessageDeflate.extensionName]: [params] + }); + headers2.push(`Sec-WebSocket-Extensions: ${value}`); + ws._extensions = extensions; + } + this.emit("headers", headers2, req); + socket.write(headers2.concat("\r\n").join("\r\n")); + socket.removeListener("error", socketOnError); + ws.setSocket(socket, head, { + allowSynchronousEvents: this.options.allowSynchronousEvents, + maxPayload: this.options.maxPayload, + skipUTF8Validation: this.options.skipUTF8Validation + }); + if (this.clients) { + this.clients.add(ws); + ws.on("close", () => { + this.clients.delete(ws); + if (this._shouldEmitClose && !this.clients.size) { + process.nextTick(emitClose, this); + } + }); + } + cb(ws, req); + } + }; + module.exports = WebSocketServer; + function addListeners(server, map3) { + for (const event of Object.keys(map3)) server.on(event, map3[event]); + return function removeListeners() { + for (const event of Object.keys(map3)) { + server.removeListener(event, map3[event]); + } + }; + } + function emitClose(server) { + server._state = CLOSED; + server.emit("close"); + } + function socketOnError() { + this.destroy(); + } + function abortHandshake(socket, code, message, headers2) { + message = message || http2.STATUS_CODES[code]; + headers2 = { + Connection: "close", + "Content-Type": "text/html", + "Content-Length": Buffer.byteLength(message), + ...headers2 + }; + socket.once("finish", socket.destroy); + socket.end( + `HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r +` + Object.keys(headers2).map((h) => `${h}: ${headers2[h]}`).join("\r\n") + "\r\n\r\n" + message + ); + } + function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers2) { + if (server.listenerCount("wsClientError")) { + const err = new Error(message); + Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError); + server.emit("wsClientError", err, socket, req); + } else { + abortHandshake(socket, code, message, headers2); + } + } + } +}); + +// node_modules/ws/index.js +var require_ws = __commonJS({ + "node_modules/ws/index.js"(exports, module) { + "use strict"; + var createWebSocketStream = require_stream(); + var extension = require_extension(); + var PerMessageDeflate = require_permessage_deflate2(); + var Receiver = require_receiver2(); + var Sender = require_sender2(); + var subprotocol = require_subprotocol(); + var WebSocket2 = require_websocket2(); + var WebSocketServer = require_websocket_server(); + WebSocket2.createWebSocketStream = createWebSocketStream; + WebSocket2.extension = extension; + WebSocket2.PerMessageDeflate = PerMessageDeflate; + WebSocket2.Receiver = Receiver; + WebSocket2.Sender = Sender; + WebSocket2.Server = WebSocketServer; + WebSocket2.subprotocol = subprotocol; + WebSocket2.WebSocket = WebSocket2; + WebSocket2.WebSocketServer = WebSocketServer; + module.exports = WebSocket2; + } +}); + +// node_modules/isomorphic-ws/node.js +var require_node2 = __commonJS({ + "node_modules/isomorphic-ws/node.js"(exports, module) { + "use strict"; + module.exports = require_ws(); + } +}); + +// node_modules/stream-buffers/lib/constants.js +var require_constants10 = __commonJS({ + "node_modules/stream-buffers/lib/constants.js"(exports, module) { + "use strict"; + module.exports = { + DEFAULT_INITIAL_SIZE: 8 * 1024, + DEFAULT_INCREMENT_AMOUNT: 8 * 1024, + DEFAULT_FREQUENCY: 1, + DEFAULT_CHUNK_SIZE: 1024 + }; + } +}); + +// node_modules/stream-buffers/lib/readable_streambuffer.js +var require_readable_streambuffer = __commonJS({ + "node_modules/stream-buffers/lib/readable_streambuffer.js"(exports, module) { + "use strict"; + var stream = __require("stream"); + var constants3 = require_constants10(); + var util2 = __require("util"); + var ReadableStreamBuffer = module.exports = function(opts) { + var that = this; + opts = opts || {}; + stream.Readable.call(this, opts); + this.stopped = false; + var frequency = opts.hasOwnProperty("frequency") ? opts.frequency : constants3.DEFAULT_FREQUENCY; + var chunkSize = opts.chunkSize || constants3.DEFAULT_CHUNK_SIZE; + var initialSize = opts.initialSize || constants3.DEFAULT_INITIAL_SIZE; + var incrementAmount = opts.incrementAmount || constants3.DEFAULT_INCREMENT_AMOUNT; + var size = 0; + var buffer = new Buffer(initialSize); + var allowPush = false; + var sendData = function() { + var amount = Math.min(chunkSize, size); + var sendMore = false; + if (amount > 0) { + var chunk = null; + chunk = new Buffer(amount); + buffer.copy(chunk, 0, 0, amount); + sendMore = that.push(chunk) !== false; + allowPush = sendMore; + buffer.copy(buffer, 0, amount, size); + size -= amount; + } + if (size === 0 && that.stopped) { + that.push(null); + } + if (sendMore) { + sendData.timeout = setTimeout(sendData, frequency); + } else { + sendData.timeout = null; + } + }; + this.stop = function() { + if (this.stopped) { + throw new Error("stop() called on already stopped ReadableStreamBuffer"); + } + this.stopped = true; + if (size === 0) { + this.push(null); + } + }; + this.size = function() { + return size; + }; + this.maxSize = function() { + return buffer.length; + }; + var increaseBufferIfNecessary = function(incomingDataSize) { + if (buffer.length - size < incomingDataSize) { + var factor = Math.ceil((incomingDataSize - (buffer.length - size)) / incrementAmount); + var newBuffer = new Buffer(buffer.length + incrementAmount * factor); + buffer.copy(newBuffer, 0, 0, size); + buffer = newBuffer; + } + }; + var kickSendDataTask = function() { + if (!sendData.timeout && allowPush) { + sendData.timeout = setTimeout(sendData, frequency); + } + }; + this.put = function(data, encoding) { + if (that.stopped) { + throw new Error("Tried to write data to a stopped ReadableStreamBuffer"); + } + if (Buffer.isBuffer(data)) { + increaseBufferIfNecessary(data.length); + data.copy(buffer, size, 0); + size += data.length; + } else { + data = data + ""; + var dataSizeInBytes = Buffer.byteLength(data); + increaseBufferIfNecessary(dataSizeInBytes); + buffer.write(data, size, encoding || "utf8"); + size += dataSizeInBytes; + } + kickSendDataTask(); + }; + this._read = function() { + allowPush = true; + kickSendDataTask(); + }; + }; + util2.inherits(ReadableStreamBuffer, stream.Readable); + } +}); + +// node_modules/stream-buffers/lib/writable_streambuffer.js +var require_writable_streambuffer = __commonJS({ + "node_modules/stream-buffers/lib/writable_streambuffer.js"(exports, module) { + "use strict"; + var util2 = __require("util"); + var stream = __require("stream"); + var constants3 = require_constants10(); + var WritableStreamBuffer2 = module.exports = function(opts) { + opts = opts || {}; + opts.decodeStrings = true; + stream.Writable.call(this, opts); + var initialSize = opts.initialSize || constants3.DEFAULT_INITIAL_SIZE; + var incrementAmount = opts.incrementAmount || constants3.DEFAULT_INCREMENT_AMOUNT; + var buffer = new Buffer(initialSize); + var size = 0; + this.size = function() { + return size; + }; + this.maxSize = function() { + return buffer.length; + }; + this.getContents = function(length) { + if (!size) return false; + var data = new Buffer(Math.min(length || size, size)); + buffer.copy(data, 0, 0, data.length); + if (data.length < size) + buffer.copy(buffer, 0, data.length); + size -= data.length; + return data; + }; + this.getContentsAsString = function(encoding, length) { + if (!size) return false; + var data = buffer.toString(encoding || "utf8", 0, Math.min(length || size, size)); + var dataLength = Buffer.byteLength(data); + if (dataLength < size) + buffer.copy(buffer, 0, dataLength); + size -= dataLength; + return data; + }; + var increaseBufferIfNecessary = function(incomingDataSize) { + if (buffer.length - size < incomingDataSize) { + var factor = Math.ceil((incomingDataSize - (buffer.length - size)) / incrementAmount); + var newBuffer = new Buffer(buffer.length + incrementAmount * factor); + buffer.copy(newBuffer, 0, 0, size); + buffer = newBuffer; + } + }; + this._write = function(chunk, encoding, callback) { + increaseBufferIfNecessary(chunk.length); + chunk.copy(buffer, size, 0); + size += chunk.length; + callback(); + }; + }; + util2.inherits(WritableStreamBuffer2, stream.Writable); + } +}); + +// node_modules/stream-buffers/lib/streambuffer.js +var require_streambuffer = __commonJS({ + "node_modules/stream-buffers/lib/streambuffer.js"(exports, module) { + "use strict"; + module.exports = require_constants10(); + module.exports.ReadableStreamBuffer = require_readable_streambuffer(); + module.exports.WritableStreamBuffer = require_writable_streambuffer(); + } +}); + +// node_modules/events-universal/default.js +var require_default = __commonJS({ + "node_modules/events-universal/default.js"(exports, module) { + module.exports = __require("events"); + } +}); + +// node_modules/fast-fifo/fixed-size.js +var require_fixed_size = __commonJS({ + "node_modules/fast-fifo/fixed-size.js"(exports, module) { + module.exports = class FixedFIFO { + constructor(hwm) { + if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two"); + this.buffer = new Array(hwm); + this.mask = hwm - 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(data) { + if (this.buffer[this.top] !== void 0) return false; + this.buffer[this.top] = data; + this.top = this.top + 1 & this.mask; + return true; + } + shift() { + const last = this.buffer[this.btm]; + if (last === void 0) return void 0; + this.buffer[this.btm] = void 0; + this.btm = this.btm + 1 & this.mask; + return last; + } + peek() { + return this.buffer[this.btm]; + } + isEmpty() { + return this.buffer[this.btm] === void 0; + } + }; + } +}); + +// node_modules/fast-fifo/index.js +var require_fast_fifo = __commonJS({ + "node_modules/fast-fifo/index.js"(exports, module) { + var FixedFIFO = require_fixed_size(); + module.exports = class FastFIFO { + constructor(hwm) { + this.hwm = hwm || 16; + this.head = new FixedFIFO(this.hwm); + this.tail = this.head; + this.length = 0; + } + clear() { + this.head = this.tail; + this.head.clear(); + this.length = 0; + } + push(val) { + this.length++; + if (!this.head.push(val)) { + const prev = this.head; + this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length); + this.head.push(val); + } + } + shift() { + if (this.length !== 0) this.length--; + const val = this.tail.shift(); + if (val === void 0 && this.tail.next) { + const next = this.tail.next; + this.tail.next = null; + this.tail = next; + return this.tail.shift(); + } + return val; + } + peek() { + const val = this.tail.peek(); + if (val === void 0 && this.tail.next) return this.tail.next.peek(); + return val; + } + isEmpty() { + return this.length === 0; + } + }; + } +}); + +// node_modules/b4a/index.js +var require_b4a = __commonJS({ + "node_modules/b4a/index.js"(exports, module) { + function isBuffer(value) { + return Buffer.isBuffer(value) || value instanceof Uint8Array; + } + function isEncoding(encoding) { + return Buffer.isEncoding(encoding); + } + function alloc(size, fill2, encoding) { + return Buffer.alloc(size, fill2, encoding); + } + function allocUnsafe(size) { + return Buffer.allocUnsafe(size); + } + function allocUnsafeSlow(size) { + return Buffer.allocUnsafeSlow(size); + } + function byteLength(string, encoding) { + return Buffer.byteLength(string, encoding); + } + function compare(a, b) { + return Buffer.compare(a, b); + } + function concat(buffers, totalLength) { + return Buffer.concat(buffers, totalLength); + } + function copy(source, target, targetStart, start, end) { + return toBuffer(source).copy(target, targetStart, start, end); + } + function equals(a, b) { + return toBuffer(a).equals(b); + } + function fill(buffer, value, offset, end, encoding) { + return toBuffer(buffer).fill(value, offset, end, encoding); + } + function from2(value, encodingOrOffset, length) { + return Buffer.from(value, encodingOrOffset, length); + } + function includes(buffer, value, byteOffset, encoding) { + return toBuffer(buffer).includes(value, byteOffset, encoding); + } + function indexOf(buffer, value, byfeOffset, encoding) { + return toBuffer(buffer).indexOf(value, byfeOffset, encoding); + } + function lastIndexOf(buffer, value, byteOffset, encoding) { + return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding); + } + function swap16(buffer) { + return toBuffer(buffer).swap16(); + } + function swap32(buffer) { + return toBuffer(buffer).swap32(); + } + function swap64(buffer) { + return toBuffer(buffer).swap64(); + } + function toBuffer(buffer) { + if (Buffer.isBuffer(buffer)) return buffer; + return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength); + } + function toString2(buffer, encoding, start, end) { + return toBuffer(buffer).toString(encoding, start, end); + } + function write(buffer, string, offset, length, encoding) { + return toBuffer(buffer).write(string, offset, length, encoding); + } + function readDoubleBE(buffer, offset) { + return toBuffer(buffer).readDoubleBE(offset); + } + function readDoubleLE(buffer, offset) { + return toBuffer(buffer).readDoubleLE(offset); + } + function readFloatBE(buffer, offset) { + return toBuffer(buffer).readFloatBE(offset); + } + function readFloatLE(buffer, offset) { + return toBuffer(buffer).readFloatLE(offset); + } + function readInt32BE(buffer, offset) { + return toBuffer(buffer).readInt32BE(offset); + } + function readInt32LE(buffer, offset) { + return toBuffer(buffer).readInt32LE(offset); + } + function readUInt32BE(buffer, offset) { + return toBuffer(buffer).readUInt32BE(offset); + } + function readUInt32LE(buffer, offset) { + return toBuffer(buffer).readUInt32LE(offset); + } + function writeDoubleBE(buffer, value, offset) { + return toBuffer(buffer).writeDoubleBE(value, offset); + } + function writeDoubleLE(buffer, value, offset) { + return toBuffer(buffer).writeDoubleLE(value, offset); + } + function writeFloatBE(buffer, value, offset) { + return toBuffer(buffer).writeFloatBE(value, offset); + } + function writeFloatLE(buffer, value, offset) { + return toBuffer(buffer).writeFloatLE(value, offset); + } + function writeInt32BE(buffer, value, offset) { + return toBuffer(buffer).writeInt32BE(value, offset); + } + function writeInt32LE(buffer, value, offset) { + return toBuffer(buffer).writeInt32LE(value, offset); + } + function writeUInt32BE(buffer, value, offset) { + return toBuffer(buffer).writeUInt32BE(value, offset); + } + function writeUInt32LE(buffer, value, offset) { + return toBuffer(buffer).writeUInt32LE(value, offset); + } + module.exports = { + isBuffer, + isEncoding, + alloc, + allocUnsafe, + allocUnsafeSlow, + byteLength, + compare, + concat, + copy, + equals, + fill, + from: from2, + includes, + indexOf, + lastIndexOf, + swap16, + swap32, + swap64, + toBuffer, + toString: toString2, + write, + readDoubleBE, + readDoubleLE, + readFloatBE, + readFloatLE, + readInt32BE, + readInt32LE, + readUInt32BE, + readUInt32LE, + writeDoubleBE, + writeDoubleLE, + writeFloatBE, + writeFloatLE, + writeInt32BE, + writeInt32LE, + writeUInt32BE, + writeUInt32LE + }; + } +}); + +// node_modules/text-decoder/lib/pass-through-decoder.js +var require_pass_through_decoder = __commonJS({ + "node_modules/text-decoder/lib/pass-through-decoder.js"(exports, module) { + var b4a = require_b4a(); + module.exports = class PassThroughDecoder { + constructor(encoding) { + this.encoding = encoding; + } + get remaining() { + return 0; + } + decode(data) { + return b4a.toString(data, this.encoding); + } + flush() { + return ""; + } + }; + } +}); + +// node_modules/text-decoder/lib/utf8-decoder.js +var require_utf8_decoder = __commonJS({ + "node_modules/text-decoder/lib/utf8-decoder.js"(exports, module) { + var b4a = require_b4a(); + module.exports = class UTF8Decoder { + constructor() { + this._reset(); + } + get remaining() { + return this.bytesSeen; + } + decode(data) { + if (data.byteLength === 0) return ""; + if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) { + this.bytesSeen = trailingBytesSeen(data); + return b4a.toString(data, "utf8"); + } + let result = ""; + let start = 0; + if (this.bytesNeeded > 0) { + while (start < data.byteLength) { + const byte = data[start]; + if (byte < this.lowerBoundary || byte > this.upperBoundary) { + result += "\uFFFD"; + this._reset(); + break; + } + this.lowerBoundary = 128; + this.upperBoundary = 191; + this.codePoint = this.codePoint << 6 | byte & 63; + this.bytesSeen++; + start++; + if (this.bytesSeen === this.bytesNeeded) { + result += String.fromCodePoint(this.codePoint); + this._reset(); + break; + } + } + if (this.bytesNeeded > 0) return result; + } + const trailing = trailingIncomplete(data, start); + const end = data.byteLength - trailing; + if (end > start) result += b4a.toString(data, "utf8", start, end); + for (let i = end; i < data.byteLength; i++) { + const byte = data[i]; + if (this.bytesNeeded === 0) { + if (byte <= 127) { + this.bytesSeen = 0; + result += String.fromCharCode(byte); + } else if (byte >= 194 && byte <= 223) { + this.bytesNeeded = 2; + this.bytesSeen = 1; + this.codePoint = byte & 31; + } else if (byte >= 224 && byte <= 239) { + if (byte === 224) this.lowerBoundary = 160; + else if (byte === 237) this.upperBoundary = 159; + this.bytesNeeded = 3; + this.bytesSeen = 1; + this.codePoint = byte & 15; + } else if (byte >= 240 && byte <= 244) { + if (byte === 240) this.lowerBoundary = 144; + else if (byte === 244) this.upperBoundary = 143; + this.bytesNeeded = 4; + this.bytesSeen = 1; + this.codePoint = byte & 7; + } else { + this.bytesSeen = 1; + result += "\uFFFD"; + } + continue; + } + if (byte < this.lowerBoundary || byte > this.upperBoundary) { + result += "\uFFFD"; + i--; + this._reset(); + continue; + } + this.lowerBoundary = 128; + this.upperBoundary = 191; + this.codePoint = this.codePoint << 6 | byte & 63; + this.bytesSeen++; + if (this.bytesSeen === this.bytesNeeded) { + result += String.fromCodePoint(this.codePoint); + this._reset(); + } + } + return result; + } + flush() { + const result = this.bytesNeeded > 0 ? "\uFFFD" : ""; + this._reset(); + return result; + } + _reset() { + this.codePoint = 0; + this.bytesNeeded = 0; + this.bytesSeen = 0; + this.lowerBoundary = 128; + this.upperBoundary = 191; + } + }; + function trailingIncomplete(data, start) { + const len = data.byteLength; + if (len <= start) return 0; + const limit = Math.max(start, len - 4); + let i = len - 1; + while (i > limit && (data[i] & 192) === 128) i--; + if (i < start) return 0; + const byte = data[i]; + let needed; + if (byte <= 127) return 0; + if (byte >= 194 && byte <= 223) needed = 2; + else if (byte >= 224 && byte <= 239) needed = 3; + else if (byte >= 240 && byte <= 244) needed = 4; + else return 0; + const available = len - i; + return available < needed ? available : 0; + } + function trailingBytesSeen(data) { + const len = data.byteLength; + if (len === 0) return 0; + const last = data[len - 1]; + if (last <= 127) return 0; + if ((last & 192) !== 128) return 1; + const limit = Math.max(0, len - 4); + let i = len - 2; + while (i >= limit && (data[i] & 192) === 128) i--; + if (i < 0) return 1; + const first = data[i]; + let needed; + if (first >= 194 && first <= 223) needed = 2; + else if (first >= 224 && first <= 239) needed = 3; + else if (first >= 240 && first <= 244) needed = 4; + else return 1; + if (len - i !== needed) return 1; + if (needed >= 3) { + const second = data[i + 1]; + if (first === 224 && second < 160) return 1; + if (first === 237 && second > 159) return 1; + if (first === 240 && second < 144) return 1; + if (first === 244 && second > 143) return 1; + } + return 0; + } + } +}); + +// node_modules/text-decoder/index.js +var require_text_decoder = __commonJS({ + "node_modules/text-decoder/index.js"(exports, module) { + var PassThroughDecoder = require_pass_through_decoder(); + var UTF8Decoder = require_utf8_decoder(); + module.exports = class TextDecoder { + constructor(encoding = "utf8") { + this.encoding = normalizeEncoding(encoding); + switch (this.encoding) { + case "utf8": + this.decoder = new UTF8Decoder(); + break; + case "utf16le": + case "base64": + throw new Error("Unsupported encoding: " + this.encoding); + default: + this.decoder = new PassThroughDecoder(this.encoding); + } + } + get remaining() { + return this.decoder.remaining; + } + push(data) { + if (typeof data === "string") return data; + return this.decoder.decode(data); + } + // For Node.js compatibility + write(data) { + return this.push(data); + } + end(data) { + let result = ""; + if (data) result = this.push(data); + result += this.decoder.flush(); + return result; + } + }; + function normalizeEncoding(encoding) { + encoding = encoding.toLowerCase(); + switch (encoding) { + 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 encoding; + default: + throw new Error("Unknown encoding: " + encoding); + } + } + } +}); + +// node_modules/streamx/index.js +var require_streamx = __commonJS({ + "node_modules/streamx/index.js"(exports, module) { + var { EventEmitter: EventEmitter2 } = require_default(); + var STREAM_DESTROYED = new Error("Stream was destroyed"); + var PREMATURE_CLOSE = new Error("Premature close"); + var FIFO = require_fast_fifo(); + var TextDecoder2 = require_text_decoder(); + var qmt = typeof queueMicrotask === "undefined" ? (fn) => global.process.nextTick(fn) : queueMicrotask; + var MAX = (1 << 29) - 1; + var OPENING = 1; + var PREDESTROYING = 2; + var DESTROYING = 4; + var DESTROYED = 8; + var NOT_OPENING = MAX ^ OPENING; + var NOT_PREDESTROYING = MAX ^ PREDESTROYING; + var READ_ACTIVE = 1 << 4; + var READ_UPDATING = 2 << 4; + var READ_PRIMARY = 4 << 4; + var READ_QUEUED = 8 << 4; + var READ_RESUMED = 16 << 4; + var READ_PIPE_DRAINED = 32 << 4; + var READ_ENDING = 64 << 4; + var READ_EMIT_DATA = 128 << 4; + var READ_EMIT_READABLE = 256 << 4; + var READ_EMITTED_READABLE = 512 << 4; + var READ_DONE = 1024 << 4; + var READ_NEXT_TICK = 2048 << 4; + var READ_NEEDS_PUSH = 4096 << 4; + var READ_READ_AHEAD = 8192 << 4; + var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED; + var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH; + var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE; + var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED; + var READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD; + var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE; + var READ_NON_PRIMARY = MAX ^ READ_PRIMARY; + var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH); + var READ_PUSHED = MAX ^ READ_NEEDS_PUSH; + var READ_PAUSED = MAX ^ READ_RESUMED; + var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE); + var READ_NOT_ENDING = MAX ^ READ_ENDING; + var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING; + var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK; + var READ_NOT_UPDATING = MAX ^ READ_UPDATING; + var READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD; + var READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD; + var WRITE_ACTIVE = 1 << 18; + var WRITE_UPDATING = 2 << 18; + var WRITE_PRIMARY = 4 << 18; + var WRITE_QUEUED = 8 << 18; + var WRITE_UNDRAINED = 16 << 18; + var WRITE_DONE = 32 << 18; + var WRITE_EMIT_DRAIN = 64 << 18; + var WRITE_NEXT_TICK = 128 << 18; + var WRITE_WRITING = 256 << 18; + var WRITE_FINISHING = 512 << 18; + var WRITE_CORKED = 1024 << 18; + var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING); + var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY; + var WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING); + var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED; + var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED; + var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK; + var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING; + var WRITE_NOT_CORKED = MAX ^ WRITE_CORKED; + var ACTIVE = READ_ACTIVE | WRITE_ACTIVE; + var NOT_ACTIVE = MAX ^ ACTIVE; + var DONE = READ_DONE | WRITE_DONE; + var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING; + var OPEN_STATUS = DESTROY_STATUS | OPENING; + var AUTO_DESTROY = DESTROY_STATUS | DONE; + var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY; + var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK; + var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE; + var IS_OPENING = OPEN_STATUS | TICKING; + var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE; + var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED; + var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED; + var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE; + var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD; + var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE; + var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY; + var READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING; + var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE; + var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED; + var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE; + var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE; + var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED; + var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE; + var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING; + var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE; + var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE; + var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY; + var WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS; + var asyncIterator = Symbol.asyncIterator || /* @__PURE__ */ Symbol("asyncIterator"); + var WritableState = class { + constructor(stream, { highWaterMark = 16384, map: map3 = null, mapWritable, byteLength, byteLengthWritable } = {}) { + this.stream = stream; + this.queue = new FIFO(); + this.highWaterMark = highWaterMark; + this.buffered = 0; + this.error = null; + this.pipeline = null; + this.drains = null; + this.byteLength = byteLengthWritable || byteLength || defaultByteLength; + this.map = mapWritable || map3; + this.afterWrite = afterWrite.bind(this); + this.afterUpdateNextTick = updateWriteNT.bind(this); + } + get ending() { + return (this.stream._duplexState & WRITE_FINISHING) !== 0; + } + get ended() { + return (this.stream._duplexState & WRITE_DONE) !== 0; + } + push(data) { + if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false; + if (this.map !== null) data = this.map(data); + this.buffered += this.byteLength(data); + this.queue.push(data); + if (this.buffered < this.highWaterMark) { + this.stream._duplexState |= WRITE_QUEUED; + return true; + } + this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED; + return false; + } + shift() { + const data = this.queue.shift(); + this.buffered -= this.byteLength(data); + if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED; + return data; + } + end(data) { + if (typeof data === "function") this.stream.once("finish", data); + else if (data !== void 0 && data !== null) this.push(data); + this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY; + } + autoBatch(data, cb) { + const buffer = []; + const stream = this.stream; + buffer.push(data); + while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) { + buffer.push(stream._writableState.shift()); + } + if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null); + stream._writev(buffer, cb); + } + update() { + const stream = this.stream; + stream._duplexState |= WRITE_UPDATING; + do { + while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) { + const data = this.shift(); + stream._duplexState |= WRITE_ACTIVE_AND_WRITING; + stream._write(data, this.afterWrite); + } + if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary(); + } while (this.continueUpdate() === true); + stream._duplexState &= WRITE_NOT_UPDATING; + } + updateNonPrimary() { + const stream = this.stream; + if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) { + stream._duplexState = stream._duplexState | WRITE_ACTIVE; + stream._final(afterFinal.bind(this)); + return; + } + if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { + if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { + stream._duplexState |= ACTIVE; + stream._destroy(afterDestroy.bind(this)); + } + return; + } + if ((stream._duplexState & IS_OPENING) === OPENING) { + stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING; + stream._open(afterOpen.bind(this)); + } + } + continueUpdate() { + if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false; + this.stream._duplexState &= WRITE_NOT_NEXT_TICK; + return true; + } + updateCallback() { + if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update(); + else this.updateNextTick(); + } + updateNextTick() { + if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return; + this.stream._duplexState |= WRITE_NEXT_TICK; + if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick); + } + }; + var ReadableState = class { + constructor(stream, { highWaterMark = 16384, map: map3 = null, mapReadable, byteLength, byteLengthReadable } = {}) { + this.stream = stream; + this.queue = new FIFO(); + this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark; + this.buffered = 0; + this.readAhead = highWaterMark > 0; + this.error = null; + this.pipeline = null; + this.byteLength = byteLengthReadable || byteLength || defaultByteLength; + this.map = mapReadable || map3; + this.pipeTo = null; + this.afterRead = afterRead.bind(this); + this.afterUpdateNextTick = updateReadNT.bind(this); + } + get ending() { + return (this.stream._duplexState & READ_ENDING) !== 0; + } + get ended() { + return (this.stream._duplexState & READ_DONE) !== 0; + } + pipe(pipeTo, cb) { + if (this.pipeTo !== null) throw new Error("Can only pipe to one destination"); + if (typeof cb !== "function") cb = null; + this.stream._duplexState |= READ_PIPE_DRAINED; + this.pipeTo = pipeTo; + this.pipeline = new Pipeline(this.stream, pipeTo, cb); + if (cb) this.stream.on("error", noop); + if (isStreamx(pipeTo)) { + pipeTo._writableState.pipeline = this.pipeline; + if (cb) pipeTo.on("error", noop); + pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline)); + } else { + const onerror = this.pipeline.done.bind(this.pipeline, pipeTo); + const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null); + pipeTo.on("error", onerror); + pipeTo.on("close", onclose); + pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline)); + } + pipeTo.on("drain", afterDrain.bind(this)); + this.stream.emit("piping", pipeTo); + pipeTo.emit("pipe", this.stream); + } + push(data) { + const stream = this.stream; + if (data === null) { + this.highWaterMark = 0; + stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED; + return false; + } + if (this.map !== null) { + data = this.map(data); + if (data === null) { + stream._duplexState &= READ_PUSHED; + return this.buffered < this.highWaterMark; + } + } + this.buffered += this.byteLength(data); + this.queue.push(data); + stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED; + return this.buffered < this.highWaterMark; + } + shift() { + const data = this.queue.shift(); + this.buffered -= this.byteLength(data); + if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED; + return data; + } + unshift(data) { + const pending = [this.map !== null ? this.map(data) : data]; + while (this.buffered > 0) pending.push(this.shift()); + for (let i = 0; i < pending.length - 1; i++) { + const data2 = pending[i]; + this.buffered += this.byteLength(data2); + this.queue.push(data2); + } + this.push(pending[pending.length - 1]); + } + read() { + const stream = this.stream; + if ((stream._duplexState & READ_STATUS) === READ_QUEUED) { + const data = this.shift(); + if (this.pipeTo !== null && this.pipeTo.write(data) === false) + stream._duplexState &= READ_PIPE_NOT_DRAINED; + if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data); + return data; + } + if (this.readAhead === false) { + stream._duplexState |= READ_READ_AHEAD; + this.updateNextTick(); + } + return null; + } + drain() { + const stream = this.stream; + while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) { + const data = this.shift(); + if (this.pipeTo !== null && this.pipeTo.write(data) === false) + stream._duplexState &= READ_PIPE_NOT_DRAINED; + if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data); + } + } + update() { + const stream = this.stream; + stream._duplexState |= READ_UPDATING; + do { + this.drain(); + while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) { + stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH; + stream._read(this.afterRead); + this.drain(); + } + if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) { + stream._duplexState |= READ_EMITTED_READABLE; + stream.emit("readable"); + } + if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary(); + } while (this.continueUpdate() === true); + stream._duplexState &= READ_NOT_UPDATING; + } + updateNonPrimary() { + const stream = this.stream; + if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) { + stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING; + stream.emit("end"); + if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING; + if (this.pipeTo !== null) this.pipeTo.end(); + } + if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { + if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { + stream._duplexState |= ACTIVE; + stream._destroy(afterDestroy.bind(this)); + } + return; + } + if ((stream._duplexState & IS_OPENING) === OPENING) { + stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING; + stream._open(afterOpen.bind(this)); + } + } + continueUpdate() { + if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false; + this.stream._duplexState &= READ_NOT_NEXT_TICK; + return true; + } + updateCallback() { + if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update(); + else this.updateNextTick(); + } + updateNextTickIfOpen() { + if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return; + this.stream._duplexState |= READ_NEXT_TICK; + if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick); + } + updateNextTick() { + if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return; + this.stream._duplexState |= READ_NEXT_TICK; + if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick); + } + }; + var TransformState = class { + constructor(stream) { + this.data = null; + this.afterTransform = afterTransform.bind(stream); + this.afterFinal = null; + } + }; + var Pipeline = class { + constructor(src, dst, cb) { + this.from = src; + this.to = dst; + this.afterPipe = cb; + this.error = null; + this.pipeToFinished = false; + } + finished() { + this.pipeToFinished = true; + } + done(stream, err) { + if (err) this.error = err; + if (stream === this.to) { + this.to = null; + if (this.from !== null) { + if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) { + this.from.destroy(this.error || new Error("Writable stream closed prematurely")); + } + return; + } + } + if (stream === this.from) { + this.from = null; + if (this.to !== null) { + if ((stream._duplexState & READ_DONE) === 0) { + this.to.destroy(this.error || new Error("Readable stream closed before ending")); + } + return; + } + } + if (this.afterPipe !== null) this.afterPipe(this.error); + this.to = this.from = this.afterPipe = null; + } + }; + function afterDrain() { + this.stream._duplexState |= READ_PIPE_DRAINED; + this.updateCallback(); + } + function afterFinal(err) { + const stream = this.stream; + if (err) stream.destroy(err); + if ((stream._duplexState & DESTROY_STATUS) === 0) { + stream._duplexState |= WRITE_DONE; + stream.emit("finish"); + } + if ((stream._duplexState & AUTO_DESTROY) === DONE) { + stream._duplexState |= DESTROYING; + } + stream._duplexState &= WRITE_NOT_FINISHING; + if ((stream._duplexState & WRITE_UPDATING) === 0) this.update(); + else this.updateNextTick(); + } + function afterDestroy(err) { + const stream = this.stream; + if (!err && this.error !== STREAM_DESTROYED) err = this.error; + if (err) stream.emit("error", err); + stream._duplexState |= DESTROYED; + stream.emit("close"); + const rs = stream._readableState; + const ws = stream._writableState; + if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err); + if (ws !== null) { + while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false); + if (ws.pipeline !== null) ws.pipeline.done(stream, err); + } + } + function afterWrite(err) { + const stream = this.stream; + if (err) stream.destroy(err); + stream._duplexState &= WRITE_NOT_ACTIVE; + if (this.drains !== null) tickDrains(this.drains); + if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) { + stream._duplexState &= WRITE_DRAINED; + if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) { + stream.emit("drain"); + } + } + this.updateCallback(); + } + function afterRead(err) { + if (err) this.stream.destroy(err); + this.stream._duplexState &= READ_NOT_ACTIVE; + if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) + this.stream._duplexState &= READ_NO_READ_AHEAD; + this.updateCallback(); + } + function updateReadNT() { + if ((this.stream._duplexState & READ_UPDATING) === 0) { + this.stream._duplexState &= READ_NOT_NEXT_TICK; + this.update(); + } + } + function updateWriteNT() { + if ((this.stream._duplexState & WRITE_UPDATING) === 0) { + this.stream._duplexState &= WRITE_NOT_NEXT_TICK; + this.update(); + } + } + function tickDrains(drains) { + for (let i = 0; i < drains.length; i++) { + if (--drains[i].writes === 0) { + drains.shift().resolve(true); + i--; + } + } + } + function afterOpen(err) { + const stream = this.stream; + if (err) stream.destroy(err); + if ((stream._duplexState & DESTROYING) === 0) { + if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY; + if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY; + stream.emit("open"); + } + stream._duplexState &= NOT_ACTIVE; + if (stream._writableState !== null) { + stream._writableState.updateCallback(); + } + if (stream._readableState !== null) { + stream._readableState.updateCallback(); + } + } + function afterTransform(err, data) { + if (data !== void 0 && data !== null) this.push(data); + this._writableState.afterWrite(err); + } + function newListener(name) { + if (this._readableState !== null) { + if (name === "data") { + this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD; + this._readableState.updateNextTick(); + } + if (name === "readable") { + this._duplexState |= READ_EMIT_READABLE; + this._readableState.updateNextTick(); + } + } + if (this._writableState !== null) { + if (name === "drain") { + this._duplexState |= WRITE_EMIT_DRAIN; + this._writableState.updateNextTick(); + } + } + } + var Stream = class extends EventEmitter2 { + constructor(opts) { + super(); + this._duplexState = 0; + this._readableState = null; + this._writableState = null; + if (opts) { + if (opts.open) this._open = opts.open; + if (opts.destroy) this._destroy = opts.destroy; + if (opts.predestroy) this._predestroy = opts.predestroy; + if (opts.signal) { + opts.signal.addEventListener("abort", abort.bind(this)); + } + } + this.on("newListener", newListener); + } + _open(cb) { + cb(null); + } + _destroy(cb) { + cb(null); + } + _predestroy() { + } + get readable() { + return this._readableState !== null ? true : void 0; + } + get writable() { + return this._writableState !== null ? true : void 0; + } + get destroyed() { + return (this._duplexState & DESTROYED) !== 0; + } + get destroying() { + return (this._duplexState & DESTROY_STATUS) !== 0; + } + destroy(err) { + if ((this._duplexState & DESTROY_STATUS) === 0) { + if (!err) err = STREAM_DESTROYED; + this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY; + if (this._readableState !== null) { + this._readableState.highWaterMark = 0; + this._readableState.error = err; + } + if (this._writableState !== null) { + this._writableState.highWaterMark = 0; + this._writableState.error = err; + } + this._duplexState |= PREDESTROYING; + this._predestroy(); + this._duplexState &= NOT_PREDESTROYING; + if (this._readableState !== null) this._readableState.updateNextTick(); + if (this._writableState !== null) this._writableState.updateNextTick(); + } + } + }; + var Readable = class _Readable extends Stream { + constructor(opts) { + super(opts); + this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD; + this._readableState = new ReadableState(this, opts); + if (opts) { + if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD; + if (opts.read) this._read = opts.read; + if (opts.eagerOpen) this._readableState.updateNextTick(); + if (opts.encoding) this.setEncoding(opts.encoding); + } + } + setEncoding(encoding) { + const dec = new TextDecoder2(encoding); + const map3 = this._readableState.map || echo; + this._readableState.map = mapOrSkip; + return this; + function mapOrSkip(data) { + const next = dec.push(data); + return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map3(next); + } + } + _read(cb) { + cb(null); + } + pipe(dest, cb) { + this._readableState.updateNextTick(); + this._readableState.pipe(dest, cb); + return dest; + } + read() { + this._readableState.updateNextTick(); + return this._readableState.read(); + } + push(data) { + this._readableState.updateNextTickIfOpen(); + return this._readableState.push(data); + } + unshift(data) { + this._readableState.updateNextTickIfOpen(); + return this._readableState.unshift(data); + } + resume() { + this._duplexState |= READ_RESUMED_READ_AHEAD; + this._readableState.updateNextTick(); + return this; + } + pause() { + this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED; + return this; + } + static _fromAsyncIterator(ite, opts) { + let destroy; + const rs = new _Readable({ + ...opts, + read(cb) { + ite.next().then(push2).then(cb.bind(null, null)).catch(cb); + }, + predestroy() { + destroy = ite.return(); + }, + destroy(cb) { + if (!destroy) return cb(null); + destroy.then(cb.bind(null, null)).catch(cb); + } + }); + return rs; + function push2(data) { + if (data.done) rs.push(null); + else rs.push(data.value); + } + } + static from(data, opts) { + if (isReadStreamx(data)) return data; + if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts); + if (!Array.isArray(data)) data = data === void 0 ? [] : [data]; + let i = 0; + return new _Readable({ + ...opts, + read(cb) { + this.push(i === data.length ? null : data[i++]); + cb(null); + } + }); + } + static isBackpressured(rs) { + return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark; + } + static isPaused(rs) { + return (rs._duplexState & READ_RESUMED) === 0; + } + [asyncIterator]() { + const stream = this; + let error2 = null; + let promiseResolve = null; + let promiseReject = null; + this.on("error", (err) => { + error2 = err; + }); + this.on("readable", onreadable); + this.on("close", onclose); + return { + [asyncIterator]() { + return this; + }, + next() { + return new Promise(function(resolve2, reject) { + promiseResolve = resolve2; + promiseReject = reject; + const data = stream.read(); + if (data !== null) ondata(data); + else if ((stream._duplexState & DESTROYED) !== 0) ondata(null); + }); + }, + return() { + return destroy(null); + }, + throw(err) { + return destroy(err); + } + }; + function onreadable() { + if (promiseResolve !== null) ondata(stream.read()); + } + function onclose() { + if (promiseResolve !== null) ondata(null); + } + function ondata(data) { + if (promiseReject === null) return; + if (error2) promiseReject(error2); + else if (data === null && (stream._duplexState & READ_DONE) === 0) + promiseReject(STREAM_DESTROYED); + else promiseResolve({ value: data, done: data === null }); + promiseReject = promiseResolve = null; + } + function destroy(err) { + stream.destroy(err); + return new Promise((resolve2, reject) => { + if (stream._duplexState & DESTROYED) return resolve2({ value: void 0, done: true }); + stream.once("close", function() { + if (err) reject(err); + else resolve2({ value: void 0, done: true }); + }); + }); + } + } + }; + var Writable = class extends Stream { + constructor(opts) { + super(opts); + this._duplexState |= OPENING | READ_DONE; + this._writableState = new WritableState(this, opts); + if (opts) { + if (opts.writev) this._writev = opts.writev; + if (opts.write) this._write = opts.write; + if (opts.final) this._final = opts.final; + if (opts.eagerOpen) this._writableState.updateNextTick(); + } + } + cork() { + this._duplexState |= WRITE_CORKED; + } + uncork() { + this._duplexState &= WRITE_NOT_CORKED; + this._writableState.updateNextTick(); + } + _writev(batch, cb) { + cb(null); + } + _write(data, cb) { + this._writableState.autoBatch(data, cb); + } + _final(cb) { + cb(null); + } + static isBackpressured(ws) { + return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0; + } + static drained(ws) { + if (ws.destroyed) return Promise.resolve(false); + const state = ws._writableState; + const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length; + const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0); + if (writes === 0) return Promise.resolve(true); + if (state.drains === null) state.drains = []; + return new Promise((resolve2) => { + state.drains.push({ writes, resolve: resolve2 }); + }); + } + write(data) { + this._writableState.updateNextTick(); + return this._writableState.push(data); + } + end(data) { + this._writableState.updateNextTick(); + this._writableState.end(data); + return this; + } + }; + var Duplex = class extends Readable { + // and Writable + constructor(opts) { + super(opts); + this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD; + this._writableState = new WritableState(this, opts); + if (opts) { + if (opts.writev) this._writev = opts.writev; + if (opts.write) this._write = opts.write; + if (opts.final) this._final = opts.final; + } + } + cork() { + this._duplexState |= WRITE_CORKED; + } + uncork() { + this._duplexState &= WRITE_NOT_CORKED; + this._writableState.updateNextTick(); + } + _writev(batch, cb) { + cb(null); + } + _write(data, cb) { + this._writableState.autoBatch(data, cb); + } + _final(cb) { + cb(null); + } + write(data) { + this._writableState.updateNextTick(); + return this._writableState.push(data); + } + end(data) { + this._writableState.updateNextTick(); + this._writableState.end(data); + return this; + } + }; + var Transform = class extends Duplex { + constructor(opts) { + super(opts); + this._transformState = new TransformState(this); + if (opts) { + if (opts.transform) this._transform = opts.transform; + if (opts.flush) this._flush = opts.flush; + } + } + _write(data, cb) { + if (this._readableState.buffered >= this._readableState.highWaterMark) { + this._transformState.data = data; + } else { + this._transform(data, this._transformState.afterTransform); + } + } + _read(cb) { + if (this._transformState.data !== null) { + const data = this._transformState.data; + this._transformState.data = null; + cb(null); + this._transform(data, this._transformState.afterTransform); + } else { + cb(null); + } + } + destroy(err) { + super.destroy(err); + if (this._transformState.data !== null) { + this._transformState.data = null; + this._transformState.afterTransform(); + } + } + _transform(data, cb) { + cb(null, data); + } + _flush(cb) { + cb(null); + } + _final(cb) { + this._transformState.afterFinal = cb; + this._flush(transformAfterFlush.bind(this)); + } + }; + var PassThrough = class extends Transform { + }; + function transformAfterFlush(err, data) { + const cb = this._transformState.afterFinal; + if (err) return cb(err); + if (data !== null && data !== void 0) this.push(data); + this.push(null); + cb(null); + } + function pipelinePromise(...streams) { + return new Promise((resolve2, reject) => { + return pipeline(...streams, (err) => { + if (err) return reject(err); + resolve2(); + }); + }); + } + function pipeline(stream, ...streams) { + const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams]; + const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null; + if (all.length < 2) throw new Error("Pipeline requires at least 2 streams"); + let src = all[0]; + let dest = null; + let error2 = null; + for (let i = 1; i < all.length; i++) { + dest = all[i]; + if (isStreamx(src)) { + src.pipe(dest, onerror); + } else { + errorHandle(src, true, i > 1, onerror); + src.pipe(dest); + } + src = dest; + } + if (done) { + let fin = false; + const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy); + dest.on("error", (err) => { + if (error2 === null) error2 = err; + }); + dest.on("finish", () => { + fin = true; + if (!autoDestroy) done(error2); + }); + if (autoDestroy) { + dest.on("close", () => done(error2 || (fin ? null : PREMATURE_CLOSE))); + } + } + return dest; + function errorHandle(s, rd, wr, onerror2) { + s.on("error", onerror2); + s.on("close", onclose); + function onclose() { + if (rd && s._readableState && !s._readableState.ended) return onerror2(PREMATURE_CLOSE); + if (wr && s._writableState && !s._writableState.ended) return onerror2(PREMATURE_CLOSE); + } + } + function onerror(err) { + if (!err || error2) return; + error2 = err; + for (const s of all) { + s.destroy(err); + } + } + } + function echo(s) { + return s; + } + function isStream(stream) { + return !!stream._readableState || !!stream._writableState; + } + function isStreamx(stream) { + return typeof stream._duplexState === "number" && isStream(stream); + } + function isEnding(stream) { + return !!stream._readableState && stream._readableState.ending; + } + function isEnded(stream) { + return !!stream._readableState && stream._readableState.ended; + } + function isFinishing(stream) { + return !!stream._writableState && stream._writableState.ending; + } + function isFinished(stream) { + return !!stream._writableState && stream._writableState.ended; + } + function getStreamError(stream, opts = {}) { + const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error; + return !opts.all && err === STREAM_DESTROYED ? null : err; + } + function isReadStreamx(stream) { + return isStreamx(stream) && stream.readable; + } + function isDisturbed(stream) { + return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0; + } + function isTypedArray(data) { + return typeof data === "object" && data !== null && typeof data.byteLength === "number"; + } + function defaultByteLength(data) { + return isTypedArray(data) ? data.byteLength : 1024; + } + function noop() { + } + function abort() { + this.destroy(new Error("Stream aborted.")); + } + function isWritev(s) { + return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev; + } + module.exports = { + pipeline, + pipelinePromise, + isStream, + isStreamx, + isEnding, + isEnded, + isFinishing, + isFinished, + isDisturbed, + getStreamError, + Stream, + Writable, + Readable, + Duplex, + Transform, + // Export PassThrough for compatibility with Node.js core's stream module + PassThrough + }; + } +}); + +// node_modules/tar-stream/headers.js +var require_headers2 = __commonJS({ + "node_modules/tar-stream/headers.js"(exports) { + var b4a = require_b4a(); + var ZEROS = "0000000000000000000"; + var SEVENS = "7777777777777777777"; + var ZERO_OFFSET = "0".charCodeAt(0); + var USTAR_MAGIC = b4a.from([117, 115, 116, 97, 114, 0]); + var USTAR_VER = b4a.from([ZERO_OFFSET, ZERO_OFFSET]); + var GNU_MAGIC = b4a.from([117, 115, 116, 97, 114, 32]); + var GNU_VER = b4a.from([32, 0]); + var MASK = 4095; + var MAGIC_OFFSET = 257; + var VERSION_OFFSET = 263; + exports.decodeLongPath = function decodeLongPath(buf2, encoding) { + return decodeStr(buf2, 0, buf2.length, encoding); + }; + exports.encodePax = function encodePax(opts) { + let result = ""; + if (opts.name) result += addLength(" path=" + opts.name + "\n"); + if (opts.linkname) result += addLength(" linkpath=" + opts.linkname + "\n"); + const pax = opts.pax; + if (pax) { + for (const key in pax) { + result += addLength(" " + key + "=" + pax[key] + "\n"); + } + } + return b4a.from(result); + }; + exports.decodePax = function decodePax(buf2) { + const result = {}; + while (buf2.length) { + let i = 0; + while (i < buf2.length && buf2[i] !== 32) i++; + const len = parseInt(b4a.toString(buf2.subarray(0, i)), 10); + if (!len) return result; + const b = b4a.toString(buf2.subarray(i + 1, len - 1)); + const keyIndex = b.indexOf("="); + if (keyIndex === -1) return result; + result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1); + buf2 = buf2.subarray(len); + } + return result; + }; + exports.encode = function encode(opts) { + const buf2 = b4a.alloc(512); + let name = opts.name; + let prefix = ""; + if (opts.typeflag === 5 && name[name.length - 1] !== "/") name += "/"; + if (b4a.byteLength(name) !== name.length) return null; + while (b4a.byteLength(name) > 100) { + const i = name.indexOf("/"); + if (i === -1) return null; + prefix += prefix ? "/" + name.slice(0, i) : name.slice(0, i); + name = name.slice(i + 1); + } + if (b4a.byteLength(name) > 100 || b4a.byteLength(prefix) > 155) return null; + if (opts.linkname && b4a.byteLength(opts.linkname) > 100) return null; + b4a.write(buf2, name); + b4a.write(buf2, encodeOct(opts.mode & MASK, 6), 100); + b4a.write(buf2, encodeOct(opts.uid, 6), 108); + b4a.write(buf2, encodeOct(opts.gid, 6), 116); + encodeSize(opts.size, buf2, 124); + b4a.write(buf2, encodeOct(opts.mtime.getTime() / 1e3 | 0, 11), 136); + buf2[156] = ZERO_OFFSET + toTypeflag(opts.type); + if (opts.linkname) b4a.write(buf2, opts.linkname, 157); + b4a.copy(USTAR_MAGIC, buf2, MAGIC_OFFSET); + b4a.copy(USTAR_VER, buf2, VERSION_OFFSET); + if (opts.uname) b4a.write(buf2, opts.uname, 265); + if (opts.gname) b4a.write(buf2, opts.gname, 297); + b4a.write(buf2, encodeOct(opts.devmajor || 0, 6), 329); + b4a.write(buf2, encodeOct(opts.devminor || 0, 6), 337); + if (prefix) b4a.write(buf2, prefix, 345); + b4a.write(buf2, encodeOct(cksum(buf2), 6), 148); + return buf2; + }; + exports.decode = function decode(buf2, filenameEncoding, allowUnknownFormat) { + let typeflag = buf2[156] === 0 ? 0 : buf2[156] - ZERO_OFFSET; + let name = decodeStr(buf2, 0, 100, filenameEncoding); + const mode = decodeOct(buf2, 100, 8); + const uid = decodeOct(buf2, 108, 8); + const gid = decodeOct(buf2, 116, 8); + const size = decodeOct(buf2, 124, 12); + const mtime = decodeOct(buf2, 136, 12); + const type2 = toType(typeflag); + const linkname = buf2[157] === 0 ? null : decodeStr(buf2, 157, 100, filenameEncoding); + const uname = decodeStr(buf2, 265, 32); + const gname = decodeStr(buf2, 297, 32); + const devmajor = decodeOct(buf2, 329, 8); + const devminor = decodeOct(buf2, 337, 8); + const c = cksum(buf2); + if (c === 8 * 32) return null; + if (c !== decodeOct(buf2, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?"); + if (isUSTAR(buf2)) { + if (buf2[345]) name = decodeStr(buf2, 345, 155, filenameEncoding) + "/" + name; + } else if (isGNU(buf2)) { + } else { + if (!allowUnknownFormat) { + throw new Error("Invalid tar header: unknown format."); + } + } + if (typeflag === 0 && name && name[name.length - 1] === "/") typeflag = 5; + return { + name, + mode, + uid, + gid, + size, + mtime: new Date(1e3 * mtime), + type: type2, + linkname, + uname, + gname, + devmajor, + devminor, + pax: null + }; + }; + function isUSTAR(buf2) { + return b4a.equals(USTAR_MAGIC, buf2.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)); + } + function isGNU(buf2) { + return b4a.equals(GNU_MAGIC, buf2.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)) && b4a.equals(GNU_VER, buf2.subarray(VERSION_OFFSET, VERSION_OFFSET + 2)); + } + function clamp(index2, len, defaultValue) { + if (typeof index2 !== "number") return defaultValue; + index2 = ~~index2; + if (index2 >= len) return len; + if (index2 >= 0) return index2; + index2 += len; + if (index2 >= 0) return index2; + return 0; + } + function toType(flag) { + switch (flag) { + case 0: + return "file"; + case 1: + return "link"; + case 2: + return "symlink"; + case 3: + return "character-device"; + case 4: + return "block-device"; + case 5: + return "directory"; + case 6: + return "fifo"; + case 7: + return "contiguous-file"; + case 72: + return "pax-header"; + case 55: + return "pax-global-header"; + case 27: + return "gnu-long-link-path"; + case 28: + case 30: + return "gnu-long-path"; + } + return null; + } + function toTypeflag(flag) { + switch (flag) { + case "file": + return 0; + case "link": + return 1; + case "symlink": + return 2; + case "character-device": + return 3; + case "block-device": + return 4; + case "directory": + return 5; + case "fifo": + return 6; + case "contiguous-file": + return 7; + case "pax-header": + return 72; + } + return 0; + } + function indexOf(block, num, offset, end) { + for (; offset < end; offset++) { + if (block[offset] === num) return offset; + } + return end; + } + function cksum(block) { + let sum = 8 * 32; + for (let i = 0; i < 148; i++) sum += block[i]; + for (let j = 156; j < 512; j++) sum += block[j]; + return sum; + } + function encodeOct(val, n) { + val = val.toString(8); + if (val.length > n) return SEVENS.slice(0, n) + " "; + return ZEROS.slice(0, n - val.length) + val + " "; + } + function encodeSizeBin(num, buf2, off) { + buf2[off] = 128; + for (let i = 11; i > 0; i--) { + buf2[off + i] = num & 255; + num = Math.floor(num / 256); + } + } + function encodeSize(num, buf2, off) { + if (num.toString(8).length > 11) { + encodeSizeBin(num, buf2, off); + } else { + b4a.write(buf2, encodeOct(num, 11), off); + } + } + function parse256(buf2) { + let positive; + if (buf2[0] === 128) positive = true; + else if (buf2[0] === 255) positive = false; + else return null; + const tuple = []; + let i; + for (i = buf2.length - 1; i > 0; i--) { + const byte = buf2[i]; + if (positive) tuple.push(byte); + else tuple.push(255 - byte); + } + let sum = 0; + const l = tuple.length; + for (i = 0; i < l; i++) { + sum += tuple[i] * Math.pow(256, i); + } + return positive ? sum : -1 * sum; + } + function decodeOct(val, offset, length) { + val = val.subarray(offset, offset + length); + offset = 0; + if (val[offset] & 128) { + return parse256(val); + } else { + while (offset < val.length && val[offset] === 32) offset++; + const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length); + while (offset < end && val[offset] === 0) offset++; + if (end === offset) return 0; + return parseInt(b4a.toString(val.subarray(offset, end)), 8); + } + } + function decodeStr(val, offset, length, encoding) { + return b4a.toString(val.subarray(offset, indexOf(val, 0, offset, offset + length)), encoding); + } + function addLength(str2) { + const len = b4a.byteLength(str2); + let digits = Math.floor(Math.log(len) / Math.log(10)) + 1; + if (len + digits >= Math.pow(10, digits)) digits++; + return len + digits + str2; + } + } +}); + +// node_modules/tar-stream/extract.js +var require_extract = __commonJS({ + "node_modules/tar-stream/extract.js"(exports, module) { + var { Writable, Readable, getStreamError } = require_streamx(); + var FIFO = require_fast_fifo(); + var b4a = require_b4a(); + var headers2 = require_headers2(); + var EMPTY = b4a.alloc(0); + var BufferList = class { + constructor() { + this.buffered = 0; + this.shifted = 0; + this.queue = new FIFO(); + this._offset = 0; + } + push(buffer) { + this.buffered += buffer.byteLength; + this.queue.push(buffer); + } + shiftFirst(size) { + return this._buffered === 0 ? null : this._next(size); + } + shift(size) { + if (size > this.buffered) return null; + if (size === 0) return EMPTY; + let chunk = this._next(size); + if (size === chunk.byteLength) return chunk; + const chunks = [chunk]; + while ((size -= chunk.byteLength) > 0) { + chunk = this._next(size); + chunks.push(chunk); + } + return b4a.concat(chunks); + } + _next(size) { + const buf2 = this.queue.peek(); + const rem = buf2.byteLength - this._offset; + if (size >= rem) { + const sub = this._offset ? buf2.subarray(this._offset, buf2.byteLength) : buf2; + this.queue.shift(); + this._offset = 0; + this.buffered -= rem; + this.shifted += rem; + return sub; + } + this.buffered -= size; + this.shifted += size; + return buf2.subarray(this._offset, this._offset += size); + } + }; + var Source = class extends Readable { + constructor(self, header, offset) { + super(); + this.header = header; + this.offset = offset; + this._parent = self; + } + _read(cb) { + if (this.header.size === 0) { + this.push(null); + } + if (this._parent._stream === this) { + this._parent._update(); + } + cb(null); + } + _predestroy() { + this._parent.destroy(getStreamError(this)); + } + _detach() { + if (this._parent._stream === this) { + this._parent._stream = null; + this._parent._missing = overflow(this.header.size); + this._parent._update(); + } + } + _destroy(cb) { + this._detach(); + cb(null); + } + }; + var Extract = class extends Writable { + constructor(opts) { + super(opts); + if (!opts) opts = {}; + this._buffer = new BufferList(); + this._offset = 0; + this._header = null; + this._stream = null; + this._missing = 0; + this._longHeader = false; + this._callback = noop; + this._locked = false; + this._finished = false; + this._pax = null; + this._paxGlobal = null; + this._gnuLongPath = null; + this._gnuLongLinkPath = null; + this._filenameEncoding = opts.filenameEncoding || "utf-8"; + this._allowUnknownFormat = !!opts.allowUnknownFormat; + this._unlockBound = this._unlock.bind(this); + } + _unlock(err) { + this._locked = false; + if (err) { + this.destroy(err); + this._continueWrite(err); + return; + } + this._update(); + } + _consumeHeader() { + if (this._locked) return false; + this._offset = this._buffer.shifted; + try { + this._header = headers2.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat); + } catch (err) { + this._continueWrite(err); + return false; + } + if (!this._header) return true; + switch (this._header.type) { + case "gnu-long-path": + case "gnu-long-link-path": + case "pax-global-header": + case "pax-header": + this._longHeader = true; + this._missing = this._header.size; + return true; + } + this._locked = true; + this._applyLongHeaders(); + if (this._header.size === 0 || this._header.type === "directory") { + this.emit("entry", this._header, this._createStream(), this._unlockBound); + return true; + } + this._stream = this._createStream(); + this._missing = this._header.size; + this.emit("entry", this._header, this._stream, this._unlockBound); + return true; + } + _applyLongHeaders() { + if (this._gnuLongPath) { + this._header.name = this._gnuLongPath; + this._gnuLongPath = null; + } + if (this._gnuLongLinkPath) { + this._header.linkname = this._gnuLongLinkPath; + this._gnuLongLinkPath = null; + } + if (this._pax) { + if (this._pax.path) this._header.name = this._pax.path; + if (this._pax.linkpath) this._header.linkname = this._pax.linkpath; + if (this._pax.size) this._header.size = parseInt(this._pax.size, 10); + this._header.pax = this._pax; + this._pax = null; + } + } + _decodeLongHeader(buf2) { + switch (this._header.type) { + case "gnu-long-path": + this._gnuLongPath = headers2.decodeLongPath(buf2, this._filenameEncoding); + break; + case "gnu-long-link-path": + this._gnuLongLinkPath = headers2.decodeLongPath(buf2, this._filenameEncoding); + break; + case "pax-global-header": + this._paxGlobal = headers2.decodePax(buf2); + break; + case "pax-header": + this._pax = this._paxGlobal === null ? headers2.decodePax(buf2) : Object.assign({}, this._paxGlobal, headers2.decodePax(buf2)); + break; + } + } + _consumeLongHeader() { + this._longHeader = false; + this._missing = overflow(this._header.size); + const buf2 = this._buffer.shift(this._header.size); + try { + this._decodeLongHeader(buf2); + } catch (err) { + this._continueWrite(err); + return false; + } + return true; + } + _consumeStream() { + const buf2 = this._buffer.shiftFirst(this._missing); + if (buf2 === null) return false; + this._missing -= buf2.byteLength; + const drained = this._stream.push(buf2); + if (this._missing === 0) { + this._stream.push(null); + if (drained) this._stream._detach(); + return drained && this._locked === false; + } + return drained; + } + _createStream() { + return new Source(this, this._header, this._offset); + } + _update() { + while (this._buffer.buffered > 0 && !this.destroying) { + if (this._missing > 0) { + if (this._stream !== null) { + if (this._consumeStream() === false) return; + continue; + } + if (this._longHeader === true) { + if (this._missing > this._buffer.buffered) break; + if (this._consumeLongHeader() === false) return false; + continue; + } + const ignore = this._buffer.shiftFirst(this._missing); + if (ignore !== null) this._missing -= ignore.byteLength; + continue; + } + if (this._buffer.buffered < 512) break; + if (this._stream !== null || this._consumeHeader() === false) return; + } + this._continueWrite(null); + } + _continueWrite(err) { + const cb = this._callback; + this._callback = noop; + cb(err); + } + _write(data, cb) { + this._callback = cb; + this._buffer.push(data); + this._update(); + } + _final(cb) { + this._finished = this._missing === 0 && this._buffer.buffered === 0; + cb(this._finished ? null : new Error("Unexpected end of data")); + } + _predestroy() { + this._continueWrite(null); + } + _destroy(cb) { + if (this._stream) this._stream.destroy(getStreamError(this)); + cb(null); + } + [Symbol.asyncIterator]() { + let error2 = null; + let promiseResolve = null; + let promiseReject = null; + let entryStream = null; + let entryCallback = null; + const extract = this; + this.on("entry", onentry); + this.on("error", (err) => { + error2 = err; + }); + this.on("close", onclose); + return { + [Symbol.asyncIterator]() { + return this; + }, + next() { + return new Promise(onnext); + }, + return() { + return destroy(null); + }, + throw(err) { + return destroy(err); + } + }; + function consumeCallback(err) { + if (!entryCallback) return; + const cb = entryCallback; + entryCallback = null; + cb(err); + } + function onnext(resolve2, reject) { + if (error2) { + return reject(error2); + } + if (entryStream) { + resolve2({ value: entryStream, done: false }); + entryStream = null; + return; + } + promiseResolve = resolve2; + promiseReject = reject; + consumeCallback(null); + if (extract._finished && promiseResolve) { + promiseResolve({ value: void 0, done: true }); + promiseResolve = promiseReject = null; + } + } + function onentry(header, stream, callback) { + entryCallback = callback; + stream.on("error", noop); + if (promiseResolve) { + promiseResolve({ value: stream, done: false }); + promiseResolve = promiseReject = null; + } else { + entryStream = stream; + } + } + function onclose() { + consumeCallback(error2); + if (!promiseResolve) return; + if (error2) promiseReject(error2); + else promiseResolve({ value: void 0, done: true }); + promiseResolve = promiseReject = null; + } + function destroy(err) { + extract.destroy(err); + consumeCallback(err); + return new Promise((resolve2, reject) => { + if (extract.destroyed) return resolve2({ value: void 0, done: true }); + extract.once("close", function() { + if (err) reject(err); + else resolve2({ value: void 0, done: true }); + }); + }); + } + } + }; + module.exports = function extract(opts) { + return new Extract(opts); + }; + function noop() { + } + function overflow(size) { + size &= 511; + return size && 512 - size; + } + } +}); + +// node_modules/tar-stream/constants.js +var require_constants11 = __commonJS({ + "node_modules/tar-stream/constants.js"(exports, module) { + var constants3 = { + // just for envs without fs + S_IFMT: 61440, + S_IFDIR: 16384, + S_IFCHR: 8192, + S_IFBLK: 24576, + S_IFIFO: 4096, + S_IFLNK: 40960 + }; + try { + module.exports = __require("fs").constants || constants3; + } catch { + module.exports = constants3; + } + } +}); + +// node_modules/tar-stream/pack.js +var require_pack = __commonJS({ + "node_modules/tar-stream/pack.js"(exports, module) { + var { Readable, Writable, getStreamError } = require_streamx(); + var b4a = require_b4a(); + var constants3 = require_constants11(); + var headers2 = require_headers2(); + var DMODE = 493; + var FMODE = 420; + var END_OF_TAR = b4a.alloc(1024); + var Sink = class extends Writable { + constructor(pack, header, callback) { + super({ mapWritable, eagerOpen: true }); + this.written = 0; + this.header = header; + this._callback = callback; + this._linkname = null; + this._isLinkname = header.type === "symlink" && !header.linkname; + this._isVoid = header.type !== "file" && header.type !== "contiguous-file"; + this._finished = false; + this._pack = pack; + this._openCallback = null; + if (this._pack._stream === null) this._pack._stream = this; + else this._pack._pending.push(this); + } + _open(cb) { + this._openCallback = cb; + if (this._pack._stream === this) this._continueOpen(); + } + _continuePack(err) { + if (this._callback === null) return; + const callback = this._callback; + this._callback = null; + callback(err); + } + _continueOpen() { + if (this._pack._stream === null) this._pack._stream = this; + const cb = this._openCallback; + this._openCallback = null; + if (cb === null) return; + if (this._pack.destroying) return cb(new Error("pack stream destroyed")); + if (this._pack._finalized) return cb(new Error("pack stream is already finalized")); + this._pack._stream = this; + if (!this._isLinkname) { + this._pack._encode(this.header); + } + if (this._isVoid) { + this._finish(); + this._continuePack(null); + } + cb(null); + } + _write(data, cb) { + if (this._isLinkname) { + this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data; + return cb(null); + } + if (this._isVoid) { + if (data.byteLength > 0) { + return cb(new Error("No body allowed for this entry")); + } + return cb(); + } + this.written += data.byteLength; + if (this._pack.push(data)) return cb(); + this._pack._drain = cb; + } + _finish() { + if (this._finished) return; + this._finished = true; + if (this._isLinkname) { + this.header.linkname = this._linkname ? b4a.toString(this._linkname, "utf-8") : ""; + this._pack._encode(this.header); + } + overflow(this._pack, this.header.size); + this._pack._done(this); + } + _final(cb) { + if (this.written !== this.header.size) { + return cb(new Error("Size mismatch")); + } + this._finish(); + cb(null); + } + _getError() { + return getStreamError(this) || new Error("tar entry destroyed"); + } + _predestroy() { + this._pack.destroy(this._getError()); + } + _destroy(cb) { + this._pack._done(this); + this._continuePack(this._finished ? null : this._getError()); + cb(); + } + }; + var Pack = class extends Readable { + constructor(opts) { + super(opts); + this._drain = noop; + this._finalized = false; + this._finalizing = false; + this._pending = []; + this._stream = null; + } + entry(header, buffer, callback) { + if (this._finalized || this.destroying) throw new Error("already finalized or destroyed"); + if (typeof buffer === "function") { + callback = buffer; + buffer = null; + } + if (!callback) callback = noop; + if (!header.size || header.type === "symlink") header.size = 0; + if (!header.type) header.type = modeToType(header.mode); + if (!header.mode) header.mode = header.type === "directory" ? DMODE : FMODE; + if (!header.uid) header.uid = 0; + if (!header.gid) header.gid = 0; + if (!header.mtime) header.mtime = /* @__PURE__ */ new Date(); + if (typeof buffer === "string") buffer = b4a.from(buffer); + const sink = new Sink(this, header, callback); + if (b4a.isBuffer(buffer)) { + header.size = buffer.byteLength; + sink.write(buffer); + sink.end(); + return sink; + } + if (sink._isVoid) { + return sink; + } + return sink; + } + finalize() { + if (this._stream || this._pending.length > 0) { + this._finalizing = true; + return; + } + if (this._finalized) return; + this._finalized = true; + this.push(END_OF_TAR); + this.push(null); + } + _done(stream) { + if (stream !== this._stream) return; + this._stream = null; + if (this._finalizing) this.finalize(); + if (this._pending.length) this._pending.shift()._continueOpen(); + } + _encode(header) { + if (!header.pax) { + const buf2 = headers2.encode(header); + if (buf2) { + this.push(buf2); + return; + } + } + this._encodePax(header); + } + _encodePax(header) { + const paxHeader = headers2.encodePax({ + name: header.name, + linkname: header.linkname, + pax: header.pax + }); + const newHeader = { + name: "PaxHeader", + mode: header.mode, + uid: header.uid, + gid: header.gid, + size: paxHeader.byteLength, + mtime: header.mtime, + type: "pax-header", + linkname: header.linkname && "PaxHeader", + uname: header.uname, + gname: header.gname, + devmajor: header.devmajor, + devminor: header.devminor + }; + this.push(headers2.encode(newHeader)); + this.push(paxHeader); + overflow(this, paxHeader.byteLength); + newHeader.size = header.size; + newHeader.type = header.type; + this.push(headers2.encode(newHeader)); + } + _doDrain() { + const drain = this._drain; + this._drain = noop; + drain(); + } + _predestroy() { + const err = getStreamError(this); + if (this._stream) this._stream.destroy(err); + while (this._pending.length) { + const stream = this._pending.shift(); + stream.destroy(err); + stream._continueOpen(); + } + this._doDrain(); + } + _read(cb) { + this._doDrain(); + cb(); + } + }; + module.exports = function pack(opts) { + return new Pack(opts); + }; + function modeToType(mode) { + switch (mode & constants3.S_IFMT) { + case constants3.S_IFBLK: + return "block-device"; + case constants3.S_IFCHR: + return "character-device"; + case constants3.S_IFDIR: + return "directory"; + case constants3.S_IFIFO: + return "fifo"; + case constants3.S_IFLNK: + return "symlink"; + } + return "file"; + } + function noop() { + } + function overflow(self, size) { + size &= 511; + if (size) self.push(END_OF_TAR.subarray(0, 512 - size)); + } + function mapWritable(buf2) { + return b4a.isBuffer(buf2) ? buf2 : b4a.from(buf2); + } + } +}); + +// node_modules/tar-stream/index.js +var require_tar_stream = __commonJS({ + "node_modules/tar-stream/index.js"(exports) { + exports.extract = require_extract(); + exports.pack = require_pack(); + } +}); + +// node_modules/wrappy/wrappy.js +var require_wrappy = __commonJS({ + "node_modules/wrappy/wrappy.js"(exports, module) { + module.exports = wrappy; + function wrappy(fn, cb) { + if (fn && cb) return wrappy(fn)(cb); + if (typeof fn !== "function") + throw new TypeError("need wrapper function"); + Object.keys(fn).forEach(function(k) { + wrapper[k] = fn[k]; + }); + return wrapper; + function wrapper() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + var ret = fn.apply(this, args); + var cb2 = args[args.length - 1]; + if (typeof ret === "function" && ret !== cb2) { + Object.keys(cb2).forEach(function(k) { + ret[k] = cb2[k]; + }); + } + return ret; + } + } + } +}); + +// node_modules/once/once.js +var require_once = __commonJS({ + "node_modules/once/once.js"(exports, module) { + var wrappy = require_wrappy(); + module.exports = wrappy(once); + module.exports.strict = wrappy(onceStrict); + once.proto = once(function() { + Object.defineProperty(Function.prototype, "once", { + value: function() { + return once(this); + }, + configurable: true + }); + Object.defineProperty(Function.prototype, "onceStrict", { + value: function() { + return onceStrict(this); + }, + configurable: true + }); + }); + function once(fn) { + var f = function() { + if (f.called) return f.value; + f.called = true; + return f.value = fn.apply(this, arguments); + }; + f.called = false; + return f; + } + function onceStrict(fn) { + var f = function() { + if (f.called) + throw new Error(f.onceError); + f.called = true; + return f.value = fn.apply(this, arguments); + }; + var name = fn.name || "Function wrapped with `once`"; + f.onceError = name + " shouldn't be called more than once"; + f.called = false; + return f; + } + } +}); + +// node_modules/end-of-stream/index.js +var require_end_of_stream = __commonJS({ + "node_modules/end-of-stream/index.js"(exports, module) { + var once = require_once(); + var noop = function() { + }; + var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process); + var isRequest = function(stream) { + return stream.setHeader && typeof stream.abort === "function"; + }; + var isChildProcess = function(stream) { + return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3; + }; + var eos = function(stream, opts, callback) { + if (typeof opts === "function") return eos(stream, null, opts); + if (!opts) opts = {}; + callback = once(callback || noop); + var ws = stream._writableState; + var rs = stream._readableState; + var readable = opts.readable || opts.readable !== false && stream.readable; + var writable = opts.writable || opts.writable !== false && stream.writable; + var cancelled = false; + var onlegacyfinish = function() { + if (!stream.writable) onfinish(); + }; + var onfinish = function() { + writable = false; + if (!readable) callback.call(stream); + }; + var onend = function() { + readable = false; + if (!writable) callback.call(stream); + }; + var onexit = function(exitCode) { + callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null); + }; + var onerror = function(err) { + callback.call(stream, err); + }; + var onclose = function() { + qnt(onclosenexttick); + }; + var onclosenexttick = function() { + if (cancelled) return; + if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error("premature close")); + if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error("premature close")); + }; + var onrequest = function() { + stream.req.on("finish", onfinish); + }; + if (isRequest(stream)) { + stream.on("complete", onfinish); + stream.on("abort", onclose); + if (stream.req) onrequest(); + else stream.on("request", onrequest); + } else if (writable && !ws) { + stream.on("end", onlegacyfinish); + stream.on("close", onlegacyfinish); + } + if (isChildProcess(stream)) stream.on("exit", onexit); + stream.on("end", onend); + stream.on("finish", onfinish); + if (opts.error !== false) stream.on("error", onerror); + stream.on("close", onclose); + return function() { + cancelled = true; + stream.removeListener("complete", onfinish); + stream.removeListener("abort", onclose); + stream.removeListener("request", onrequest); + if (stream.req) stream.req.removeListener("finish", onfinish); + stream.removeListener("end", onlegacyfinish); + stream.removeListener("close", onlegacyfinish); + stream.removeListener("finish", onfinish); + stream.removeListener("exit", onexit); + stream.removeListener("end", onend); + stream.removeListener("error", onerror); + stream.removeListener("close", onclose); + }; + }; + module.exports = eos; + } +}); + +// node_modules/pump/index.js +var require_pump = __commonJS({ + "node_modules/pump/index.js"(exports, module) { + var once = require_once(); + var eos = require_end_of_stream(); + var fs8; + try { + fs8 = __require("fs"); + } catch (e2) { + } + var noop = function() { + }; + var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version); + var isFn = function(fn) { + return typeof fn === "function"; + }; + var isFS = function(stream) { + if (!ancient) return false; + if (!fs8) return false; + return (stream instanceof (fs8.ReadStream || noop) || stream instanceof (fs8.WriteStream || noop)) && isFn(stream.close); + }; + var isRequest = function(stream) { + return stream.setHeader && isFn(stream.abort); + }; + var destroyer = function(stream, reading, writing, callback) { + callback = once(callback); + var closed = false; + stream.on("close", function() { + closed = true; + }); + eos(stream, { readable: reading, writable: writing }, function(err) { + if (err) return callback(err); + closed = true; + callback(); + }); + var destroyed = false; + return function(err) { + if (closed) return; + if (destroyed) return; + destroyed = true; + if (isFS(stream)) return stream.close(noop); + if (isRequest(stream)) return stream.abort(); + if (isFn(stream.destroy)) return stream.destroy(); + callback(err || new Error("stream was destroyed")); + }; + }; + var call = function(fn) { + fn(); + }; + var pipe = function(from2, to) { + return from2.pipe(to); + }; + var pump = function() { + var streams = Array.prototype.slice.call(arguments); + var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop; + if (Array.isArray(streams[0])) streams = streams[0]; + if (streams.length < 2) throw new Error("pump requires two streams per minimum"); + var error2; + var destroys = streams.map(function(stream, i) { + var reading = i < streams.length - 1; + var writing = i > 0; + return destroyer(stream, reading, writing, function(err) { + if (!error2) error2 = err; + if (err) destroys.forEach(call); + if (reading) return; + destroys.forEach(call); + callback(error2); + }); + }); + return streams.reduce(pipe); + }; + module.exports = pump; + } +}); + +// node_modules/tar-fs/index.js +var require_tar_fs = __commonJS({ + "node_modules/tar-fs/index.js"(exports) { + var tar2 = require_tar_stream(); + var pump = require_pump(); + var fs8 = __require("fs"); + var path7 = __require("path"); + var win32 = (global.Bare ? global.Bare.platform : process.platform) === "win32"; + exports.pack = function pack(cwd, opts) { + if (!cwd) cwd = "."; + if (!opts) opts = {}; + const xfs = opts.fs || fs8; + const ignore = opts.ignore || opts.filter || noop; + const mapStream = opts.mapStream || echo; + const statNext = statAll(xfs, opts.dereference ? xfs.stat : xfs.lstat, cwd, ignore, opts.entries, opts.sort); + const strict = opts.strict !== false; + const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask(); + const pack2 = opts.pack || tar2.pack(); + const finish = opts.finish || noop; + let map3 = opts.map || noop; + let dmode = typeof opts.dmode === "number" ? opts.dmode : 0; + let fmode = typeof opts.fmode === "number" ? opts.fmode : 0; + if (opts.strip) map3 = strip(map3, opts.strip); + if (opts.readable) { + dmode |= parseInt(555, 8); + fmode |= parseInt(444, 8); + } + if (opts.writable) { + dmode |= parseInt(333, 8); + fmode |= parseInt(222, 8); + } + onnextentry(); + function onsymlink(filename, header) { + xfs.readlink(path7.join(cwd, filename), function(err, linkname) { + if (err) return pack2.destroy(err); + header.linkname = normalize(linkname); + pack2.entry(header, onnextentry); + }); + } + function onstat(err, filename, stat2) { + if (pack2.destroyed) return; + if (err) return pack2.destroy(err); + if (!filename) { + if (opts.finalize !== false) pack2.finalize(); + return finish(pack2); + } + if (stat2.isSocket()) return onnextentry(); + let header = { + name: normalize(filename), + mode: (stat2.mode | (stat2.isDirectory() ? dmode : fmode)) & umask, + mtime: stat2.mtime, + size: stat2.size, + type: "file", + uid: stat2.uid, + gid: stat2.gid + }; + if (stat2.isDirectory()) { + header.size = 0; + header.type = "directory"; + header = map3(header) || header; + return pack2.entry(header, onnextentry); + } + if (stat2.isSymbolicLink()) { + header.size = 0; + header.type = "symlink"; + header = map3(header) || header; + return onsymlink(filename, header); + } + header = map3(header) || header; + if (!stat2.isFile()) { + if (strict) return pack2.destroy(new Error("unsupported type for " + filename)); + return onnextentry(); + } + const entry = pack2.entry(header, onnextentry); + const rs = mapStream(xfs.createReadStream(path7.join(cwd, filename), { start: 0, end: header.size > 0 ? header.size - 1 : header.size }), header); + rs.on("error", function(err2) { + entry.destroy(err2); + }); + pump(rs, entry); + } + function onnextentry(err) { + if (err) return pack2.destroy(err); + statNext(onstat); + } + return pack2; + }; + function head(list) { + return list.length ? list[list.length - 1] : null; + } + function processGetuid() { + return !global.Bare && process.getuid ? process.getuid() : -1; + } + function processUmask() { + return !global.Bare && process.umask ? process.umask() : 0; + } + exports.extract = function extract(cwd, opts) { + if (!cwd) cwd = "."; + if (!opts) opts = {}; + cwd = path7.resolve(cwd); + const xfs = opts.fs || fs8; + const ignore = opts.ignore || opts.filter || noop; + const mapStream = opts.mapStream || echo; + const own = opts.chown !== false && !win32 && processGetuid() === 0; + const extract2 = opts.extract || tar2.extract(); + const stack = []; + const now = /* @__PURE__ */ new Date(); + const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask(); + const strict = opts.strict !== false; + const validateSymLinks = opts.validateSymlinks !== false; + let map3 = opts.map || noop; + let dmode = typeof opts.dmode === "number" ? opts.dmode : 0; + let fmode = typeof opts.fmode === "number" ? opts.fmode : 0; + if (opts.strip) map3 = strip(map3, opts.strip); + if (opts.readable) { + dmode |= parseInt(555, 8); + fmode |= parseInt(444, 8); + } + if (opts.writable) { + dmode |= parseInt(333, 8); + fmode |= parseInt(222, 8); + } + extract2.on("entry", onentry); + if (opts.finish) extract2.on("finish", opts.finish); + return extract2; + function onentry(header, stream, next) { + header = map3(header) || header; + header.name = normalize(header.name); + const name = path7.join(cwd, path7.join("/", header.name)); + if (ignore(name, header)) { + stream.resume(); + return next(); + } + const dir = path7.join(name, ".") === path7.join(cwd, ".") ? cwd : path7.dirname(name); + validate(xfs, dir, path7.join(cwd, "."), function(err, valid) { + if (err) return next(err); + if (!valid) return next(new Error(dir + " is not a valid path")); + if (header.type === "directory") { + stack.push([name, header.mtime]); + return mkdirfix(name, { + fs: xfs, + own, + uid: header.uid, + gid: header.gid, + mode: header.mode + }, stat2); + } + mkdirfix(dir, { + fs: xfs, + own, + uid: header.uid, + gid: header.gid, + // normally, the folders with rights and owner should be part of the TAR file + // if this is not the case, create folder for same user as file and with + // standard permissions of 0o755 (rwxr-xr-x) + mode: 493 + }, function(err2) { + if (err2) return next(err2); + switch (header.type) { + case "file": + return onfile(); + case "link": + return onlink(); + case "symlink": + return onsymlink(); + } + if (strict) return next(new Error("unsupported type for " + name + " (" + header.type + ")")); + stream.resume(); + next(); + }); + }); + function stat2(err) { + if (err) return next(err); + utimes(name, header, function(err2) { + if (err2) return next(err2); + if (win32) return next(); + chperm(name, header, next); + }); + } + function onsymlink() { + if (win32) return next(); + xfs.unlink(name, function() { + const dst = path7.resolve(path7.dirname(name), header.linkname); + if (!inCwd(dst) && validateSymLinks) return next(new Error(name + " is not a valid symlink")); + validateNotSymlink(xfs, dst, path7.join(cwd, "."), function(err, valid) { + if (err) return next(err); + if (!valid && validateSymLinks) return next(new Error(name + " is not a valid symlink")); + xfs.symlink(header.linkname, name, stat2); + }); + }); + } + function onlink() { + if (win32) return next(); + xfs.unlink(name, function() { + const link = path7.join(cwd, path7.join("/", header.linkname)); + xfs.realpath(link, function(err, dst) { + if (err || !inCwd(dst)) return next(new Error(name + " is not a valid hardlink")); + xfs.link(dst, name, function(err2) { + if (err2 && err2.code === "EPERM" && opts.hardlinkAsFilesFallback) { + stream = xfs.createReadStream(dst); + return onfile(); + } + stat2(err2); + }); + }); + }); + } + function inCwd(dst) { + return dst === cwd || dst.startsWith(cwd + path7.sep); + } + function onfile() { + const ws = xfs.createWriteStream(name); + const rs = mapStream(stream, header); + ws.on("error", function(err) { + rs.destroy(err); + }); + pump(rs, ws, function(err) { + if (err) return next(err); + ws.on("close", stat2); + }); + } + } + function utimesParent(name, cb) { + let top; + while ((top = head(stack)) && name.slice(0, top[0].length) !== top[0]) stack.pop(); + if (!top) return cb(); + xfs.utimes(top[0], now, top[1], cb); + } + function utimes(name, header, cb) { + if (opts.utimes === false) return cb(); + if (header.type === "directory") return xfs.utimes(name, now, header.mtime, cb); + if (header.type === "symlink") return utimesParent(name, cb); + xfs.utimes(name, now, header.mtime, function(err) { + if (err) return cb(err); + utimesParent(name, cb); + }); + } + function chperm(name, header, cb) { + const link = header.type === "symlink"; + const chmod2 = link ? xfs.lchmod : xfs.chmod; + const chown = link ? xfs.lchown : xfs.chown; + if (!chmod2) return cb(); + const mode = (header.mode | (header.type === "directory" ? dmode : fmode)) & umask; + if (chown && own) chown.call(xfs, name, header.uid, header.gid, onchown); + else onchown(null); + function onchown(err) { + if (err) return cb(err); + if (!chmod2) return cb(); + chmod2.call(xfs, name, mode, cb); + } + } + function mkdirfix(name, opts2, cb) { + xfs.stat(name, function(err) { + if (!err) return cb(null); + if (err.code !== "ENOENT") return cb(err); + xfs.mkdir(name, { mode: opts2.mode, recursive: true }, function(err2, made) { + if (err2) return cb(err2); + chperm(name, opts2, cb); + }); + }); + } + }; + function validateNotSymlink(fs9, name, root, cb) { + if (name === root) return cb(null, true); + if (!name.startsWith(root + path7.sep)) return cb(null, false); + fs9.lstat(name, function(err, st) { + if (err && err.code !== "ENOENT" && err.code !== "EPERM") return cb(err); + if (err || !st.isSymbolicLink()) return validateNotSymlink(fs9, path7.join(name, ".."), root, cb); + cb(null, false); + }); + } + function validate(fs9, name, root, cb) { + if (name === root) return cb(null, true); + fs9.lstat(name, function(err, st) { + if (err && err.code !== "ENOENT" && err.code !== "EPERM") return cb(err); + if (err || st.isDirectory()) return validate(fs9, path7.join(name, ".."), root, cb); + cb(null, false); + }); + } + function noop() { + } + function echo(name) { + return name; + } + function normalize(name) { + return win32 ? name.replace(/\\/g, "/").replace(/[:?<>|]/g, "_") : name; + } + function statAll(fs9, stat2, cwd, ignore, entries, sort) { + if (!entries) entries = ["."]; + const queue = entries.slice(0); + return function loop(callback) { + if (!queue.length) return callback(null); + const next = queue.shift(); + const nextAbs = path7.join(cwd, next); + stat2.call(fs9, nextAbs, function(err, stat3) { + if (err) return callback(entries.indexOf(next) === -1 && err.code === "ENOENT" ? null : err); + if (!stat3.isDirectory()) return callback(null, next, stat3); + fs9.readdir(nextAbs, function(err2, files) { + if (err2) return callback(err2); + if (sort) files.sort(); + for (let i = 0; i < files.length; i++) { + if (!ignore(path7.join(cwd, next, files[i]))) queue.push(path7.join(next, files[i])); + } + callback(null, next, stat3); + }); + }); + }; + } + function strip(map3, level) { + return function(header) { + header.name = header.name.split("/").slice(level).join("/"); + const linkname = header.linkname; + if (linkname && (header.type === "link" || path7.isAbsolute(linkname))) { + header.linkname = linkname.split("/").slice(level).join("/"); + } + return map3(header); + }; + } + } +}); + +// node_modules/@actions/core/lib/command.js +import * as os from "os"; + +// node_modules/@actions/core/lib/utils.js +function toCommandValue(input) { + if (input === null || input === void 0) { + return ""; + } else if (typeof input === "string" || input instanceof String) { + return input; + } + return JSON.stringify(input); +} +function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; +} + +// node_modules/@actions/core/lib/command.js +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); +} +var CMD_STRING = "::"; +var Command = class { + constructor(command, properties, message) { + if (!command) { + command = "missing.command"; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += " "; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } else { + cmdStr += ","; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } +}; +function escapeData(s) { + return toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); +} +function escapeProperty(s) { + return toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); +} + +// node_modules/@actions/core/lib/file-command.js +import * as crypto2 from "crypto"; +import * as fs from "fs"; +import * as os2 from "os"; +function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs.appendFileSync(filePath, `${toCommandValue(message)}${os2.EOL}`, { + encoding: "utf8" + }); +} +function prepareKeyValueMessage(key, value) { + const delimiter2 = `ghadelimiter_${crypto2.randomUUID()}`; + const convertedValue = toCommandValue(value); + if (key.includes(delimiter2)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter2}"`); + } + if (convertedValue.includes(delimiter2)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter2}"`); + } + return `${key}<<${delimiter2}${os2.EOL}${convertedValue}${os2.EOL}${delimiter2}`; +} + +// node_modules/@actions/http-client/lib/index.js +var tunnel = __toESM(require_tunnel2(), 1); +var import_undici = __toESM(require_undici(), 1); +var HttpCodes; +(function(HttpCodes2) { + HttpCodes2[HttpCodes2["OK"] = 200] = "OK"; + HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther"; + HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified"; + HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy"; + HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest"; + HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden"; + HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound"; + HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict"; + HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone"; + HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway"; + HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes || (HttpCodes = {})); +var Headers2; +(function(Headers4) { + Headers4["Accept"] = "accept"; + Headers4["ContentType"] = "content-type"; +})(Headers2 || (Headers2 = {})); +var MediaTypes; +(function(MediaTypes2) { + MediaTypes2["ApplicationJson"] = "application/json"; +})(MediaTypes || (MediaTypes = {})); +var HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +var HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; + +// node_modules/@actions/core/lib/summary.js +import { EOL as EOL3 } from "os"; +import { constants, promises } from "fs"; +var __awaiter = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve2) { + resolve2(value); + }); + } + return new (P || (P = Promise))(function(resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e2) { + reject(e2); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e2) { + reject(e2); + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var { access, appendFile, writeFile } = promises; +var SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY"; +var Summary = class { + constructor() { + this._buffer = ""; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, constants.R_OK | constants.W_OK); + } catch (_a) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join(""); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: "utf8" }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ""; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(EOL3); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, lang && { lang }); + const element = this.wrap("pre", this.wrap("code", code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? "ol" : "ul"; + const listItems = items.map((item) => this.wrap("li", item)).join(""); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows.map((row) => { + const cells = row.map((cell) => { + if (typeof cell === "string") { + return this.wrap("td", cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? "th" : "td"; + const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan }); + return this.wrap(tag, data, attrs); + }).join(""); + return this.wrap("tr", cells); + }).join(""); + const element = this.wrap("table", tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap("details", this.wrap("summary", label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, width && { width }), height && { height }); + const element = this.wrap("img", null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1"; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap("hr", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap("br", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, cite && { cite }); + const element = this.wrap("blockquote", text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap("a", text, { href }); + return this.addRaw(element).addEOL(); + } +}; +var _summary = new Summary(); + +// node_modules/@actions/core/lib/platform.js +import os4 from "os"; + +// node_modules/@actions/exec/lib/toolrunner.js +import * as os3 from "os"; +import * as events from "events"; +import * as child from "child_process"; +import * as path3 from "path"; + +// node_modules/@actions/io/lib/io.js +import * as path2 from "path"; + +// node_modules/@actions/io/lib/io-util.js +import * as fs2 from "fs"; +import * as path from "path"; +var __awaiter2 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve2) { + resolve2(value); + }); + } + return new (P || (P = Promise))(function(resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e2) { + reject(e2); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e2) { + reject(e2); + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var { chmod, copyFile, lstat, mkdir, open, readdir, rename, rm, rmdir, stat, symlink, unlink } = fs2.promises; +var IS_WINDOWS = process.platform === "win32"; +var READONLY = fs2.constants.O_RDONLY; +function exists(fsPath) { + return __awaiter2(this, void 0, void 0, function* () { + try { + yield stat(fsPath); + } catch (err) { + if (err.code === "ENOENT") { + return false; + } + throw err; + } + return true; + }); +} +function isRooted(p) { + p = normalizeSeparators(p); + if (!p) { + throw new Error('isRooted() parameter "p" cannot be empty'); + } + if (IS_WINDOWS) { + return p.startsWith("\\") || /^[A-Z]:/i.test(p); + } + return p.startsWith("/"); +} +function tryGetExecutablePath(filePath, extensions) { + return __awaiter2(this, void 0, void 0, function* () { + let stats = void 0; + try { + stats = yield stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (IS_WINDOWS) { + const upperExt = path.extname(filePath).toUpperCase(); + if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) { + return filePath; + } + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + const originalFilePath = filePath; + for (const extension of extensions) { + filePath = originalFilePath + extension; + stats = void 0; + try { + stats = yield stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (IS_WINDOWS) { + try { + const directory = path.dirname(filePath); + const upperName = path.basename(filePath).toUpperCase(); + for (const actualName of yield readdir(directory)) { + if (upperName === actualName.toUpperCase()) { + filePath = path.join(directory, actualName); + break; + } + } + } catch (err) { + console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); + } + return filePath; + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + } + return ""; + }); +} +function normalizeSeparators(p) { + p = p || ""; + if (IS_WINDOWS) { + p = p.replace(/\//g, "\\"); + return p.replace(/\\\\+/g, "\\"); + } + return p.replace(/\/\/+/g, "/"); +} +function isUnixExecutable(stats) { + return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && process.getgid !== void 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && process.getuid !== void 0 && stats.uid === process.getuid(); +} + +// node_modules/@actions/io/lib/io.js +var __awaiter3 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve2) { + resolve2(value); + }); + } + return new (P || (P = Promise))(function(resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e2) { + reject(e2); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e2) { + reject(e2); + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +function which(tool, check) { + return __awaiter3(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + if (check) { + const result = yield which(tool, false); + if (!result) { + if (IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + return result; + } + const matches = yield findInPath(tool); + if (matches && matches.length > 0) { + return matches[0]; + } + return ""; + }); +} +function findInPath(tool) { + return __awaiter3(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + const extensions = []; + if (IS_WINDOWS && process.env["PATHEXT"]) { + for (const extension of process.env["PATHEXT"].split(path2.delimiter)) { + if (extension) { + extensions.push(extension); + } + } + } + if (isRooted(tool)) { + const filePath = yield tryGetExecutablePath(tool, extensions); + if (filePath) { + return [filePath]; + } + return []; + } + if (tool.includes(path2.sep)) { + return []; + } + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path2.delimiter)) { + if (p) { + directories.push(p); + } + } + } + const matches = []; + for (const directory of directories) { + const filePath = yield tryGetExecutablePath(path2.join(directory, tool), extensions); + if (filePath) { + matches.push(filePath); + } + } + return matches; + }); +} + +// node_modules/@actions/exec/lib/toolrunner.js +import { setTimeout as setTimeout2 } from "timers"; +var __awaiter4 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve2) { + resolve2(value); + }); + } + return new (P || (P = Promise))(function(resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e2) { + reject(e2); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e2) { + reject(e2); + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var IS_WINDOWS2 = process.platform === "win32"; +var ToolRunner = class extends events.EventEmitter { + constructor(toolPath, args, options) { + super(); + if (!toolPath) { + throw new Error("Parameter 'toolPath' cannot be null or empty."); + } + this.toolPath = toolPath; + this.args = args || []; + this.options = options || {}; + } + _debug(message) { + if (this.options.listeners && this.options.listeners.debug) { + this.options.listeners.debug(message); + } + } + _getCommandString(options, noPrefix) { + const toolPath = this._getSpawnFileName(); + const args = this._getSpawnArgs(options); + let cmd = noPrefix ? "" : "[command]"; + if (IS_WINDOWS2) { + if (this._isCmdFile()) { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } else if (options.windowsVerbatimArguments) { + cmd += `"${toolPath}"`; + for (const a of args) { + cmd += ` ${a}`; + } + } else { + cmd += this._windowsQuoteCmdArg(toolPath); + for (const a of args) { + cmd += ` ${this._windowsQuoteCmdArg(a)}`; + } + } + } else { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } + return cmd; + } + _processLineBuffer(data, strBuffer, onLine) { + try { + let s = strBuffer + data.toString(); + let n = s.indexOf(os3.EOL); + while (n > -1) { + const line = s.substring(0, n); + onLine(line); + s = s.substring(n + os3.EOL.length); + n = s.indexOf(os3.EOL); + } + return s; + } catch (err) { + this._debug(`error processing line. Failed with error ${err}`); + return ""; + } + } + _getSpawnFileName() { + if (IS_WINDOWS2) { + if (this._isCmdFile()) { + return process.env["COMSPEC"] || "cmd.exe"; + } + } + return this.toolPath; + } + _getSpawnArgs(options) { + if (IS_WINDOWS2) { + if (this._isCmdFile()) { + let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; + for (const a of this.args) { + argline += " "; + argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a); + } + argline += '"'; + return [argline]; + } + } + return this.args; + } + _endsWith(str2, end) { + return str2.endsWith(end); + } + _isCmdFile() { + const upperToolPath = this.toolPath.toUpperCase(); + return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT"); + } + _windowsQuoteCmdArg(arg) { + if (!this._isCmdFile()) { + return this._uvQuoteCmdArg(arg); + } + if (!arg) { + return '""'; + } + const cmdSpecialChars = [ + " ", + " ", + "&", + "(", + ")", + "[", + "]", + "{", + "}", + "^", + "=", + ";", + "!", + "'", + "+", + ",", + "`", + "~", + "|", + "<", + ">", + '"' + ]; + let needsQuotes = false; + for (const char of arg) { + if (cmdSpecialChars.some((x) => x === char)) { + needsQuotes = true; + break; + } + } + if (!needsQuotes) { + return arg; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '"'; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _uvQuoteCmdArg(arg) { + if (!arg) { + return '""'; + } + if (!arg.includes(" ") && !arg.includes(" ") && !arg.includes('"')) { + return arg; + } + if (!arg.includes('"') && !arg.includes("\\")) { + return `"${arg}"`; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += "\\"; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _cloneExecOptions(options) { + options = options || {}; + const result = { + cwd: options.cwd || process.cwd(), + env: options.env || process.env, + silent: options.silent || false, + windowsVerbatimArguments: options.windowsVerbatimArguments || false, + failOnStdErr: options.failOnStdErr || false, + ignoreReturnCode: options.ignoreReturnCode || false, + delay: options.delay || 1e4 + }; + result.outStream = options.outStream || process.stdout; + result.errStream = options.errStream || process.stderr; + return result; + } + _getSpawnOptions(options, toolPath) { + options = options || {}; + const result = {}; + result.cwd = options.cwd; + result.env = options.env; + result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile(); + if (options.windowsVerbatimArguments) { + result.argv0 = `"${toolPath}"`; + } + return result; + } + /** + * Exec a tool. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param tool path to tool to exec + * @param options optional exec options. See ExecOptions + * @returns number + */ + exec() { + return __awaiter4(this, void 0, void 0, function* () { + if (!isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS2 && this.toolPath.includes("\\"))) { + this.toolPath = path3.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); + } + this.toolPath = yield which(this.toolPath, true); + return new Promise((resolve2, reject) => __awaiter4(this, void 0, void 0, function* () { + this._debug(`exec tool: ${this.toolPath}`); + this._debug("arguments:"); + for (const arg of this.args) { + this._debug(` ${arg}`); + } + const optionsNonNull = this._cloneExecOptions(this.options); + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os3.EOL); + } + const state = new ExecState(optionsNonNull, this.toolPath); + state.on("debug", (message) => { + this._debug(message); + }); + if (this.options.cwd && !(yield exists(this.options.cwd))) { + return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); + } + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + let stdbuffer = ""; + if (cp.stdout) { + cp.stdout.on("data", (data) => { + if (this.options.listeners && this.options.listeners.stdout) { + this.options.listeners.stdout(data); + } + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(data); + } + stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); + } + let errbuffer = ""; + if (cp.stderr) { + cp.stderr.on("data", (data) => { + state.processStderr = true; + if (this.options.listeners && this.options.listeners.stderr) { + this.options.listeners.stderr(data); + } + if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) { + const s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream; + s.write(data); + } + errbuffer = this._processLineBuffer(data, errbuffer, (line) => { + if (this.options.listeners && this.options.listeners.errline) { + this.options.listeners.errline(line); + } + }); + }); + } + cp.on("error", (err) => { + state.processError = err.message; + state.processExited = true; + state.processClosed = true; + state.CheckComplete(); + }); + cp.on("exit", (code) => { + state.processExitCode = code; + state.processExited = true; + this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); + state.CheckComplete(); + }); + cp.on("close", (code) => { + state.processExitCode = code; + state.processExited = true; + state.processClosed = true; + this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); + state.CheckComplete(); + }); + state.on("done", (error2, exitCode) => { + if (stdbuffer.length > 0) { + this.emit("stdline", stdbuffer); + } + if (errbuffer.length > 0) { + this.emit("errline", errbuffer); + } + cp.removeAllListeners(); + if (error2) { + reject(error2); + } else { + resolve2(exitCode); + } + }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error("child process missing stdin"); + } + cp.stdin.end(this.options.input); + } + })); + }); + } +}; +function argStringToArray(argString) { + const args = []; + let inQuotes = false; + let escaped = false; + let arg = ""; + function append(c) { + if (escaped && c !== '"') { + arg += "\\"; + } + arg += c; + escaped = false; + } + for (let i = 0; i < argString.length; i++) { + const c = argString.charAt(i); + if (c === '"') { + if (!escaped) { + inQuotes = !inQuotes; + } else { + append(c); + } + continue; + } + if (c === "\\" && escaped) { + append(c); + continue; + } + if (c === "\\" && inQuotes) { + escaped = true; + continue; + } + if (c === " " && !inQuotes) { + if (arg.length > 0) { + args.push(arg); + arg = ""; + } + continue; + } + append(c); + } + if (arg.length > 0) { + args.push(arg.trim()); + } + return args; +} +var ExecState = class _ExecState extends events.EventEmitter { + constructor(options, toolPath) { + super(); + this.processClosed = false; + this.processError = ""; + this.processExitCode = 0; + this.processExited = false; + this.processStderr = false; + this.delay = 1e4; + this.done = false; + this.timeout = null; + if (!toolPath) { + throw new Error("toolPath must not be empty"); + } + this.options = options; + this.toolPath = toolPath; + if (options.delay) { + this.delay = options.delay; + } + } + CheckComplete() { + if (this.done) { + return; + } + if (this.processClosed) { + this._setResult(); + } else if (this.processExited) { + this.timeout = setTimeout2(_ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit("debug", message); + } + _setResult() { + let error2; + if (this.processExited) { + if (this.processError) { + error2 = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); + } else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { + error2 = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); + } else if (this.processStderr && this.options.failOnStdErr) { + error2 = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); + } + } + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.done = true; + this.emit("done", error2, this.processExitCode); + } + static HandleTimeout(state) { + if (state.done) { + return; + } + if (!state.processClosed && state.processExited) { + const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; + state._debug(message); + } + state._setResult(); + } +}; + +// node_modules/@actions/exec/lib/exec.js +var __awaiter5 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve2) { + resolve2(value); + }); + } + return new (P || (P = Promise))(function(resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e2) { + reject(e2); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e2) { + reject(e2); + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +function exec(commandLine, args, options) { + return __awaiter5(this, void 0, void 0, function* () { + const commandArgs = argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + } + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new ToolRunner(toolPath, args, options); + return runner.exec(); + }); +} + +// node_modules/@actions/core/lib/platform.js +var platform = os4.platform(); +var arch = os4.arch(); + +// node_modules/@actions/core/lib/core.js +var ExitCode; +(function(ExitCode2) { + ExitCode2[ExitCode2["Success"] = 0] = "Success"; + ExitCode2[ExitCode2["Failure"] = 1] = "Failure"; +})(ExitCode || (ExitCode = {})); +function exportVariable(name, val) { + const convertedVal = toCommandValue(val); + process.env[name] = convertedVal; + const filePath = process.env["GITHUB_ENV"] || ""; + if (filePath) { + return issueFileCommand("ENV", prepareKeyValueMessage(name, val)); + } + issueCommand("set-env", { name }, convertedVal); +} +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || ""; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); +} +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +function debug(message) { + issueCommand("debug", {}, message); +} +function error(message, properties = {}) { + issueCommand("error", toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +function warning(message, properties = {}) { + issueCommand("warning", toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} + +// src/action.ts +import * as path6 from "path"; +import * as fs7 from "fs"; + +// src/types/cluster.ts +var Cluster = /* @__PURE__ */ ((Cluster3) => { + Cluster3["ARC"] = "arc"; + Cluster3["GENERIC"] = "generic"; + return Cluster3; +})(Cluster || {}); +var parseCluster = (str2) => { + const key = Object.keys(Cluster).find( + (k) => Cluster[k].toLowerCase() === str2.toLowerCase() + ); + return key !== void 0 ? Cluster[key] : void 0; +}; + +// node_modules/@kubernetes/client-node/dist/config.js +import fs5 from "node:fs"; +import https from "node:https"; +import http from "node:http"; + +// node_modules/js-yaml/dist/js-yaml.mjs +function isNothing(subject) { + return typeof subject === "undefined" || subject === null; +} +function isObject(subject) { + return typeof subject === "object" && subject !== null; +} +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + return [sequence]; +} +function extend(target, source) { + var index2, length, key, sourceKeys; + if (source) { + sourceKeys = Object.keys(source); + for (index2 = 0, length = sourceKeys.length; index2 < length; index2 += 1) { + key = sourceKeys[index2]; + target[key] = source[key]; + } + } + return target; +} +function repeat(string, count) { + var result = "", cycle; + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + return result; +} +function isNegativeZero(number) { + return number === 0 && Number.NEGATIVE_INFINITY === 1 / number; +} +var isNothing_1 = isNothing; +var isObject_1 = isObject; +var toArray_1 = toArray; +var repeat_1 = repeat; +var isNegativeZero_1 = isNegativeZero; +var extend_1 = extend; +var common = { + isNothing: isNothing_1, + isObject: isObject_1, + toArray: toArray_1, + repeat: repeat_1, + isNegativeZero: isNegativeZero_1, + extend: extend_1 +}; +function formatError(exception2, compact) { + var where = "", message = exception2.reason || "(unknown reason)"; + if (!exception2.mark) return message; + if (exception2.mark.name) { + where += 'in "' + exception2.mark.name + '" '; + } + where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")"; + if (!compact && exception2.mark.snippet) { + where += "\n\n" + exception2.mark.snippet; + } + return message + " " + where; +} +function YAMLException$1(reason, mark) { + Error.call(this); + this.name = "YAMLException"; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } else { + this.stack = new Error().stack || ""; + } +} +YAMLException$1.prototype = Object.create(Error.prototype); +YAMLException$1.prototype.constructor = YAMLException$1; +YAMLException$1.prototype.toString = function toString(compact) { + return this.name + ": " + formatError(this, compact); +}; +var exception = YAMLException$1; +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + var head = ""; + var tail = ""; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; + if (position - lineStart > maxHalfLength) { + head = " ... "; + lineStart = position - maxHalfLength + head.length; + } + if (lineEnd - position > maxHalfLength) { + tail = " ..."; + lineEnd = position + maxHalfLength - tail.length; + } + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail, + pos: position - lineStart + head.length + // relative position + }; +} +function padStart(string, max) { + return common.repeat(" ", max - string.length) + string; +} +function makeSnippet(mark, options) { + options = Object.create(options || null); + if (!mark.buffer) return null; + if (!options.maxLength) options.maxLength = 79; + if (typeof options.indent !== "number") options.indent = 1; + if (typeof options.linesBefore !== "number") options.linesBefore = 3; + if (typeof options.linesAfter !== "number") options.linesAfter = 2; + var re = /\r?\n|\r|\0/g; + var lineStarts = [0]; + var lineEnds = []; + var match; + var foundLineNo = -1; + while (match = re.exec(mark.buffer)) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); + if (mark.position <= match.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } + if (foundLineNo < 0) foundLineNo = lineStarts.length - 1; + var result = "", i, line; + var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length; + var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3); + for (i = 1; i <= options.linesBefore; i++) { + if (foundLineNo - i < 0) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo - i], + lineEnds[foundLineNo - i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), + maxLineLength + ); + result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result; + } + line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n"; + result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n"; + for (i = 1; i <= options.linesAfter; i++) { + if (foundLineNo + i >= lineEnds.length) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo + i], + lineEnds[foundLineNo + i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), + maxLineLength + ); + result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n"; + } + return result.replace(/\n$/, ""); +} +var snippet = makeSnippet; +var TYPE_CONSTRUCTOR_OPTIONS = [ + "kind", + "multi", + "resolve", + "construct", + "instanceOf", + "predicate", + "represent", + "representName", + "defaultStyle", + "styleAliases" +]; +var YAML_NODE_KINDS = [ + "scalar", + "sequence", + "mapping" +]; +function compileStyleAliases(map3) { + var result = {}; + if (map3 !== null) { + Object.keys(map3).forEach(function(style) { + map3[style].forEach(function(alias) { + result[String(alias)] = style; + }); + }); + } + return result; +} +function Type$1(tag, options) { + options = options || {}; + Object.keys(options).forEach(function(name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + this.options = options; + this.tag = tag; + this.kind = options["kind"] || null; + this.resolve = options["resolve"] || function() { + return true; + }; + this.construct = options["construct"] || function(data) { + return data; + }; + this.instanceOf = options["instanceOf"] || null; + this.predicate = options["predicate"] || null; + this.represent = options["represent"] || null; + this.representName = options["representName"] || null; + this.defaultStyle = options["defaultStyle"] || null; + this.multi = options["multi"] || false; + this.styleAliases = compileStyleAliases(options["styleAliases"] || null); + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} +var type = Type$1; +function compileList(schema2, name) { + var result = []; + schema2[name].forEach(function(currentType) { + var newIndex = result.length; + result.forEach(function(previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) { + newIndex = previousIndex; + } + }); + result[newIndex] = currentType; + }); + return result; +} +function compileMap() { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {}, + multi: { + scalar: [], + sequence: [], + mapping: [], + fallback: [] + } + }, index2, length; + function collectType(type2) { + if (type2.multi) { + result.multi[type2.kind].push(type2); + result.multi["fallback"].push(type2); + } else { + result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2; + } + } + for (index2 = 0, length = arguments.length; index2 < length; index2 += 1) { + arguments[index2].forEach(collectType); + } + return result; +} +function Schema$1(definition) { + return this.extend(definition); +} +Schema$1.prototype.extend = function extend2(definition) { + var implicit = []; + var explicit = []; + if (definition instanceof type) { + explicit.push(definition); + } else if (Array.isArray(definition)) { + explicit = explicit.concat(definition); + } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { + if (definition.implicit) implicit = implicit.concat(definition.implicit); + if (definition.explicit) explicit = explicit.concat(definition.explicit); + } else { + throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })"); + } + implicit.forEach(function(type$1) { + if (!(type$1 instanceof type)) { + throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + if (type$1.loadKind && type$1.loadKind !== "scalar") { + throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported."); + } + if (type$1.multi) { + throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit."); + } + }); + explicit.forEach(function(type$1) { + if (!(type$1 instanceof type)) { + throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + }); + var result = Object.create(Schema$1.prototype); + result.implicit = (this.implicit || []).concat(implicit); + result.explicit = (this.explicit || []).concat(explicit); + result.compiledImplicit = compileList(result, "implicit"); + result.compiledExplicit = compileList(result, "explicit"); + result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); + return result; +}; +var schema = Schema$1; +var str = new type("tag:yaml.org,2002:str", { + kind: "scalar", + construct: function(data) { + return data !== null ? data : ""; + } +}); +var seq = new type("tag:yaml.org,2002:seq", { + kind: "sequence", + construct: function(data) { + return data !== null ? data : []; + } +}); +var map = new type("tag:yaml.org,2002:map", { + kind: "mapping", + construct: function(data) { + return data !== null ? data : {}; + } +}); +var failsafe = new schema({ + explicit: [ + str, + seq, + map + ] +}); +function resolveYamlNull(data) { + if (data === null) return true; + var max = data.length; + return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL"); +} +function constructYamlNull() { + return null; +} +function isNull(object) { + return object === null; +} +var _null = new type("tag:yaml.org,2002:null", { + kind: "scalar", + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function() { + return "~"; + }, + lowercase: function() { + return "null"; + }, + uppercase: function() { + return "NULL"; + }, + camelcase: function() { + return "Null"; + }, + empty: function() { + return ""; + } + }, + defaultStyle: "lowercase" +}); +function resolveYamlBoolean(data) { + if (data === null) return false; + var max = data.length; + return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE"); +} +function constructYamlBoolean(data) { + return data === "true" || data === "True" || data === "TRUE"; +} +function isBoolean(object) { + return Object.prototype.toString.call(object) === "[object Boolean]"; +} +var bool = new type("tag:yaml.org,2002:bool", { + kind: "scalar", + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function(object) { + return object ? "true" : "false"; + }, + uppercase: function(object) { + return object ? "TRUE" : "FALSE"; + }, + camelcase: function(object) { + return object ? "True" : "False"; + } + }, + defaultStyle: "lowercase" +}); +function isHexCode(c) { + return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102; +} +function isOctCode(c) { + return 48 <= c && c <= 55; +} +function isDecCode(c) { + return 48 <= c && c <= 57; +} +function resolveYamlInteger(data) { + if (data === null) return false; + var max = data.length, index2 = 0, hasDigits = false, ch; + if (!max) return false; + ch = data[index2]; + if (ch === "-" || ch === "+") { + ch = data[++index2]; + } + if (ch === "0") { + if (index2 + 1 === max) return true; + ch = data[++index2]; + if (ch === "b") { + index2++; + for (; index2 < max; index2++) { + ch = data[index2]; + if (ch === "_") continue; + if (ch !== "0" && ch !== "1") return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "x") { + index2++; + for (; index2 < max; index2++) { + ch = data[index2]; + if (ch === "_") continue; + if (!isHexCode(data.charCodeAt(index2))) return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "o") { + index2++; + for (; index2 < max; index2++) { + ch = data[index2]; + if (ch === "_") continue; + if (!isOctCode(data.charCodeAt(index2))) return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + } + if (ch === "_") return false; + for (; index2 < max; index2++) { + ch = data[index2]; + if (ch === "_") continue; + if (!isDecCode(data.charCodeAt(index2))) { + return false; + } + hasDigits = true; + } + if (!hasDigits || ch === "_") return false; + return true; +} +function constructYamlInteger(data) { + var value = data, sign = 1, ch; + if (value.indexOf("_") !== -1) { + value = value.replace(/_/g, ""); + } + ch = value[0]; + if (ch === "-" || ch === "+") { + if (ch === "-") sign = -1; + value = value.slice(1); + ch = value[0]; + } + if (value === "0") return 0; + if (ch === "0") { + if (value[1] === "b") return sign * parseInt(value.slice(2), 2); + if (value[1] === "x") return sign * parseInt(value.slice(2), 16); + if (value[1] === "o") return sign * parseInt(value.slice(2), 8); + } + return sign * parseInt(value, 10); +} +function isInteger(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object)); +} +var int = new type("tag:yaml.org,2002:int", { + kind: "scalar", + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function(obj) { + return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1); + }, + octal: function(obj) { + return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1); + }, + decimal: function(obj) { + return obj.toString(10); + }, + /* eslint-disable max-len */ + hexadecimal: function(obj) { + return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1); + } + }, + defaultStyle: "decimal", + styleAliases: { + binary: [2, "bin"], + octal: [8, "oct"], + decimal: [10, "dec"], + hexadecimal: [16, "hex"] + } +}); +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$" +); +function resolveYamlFloat(data) { + if (data === null) return false; + if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === "_") { + return false; + } + return true; +} +function constructYamlFloat(data) { + var value, sign; + value = data.replace(/_/g, "").toLowerCase(); + sign = value[0] === "-" ? -1 : 1; + if ("+-".indexOf(value[0]) >= 0) { + value = value.slice(1); + } + if (value === ".inf") { + return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + } else if (value === ".nan") { + return NaN; + } + return sign * parseFloat(value, 10); +} +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; +function representYamlFloat(object, style) { + var res; + if (isNaN(object)) { + switch (style) { + case "lowercase": + return ".nan"; + case "uppercase": + return ".NAN"; + case "camelcase": + return ".NaN"; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case "lowercase": + return ".inf"; + case "uppercase": + return ".INF"; + case "camelcase": + return ".Inf"; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case "lowercase": + return "-.inf"; + case "uppercase": + return "-.INF"; + case "camelcase": + return "-.Inf"; + } + } else if (common.isNegativeZero(object)) { + return "-0.0"; + } + res = object.toString(10); + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res; +} +function isFloat(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object)); +} +var float = new type("tag:yaml.org,2002:float", { + kind: "scalar", + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: "lowercase" +}); +var json = failsafe.extend({ + implicit: [ + _null, + bool, + int, + float + ] +}); +var core = json; +var YAML_DATE_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$" +); +var YAML_TIMESTAMP_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$" +); +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; +} +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date; + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); + if (match === null) throw new Error("Date resolve error"); + year = +match[1]; + month = +match[2] - 1; + day = +match[3]; + if (!match[4]) { + return new Date(Date.UTC(year, month, day)); + } + hour = +match[4]; + minute = +match[5]; + second = +match[6]; + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { + fraction += "0"; + } + fraction = +fraction; + } + if (match[9]) { + tz_hour = +match[10]; + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 6e4; + if (match[9] === "-") delta = -delta; + } + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + if (delta) date.setTime(date.getTime() - delta); + return date; +} +function representYamlTimestamp(object) { + return object.toISOString(); +} +var timestamp = new type("tag:yaml.org,2002:timestamp", { + kind: "scalar", + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); +function resolveYamlMerge(data) { + return data === "<<" || data === null; +} +var merge = new type("tag:yaml.org,2002:merge", { + kind: "scalar", + resolve: resolveYamlMerge +}); +var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r"; +function resolveYamlBinary(data) { + if (data === null) return false; + var code, idx, bitlen = 0, max = data.length, map3 = BASE64_MAP; + for (idx = 0; idx < max; idx++) { + code = map3.indexOf(data.charAt(idx)); + if (code > 64) continue; + if (code < 0) return false; + bitlen += 6; + } + return bitlen % 8 === 0; +} +function constructYamlBinary(data) { + var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map3 = BASE64_MAP, bits = 0, result = []; + for (idx = 0; idx < max; idx++) { + if (idx % 4 === 0 && idx) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } + bits = bits << 6 | map3.indexOf(input.charAt(idx)); + } + tailbits = max % 4 * 6; + if (tailbits === 0) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } else if (tailbits === 18) { + result.push(bits >> 10 & 255); + result.push(bits >> 2 & 255); + } else if (tailbits === 12) { + result.push(bits >> 4 & 255); + } + return new Uint8Array(result); +} +function representYamlBinary(object) { + var result = "", bits = 0, idx, tail, max = object.length, map3 = BASE64_MAP; + for (idx = 0; idx < max; idx++) { + if (idx % 3 === 0 && idx) { + result += map3[bits >> 18 & 63]; + result += map3[bits >> 12 & 63]; + result += map3[bits >> 6 & 63]; + result += map3[bits & 63]; + } + bits = (bits << 8) + object[idx]; + } + tail = max % 3; + if (tail === 0) { + result += map3[bits >> 18 & 63]; + result += map3[bits >> 12 & 63]; + result += map3[bits >> 6 & 63]; + result += map3[bits & 63]; + } else if (tail === 2) { + result += map3[bits >> 10 & 63]; + result += map3[bits >> 4 & 63]; + result += map3[bits << 2 & 63]; + result += map3[64]; + } else if (tail === 1) { + result += map3[bits >> 2 & 63]; + result += map3[bits << 4 & 63]; + result += map3[64]; + result += map3[64]; + } + return result; +} +function isBinary(obj) { + return Object.prototype.toString.call(obj) === "[object Uint8Array]"; +} +var binary = new type("tag:yaml.org,2002:binary", { + kind: "scalar", + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); +var _hasOwnProperty$3 = Object.prototype.hasOwnProperty; +var _toString$2 = Object.prototype.toString; +function resolveYamlOmap(data) { + if (data === null) return true; + var objectKeys = [], index2, length, pair, pairKey, pairHasKey, object = data; + for (index2 = 0, length = object.length; index2 < length; index2 += 1) { + pair = object[index2]; + pairHasKey = false; + if (_toString$2.call(pair) !== "[object Object]") return false; + for (pairKey in pair) { + if (_hasOwnProperty$3.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } + if (!pairHasKey) return false; + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } + return true; +} +function constructYamlOmap(data) { + return data !== null ? data : []; +} +var omap = new type("tag:yaml.org,2002:omap", { + kind: "sequence", + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); +var _toString$1 = Object.prototype.toString; +function resolveYamlPairs(data) { + if (data === null) return true; + var index2, length, pair, keys, result, object = data; + result = new Array(object.length); + for (index2 = 0, length = object.length; index2 < length; index2 += 1) { + pair = object[index2]; + if (_toString$1.call(pair) !== "[object Object]") return false; + keys = Object.keys(pair); + if (keys.length !== 1) return false; + result[index2] = [keys[0], pair[keys[0]]]; + } + return true; +} +function constructYamlPairs(data) { + if (data === null) return []; + var index2, length, pair, keys, result, object = data; + result = new Array(object.length); + for (index2 = 0, length = object.length; index2 < length; index2 += 1) { + pair = object[index2]; + keys = Object.keys(pair); + result[index2] = [keys[0], pair[keys[0]]]; + } + return result; +} +var pairs = new type("tag:yaml.org,2002:pairs", { + kind: "sequence", + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); +var _hasOwnProperty$2 = Object.prototype.hasOwnProperty; +function resolveYamlSet(data) { + if (data === null) return true; + var key, object = data; + for (key in object) { + if (_hasOwnProperty$2.call(object, key)) { + if (object[key] !== null) return false; + } + } + return true; +} +function constructYamlSet(data) { + return data !== null ? data : {}; +} +var set = new type("tag:yaml.org,2002:set", { + kind: "mapping", + resolve: resolveYamlSet, + construct: constructYamlSet +}); +var _default = core.extend({ + implicit: [ + timestamp, + merge + ], + explicit: [ + binary, + omap, + pairs, + set + ] +}); +var _hasOwnProperty$1 = Object.prototype.hasOwnProperty; +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; +function _class(obj) { + return Object.prototype.toString.call(obj); +} +function is_EOL(c) { + return c === 10 || c === 13; +} +function is_WHITE_SPACE(c) { + return c === 9 || c === 32; +} +function is_WS_OR_EOL(c) { + return c === 9 || c === 32 || c === 10 || c === 13; +} +function is_FLOW_INDICATOR(c) { + return c === 44 || c === 91 || c === 93 || c === 123 || c === 125; +} +function fromHexCode(c) { + var lc; + if (48 <= c && c <= 57) { + return c - 48; + } + lc = c | 32; + if (97 <= lc && lc <= 102) { + return lc - 97 + 10; + } + return -1; +} +function escapedHexLen(c) { + if (c === 120) { + return 2; + } + if (c === 117) { + return 4; + } + if (c === 85) { + return 8; + } + return 0; +} +function fromDecimalCode(c) { + if (48 <= c && c <= 57) { + return c - 48; + } + return -1; +} +function simpleEscapeSequence(c) { + return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? " " : c === 9 ? " " : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : ""; +} +function charFromCodepoint(c) { + if (c <= 65535) { + return String.fromCharCode(c); + } + return String.fromCharCode( + (c - 65536 >> 10) + 55296, + (c - 65536 & 1023) + 56320 + ); +} +function setProperty(object, key, value) { + if (key === "__proto__") { + Object.defineProperty(object, key, { + configurable: true, + enumerable: true, + writable: true, + value + }); + } else { + object[key] = value; + } +} +var simpleEscapeCheck = new Array(256); +var simpleEscapeMap = new Array(256); +for (i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} +var i; +function State$1(input, options) { + this.input = input; + this.filename = options["filename"] || null; + this.schema = options["schema"] || _default; + this.onWarning = options["onWarning"] || null; + this.legacy = options["legacy"] || false; + this.json = options["json"] || false; + this.listener = options["listener"] || null; + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + this.firstTabInLine = -1; + this.documents = []; +} +function generateError(state, message) { + var mark = { + name: state.filename, + buffer: state.input.slice(0, -1), + // omit trailing \0 + position: state.position, + line: state.line, + column: state.position - state.lineStart + }; + mark.snippet = snippet(mark); + return new exception(message, mark); +} +function throwError(state, message) { + throw generateError(state, message); +} +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} +var directiveHandlers = { + YAML: function handleYamlDirective(state, name, args) { + var match, major, minor; + if (state.version !== null) { + throwError(state, "duplication of %YAML directive"); + } + if (args.length !== 1) { + throwError(state, "YAML directive accepts exactly one argument"); + } + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + if (match === null) { + throwError(state, "ill-formed argument of the YAML directive"); + } + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + if (major !== 1) { + throwError(state, "unacceptable YAML version of the document"); + } + state.version = args[0]; + state.checkLineBreaks = minor < 2; + if (minor !== 1 && minor !== 2) { + throwWarning(state, "unsupported YAML version of the document"); + } + }, + TAG: function handleTagDirective(state, name, args) { + var handle, prefix; + if (args.length !== 2) { + throwError(state, "TAG directive accepts exactly two arguments"); + } + handle = args[0]; + prefix = args[1]; + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, "ill-formed tag handle (first argument) of the TAG directive"); + } + if (_hasOwnProperty$1.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, "ill-formed tag prefix (second argument) of the TAG directive"); + } + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state, "tag prefix is malformed: " + prefix); + } + state.tagMap[handle] = prefix; + } +}; +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + if (start < end) { + _result = state.input.slice(start, end); + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 9 || 32 <= _character && _character <= 1114111)) { + throwError(state, "expected valid JSON character"); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, "the stream contains non-printable characters"); + } + state.result += _result; + } +} +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index2, quantity; + if (!common.isObject(source)) { + throwError(state, "cannot merge mappings; the provided source object is unacceptable"); + } + sourceKeys = Object.keys(source); + for (index2 = 0, quantity = sourceKeys.length; index2 < quantity; index2 += 1) { + key = sourceKeys[index2]; + if (!_hasOwnProperty$1.call(destination, key)) { + setProperty(destination, key, source[key]); + overridableKeys[key] = true; + } + } +} +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) { + var index2, quantity; + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + for (index2 = 0, quantity = keyNode.length; index2 < quantity; index2 += 1) { + if (Array.isArray(keyNode[index2])) { + throwError(state, "nested arrays are not supported inside keys"); + } + if (typeof keyNode === "object" && _class(keyNode[index2]) === "[object Object]") { + keyNode[index2] = "[object Object]"; + } + } + } + if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") { + keyNode = "[object Object]"; + } + keyNode = String(keyNode); + if (_result === null) { + _result = {}; + } + if (keyTag === "tag:yaml.org,2002:merge") { + if (Array.isArray(valueNode)) { + for (index2 = 0, quantity = valueNode.length; index2 < quantity; index2 += 1) { + mergeMappings(state, _result, valueNode[index2], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) { + state.line = startLine || state.line; + state.lineStart = startLineStart || state.lineStart; + state.position = startPos || state.position; + throwError(state, "duplicated mapping key"); + } + setProperty(_result, keyNode, valueNode); + delete overridableKeys[keyNode]; + } + return _result; +} +function readLineBreak(state) { + var ch; + ch = state.input.charCodeAt(state.position); + if (ch === 10) { + state.position++; + } else if (ch === 13) { + state.position++; + if (state.input.charCodeAt(state.position) === 10) { + state.position++; + } + } else { + throwError(state, "a line break is expected"); + } + state.line += 1; + state.lineStart = state.position; + state.firstTabInLine = -1; +} +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 9 && state.firstTabInLine === -1) { + state.firstTabInLine = state.position; + } + ch = state.input.charCodeAt(++state.position); + } + if (allowComments && ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 10 && ch !== 13 && ch !== 0); + } + if (is_EOL(ch)) { + readLineBreak(state); + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + while (ch === 32) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, "deficient indentation"); + } + return lineBreaks; +} +function testDocumentSeparator(state) { + var _position = state.position, ch; + ch = state.input.charCodeAt(_position); + if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) { + _position += 3; + ch = state.input.charCodeAt(_position); + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + return false; +} +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += " "; + } else if (count > 1) { + state.result += common.repeat("\n", count - 1); + } +} +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch; + ch = state.input.charCodeAt(state.position); + if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) { + return false; + } + if (ch === 63 || ch === 45) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + state.kind = "scalar"; + state.result = ""; + captureStart = captureEnd = state.position; + hasPendingContent = false; + while (ch !== 0) { + if (ch === 58) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + } else if (ch === 35) { + preceding = state.input.charCodeAt(state.position - 1); + if (is_WS_OR_EOL(preceding)) { + break; + } + } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + ch = state.input.charCodeAt(++state.position); + } + captureSegment(state, captureStart, captureEnd, false); + if (state.result) { + return true; + } + state.kind = _kind; + state.result = _result; + return false; +} +function readSingleQuotedScalar(state, nodeIndent) { + var ch, captureStart, captureEnd; + ch = state.input.charCodeAt(state.position); + if (ch !== 39) { + return false; + } + state.kind = "scalar"; + state.result = ""; + state.position++; + captureStart = captureEnd = state.position; + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 39) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + if (ch === 39) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, "unexpected end of the document within a single quoted scalar"); + } else { + state.position++; + captureEnd = state.position; + } + } + throwError(state, "unexpected end of the stream within a single quoted scalar"); +} +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, captureEnd, hexLength, hexResult, tmp, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 34) { + return false; + } + state.kind = "scalar"; + state.result = ""; + state.position++; + captureStart = captureEnd = state.position; + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 34) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + } else if (ch === 92) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + } else { + throwError(state, "expected hexadecimal character"); + } + } + state.result += charFromCodepoint(hexResult); + state.position++; + } else { + throwError(state, "unknown escape sequence"); + } + captureStart = captureEnd = state.position; + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, "unexpected end of the document within a double quoted scalar"); + } else { + state.position++; + captureEnd = state.position; + } + } + throwError(state, "unexpected end of the stream within a double quoted scalar"); +} +function readFlowCollection(state, nodeIndent) { + var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch; + ch = state.input.charCodeAt(state.position); + if (ch === 91) { + terminator = 93; + isMapping = false; + _result = []; + } else if (ch === 123) { + terminator = 125; + isMapping = true; + _result = {}; + } else { + return false; + } + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(++state.position); + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + ch = state.input.charCodeAt(state.position); + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? "mapping" : "sequence"; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, "missed comma between flow collection entries"); + } else if (ch === 44) { + throwError(state, "expected the node content, but found ','"); + } + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + if (ch === 63) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + _line = state.line; + _lineStart = state.lineStart; + _pos = state.position; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + ch = state.input.charCodeAt(state.position); + if ((isExplicitPair || state.line === _line) && ch === 58) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } + skipSeparationSpace(state, true, nodeIndent); + ch = state.input.charCodeAt(state.position); + if (ch === 44) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + throwError(state, "unexpected end of the stream within a flow collection"); +} +function readBlockScalar(state, nodeIndent) { + var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch; + ch = state.input.charCodeAt(state.position); + if (ch === 124) { + folding = false; + } else if (ch === 62) { + folding = true; + } else { + return false; + } + state.kind = "scalar"; + state.result = ""; + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + if (ch === 43 || ch === 45) { + if (CHOMPING_CLIP === chomping) { + chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, "repeat of a chomping mode identifier"); + } + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one"); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, "repeat of an indentation width identifier"); + } + } else { + break; + } + } + if (is_WHITE_SPACE(ch)) { + do { + ch = state.input.charCodeAt(++state.position); + } while (is_WHITE_SPACE(ch)); + if (ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (!is_EOL(ch) && ch !== 0); + } + } + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + ch = state.input.charCodeAt(state.position); + while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + if (is_EOL(ch)) { + emptyLines++; + continue; + } + if (state.lineIndent < textIndent) { + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { + state.result += "\n"; + } + } + break; + } + if (folding) { + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat("\n", emptyLines + 1); + } else if (emptyLines === 0) { + if (didReadContent) { + state.result += " "; + } + } else { + state.result += common.repeat("\n", emptyLines); + } + } else { + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + while (!is_EOL(ch) && ch !== 0) { + ch = state.input.charCodeAt(++state.position); + } + captureSegment(state, captureStart, state.position, false); + } + return true; +} +function readBlockSequence(state, nodeIndent) { + var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch; + if (state.firstTabInLine !== -1) return false; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + if (state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, "tab characters must not be used in indentation"); + } + if (ch !== 45) { + break; + } + following = state.input.charCodeAt(state.position + 1); + if (!is_WS_OR_EOL(following)) { + break; + } + detected = true; + state.position++; + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) { + throwError(state, "bad indentation of a sequence entry"); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = "sequence"; + state.result = _result; + return true; + } + return false; +} +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch; + if (state.firstTabInLine !== -1) return false; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + if (!atExplicitKey && state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, "tab characters must not be used in indentation"); + } + following = state.input.charCodeAt(state.position + 1); + _line = state.line; + if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) { + if (ch === 63) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = true; + allowCompact = true; + } else if (atExplicitKey) { + atExplicitKey = false; + allowCompact = true; + } else { + throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"); + } + state.position += 1; + ch = following; + } else { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + break; + } + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (ch === 58) { + ch = state.input.charCodeAt(++state.position); + if (!is_WS_OR_EOL(ch)) { + throwError(state, "a whitespace character is expected after the key-value separator within a block mapping"); + } + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + } else if (detected) { + throwError(state, "can not read an implicit mapping pair; a colon is missed"); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; + } + } else if (detected) { + throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key"); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; + } + } + if (state.line === _line || state.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + } + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) { + throwError(state, "bad indentation of a mapping entry"); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = "mapping"; + state.result = _result; + } + return detected; +} +function readTagProperty(state) { + var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 33) return false; + if (state.tag !== null) { + throwError(state, "duplication of a tag property"); + } + ch = state.input.charCodeAt(++state.position); + if (ch === 60) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + } else if (ch === 33) { + isNamed = true; + tagHandle = "!!"; + ch = state.input.charCodeAt(++state.position); + } else { + tagHandle = "!"; + } + _position = state.position; + if (isVerbatim) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0 && ch !== 62); + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, "unexpected end of the stream within a verbatim tag"); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + if (ch === 33) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, "named tag handle cannot contain such characters"); + } + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, "tag suffix cannot contain exclamation marks"); + } + } + ch = state.input.charCodeAt(++state.position); + } + tagName = state.input.slice(_position, state.position); + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, "tag suffix cannot contain flow indicator characters"); + } + } + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, "tag name cannot contain such characters: " + tagName); + } + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state, "tag name is malformed: " + tagName); + } + if (isVerbatim) { + state.tag = tagName; + } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + } else if (tagHandle === "!") { + state.tag = "!" + tagName; + } else if (tagHandle === "!!") { + state.tag = "tag:yaml.org,2002:" + tagName; + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + return true; +} +function readAnchorProperty(state) { + var _position, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 38) return false; + if (state.anchor !== null) { + throwError(state, "duplication of an anchor property"); + } + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (state.position === _position) { + throwError(state, "name of an anchor node must contain at least one character"); + } + state.anchor = state.input.slice(_position, state.position); + return true; +} +function readAlias(state) { + var _position, alias, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 42) return false; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (state.position === _position) { + throwError(state, "name of an alias node must contain at least one character"); + } + alias = state.input.slice(_position, state.position); + if (!_hasOwnProperty$1.call(state.anchorMap, alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type2, flowIndent, blockIndent; + if (state.listener !== null) { + state.listener("open", state); + } + state.tag = null; + state.anchor = null; + state.kind = null; + state.result = null; + allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext; + if (allowToSeek) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + blockIndent = state.position - state.lineStart; + if (indentStatus === 1) { + if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + } else if (readAlias(state)) { + hasContent = true; + if (state.tag !== null || state.anchor !== null) { + throwError(state, "alias node should not have any properties"); + } + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + if (state.tag === null) { + state.tag = "?"; + } + } + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + if (state.tag === null) { + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } else if (state.tag === "?") { + if (state.result !== null && state.kind !== "scalar") { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type2 = state.implicitTypes[typeIndex]; + if (type2.resolve(state.result)) { + state.result = type2.construct(state.result); + state.tag = type2.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (state.tag !== "!") { + if (_hasOwnProperty$1.call(state.typeMap[state.kind || "fallback"], state.tag)) { + type2 = state.typeMap[state.kind || "fallback"][state.tag]; + } else { + type2 = null; + typeList = state.typeMap.multi[state.kind || "fallback"]; + for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) { + if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { + type2 = typeList[typeIndex]; + break; + } + } + } + if (!type2) { + throwError(state, "unknown tag !<" + state.tag + ">"); + } + if (state.result !== null && type2.kind !== state.kind) { + throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"'); + } + if (!type2.resolve(state.result, state.tag)) { + throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag"); + } else { + state.result = type2.construct(state.result, state.tag); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } + if (state.listener !== null) { + state.listener("close", state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} +function readDocument(state) { + var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch; + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = /* @__PURE__ */ Object.create(null); + state.anchorMap = /* @__PURE__ */ Object.create(null); + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + if (state.lineIndent > 0 || ch !== 37) { + break; + } + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + if (directiveName.length < 1) { + throwError(state, "directive name must not be less than one character in length"); + } + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0 && !is_EOL(ch)); + break; + } + if (is_EOL(ch)) break; + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + directiveArgs.push(state.input.slice(_position, state.position)); + } + if (ch !== 0) readLineBreak(state); + if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + skipSeparationSpace(state, true, -1); + if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } else if (hasDirectives) { + throwError(state, "directives end mark is expected"); + } + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, "non-ASCII line breaks are interpreted as content"); + } + state.documents.push(state.result); + if (state.position === state.lineStart && testDocumentSeparator(state)) { + if (state.input.charCodeAt(state.position) === 46) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + if (state.position < state.length - 1) { + throwError(state, "end of the stream or a document separator is expected"); + } else { + return; + } +} +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + if (input.length !== 0) { + if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) { + input += "\n"; + } + if (input.charCodeAt(0) === 65279) { + input = input.slice(1); + } + } + var state = new State$1(input, options); + var nullpos = input.indexOf("\0"); + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, "null byte is not allowed in input"); + } + state.input += "\0"; + while (state.input.charCodeAt(state.position) === 32) { + state.lineIndent += 1; + state.position += 1; + } + while (state.position < state.length - 1) { + readDocument(state); + } + return state.documents; +} +function loadAll$1(input, iterator, options) { + if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") { + options = iterator; + iterator = null; + } + var documents = loadDocuments(input, options); + if (typeof iterator !== "function") { + return documents; + } + for (var index2 = 0, length = documents.length; index2 < length; index2 += 1) { + iterator(documents[index2]); + } +} +function load$1(input, options) { + var documents = loadDocuments(input, options); + if (documents.length === 0) { + return void 0; + } else if (documents.length === 1) { + return documents[0]; + } + throw new exception("expected a single document in the stream, but found more"); +} +var loadAll_1 = loadAll$1; +var load_1 = load$1; +var loader = { + loadAll: loadAll_1, + load: load_1 +}; +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var CHAR_BOM = 65279; +var CHAR_TAB = 9; +var CHAR_LINE_FEED = 10; +var CHAR_CARRIAGE_RETURN = 13; +var CHAR_SPACE = 32; +var CHAR_EXCLAMATION = 33; +var CHAR_DOUBLE_QUOTE = 34; +var CHAR_SHARP = 35; +var CHAR_PERCENT = 37; +var CHAR_AMPERSAND = 38; +var CHAR_SINGLE_QUOTE = 39; +var CHAR_ASTERISK = 42; +var CHAR_COMMA = 44; +var CHAR_MINUS = 45; +var CHAR_COLON = 58; +var CHAR_EQUALS = 61; +var CHAR_GREATER_THAN = 62; +var CHAR_QUESTION = 63; +var CHAR_COMMERCIAL_AT = 64; +var CHAR_LEFT_SQUARE_BRACKET = 91; +var CHAR_RIGHT_SQUARE_BRACKET = 93; +var CHAR_GRAVE_ACCENT = 96; +var CHAR_LEFT_CURLY_BRACKET = 123; +var CHAR_VERTICAL_LINE = 124; +var CHAR_RIGHT_CURLY_BRACKET = 125; +var ESCAPE_SEQUENCES = {}; +ESCAPE_SEQUENCES[0] = "\\0"; +ESCAPE_SEQUENCES[7] = "\\a"; +ESCAPE_SEQUENCES[8] = "\\b"; +ESCAPE_SEQUENCES[9] = "\\t"; +ESCAPE_SEQUENCES[10] = "\\n"; +ESCAPE_SEQUENCES[11] = "\\v"; +ESCAPE_SEQUENCES[12] = "\\f"; +ESCAPE_SEQUENCES[13] = "\\r"; +ESCAPE_SEQUENCES[27] = "\\e"; +ESCAPE_SEQUENCES[34] = '\\"'; +ESCAPE_SEQUENCES[92] = "\\\\"; +ESCAPE_SEQUENCES[133] = "\\N"; +ESCAPE_SEQUENCES[160] = "\\_"; +ESCAPE_SEQUENCES[8232] = "\\L"; +ESCAPE_SEQUENCES[8233] = "\\P"; +var DEPRECATED_BOOLEANS_SYNTAX = [ + "y", + "Y", + "yes", + "Yes", + "YES", + "on", + "On", + "ON", + "n", + "N", + "no", + "No", + "NO", + "off", + "Off", + "OFF" +]; +var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; +function compileStyleMap(schema2, map3) { + var result, keys, index2, length, tag, style, type2; + if (map3 === null) return {}; + result = {}; + keys = Object.keys(map3); + for (index2 = 0, length = keys.length; index2 < length; index2 += 1) { + tag = keys[index2]; + style = String(map3[tag]); + if (tag.slice(0, 2) === "!!") { + tag = "tag:yaml.org,2002:" + tag.slice(2); + } + type2 = schema2.compiledTypeMap["fallback"][tag]; + if (type2 && _hasOwnProperty.call(type2.styleAliases, style)) { + style = type2.styleAliases[style]; + } + result[tag] = style; + } + return result; +} +function encodeHex(character) { + var string, handle, length; + string = character.toString(16).toUpperCase(); + if (character <= 255) { + handle = "x"; + length = 2; + } else if (character <= 65535) { + handle = "u"; + length = 4; + } else if (character <= 4294967295) { + handle = "U"; + length = 8; + } else { + throw new exception("code point within a string may not be greater than 0xFFFFFFFF"); + } + return "\\" + handle + common.repeat("0", length - string.length) + string; +} +var QUOTING_TYPE_SINGLE = 1; +var QUOTING_TYPE_DOUBLE = 2; +function State(options) { + this.schema = options["schema"] || _default; + this.indent = Math.max(1, options["indent"] || 2); + this.noArrayIndent = options["noArrayIndent"] || false; + this.skipInvalid = options["skipInvalid"] || false; + this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"]; + this.styleMap = compileStyleMap(this.schema, options["styles"] || null); + this.sortKeys = options["sortKeys"] || false; + this.lineWidth = options["lineWidth"] || 80; + this.noRefs = options["noRefs"] || false; + this.noCompatMode = options["noCompatMode"] || false; + this.condenseFlow = options["condenseFlow"] || false; + this.quotingType = options["quotingType"] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; + this.forceQuotes = options["forceQuotes"] || false; + this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null; + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + this.tag = null; + this.result = ""; + this.duplicates = []; + this.usedDuplicates = null; +} +function indentString(string, spaces) { + var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length; + while (position < length) { + next = string.indexOf("\n", position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + if (line.length && line !== "\n") result += ind; + result += line; + } + return result; +} +function generateNextLine(state, level) { + return "\n" + common.repeat(" ", state.indent * level); +} +function testImplicitResolving(state, str2) { + var index2, length, type2; + for (index2 = 0, length = state.implicitTypes.length; index2 < length; index2 += 1) { + type2 = state.implicitTypes[index2]; + if (type2.resolve(str2)) { + return true; + } + } + return false; +} +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} +function isPrintable(c) { + return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== CHAR_BOM || 65536 <= c && c <= 1114111; +} +function isNsCharOrWhitespace(c) { + return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED; +} +function isPlainSafe(c, prev, inblock) { + var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); + var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); + return ( + // ns-plain-safe + (inblock ? ( + // c = flow-in + cIsNsCharOrWhitespace + ) : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar + ); +} +function isPlainSafeFirst(c) { + return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT; +} +function isPlainSafeLast(c) { + return !isWhitespace(c) && c !== CHAR_COLON; +} +function codePointAt(string, pos) { + var first = string.charCodeAt(pos), second; + if (first >= 55296 && first <= 56319 && pos + 1 < string.length) { + second = string.charCodeAt(pos + 1); + if (second >= 56320 && second <= 57343) { + return (first - 55296) * 1024 + second - 56320 + 65536; + } + } + return first; +} +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} +var STYLE_PLAIN = 1; +var STYLE_SINGLE = 2; +var STYLE_LITERAL = 3; +var STYLE_FOLDED = 4; +var STYLE_DOUBLE = 5; +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) { + var i; + var char = 0; + var prevChar = null; + var hasLineBreak = false; + var hasFoldableLine = false; + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; + var plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1)); + if (singleLineOnly || forceQuotes) { + for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + } else { + for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented. + i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "; + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "); + } + if (!hasLineBreak && !hasFoldableLine) { + if (plain && !forceQuotes && !testAmbiguousType(string)) { + return STYLE_PLAIN; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + if (!forceQuotes) { + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; +} +function writeScalar(state, string, level, iskey, inblock) { + state.dump = (function() { + if (string.length === 0) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"; + } + if (!state.noCompatMode) { + if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string + '"' : "'" + string + "'"; + } + } + var indent = state.indent * Math.max(1, level); + var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel; + function testAmbiguity(string2) { + return testImplicitResolving(state, string2); + } + switch (chooseScalarStyle( + string, + singleLineOnly, + state.indent, + lineWidth, + testAmbiguity, + state.quotingType, + state.forceQuotes && !iskey, + inblock + )) { + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string) + '"'; + default: + throw new exception("impossible error: invalid scalar style"); + } + })(); +} +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ""; + var clip = string[string.length - 1] === "\n"; + var keep = clip && (string[string.length - 2] === "\n" || string === "\n"); + var chomp = keep ? "+" : clip ? "" : "-"; + return indentIndicator + chomp + "\n"; +} +function dropEndingNewline(string) { + return string[string.length - 1] === "\n" ? string.slice(0, -1) : string; +} +function foldString(string, width) { + var lineRe = /(\n+)([^\n]*)/g; + var result = (function() { + var nextLF = string.indexOf("\n"); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + })(); + var prevMoreIndented = string[0] === "\n" || string[0] === " "; + var moreIndented; + var match; + while (match = lineRe.exec(string)) { + var prefix = match[1], line = match[2]; + moreIndented = line[0] === " "; + result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width); + prevMoreIndented = moreIndented; + } + return result; +} +function foldLine(line, width) { + if (line === "" || line[0] === " ") return line; + var breakRe = / [^ ]/g; + var match; + var start = 0, end, curr = 0, next = 0; + var result = ""; + while (match = breakRe.exec(line)) { + next = match.index; + if (next - start > width) { + end = curr > start ? curr : next; + result += "\n" + line.slice(start, end); + start = end + 1; + } + curr = next; + } + result += "\n"; + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + "\n" + line.slice(curr + 1); + } else { + result += line.slice(start); + } + return result.slice(1); +} +function escapeString(string) { + var result = ""; + var char = 0; + var escapeSeq; + for (var i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + escapeSeq = ESCAPE_SEQUENCES[char]; + if (!escapeSeq && isPrintable(char)) { + result += string[i]; + if (char >= 65536) result += string[i + 1]; + } else { + result += escapeSeq || encodeHex(char); + } + } + return result; +} +function writeFlowSequence(state, level, object) { + var _result = "", _tag = state.tag, index2, length, value; + for (index2 = 0, length = object.length; index2 < length; index2 += 1) { + value = object[index2]; + if (state.replacer) { + value = state.replacer.call(object, String(index2), value); + } + if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) { + if (_result !== "") _result += "," + (!state.condenseFlow ? " " : ""); + _result += state.dump; + } + } + state.tag = _tag; + state.dump = "[" + _result + "]"; +} +function writeBlockSequence(state, level, object, compact) { + var _result = "", _tag = state.tag, index2, length, value; + for (index2 = 0, length = object.length; index2 < length; index2 += 1) { + value = object[index2]; + if (state.replacer) { + value = state.replacer.call(object, String(index2), value); + } + if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) { + if (!compact || _result !== "") { + _result += generateNextLine(state, level); + } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += "-"; + } else { + _result += "- "; + } + _result += state.dump; + } + } + state.tag = _tag; + state.dump = _result || "[]"; +} +function writeFlowMapping(state, level, object) { + var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index2, length, objectKey, objectValue, pairBuffer; + for (index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) { + pairBuffer = ""; + if (_result !== "") pairBuffer += ", "; + if (state.condenseFlow) pairBuffer += '"'; + objectKey = objectKeyList[index2]; + objectValue = object[objectKey]; + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + if (!writeNode(state, level, objectKey, false, false)) { + continue; + } + if (state.dump.length > 1024) pairBuffer += "? "; + pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " "); + if (!writeNode(state, level, objectValue, false, false)) { + continue; + } + pairBuffer += state.dump; + _result += pairBuffer; + } + state.tag = _tag; + state.dump = "{" + _result + "}"; +} +function writeBlockMapping(state, level, object, compact) { + var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index2, length, objectKey, objectValue, explicitPair, pairBuffer; + if (state.sortKeys === true) { + objectKeyList.sort(); + } else if (typeof state.sortKeys === "function") { + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + throw new exception("sortKeys must be a boolean or a function"); + } + for (index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) { + pairBuffer = ""; + if (!compact || _result !== "") { + pairBuffer += generateNextLine(state, level); + } + objectKey = objectKeyList[index2]; + objectValue = object[objectKey]; + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; + } + explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024; + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += "?"; + } else { + pairBuffer += "? "; + } + } + pairBuffer += state.dump; + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; + } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ":"; + } else { + pairBuffer += ": "; + } + pairBuffer += state.dump; + _result += pairBuffer; + } + state.tag = _tag; + state.dump = _result || "{}"; +} +function detectType(state, object, explicit) { + var _result, typeList, index2, length, type2, style; + typeList = explicit ? state.explicitTypes : state.implicitTypes; + for (index2 = 0, length = typeList.length; index2 < length; index2 += 1) { + type2 = typeList[index2]; + if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) { + if (explicit) { + if (type2.multi && type2.representName) { + state.tag = type2.representName(object); + } else { + state.tag = type2.tag; + } + } else { + state.tag = "?"; + } + if (type2.represent) { + style = state.styleMap[type2.tag] || type2.defaultStyle; + if (_toString.call(type2.represent) === "[object Function]") { + _result = type2.represent(object, style); + } else if (_hasOwnProperty.call(type2.represent, style)) { + _result = type2.represent[style](object, style); + } else { + throw new exception("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style'); + } + state.dump = _result; + } + return true; + } + } + return false; +} +function writeNode(state, level, object, block, compact, iskey, isblockseq) { + state.tag = null; + state.dump = object; + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + var type2 = _toString.call(state.dump); + var inblock = block; + var tagStr; + if (block) { + block = state.flowLevel < 0 || state.flowLevel > level; + } + var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate; + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) { + compact = false; + } + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = "*ref_" + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type2 === "[object Object]") { + if (block && Object.keys(state.dump).length !== 0) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + " " + state.dump; + } + } + } else if (type2 === "[object Array]") { + if (block && state.dump.length !== 0) { + if (state.noArrayIndent && !isblockseq && level > 0) { + writeBlockSequence(state, level - 1, state.dump, compact); + } else { + writeBlockSequence(state, level, state.dump, compact); + } + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, level, state.dump); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + " " + state.dump; + } + } + } else if (type2 === "[object String]") { + if (state.tag !== "?") { + writeScalar(state, state.dump, level, iskey, inblock); + } + } else if (type2 === "[object Undefined]") { + return false; + } else { + if (state.skipInvalid) return false; + throw new exception("unacceptable kind of an object to dump " + type2); + } + if (state.tag !== null && state.tag !== "?") { + tagStr = encodeURI( + state.tag[0] === "!" ? state.tag.slice(1) : state.tag + ).replace(/!/g, "%21"); + if (state.tag[0] === "!") { + tagStr = "!" + tagStr; + } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") { + tagStr = "!!" + tagStr.slice(18); + } else { + tagStr = "!<" + tagStr + ">"; + } + state.dump = tagStr + " " + state.dump; + } + } + return true; +} +function getDuplicateReferences(object, state) { + var objects = [], duplicatesIndexes = [], index2, length; + inspectNode(object, objects, duplicatesIndexes); + for (index2 = 0, length = duplicatesIndexes.length; index2 < length; index2 += 1) { + state.duplicates.push(objects[duplicatesIndexes[index2]]); + } + state.usedDuplicates = new Array(length); +} +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, index2, length; + if (object !== null && typeof object === "object") { + index2 = objects.indexOf(object); + if (index2 !== -1) { + if (duplicatesIndexes.indexOf(index2) === -1) { + duplicatesIndexes.push(index2); + } + } else { + objects.push(object); + if (Array.isArray(object)) { + for (index2 = 0, length = object.length; index2 < length; index2 += 1) { + inspectNode(object[index2], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + for (index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) { + inspectNode(object[objectKeyList[index2]], objects, duplicatesIndexes); + } + } + } + } +} +function dump$1(input, options) { + options = options || {}; + var state = new State(options); + if (!state.noRefs) getDuplicateReferences(input, state); + var value = input; + if (state.replacer) { + value = state.replacer.call({ "": value }, "", value); + } + if (writeNode(state, 0, value, true, true)) return state.dump + "\n"; + return ""; +} +var dump_1 = dump$1; +var dumper = { + dump: dump_1 +}; +function renamed(from2, to) { + return function() { + throw new Error("Function yaml." + from2 + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default."); + }; +} +var Type = type; +var Schema = schema; +var FAILSAFE_SCHEMA = failsafe; +var JSON_SCHEMA = json; +var CORE_SCHEMA = core; +var DEFAULT_SCHEMA = _default; +var load = loader.load; +var loadAll = loader.loadAll; +var dump = dumper.dump; +var YAMLException = exception; +var types = { + binary, + float, + map, + null: _null, + pairs, + set, + timestamp, + bool, + int, + merge, + omap, + seq, + str +}; +var safeLoad = renamed("safeLoad", "load"); +var safeLoadAll = renamed("safeLoadAll", "loadAll"); +var safeDump = renamed("safeDump", "dump"); +var jsYaml = { + Type, + Schema, + FAILSAFE_SCHEMA, + JSON_SCHEMA, + CORE_SCHEMA, + DEFAULT_SCHEMA, + load, + loadAll, + dump, + YAMLException, + types, + safeLoad, + safeLoadAll, + safeDump +}; + +// node_modules/@kubernetes/client-node/dist/config.js +var import_node_fetch2 = __toESM(require_lib2(), 1); +import net from "node:net"; +import path4 from "node:path"; + +// node_modules/@kubernetes/client-node/dist/azure_auth.js +import proc from "node:child_process"; + +// node_modules/jsonpath-plus/dist/index-node-esm.js +import vm from "vm"; +var Hooks = class { + /** + * @callback HookCallback + * @this {*|Jsep} this + * @param {Jsep} env + * @returns: void + */ + /** + * Adds the given callback to the list of callbacks for the given hook. + * + * The callback will be invoked when the hook it is registered for is run. + * + * One callback function can be registered to multiple hooks and the same hook multiple times. + * + * @param {string|object} name The name of the hook, or an object of callbacks keyed by name + * @param {HookCallback|boolean} callback The callback function which is given environment variables. + * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom) + * @public + */ + add(name, callback, first) { + if (typeof arguments[0] != "string") { + for (let name2 in arguments[0]) { + this.add(name2, arguments[0][name2], arguments[1]); + } + } else { + (Array.isArray(name) ? name : [name]).forEach(function(name2) { + this[name2] = this[name2] || []; + if (callback) { + this[name2][first ? "unshift" : "push"](callback); + } + }, this); + } + } + /** + * Runs a hook invoking all registered callbacks with the given environment variables. + * + * Callbacks will be invoked synchronously and in the order in which they were registered. + * + * @param {string} name The name of the hook. + * @param {Object} env The environment variables of the hook passed to all callbacks registered. + * @public + */ + run(name, env) { + this[name] = this[name] || []; + this[name].forEach(function(callback) { + callback.call(env && env.context ? env.context : env, env); + }); + } +}; +var Plugins = class { + constructor(jsep2) { + this.jsep = jsep2; + this.registered = {}; + } + /** + * @callback PluginSetup + * @this {Jsep} jsep + * @returns: void + */ + /** + * Adds the given plugin(s) to the registry + * + * @param {object} plugins + * @param {string} plugins.name The name of the plugin + * @param {PluginSetup} plugins.init The init function + * @public + */ + register(...plugins) { + plugins.forEach((plugin2) => { + if (typeof plugin2 !== "object" || !plugin2.name || !plugin2.init) { + throw new Error("Invalid JSEP plugin format"); + } + if (this.registered[plugin2.name]) { + return; + } + plugin2.init(this.jsep); + this.registered[plugin2.name] = plugin2; + }); + } +}; +var Jsep = class _Jsep { + /** + * @returns {string} + */ + static get version() { + return "1.4.0"; + } + /** + * @returns {string} + */ + static toString() { + return "JavaScript Expression Parser (JSEP) v" + _Jsep.version; + } + // ==================== CONFIG ================================ + /** + * @method addUnaryOp + * @param {string} op_name The name of the unary op to add + * @returns {Jsep} + */ + static addUnaryOp(op_name) { + _Jsep.max_unop_len = Math.max(op_name.length, _Jsep.max_unop_len); + _Jsep.unary_ops[op_name] = 1; + return _Jsep; + } + /** + * @method jsep.addBinaryOp + * @param {string} op_name The name of the binary op to add + * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence + * @param {boolean} [isRightAssociative=false] whether operator is right-associative + * @returns {Jsep} + */ + static addBinaryOp(op_name, precedence, isRightAssociative) { + _Jsep.max_binop_len = Math.max(op_name.length, _Jsep.max_binop_len); + _Jsep.binary_ops[op_name] = precedence; + if (isRightAssociative) { + _Jsep.right_associative.add(op_name); + } else { + _Jsep.right_associative.delete(op_name); + } + return _Jsep; + } + /** + * @method addIdentifierChar + * @param {string} char The additional character to treat as a valid part of an identifier + * @returns {Jsep} + */ + static addIdentifierChar(char) { + _Jsep.additional_identifier_chars.add(char); + return _Jsep; + } + /** + * @method addLiteral + * @param {string} literal_name The name of the literal to add + * @param {*} literal_value The value of the literal + * @returns {Jsep} + */ + static addLiteral(literal_name, literal_value) { + _Jsep.literals[literal_name] = literal_value; + return _Jsep; + } + /** + * @method removeUnaryOp + * @param {string} op_name The name of the unary op to remove + * @returns {Jsep} + */ + static removeUnaryOp(op_name) { + delete _Jsep.unary_ops[op_name]; + if (op_name.length === _Jsep.max_unop_len) { + _Jsep.max_unop_len = _Jsep.getMaxKeyLen(_Jsep.unary_ops); + } + return _Jsep; + } + /** + * @method removeAllUnaryOps + * @returns {Jsep} + */ + static removeAllUnaryOps() { + _Jsep.unary_ops = {}; + _Jsep.max_unop_len = 0; + return _Jsep; + } + /** + * @method removeIdentifierChar + * @param {string} char The additional character to stop treating as a valid part of an identifier + * @returns {Jsep} + */ + static removeIdentifierChar(char) { + _Jsep.additional_identifier_chars.delete(char); + return _Jsep; + } + /** + * @method removeBinaryOp + * @param {string} op_name The name of the binary op to remove + * @returns {Jsep} + */ + static removeBinaryOp(op_name) { + delete _Jsep.binary_ops[op_name]; + if (op_name.length === _Jsep.max_binop_len) { + _Jsep.max_binop_len = _Jsep.getMaxKeyLen(_Jsep.binary_ops); + } + _Jsep.right_associative.delete(op_name); + return _Jsep; + } + /** + * @method removeAllBinaryOps + * @returns {Jsep} + */ + static removeAllBinaryOps() { + _Jsep.binary_ops = {}; + _Jsep.max_binop_len = 0; + return _Jsep; + } + /** + * @method removeLiteral + * @param {string} literal_name The name of the literal to remove + * @returns {Jsep} + */ + static removeLiteral(literal_name) { + delete _Jsep.literals[literal_name]; + return _Jsep; + } + /** + * @method removeAllLiterals + * @returns {Jsep} + */ + static removeAllLiterals() { + _Jsep.literals = {}; + return _Jsep; + } + // ==================== END CONFIG ============================ + /** + * @returns {string} + */ + get char() { + return this.expr.charAt(this.index); + } + /** + * @returns {number} + */ + get code() { + return this.expr.charCodeAt(this.index); + } + /** + * @param {string} expr a string with the passed in express + * @returns Jsep + */ + constructor(expr) { + this.expr = expr; + this.index = 0; + } + /** + * static top-level parser + * @returns {jsep.Expression} + */ + static parse(expr) { + return new _Jsep(expr).parse(); + } + /** + * Get the longest key length of any object + * @param {object} obj + * @returns {number} + */ + static getMaxKeyLen(obj) { + return Math.max(0, ...Object.keys(obj).map((k) => k.length)); + } + /** + * `ch` is a character code in the next three functions + * @param {number} ch + * @returns {boolean} + */ + static isDecimalDigit(ch) { + return ch >= 48 && ch <= 57; + } + /** + * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float. + * @param {string} op_val + * @returns {number} + */ + static binaryPrecedence(op_val) { + return _Jsep.binary_ops[op_val] || 0; + } + /** + * Looks for start of identifier + * @param {number} ch + * @returns {boolean} + */ + static isIdentifierStart(ch) { + return ch >= 65 && ch <= 90 || // A...Z + ch >= 97 && ch <= 122 || // a...z + ch >= 128 && !_Jsep.binary_ops[String.fromCharCode(ch)] || // any non-ASCII that is not an operator + _Jsep.additional_identifier_chars.has(String.fromCharCode(ch)); + } + /** + * @param {number} ch + * @returns {boolean} + */ + static isIdentifierPart(ch) { + return _Jsep.isIdentifierStart(ch) || _Jsep.isDecimalDigit(ch); + } + /** + * throw error at index of the expression + * @param {string} message + * @throws + */ + throwError(message) { + const error2 = new Error(message + " at character " + this.index); + error2.index = this.index; + error2.description = message; + throw error2; + } + /** + * Run a given hook + * @param {string} name + * @param {jsep.Expression|false} [node] + * @returns {?jsep.Expression} + */ + runHook(name, node) { + if (_Jsep.hooks[name]) { + const env = { + context: this, + node + }; + _Jsep.hooks.run(name, env); + return env.node; + } + return node; + } + /** + * Runs a given hook until one returns a node + * @param {string} name + * @returns {?jsep.Expression} + */ + searchHook(name) { + if (_Jsep.hooks[name]) { + const env = { + context: this + }; + _Jsep.hooks[name].find(function(callback) { + callback.call(env.context, env); + return env.node; + }); + return env.node; + } + } + /** + * Push `index` up to the next non-space character + */ + gobbleSpaces() { + let ch = this.code; + while (ch === _Jsep.SPACE_CODE || ch === _Jsep.TAB_CODE || ch === _Jsep.LF_CODE || ch === _Jsep.CR_CODE) { + ch = this.expr.charCodeAt(++this.index); + } + this.runHook("gobble-spaces"); + } + /** + * Top-level method to parse all expressions and returns compound or single node + * @returns {jsep.Expression} + */ + parse() { + this.runHook("before-all"); + const nodes = this.gobbleExpressions(); + const node = nodes.length === 1 ? nodes[0] : { + type: _Jsep.COMPOUND, + body: nodes + }; + return this.runHook("after-all", node); + } + /** + * top-level parser (but can be reused within as well) + * @param {number} [untilICode] + * @returns {jsep.Expression[]} + */ + gobbleExpressions(untilICode) { + let nodes = [], ch_i, node; + while (this.index < this.expr.length) { + ch_i = this.code; + if (ch_i === _Jsep.SEMCOL_CODE || ch_i === _Jsep.COMMA_CODE) { + this.index++; + } else { + if (node = this.gobbleExpression()) { + nodes.push(node); + } else if (this.index < this.expr.length) { + if (ch_i === untilICode) { + break; + } + this.throwError('Unexpected "' + this.char + '"'); + } + } + } + return nodes; + } + /** + * The main parsing function. + * @returns {?jsep.Expression} + */ + gobbleExpression() { + const node = this.searchHook("gobble-expression") || this.gobbleBinaryExpression(); + this.gobbleSpaces(); + return this.runHook("after-expression", node); + } + /** + * Search for the operation portion of the string (e.g. `+`, `===`) + * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`) + * and move down from 3 to 2 to 1 character until a matching binary operation is found + * then, return that binary operation + * @returns {string|boolean} + */ + gobbleBinaryOp() { + this.gobbleSpaces(); + let to_check = this.expr.substr(this.index, _Jsep.max_binop_len); + let tc_len = to_check.length; + while (tc_len > 0) { + if (_Jsep.binary_ops.hasOwnProperty(to_check) && (!_Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !_Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) { + this.index += tc_len; + return to_check; + } + to_check = to_check.substr(0, --tc_len); + } + return false; + } + /** + * This function is responsible for gobbling an individual expression, + * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)` + * @returns {?jsep.BinaryExpression} + */ + gobbleBinaryExpression() { + let node, biop, prec, stack, biop_info, left, right, i, cur_biop; + left = this.gobbleToken(); + if (!left) { + return left; + } + biop = this.gobbleBinaryOp(); + if (!biop) { + return left; + } + biop_info = { + value: biop, + prec: _Jsep.binaryPrecedence(biop), + right_a: _Jsep.right_associative.has(biop) + }; + right = this.gobbleToken(); + if (!right) { + this.throwError("Expected expression after " + biop); + } + stack = [left, biop_info, right]; + while (biop = this.gobbleBinaryOp()) { + prec = _Jsep.binaryPrecedence(biop); + if (prec === 0) { + this.index -= biop.length; + break; + } + biop_info = { + value: biop, + prec, + right_a: _Jsep.right_associative.has(biop) + }; + cur_biop = biop; + const comparePrev = (prev) => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec; + while (stack.length > 2 && comparePrev(stack[stack.length - 2])) { + right = stack.pop(); + biop = stack.pop().value; + left = stack.pop(); + node = { + type: _Jsep.BINARY_EXP, + operator: biop, + left, + right + }; + stack.push(node); + } + node = this.gobbleToken(); + if (!node) { + this.throwError("Expected expression after " + cur_biop); + } + stack.push(biop_info, node); + } + i = stack.length - 1; + node = stack[i]; + while (i > 1) { + node = { + type: _Jsep.BINARY_EXP, + operator: stack[i - 1].value, + left: stack[i - 2], + right: node + }; + i -= 2; + } + return node; + } + /** + * An individual part of a binary expression: + * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis) + * @returns {boolean|jsep.Expression} + */ + gobbleToken() { + let ch, to_check, tc_len, node; + this.gobbleSpaces(); + node = this.searchHook("gobble-token"); + if (node) { + return this.runHook("after-token", node); + } + ch = this.code; + if (_Jsep.isDecimalDigit(ch) || ch === _Jsep.PERIOD_CODE) { + return this.gobbleNumericLiteral(); + } + if (ch === _Jsep.SQUOTE_CODE || ch === _Jsep.DQUOTE_CODE) { + node = this.gobbleStringLiteral(); + } else if (ch === _Jsep.OBRACK_CODE) { + node = this.gobbleArray(); + } else { + to_check = this.expr.substr(this.index, _Jsep.max_unop_len); + tc_len = to_check.length; + while (tc_len > 0) { + if (_Jsep.unary_ops.hasOwnProperty(to_check) && (!_Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !_Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) { + this.index += tc_len; + const argument = this.gobbleToken(); + if (!argument) { + this.throwError("missing unaryOp argument"); + } + return this.runHook("after-token", { + type: _Jsep.UNARY_EXP, + operator: to_check, + argument, + prefix: true + }); + } + to_check = to_check.substr(0, --tc_len); + } + if (_Jsep.isIdentifierStart(ch)) { + node = this.gobbleIdentifier(); + if (_Jsep.literals.hasOwnProperty(node.name)) { + node = { + type: _Jsep.LITERAL, + value: _Jsep.literals[node.name], + raw: node.name + }; + } else if (node.name === _Jsep.this_str) { + node = { + type: _Jsep.THIS_EXP + }; + } + } else if (ch === _Jsep.OPAREN_CODE) { + node = this.gobbleGroup(); + } + } + if (!node) { + return this.runHook("after-token", false); + } + node = this.gobbleTokenProperty(node); + return this.runHook("after-token", node); + } + /** + * Gobble properties of of identifiers/strings/arrays/groups. + * e.g. `foo`, `bar.baz`, `foo['bar'].baz` + * It also gobbles function calls: + * e.g. `Math.acos(obj.angle)` + * @param {jsep.Expression} node + * @returns {jsep.Expression} + */ + gobbleTokenProperty(node) { + this.gobbleSpaces(); + let ch = this.code; + while (ch === _Jsep.PERIOD_CODE || ch === _Jsep.OBRACK_CODE || ch === _Jsep.OPAREN_CODE || ch === _Jsep.QUMARK_CODE) { + let optional; + if (ch === _Jsep.QUMARK_CODE) { + if (this.expr.charCodeAt(this.index + 1) !== _Jsep.PERIOD_CODE) { + break; + } + optional = true; + this.index += 2; + this.gobbleSpaces(); + ch = this.code; + } + this.index++; + if (ch === _Jsep.OBRACK_CODE) { + node = { + type: _Jsep.MEMBER_EXP, + computed: true, + object: node, + property: this.gobbleExpression() + }; + if (!node.property) { + this.throwError('Unexpected "' + this.char + '"'); + } + this.gobbleSpaces(); + ch = this.code; + if (ch !== _Jsep.CBRACK_CODE) { + this.throwError("Unclosed ["); + } + this.index++; + } else if (ch === _Jsep.OPAREN_CODE) { + node = { + type: _Jsep.CALL_EXP, + "arguments": this.gobbleArguments(_Jsep.CPAREN_CODE), + callee: node + }; + } else if (ch === _Jsep.PERIOD_CODE || optional) { + if (optional) { + this.index--; + } + this.gobbleSpaces(); + node = { + type: _Jsep.MEMBER_EXP, + computed: false, + object: node, + property: this.gobbleIdentifier() + }; + } + if (optional) { + node.optional = true; + } + this.gobbleSpaces(); + ch = this.code; + } + return node; + } + /** + * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to + * keep track of everything in the numeric literal and then calling `parseFloat` on that string + * @returns {jsep.Literal} + */ + gobbleNumericLiteral() { + let number = "", ch, chCode; + while (_Jsep.isDecimalDigit(this.code)) { + number += this.expr.charAt(this.index++); + } + if (this.code === _Jsep.PERIOD_CODE) { + number += this.expr.charAt(this.index++); + while (_Jsep.isDecimalDigit(this.code)) { + number += this.expr.charAt(this.index++); + } + } + ch = this.char; + if (ch === "e" || ch === "E") { + number += this.expr.charAt(this.index++); + ch = this.char; + if (ch === "+" || ch === "-") { + number += this.expr.charAt(this.index++); + } + while (_Jsep.isDecimalDigit(this.code)) { + number += this.expr.charAt(this.index++); + } + if (!_Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) { + this.throwError("Expected exponent (" + number + this.char + ")"); + } + } + chCode = this.code; + if (_Jsep.isIdentifierStart(chCode)) { + this.throwError("Variable names cannot start with a number (" + number + this.char + ")"); + } else if (chCode === _Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === _Jsep.PERIOD_CODE) { + this.throwError("Unexpected period"); + } + return { + type: _Jsep.LITERAL, + value: parseFloat(number), + raw: number + }; + } + /** + * Parses a string literal, staring with single or double quotes with basic support for escape codes + * e.g. `"hello world"`, `'this is\nJSEP'` + * @returns {jsep.Literal} + */ + gobbleStringLiteral() { + let str2 = ""; + const startIndex = this.index; + const quote = this.expr.charAt(this.index++); + let closed = false; + while (this.index < this.expr.length) { + let ch = this.expr.charAt(this.index++); + if (ch === quote) { + closed = true; + break; + } else if (ch === "\\") { + ch = this.expr.charAt(this.index++); + switch (ch) { + case "n": + str2 += "\n"; + break; + case "r": + str2 += "\r"; + break; + case "t": + str2 += " "; + break; + case "b": + str2 += "\b"; + break; + case "f": + str2 += "\f"; + break; + case "v": + str2 += "\v"; + break; + default: + str2 += ch; + } + } else { + str2 += ch; + } + } + if (!closed) { + this.throwError('Unclosed quote after "' + str2 + '"'); + } + return { + type: _Jsep.LITERAL, + value: str2, + raw: this.expr.substring(startIndex, this.index) + }; + } + /** + * Gobbles only identifiers + * e.g.: `foo`, `_value`, `$x1` + * Also, this function checks if that identifier is a literal: + * (e.g. `true`, `false`, `null`) or `this` + * @returns {jsep.Identifier} + */ + gobbleIdentifier() { + let ch = this.code, start = this.index; + if (_Jsep.isIdentifierStart(ch)) { + this.index++; + } else { + this.throwError("Unexpected " + this.char); + } + while (this.index < this.expr.length) { + ch = this.code; + if (_Jsep.isIdentifierPart(ch)) { + this.index++; + } else { + break; + } + } + return { + type: _Jsep.IDENTIFIER, + name: this.expr.slice(start, this.index) + }; + } + /** + * Gobbles a list of arguments within the context of a function call + * or array literal. This function also assumes that the opening character + * `(` or `[` has already been gobbled, and gobbles expressions and commas + * until the terminator character `)` or `]` is encountered. + * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]` + * @param {number} termination + * @returns {jsep.Expression[]} + */ + gobbleArguments(termination) { + const args = []; + let closed = false; + let separator_count = 0; + while (this.index < this.expr.length) { + this.gobbleSpaces(); + let ch_i = this.code; + if (ch_i === termination) { + closed = true; + this.index++; + if (termination === _Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) { + this.throwError("Unexpected token " + String.fromCharCode(termination)); + } + break; + } else if (ch_i === _Jsep.COMMA_CODE) { + this.index++; + separator_count++; + if (separator_count !== args.length) { + if (termination === _Jsep.CPAREN_CODE) { + this.throwError("Unexpected token ,"); + } else if (termination === _Jsep.CBRACK_CODE) { + for (let arg = args.length; arg < separator_count; arg++) { + args.push(null); + } + } + } + } else if (args.length !== separator_count && separator_count !== 0) { + this.throwError("Expected comma"); + } else { + const node = this.gobbleExpression(); + if (!node || node.type === _Jsep.COMPOUND) { + this.throwError("Expected comma"); + } + args.push(node); + } + } + if (!closed) { + this.throwError("Expected " + String.fromCharCode(termination)); + } + return args; + } + /** + * Responsible for parsing a group of things within parentheses `()` + * that have no identifier in front (so not a function call) + * This function assumes that it needs to gobble the opening parenthesis + * and then tries to gobble everything within that parenthesis, assuming + * that the next thing it should see is the close parenthesis. If not, + * then the expression probably doesn't have a `)` + * @returns {boolean|jsep.Expression} + */ + gobbleGroup() { + this.index++; + let nodes = this.gobbleExpressions(_Jsep.CPAREN_CODE); + if (this.code === _Jsep.CPAREN_CODE) { + this.index++; + if (nodes.length === 1) { + return nodes[0]; + } else if (!nodes.length) { + return false; + } else { + return { + type: _Jsep.SEQUENCE_EXP, + expressions: nodes + }; + } + } else { + this.throwError("Unclosed ("); + } + } + /** + * Responsible for parsing Array literals `[1, 2, 3]` + * This function assumes that it needs to gobble the opening bracket + * and then tries to gobble the expressions as arguments. + * @returns {jsep.ArrayExpression} + */ + gobbleArray() { + this.index++; + return { + type: _Jsep.ARRAY_EXP, + elements: this.gobbleArguments(_Jsep.CBRACK_CODE) + }; + } +}; +var hooks = new Hooks(); +Object.assign(Jsep, { + hooks, + plugins: new Plugins(Jsep), + // Node Types + // ---------- + // This is the full set of types that any JSEP node can be. + // Store them here to save space when minified + COMPOUND: "Compound", + SEQUENCE_EXP: "SequenceExpression", + IDENTIFIER: "Identifier", + MEMBER_EXP: "MemberExpression", + LITERAL: "Literal", + THIS_EXP: "ThisExpression", + CALL_EXP: "CallExpression", + UNARY_EXP: "UnaryExpression", + BINARY_EXP: "BinaryExpression", + ARRAY_EXP: "ArrayExpression", + TAB_CODE: 9, + LF_CODE: 10, + CR_CODE: 13, + SPACE_CODE: 32, + PERIOD_CODE: 46, + // '.' + COMMA_CODE: 44, + // ',' + SQUOTE_CODE: 39, + // single quote + DQUOTE_CODE: 34, + // double quotes + OPAREN_CODE: 40, + // ( + CPAREN_CODE: 41, + // ) + OBRACK_CODE: 91, + // [ + CBRACK_CODE: 93, + // ] + QUMARK_CODE: 63, + // ? + SEMCOL_CODE: 59, + // ; + COLON_CODE: 58, + // : + // Operations + // ---------- + // Use a quickly-accessible map to store all of the unary operators + // Values are set to `1` (it really doesn't matter) + unary_ops: { + "-": 1, + "!": 1, + "~": 1, + "+": 1 + }, + // Also use a map for the binary operations but set their values to their + // binary precedence for quick reference (higher number = higher precedence) + // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) + binary_ops: { + "||": 1, + "??": 1, + "&&": 2, + "|": 3, + "^": 4, + "&": 5, + "==": 6, + "!=": 6, + "===": 6, + "!==": 6, + "<": 7, + ">": 7, + "<=": 7, + ">=": 7, + "<<": 8, + ">>": 8, + ">>>": 8, + "+": 9, + "-": 9, + "*": 10, + "/": 10, + "%": 10, + "**": 11 + }, + // sets specific binary_ops as right-associative + right_associative: /* @__PURE__ */ new Set(["**"]), + // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char) + additional_identifier_chars: /* @__PURE__ */ new Set(["$", "_"]), + // Literals + // ---------- + // Store the values to return for the various literals we may encounter + literals: { + "true": true, + "false": false, + "null": null + }, + // Except for `this`, which is special. This could be changed to something like `'self'` as well + this_str: "this" +}); +Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops); +Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops); +var jsep = (expr) => new Jsep(expr).parse(); +var stdClassProps = Object.getOwnPropertyNames(class Test { +}); +Object.getOwnPropertyNames(Jsep).filter((prop) => !stdClassProps.includes(prop) && jsep[prop] === void 0).forEach((m) => { + jsep[m] = Jsep[m]; +}); +jsep.Jsep = Jsep; +var CONDITIONAL_EXP = "ConditionalExpression"; +var ternary = { + name: "ternary", + init(jsep2) { + jsep2.hooks.add("after-expression", function gobbleTernary(env) { + if (env.node && this.code === jsep2.QUMARK_CODE) { + this.index++; + const test = env.node; + const consequent = this.gobbleExpression(); + if (!consequent) { + this.throwError("Expected expression"); + } + this.gobbleSpaces(); + if (this.code === jsep2.COLON_CODE) { + this.index++; + const alternate = this.gobbleExpression(); + if (!alternate) { + this.throwError("Expected expression"); + } + env.node = { + type: CONDITIONAL_EXP, + test, + consequent, + alternate + }; + if (test.operator && jsep2.binary_ops[test.operator] <= 0.9) { + let newTest = test; + while (newTest.right.operator && jsep2.binary_ops[newTest.right.operator] <= 0.9) { + newTest = newTest.right; + } + env.node.test = newTest.right; + newTest.right = env.node; + env.node = test; + } + } else { + this.throwError("Expected :"); + } + } + }); + } +}; +jsep.plugins.register(ternary); +var FSLASH_CODE = 47; +var BSLASH_CODE = 92; +var index = { + name: "regex", + init(jsep2) { + jsep2.hooks.add("gobble-token", function gobbleRegexLiteral(env) { + if (this.code === FSLASH_CODE) { + const patternIndex = ++this.index; + let inCharSet = false; + while (this.index < this.expr.length) { + if (this.code === FSLASH_CODE && !inCharSet) { + const pattern = this.expr.slice(patternIndex, this.index); + let flags = ""; + while (++this.index < this.expr.length) { + const code = this.code; + if (code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57) { + flags += this.char; + } else { + break; + } + } + let value; + try { + value = new RegExp(pattern, flags); + } catch (e2) { + this.throwError(e2.message); + } + env.node = { + type: jsep2.LITERAL, + value, + raw: this.expr.slice(patternIndex - 1, this.index) + }; + env.node = this.gobbleTokenProperty(env.node); + return env.node; + } + if (this.code === jsep2.OBRACK_CODE) { + inCharSet = true; + } else if (inCharSet && this.code === jsep2.CBRACK_CODE) { + inCharSet = false; + } + this.index += this.code === BSLASH_CODE ? 2 : 1; + } + this.throwError("Unclosed Regex"); + } + }); + } +}; +var PLUS_CODE = 43; +var MINUS_CODE = 45; +var plugin = { + name: "assignment", + assignmentOperators: /* @__PURE__ */ new Set(["=", "*=", "**=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=", "||=", "&&=", "??="]), + updateOperators: [PLUS_CODE, MINUS_CODE], + assignmentPrecedence: 0.9, + init(jsep2) { + const updateNodeTypes = [jsep2.IDENTIFIER, jsep2.MEMBER_EXP]; + plugin.assignmentOperators.forEach((op) => jsep2.addBinaryOp(op, plugin.assignmentPrecedence, true)); + jsep2.hooks.add("gobble-token", function gobbleUpdatePrefix(env) { + const code = this.code; + if (plugin.updateOperators.some((c) => c === code && c === this.expr.charCodeAt(this.index + 1))) { + this.index += 2; + env.node = { + type: "UpdateExpression", + operator: code === PLUS_CODE ? "++" : "--", + argument: this.gobbleTokenProperty(this.gobbleIdentifier()), + prefix: true + }; + if (!env.node.argument || !updateNodeTypes.includes(env.node.argument.type)) { + this.throwError(`Unexpected ${env.node.operator}`); + } + } + }); + jsep2.hooks.add("after-token", function gobbleUpdatePostfix(env) { + if (env.node) { + const code = this.code; + if (plugin.updateOperators.some((c) => c === code && c === this.expr.charCodeAt(this.index + 1))) { + if (!updateNodeTypes.includes(env.node.type)) { + this.throwError(`Unexpected ${env.node.operator}`); + } + this.index += 2; + env.node = { + type: "UpdateExpression", + operator: code === PLUS_CODE ? "++" : "--", + argument: env.node, + prefix: false + }; + } + } + }); + jsep2.hooks.add("after-expression", function gobbleAssignment(env) { + if (env.node) { + updateBinariesToAssignments(env.node); + } + }); + function updateBinariesToAssignments(node) { + if (plugin.assignmentOperators.has(node.operator)) { + node.type = "AssignmentExpression"; + updateBinariesToAssignments(node.left); + updateBinariesToAssignments(node.right); + } else if (!node.operator) { + Object.values(node).forEach((val) => { + if (val && typeof val === "object") { + updateBinariesToAssignments(val); + } + }); + } + } + } +}; +jsep.plugins.register(index, plugin); +jsep.addUnaryOp("typeof"); +jsep.addUnaryOp("void"); +jsep.addLiteral("null", null); +jsep.addLiteral("undefined", void 0); +var BLOCKED_PROTO_PROPERTIES = /* @__PURE__ */ new Set(["constructor", "__proto__", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"]); +var SafeEval = { + /** + * @param {jsep.Expression} ast + * @param {Record} subs + */ + evalAst(ast, subs) { + switch (ast.type) { + case "BinaryExpression": + case "LogicalExpression": + return SafeEval.evalBinaryExpression(ast, subs); + case "Compound": + return SafeEval.evalCompound(ast, subs); + case "ConditionalExpression": + return SafeEval.evalConditionalExpression(ast, subs); + case "Identifier": + return SafeEval.evalIdentifier(ast, subs); + case "Literal": + return SafeEval.evalLiteral(ast, subs); + case "MemberExpression": + return SafeEval.evalMemberExpression(ast, subs); + case "UnaryExpression": + return SafeEval.evalUnaryExpression(ast, subs); + case "ArrayExpression": + return SafeEval.evalArrayExpression(ast, subs); + case "CallExpression": + return SafeEval.evalCallExpression(ast, subs); + case "AssignmentExpression": + return SafeEval.evalAssignmentExpression(ast, subs); + default: + throw SyntaxError("Unexpected expression", ast); + } + }, + evalBinaryExpression(ast, subs) { + const result = { + "||": (a, b) => a || b(), + "&&": (a, b) => a && b(), + "|": (a, b) => a | b(), + "^": (a, b) => a ^ b(), + "&": (a, b) => a & b(), + // eslint-disable-next-line eqeqeq -- API + "==": (a, b) => a == b(), + // eslint-disable-next-line eqeqeq -- API + "!=": (a, b) => a != b(), + "===": (a, b) => a === b(), + "!==": (a, b) => a !== b(), + "<": (a, b) => a < b(), + ">": (a, b) => a > b(), + "<=": (a, b) => a <= b(), + ">=": (a, b) => a >= b(), + "<<": (a, b) => a << b(), + ">>": (a, b) => a >> b(), + ">>>": (a, b) => a >>> b(), + "+": (a, b) => a + b(), + "-": (a, b) => a - b(), + "*": (a, b) => a * b(), + "/": (a, b) => a / b(), + "%": (a, b) => a % b() + }[ast.operator](SafeEval.evalAst(ast.left, subs), () => SafeEval.evalAst(ast.right, subs)); + return result; + }, + evalCompound(ast, subs) { + let last; + for (let i = 0; i < ast.body.length; i++) { + if (ast.body[i].type === "Identifier" && ["var", "let", "const"].includes(ast.body[i].name) && ast.body[i + 1] && ast.body[i + 1].type === "AssignmentExpression") { + i += 1; + } + const expr = ast.body[i]; + last = SafeEval.evalAst(expr, subs); + } + return last; + }, + evalConditionalExpression(ast, subs) { + if (SafeEval.evalAst(ast.test, subs)) { + return SafeEval.evalAst(ast.consequent, subs); + } + return SafeEval.evalAst(ast.alternate, subs); + }, + evalIdentifier(ast, subs) { + if (Object.hasOwn(subs, ast.name)) { + return subs[ast.name]; + } + throw ReferenceError(`${ast.name} is not defined`); + }, + evalLiteral(ast) { + return ast.value; + }, + evalMemberExpression(ast, subs) { + const prop = String( + // NOTE: `String(value)` throws error when + // value has overwritten the toString method to return non-string + // i.e. `value = {toString: () => []}` + ast.computed ? SafeEval.evalAst(ast.property) : ast.property.name + // `object.property` property is Identifier + ); + const obj = SafeEval.evalAst(ast.object, subs); + if (obj === void 0 || obj === null) { + throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`); + } + if (!Object.hasOwn(obj, prop) && BLOCKED_PROTO_PROPERTIES.has(prop)) { + throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`); + } + const result = obj[prop]; + if (typeof result === "function") { + return result.bind(obj); + } + return result; + }, + evalUnaryExpression(ast, subs) { + const result = { + "-": (a) => -SafeEval.evalAst(a, subs), + "!": (a) => !SafeEval.evalAst(a, subs), + "~": (a) => ~SafeEval.evalAst(a, subs), + // eslint-disable-next-line no-implicit-coercion -- API + "+": (a) => +SafeEval.evalAst(a, subs), + typeof: (a) => typeof SafeEval.evalAst(a, subs), + // eslint-disable-next-line no-void, sonarjs/void-use -- feature + void: (a) => void SafeEval.evalAst(a, subs) + }[ast.operator](ast.argument); + return result; + }, + evalArrayExpression(ast, subs) { + return ast.elements.map((el) => SafeEval.evalAst(el, subs)); + }, + evalCallExpression(ast, subs) { + const args = ast.arguments.map((arg) => SafeEval.evalAst(arg, subs)); + const func = SafeEval.evalAst(ast.callee, subs); + if (func === Function) { + throw new Error("Function constructor is disabled"); + } + return func(...args); + }, + evalAssignmentExpression(ast, subs) { + if (ast.left.type !== "Identifier") { + throw SyntaxError("Invalid left-hand side in assignment"); + } + const id = ast.left.name; + const value = SafeEval.evalAst(ast.right, subs); + subs[id] = value; + return subs[id]; + } +}; +var SafeScript = class { + /** + * @param {string} expr Expression to evaluate + */ + constructor(expr) { + this.code = expr; + this.ast = jsep(this.code); + } + /** + * @param {object} context Object whose items will be added + * to evaluation + * @returns {EvaluatedResult} Result of evaluated code + */ + runInNewContext(context) { + const keyMap = Object.assign(/* @__PURE__ */ Object.create(null), context); + return SafeEval.evalAst(this.ast, keyMap); + } +}; +function push(arr, item) { + arr = arr.slice(); + arr.push(item); + return arr; +} +function unshift(item, arr) { + arr = arr.slice(); + arr.unshift(item); + return arr; +} +var NewError = class extends Error { + /** + * @param {AnyResult} value The evaluated scalar value + */ + constructor(value) { + super('JSONPath should not be called with "new" (it prevents return of (unwrapped) scalar values)'); + this.avoidNew = true; + this.value = value; + this.name = "NewError"; + } +}; +function JSONPath(opts, expr, obj, callback, otherTypeCallback) { + if (!(this instanceof JSONPath)) { + try { + return new JSONPath(opts, expr, obj, callback, otherTypeCallback); + } catch (e2) { + if (!e2.avoidNew) { + throw e2; + } + return e2.value; + } + } + if (typeof opts === "string") { + otherTypeCallback = callback; + callback = obj; + obj = expr; + expr = opts; + opts = null; + } + const optObj = opts && typeof opts === "object"; + opts = opts || {}; + this.json = opts.json || obj; + this.path = opts.path || expr; + this.resultType = opts.resultType || "value"; + this.flatten = opts.flatten || false; + this.wrap = Object.hasOwn(opts, "wrap") ? opts.wrap : true; + this.sandbox = opts.sandbox || {}; + this.eval = opts.eval === void 0 ? "safe" : opts.eval; + this.ignoreEvalErrors = typeof opts.ignoreEvalErrors === "undefined" ? false : opts.ignoreEvalErrors; + this.parent = opts.parent || null; + this.parentProperty = opts.parentProperty || null; + this.callback = opts.callback || callback || null; + this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function() { + throw new TypeError("You must supply an otherTypeCallback callback option with the @other() operator."); + }; + if (opts.autostart !== false) { + const args = { + path: optObj ? opts.path : expr + }; + if (!optObj) { + args.json = obj; + } else if ("json" in opts) { + args.json = opts.json; + } + const ret = this.evaluate(args); + if (!ret || typeof ret !== "object") { + throw new NewError(ret); + } + return ret; + } +} +JSONPath.prototype.evaluate = function(expr, json2, callback, otherTypeCallback) { + let currParent = this.parent, currParentProperty = this.parentProperty; + let { + flatten, + wrap + } = this; + this.currResultType = this.resultType; + this.currEval = this.eval; + this.currSandbox = this.sandbox; + callback = callback || this.callback; + this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback; + json2 = json2 || this.json; + expr = expr || this.path; + if (expr && typeof expr === "object" && !Array.isArray(expr)) { + if (!expr.path && expr.path !== "") { + throw new TypeError('You must supply a "path" property when providing an object argument to JSONPath.evaluate().'); + } + if (!Object.hasOwn(expr, "json")) { + throw new TypeError('You must supply a "json" property when providing an object argument to JSONPath.evaluate().'); + } + ({ + json: json2 + } = expr); + flatten = Object.hasOwn(expr, "flatten") ? expr.flatten : flatten; + this.currResultType = Object.hasOwn(expr, "resultType") ? expr.resultType : this.currResultType; + this.currSandbox = Object.hasOwn(expr, "sandbox") ? expr.sandbox : this.currSandbox; + wrap = Object.hasOwn(expr, "wrap") ? expr.wrap : wrap; + this.currEval = Object.hasOwn(expr, "eval") ? expr.eval : this.currEval; + callback = Object.hasOwn(expr, "callback") ? expr.callback : callback; + this.currOtherTypeCallback = Object.hasOwn(expr, "otherTypeCallback") ? expr.otherTypeCallback : this.currOtherTypeCallback; + currParent = Object.hasOwn(expr, "parent") ? expr.parent : currParent; + currParentProperty = Object.hasOwn(expr, "parentProperty") ? expr.parentProperty : currParentProperty; + expr = expr.path; + } + currParent = currParent || null; + currParentProperty = currParentProperty || null; + if (Array.isArray(expr)) { + expr = JSONPath.toPathString(expr); + } + if (!expr && expr !== "" || !json2) { + return void 0; + } + const exprList = JSONPath.toPathArray(expr); + if (exprList[0] === "$" && exprList.length > 1) { + exprList.shift(); + } + this._hasParentSelector = null; + const result = this._trace(exprList, json2, ["$"], currParent, currParentProperty, callback).filter(function(ea) { + return ea && !ea.isParentSelector; + }); + if (!result.length) { + return wrap ? [] : void 0; + } + if (!wrap && result.length === 1 && !result[0].hasArrExpr) { + return this._getPreferredOutput(result[0]); + } + return result.reduce((rslt, ea) => { + const valOrPath = this._getPreferredOutput(ea); + if (flatten && Array.isArray(valOrPath)) { + rslt = rslt.concat(valOrPath); + } else { + rslt.push(valOrPath); + } + return rslt; + }, []); +}; +JSONPath.prototype._getPreferredOutput = function(ea) { + const resultType = this.currResultType; + switch (resultType) { + case "all": { + const path7 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path); + ea.pointer = JSONPath.toPointer(path7); + ea.path = typeof ea.path === "string" ? ea.path : JSONPath.toPathString(ea.path); + return ea; + } + case "value": + case "parent": + case "parentProperty": + return ea[resultType]; + case "path": + return JSONPath.toPathString(ea[resultType]); + case "pointer": + return JSONPath.toPointer(ea.path); + default: + throw new TypeError("Unknown result type"); + } +}; +JSONPath.prototype._handleCallback = function(fullRetObj, callback, type2) { + if (callback) { + const preferredOutput = this._getPreferredOutput(fullRetObj); + fullRetObj.path = typeof fullRetObj.path === "string" ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path); + callback(preferredOutput, type2, fullRetObj); + } +}; +JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, callback, hasArrExpr, literalPriority) { + let retObj; + if (!expr.length) { + retObj = { + path: path7, + value: val, + parent, + parentProperty: parentPropName, + hasArrExpr + }; + this._handleCallback(retObj, callback, "value"); + return retObj; + } + const loc = expr[0], x = expr.slice(1); + const ret = []; + function addRet(elems) { + if (Array.isArray(elems)) { + elems.forEach((t) => { + ret.push(t); + }); + } else { + ret.push(elems); + } + } + if ((typeof loc !== "string" || literalPriority) && val && Object.hasOwn(val, loc)) { + addRet(this._trace(x, val[loc], push(path7, loc), val, loc, callback, hasArrExpr)); + } else if (loc === "*") { + this._walk(val, (m) => { + addRet(this._trace(x, val[m], push(path7, m), val, m, callback, true, true)); + }); + } else if (loc === "..") { + addRet(this._trace(x, val, path7, parent, parentPropName, callback, hasArrExpr)); + this._walk(val, (m) => { + if (typeof val[m] === "object") { + addRet(this._trace(expr.slice(), val[m], push(path7, m), val, m, callback, true)); + } + }); + } else if (loc === "^") { + this._hasParentSelector = true; + return { + path: path7.slice(0, -1), + expr: x, + isParentSelector: true + }; + } else if (loc === "~") { + retObj = { + path: push(path7, loc), + value: parentPropName, + parent, + parentProperty: null + }; + this._handleCallback(retObj, callback, "property"); + return retObj; + } else if (loc === "$") { + addRet(this._trace(x, val, path7, null, null, callback, hasArrExpr)); + } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) { + addRet(this._slice(loc, x, val, path7, parent, parentPropName, callback)); + } else if (loc.indexOf("?(") === 0) { + if (this.currEval === false) { + throw new Error("Eval [?(expr)] prevented in JSONPath expression."); + } + const safeLoc = loc.replace(/^\?\((.*?)\)$/u, "$1"); + const nested = /@.?([^?]*)[['](\??\(.*?\))(?!.\)\])[\]']/gu.exec(safeLoc); + if (nested) { + this._walk(val, (m) => { + const npath = [nested[2]]; + const nvalue = nested[1] ? val[m][nested[1]] : val[m]; + const filterResults = this._trace(npath, nvalue, path7, parent, parentPropName, callback, true); + if (filterResults.length > 0) { + addRet(this._trace(x, val[m], push(path7, m), val, m, callback, true)); + } + }); + } else { + this._walk(val, (m) => { + if (this._eval(safeLoc, val[m], m, path7, parent, parentPropName)) { + addRet(this._trace(x, val[m], push(path7, m), val, m, callback, true)); + } + }); + } + } else if (loc[0] === "(") { + if (this.currEval === false) { + throw new Error("Eval [(expr)] prevented in JSONPath expression."); + } + addRet(this._trace(unshift(this._eval(loc, val, path7.at(-1), path7.slice(0, -1), parent, parentPropName), x), val, path7, parent, parentPropName, callback, hasArrExpr)); + } else if (loc[0] === "@") { + let addType = false; + const valueType = loc.slice(1, -2); + switch (valueType) { + case "scalar": + if (!val || !["object", "function"].includes(typeof val)) { + addType = true; + } + break; + case "boolean": + case "string": + case "undefined": + case "function": + if (typeof val === valueType) { + addType = true; + } + break; + case "integer": + if (Number.isFinite(val) && !(val % 1)) { + addType = true; + } + break; + case "number": + if (Number.isFinite(val)) { + addType = true; + } + break; + case "nonFinite": + if (typeof val === "number" && !Number.isFinite(val)) { + addType = true; + } + break; + case "object": + if (val && typeof val === valueType) { + addType = true; + } + break; + case "array": + if (Array.isArray(val)) { + addType = true; + } + break; + case "other": + addType = this.currOtherTypeCallback(val, path7, parent, parentPropName); + break; + case "null": + if (val === null) { + addType = true; + } + break; + /* c8 ignore next 2 */ + default: + throw new TypeError("Unknown value type " + valueType); + } + if (addType) { + retObj = { + path: path7, + value: val, + parent, + parentProperty: parentPropName + }; + this._handleCallback(retObj, callback, "value"); + return retObj; + } + } else if (loc[0] === "`" && val && Object.hasOwn(val, loc.slice(1))) { + const locProp = loc.slice(1); + addRet(this._trace(x, val[locProp], push(path7, locProp), val, locProp, callback, hasArrExpr, true)); + } else if (loc.includes(",")) { + const parts = loc.split(","); + for (const part of parts) { + addRet(this._trace(unshift(part, x), val, path7, parent, parentPropName, callback, true)); + } + } else if (!literalPriority && val && Object.hasOwn(val, loc)) { + addRet(this._trace(x, val[loc], push(path7, loc), val, loc, callback, hasArrExpr, true)); + } + if (this._hasParentSelector) { + for (let t = 0; t < ret.length; t++) { + const rett = ret[t]; + if (rett && rett.isParentSelector) { + const tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr); + if (Array.isArray(tmp)) { + ret[t] = tmp[0]; + const tl = tmp.length; + for (let tt = 1; tt < tl; tt++) { + t++; + ret.splice(t, 0, tmp[tt]); + } + } else { + ret[t] = tmp; + } + } + } + } + return ret; +}; +JSONPath.prototype._walk = function(val, f) { + if (Array.isArray(val)) { + const n = val.length; + for (let i = 0; i < n; i++) { + f(i); + } + } else if (val && typeof val === "object") { + Object.keys(val).forEach((m) => { + f(m); + }); + } +}; +JSONPath.prototype._slice = function(loc, expr, val, path7, parent, parentPropName, callback) { + if (!Array.isArray(val)) { + return void 0; + } + const len = val.length, parts = loc.split(":"), step = parts[2] && Number.parseInt(parts[2]) || 1; + let start = parts[0] && Number.parseInt(parts[0]) || 0, end = parts[1] && Number.parseInt(parts[1]) || len; + start = start < 0 ? Math.max(0, start + len) : Math.min(len, start); + end = end < 0 ? Math.max(0, end + len) : Math.min(len, end); + const ret = []; + for (let i = start; i < end; i += step) { + const tmp = this._trace(unshift(i, expr), val, path7, parent, parentPropName, callback, true); + tmp.forEach((t) => { + ret.push(t); + }); + } + return ret; +}; +JSONPath.prototype._eval = function(code, _v, _vname, path7, parent, parentPropName) { + this.currSandbox._$_parentProperty = parentPropName; + this.currSandbox._$_parent = parent; + this.currSandbox._$_property = _vname; + this.currSandbox._$_root = this.json; + this.currSandbox._$_v = _v; + const containsPath = code.includes("@path"); + if (containsPath) { + this.currSandbox._$_path = JSONPath.toPathString(path7.concat([_vname])); + } + const scriptCacheKey = this.currEval + "Script:" + code; + if (!JSONPath.cache[scriptCacheKey]) { + let script = code.replaceAll("@parentProperty", "_$_parentProperty").replaceAll("@parent", "_$_parent").replaceAll("@property", "_$_property").replaceAll("@root", "_$_root").replaceAll(/@([.\s)[])/gu, "_$_v$1"); + if (containsPath) { + script = script.replaceAll("@path", "_$_path"); + } + if (this.currEval === "safe" || this.currEval === true || this.currEval === void 0) { + JSONPath.cache[scriptCacheKey] = new this.safeVm.Script(script); + } else if (this.currEval === "native") { + JSONPath.cache[scriptCacheKey] = new this.vm.Script(script); + } else if (typeof this.currEval === "function" && this.currEval.prototype && Object.hasOwn(this.currEval.prototype, "runInNewContext")) { + const CurrEval = this.currEval; + JSONPath.cache[scriptCacheKey] = new CurrEval(script); + } else if (typeof this.currEval === "function") { + JSONPath.cache[scriptCacheKey] = { + runInNewContext: (context) => this.currEval(script, context) + }; + } else { + throw new TypeError(`Unknown "eval" property "${this.currEval}"`); + } + } + try { + return JSONPath.cache[scriptCacheKey].runInNewContext(this.currSandbox); + } catch (e2) { + if (this.ignoreEvalErrors) { + return false; + } + throw new Error("jsonPath: " + e2.message + ": " + code); + } +}; +JSONPath.cache = {}; +JSONPath.toPathString = function(pathArr) { + const x = pathArr, n = x.length; + let p = "$"; + for (let i = 1; i < n; i++) { + if (!/^(~|\^|@.*?\(\))$/u.test(x[i])) { + p += /^[0-9*]+$/u.test(x[i]) ? "[" + x[i] + "]" : "['" + x[i] + "']"; + } + } + return p; +}; +JSONPath.toPointer = function(pointer) { + const x = pointer, n = x.length; + let p = ""; + for (let i = 1; i < n; i++) { + if (!/^(~|\^|@.*?\(\))$/u.test(x[i])) { + p += "/" + x[i].toString().replaceAll("~", "~0").replaceAll("/", "~1"); + } + } + return p; +}; +JSONPath.toPathArray = function(expr) { + const { + cache + } = JSONPath; + if (cache[expr]) { + return cache[expr].concat(); + } + const subx = []; + const normalized = expr.replaceAll(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/gu, ";$&;").replaceAll(/[['](\??\(.*?\))[\]'](?!.\])/gu, function($0, $1) { + return "[#" + (subx.push($1) - 1) + "]"; + }).replaceAll(/\[['"]([^'\]]*)['"]\]/gu, function($0, prop) { + return "['" + prop.replaceAll(".", "%@%").replaceAll("~", "%%@@%%") + "']"; + }).replaceAll("~", ";~;").replaceAll(/['"]?\.['"]?(?![^[]*\])|\[['"]?/gu, ";").replaceAll("%@%", ".").replaceAll("%%@@%%", "~").replaceAll(/(?:;)?(\^+)(?:;)?/gu, function($0, ups) { + return ";" + ups.split("").join(";") + ";"; + }).replaceAll(/;;;|;;/gu, ";..;").replaceAll(/;$|'?\]|'$/gu, ""); + const exprList = normalized.split(";").map(function(exp) { + const match = exp.match(/#(\d+)/u); + return !match || !match[1] ? exp : subx[match[1]]; + }); + cache[expr] = exprList; + return cache[expr].concat(); +}; +JSONPath.prototype.safeVm = { + Script: SafeScript +}; +JSONPath.prototype.vm = vm; + +// node_modules/@kubernetes/client-node/dist/azure_auth.js +var AzureAuth = class { + isAuthProvider(user) { + if (!user || !user.authProvider) { + return false; + } + return user.authProvider.name === "azure"; + } + async applyAuthentication(user, opts) { + const token = this.getToken(user); + if (token) { + opts.headers["Authorization"] = `Bearer ${token}`; + } + } + getToken(user) { + const config = user.authProvider.config; + if (this.isExpired(config)) { + this.updateAccessToken(config); + } + return config["access-token"]; + } + isExpired(config) { + const token = config["access-token"]; + const expiry = config.expiry; + const expiresOn = config["expires-on"]; + if (!token) { + return true; + } + if (!expiry && !expiresOn) { + return false; + } + const expiresOnDate = expiresOn ? new Date(parseInt(expiresOn, 10) * 1e3) : void 0; + const expiration = expiry ? Date.parse(expiry) : expiresOnDate.getTime(); + if (expiration < Date.now()) { + return true; + } + return false; + } + updateAccessToken(config) { + let cmd = config["cmd-path"]; + if (!cmd) { + throw new Error("Token is expired!"); + } + cmd = `"${cmd}"`; + const args = config["cmd-args"]; + if (args) { + cmd = cmd + " " + args; + } + let output; + try { + output = proc.execSync(cmd); + } catch (err) { + throw new Error("Failed to refresh token: " + err); + } + const resultObj = JSON.parse(output); + const tokenPathKeyInConfig = config["token-key"]; + const expiryPathKeyInConfig = config["expiry-key"]; + const tokenPathKey = "$" + tokenPathKeyInConfig.slice(1, -1); + const expiryPathKey = "$" + expiryPathKeyInConfig.slice(1, -1); + config["access-token"] = JSONPath({ path: tokenPathKey, json: resultObj }); + config.expiry = JSONPath({ path: expiryPathKey, json: resultObj }); + } +}; + +// node_modules/@kubernetes/client-node/dist/config_types.js +import fs3 from "node:fs"; +var ActionOnInvalid = { + THROW: "throw", + FILTER: "filter" +}; +function defaultNewConfigOptions() { + return { + onInvalidEntry: ActionOnInvalid.THROW + }; +} +function newClusters(a, opts) { + if (!Array.isArray(a)) { + return []; + } + const options = Object.assign(defaultNewConfigOptions(), opts || {}); + return a.map(clusterIterator(options.onInvalidEntry)).filter(Boolean); +} +function exportCluster(cluster) { + return { + name: cluster.name, + cluster: { + server: cluster.server, + "certificate-authority-data": cluster.caData, + "certificate-authority": cluster.caFile, + "insecure-skip-tls-verify": cluster.skipTLSVerify, + "tls-server-name": cluster.tlsServerName, + "proxy-url": cluster.proxyUrl + } + }; +} +function clusterIterator(onInvalidEntry) { + return (elt, i, list) => { + try { + if (!elt.name) { + throw new Error(`clusters[${i}].name is missing`); + } + if (!elt.cluster) { + throw new Error(`clusters[${i}].cluster is missing`); + } + if (!elt.cluster.server) { + throw new Error(`clusters[${i}].cluster.server is missing`); + } + return { + caData: elt.cluster["certificate-authority-data"], + caFile: elt.cluster["certificate-authority"], + name: elt.name, + server: elt.cluster.server.replace(/\/$/, ""), + skipTLSVerify: elt.cluster["insecure-skip-tls-verify"] === true, + tlsServerName: elt.cluster["tls-server-name"], + proxyUrl: elt.cluster["proxy-url"] + }; + } catch (err) { + switch (onInvalidEntry) { + case ActionOnInvalid.FILTER: + return null; + default: + case ActionOnInvalid.THROW: + throw err; + } + } + }; +} +function newUsers(a, opts) { + if (!Array.isArray(a)) { + return []; + } + const options = Object.assign(defaultNewConfigOptions(), opts || {}); + return a.map(userIterator(options.onInvalidEntry)).filter(Boolean); +} +function exportUser(user) { + return { + name: user.name, + user: { + as: user.impersonateUser, + "auth-provider": user.authProvider, + "client-certificate-data": user.certData, + "client-certificate": user.certFile, + exec: user.exec, + "client-key-data": user.keyData, + "client-key": user.keyFile, + token: user.token, + password: user.password, + username: user.username + } + }; +} +function userIterator(onInvalidEntry) { + return (elt, i, list) => { + try { + if (!elt.name) { + throw new Error(`users[${i}].name is missing`); + } + return { + authProvider: elt.user ? elt.user["auth-provider"] : null, + certData: elt.user ? elt.user["client-certificate-data"] : null, + certFile: elt.user ? elt.user["client-certificate"] : null, + exec: elt.user ? elt.user.exec : null, + keyData: elt.user ? elt.user["client-key-data"] : null, + keyFile: elt.user ? elt.user["client-key"] : null, + name: elt.name, + token: findToken(elt.user), + password: elt.user ? elt.user.password : null, + username: elt.user ? elt.user.username : null, + impersonateUser: elt.user ? elt.user.as : null + }; + } catch (err) { + switch (onInvalidEntry) { + case ActionOnInvalid.FILTER: + return null; + default: + case ActionOnInvalid.THROW: + throw err; + } + } + }; +} +function findToken(user) { + if (user) { + if (user.token) { + return user.token; + } + if (user["token-file"]) { + return fs3.readFileSync(user["token-file"]).toString(); + } + } +} +function newContexts(a, opts) { + if (!Array.isArray(a)) { + return []; + } + const options = Object.assign(defaultNewConfigOptions(), opts || {}); + return a.map(contextIterator(options.onInvalidEntry)).filter(Boolean); +} +function exportContext(ctx) { + return { + name: ctx.name, + context: ctx + }; +} +function contextIterator(onInvalidEntry) { + return (elt, i, list) => { + try { + if (!elt.name) { + throw new Error(`contexts[${i}].name is missing`); + } + if (!elt.context) { + throw new Error(`contexts[${i}].context is missing`); + } + if (!elt.context.cluster) { + throw new Error(`contexts[${i}].context.cluster is missing`); + } + return { + cluster: elt.context.cluster, + name: elt.name, + user: elt.context.user || void 0, + namespace: elt.context.namespace || void 0 + }; + } catch (err) { + switch (onInvalidEntry) { + case ActionOnInvalid.FILTER: + return null; + default: + case ActionOnInvalid.THROW: + throw err; + } + } + }; +} + +// node_modules/@kubernetes/client-node/dist/exec_auth.js +import child_process from "node:child_process"; +var ExecAuth = class { + constructor() { + this.tokenCache = {}; + this.execFn = child_process.spawn; + } + isAuthProvider(user) { + if (!user) { + return false; + } + if (user.exec) { + return true; + } + if (!user.authProvider) { + return false; + } + return user.authProvider.name === "exec" || !!(user.authProvider.config && user.authProvider.config.exec); + } + async applyAuthentication(user, opts) { + const credential = await this.getCredential(user); + if (!credential) { + return; + } + if (credential.status.clientCertificateData) { + opts.cert = credential.status.clientCertificateData; + } + if (credential.status.clientKeyData) { + opts.key = credential.status.clientKeyData; + } + const token = this.getToken(credential); + if (token) { + if (!opts.headers) { + opts.headers = {}; + } + opts.headers["Authorization"] = `Bearer ${token}`; + } + } + getToken(credential) { + if (!credential) { + return null; + } + if (credential.status.token) { + return credential.status.token; + } + return null; + } + async getCredential(user) { + const cachedToken = this.tokenCache[user.name]; + if (cachedToken) { + const date = Date.parse(cachedToken.status.expirationTimestamp); + if (date > Date.now()) { + return cachedToken; + } + this.tokenCache[user.name] = null; + } + let exec2 = null; + if (user.authProvider && user.authProvider.config) { + exec2 = user.authProvider.config.exec; + } + if (user.exec) { + exec2 = user.exec; + } + if (!exec2) { + return null; + } + if (!exec2.command) { + throw new Error("No command was specified for exec authProvider!"); + } + let opts = {}; + if (exec2.env) { + const env = { ...process.env }; + exec2.env.forEach((elt) => env[elt.name] = elt.value); + opts = { ...opts, env }; + } + return new Promise((resolve2, reject) => { + let stdoutData = ""; + let stderrData = ""; + let savedError = void 0; + const subprocess = this.execFn(exec2.command, exec2.args, opts); + subprocess.stdout.setEncoding("utf8"); + subprocess.stderr.setEncoding("utf8"); + subprocess.stdout.on("data", (data) => { + stdoutData += data; + }); + subprocess.stderr.on("data", (data) => { + stderrData += data; + }); + subprocess.on("error", (error2) => { + savedError = error2; + }); + subprocess.on("close", (code) => { + if (savedError) { + reject(savedError); + return; + } + if (code !== 0) { + reject(new Error(stderrData)); + return; + } + try { + const obj = JSON.parse(stdoutData); + this.tokenCache[user.name] = obj; + resolve2(obj); + } catch (error2) { + reject(error2); + } + }); + }); + } +}; + +// node_modules/@kubernetes/client-node/dist/file_auth.js +import fs4 from "node:fs"; +var FileAuth = class { + constructor() { + this.token = null; + this.lastRead = null; + } + isAuthProvider(user) { + return user.authProvider && user.authProvider.config && user.authProvider.config.tokenFile; + } + async applyAuthentication(user, opts) { + if (this.token == null) { + this.refreshToken(user.authProvider.config.tokenFile); + } + if (this.isTokenExpired()) { + this.refreshToken(user.authProvider.config.tokenFile); + } + if (this.token) { + opts.headers["Authorization"] = `Bearer ${this.token}`; + } + } + refreshToken(filePath) { + this.token = fs4.readFileSync(filePath).toString("utf-8"); + this.lastRead = /* @__PURE__ */ new Date(); + } + isTokenExpired() { + if (this.lastRead === null) { + return true; + } + const now = /* @__PURE__ */ new Date(); + const delta = (now.getTime() - this.lastRead.getTime()) / 1e3; + return delta > 60; + } +}; + +// node_modules/@kubernetes/client-node/dist/gcp_auth.js +import proc2 from "node:child_process"; +var GoogleCloudPlatformAuth = class { + isAuthProvider(user) { + if (!user || !user.authProvider) { + return false; + } + return user.authProvider.name === "gcp"; + } + async applyAuthentication(user, opts) { + const token = this.getToken(user); + if (token) { + opts.headers["Authorization"] = `Bearer ${token}`; + } + } + getToken(user) { + const config = user.authProvider.config; + if (this.isExpired(config)) { + this.updateAccessToken(config); + } + return config["access-token"]; + } + isExpired(config) { + const token = config["access-token"]; + const expiry = config.expiry; + if (!token) { + return true; + } + if (!expiry) { + return false; + } + const expiration = Date.parse(expiry); + if (expiration < Date.now()) { + return true; + } + return false; + } + updateAccessToken(config) { + let cmd = config["cmd-path"]; + if (!cmd) { + throw new Error("Token is expired!"); + } + cmd = `"${cmd}"`; + const args = config["cmd-args"]; + if (args) { + cmd = cmd + " " + args; + } + let output; + try { + output = proc2.execSync(cmd); + } catch (err) { + throw new Error("Failed to refresh token: " + err); + } + const resultObj = JSON.parse(output); + const tokenPathKeyInConfig = config["token-key"]; + const expiryPathKeyInConfig = config["expiry-key"]; + const tokenPathKey = "$" + tokenPathKeyInConfig.slice(1, -1); + const expiryPathKey = "$" + expiryPathKeyInConfig.slice(1, -1); + config["access-token"] = JSONPath({ path: tokenPathKey, json: resultObj }); + config.expiry = JSONPath({ path: expiryPathKey, json: resultObj }); + } +}; + +// node_modules/@kubernetes/client-node/dist/gen/http/http.js +import { URL as URL2 } from "url"; + +// node_modules/@kubernetes/client-node/dist/gen/rxjsStub.js +var Observable = class _Observable { + constructor(promise) { + this.promise = promise; + } + toPromise() { + return this.promise; + } + pipe(callback) { + return new _Observable(this.promise.then(callback)); + } +}; +function from(promise) { + return new Observable(promise); +} + +// node_modules/@kubernetes/client-node/dist/gen/http/isomorphic-fetch.js +var import_node_fetch = __toESM(require_lib2(), 1); +var IsomorphicFetchHttpLibrary = class { + send(request) { + let method = request.getHttpMethod().toString(); + let body = request.getBody(); + const resultPromise = (0, import_node_fetch.default)(request.getUrl(), { + method, + body, + headers: request.getHeaders(), + signal: request.getSignal(), + agent: request.getAgent() + }).then((resp) => { + const headers2 = {}; + resp.headers.forEach((value, name) => { + headers2[name] = value; + }); + const body2 = { + text: () => resp.text(), + binary: () => resp.buffer() + }; + return new ResponseContext(resp.status, headers2, body2); + }); + return from(resultPromise); + } +}; + +// node_modules/@kubernetes/client-node/dist/gen/http/http.js +var HttpMethod; +(function(HttpMethod2) { + HttpMethod2["GET"] = "GET"; + HttpMethod2["HEAD"] = "HEAD"; + HttpMethod2["POST"] = "POST"; + HttpMethod2["PUT"] = "PUT"; + HttpMethod2["DELETE"] = "DELETE"; + HttpMethod2["CONNECT"] = "CONNECT"; + HttpMethod2["OPTIONS"] = "OPTIONS"; + HttpMethod2["TRACE"] = "TRACE"; + HttpMethod2["PATCH"] = "PATCH"; +})(HttpMethod || (HttpMethod = {})); +function ensureAbsoluteUrl(url) { + if (url.startsWith("http://") || url.startsWith("https://")) { + return url; + } + throw new Error("You need to define an absolute base url for the server."); +} +var RequestContext = class { + /** + * Creates the request context using a http method and request resource url + * + * @param url url of the requested resource + * @param httpMethod http method + */ + constructor(url, httpMethod) { + this.httpMethod = httpMethod; + this.headers = {}; + this.body = void 0; + this.signal = void 0; + this.agent = void 0; + this.url = new URL2(ensureAbsoluteUrl(url)); + } + /* + * Returns the url set in the constructor including the query string + * + */ + getUrl() { + return this.url.toString().endsWith("/") ? this.url.toString().slice(0, -1) : this.url.toString(); + } + /** + * Replaces the url set in the constructor with this url. + * + */ + setUrl(url) { + this.url = new URL2(ensureAbsoluteUrl(url)); + } + /** + * Sets the body of the http request either as a string or FormData + * + * Note that setting a body on a HTTP GET, HEAD, DELETE, CONNECT or TRACE + * request is discouraged. + * https://httpwg.org/http-core/draft-ietf-httpbis-semantics-latest.html#rfc.section.7.3.1 + * + * @param body the body of the request + */ + setBody(body) { + this.body = body; + } + getHttpMethod() { + return this.httpMethod; + } + getHeaders() { + return this.headers; + } + getBody() { + return this.body; + } + setQueryParam(name, value) { + this.url.searchParams.set(name, value); + } + appendQueryParam(name, value) { + this.url.searchParams.append(name, value); + } + /** + * Sets a cookie with the name and value. NO check for duplicate cookies is performed + * + */ + addCookie(name, value) { + if (!this.headers["Cookie"]) { + this.headers["Cookie"] = ""; + } + this.headers["Cookie"] += name + "=" + value + "; "; + } + setHeaderParam(key, value) { + this.headers[key] = value; + } + setSignal(signal3) { + this.signal = signal3; + } + getSignal() { + return this.signal; + } + setAgent(agent) { + this.agent = agent; + } + getAgent() { + return this.agent; + } +}; +var ResponseContext = class { + constructor(httpStatusCode, headers2, body) { + this.httpStatusCode = httpStatusCode; + this.headers = headers2; + this.body = body; + } + /** + * Parse header value in the form `value; param1="value1"` + * + * E.g. for Content-Type or Content-Disposition + * Parameter names are converted to lower case + * The first parameter is returned with the key `""` + */ + getParsedHeader(headerName) { + const result = {}; + if (!this.headers[headerName]) { + return result; + } + const parameters = this.headers[headerName].split(";"); + for (const parameter of parameters) { + let [key, value] = parameter.split("=", 2); + if (!key) { + continue; + } + key = key.toLowerCase().trim(); + if (value === void 0) { + result[""] = key; + } else { + value = value.trim(); + if (value.startsWith('"') && value.endsWith('"')) { + value = value.substring(1, value.length - 1); + } + result[key] = value; + } + } + return result; + } + async getBodyAsFile() { + const data = await this.body.binary(); + const fileName = this.getParsedHeader("content-disposition")["filename"] || ""; + return { data, name: fileName }; + } + /** + * Use a heuristic to get a body of unknown data structure. + * Return as string if possible, otherwise as binary. + */ + getBodyAsAny() { + try { + return this.body.text(); + } catch { + } + try { + return this.body.binary(); + } catch { + } + return Promise.resolve(void 0); + } +}; + +// node_modules/@kubernetes/client-node/dist/gen/auth/auth.js +var BearerTokenAuthentication = class { + /** + * Configures this api key authentication with the necessary properties + * + * @param apiKey: The api key to be used for every request + */ + constructor(apiKey) { + this.apiKey = apiKey; + } + getName() { + return "BearerToken"; + } + applySecurityAuthentication(context) { + context.setHeaderParam("authorization", this.apiKey); + } +}; +function configureAuthMethods(config) { + let authMethods = {}; + if (!config) { + return authMethods; + } + authMethods["default"] = config["default"]; + if (config["BearerToken"]) { + authMethods["BearerToken"] = new BearerTokenAuthentication(config["BearerToken"]); + } + return authMethods; +} + +// node_modules/@kubernetes/client-node/dist/gen/models/AdmissionregistrationV1ServiceReference.js +var AdmissionregistrationV1ServiceReference = class _AdmissionregistrationV1ServiceReference { + static getAttributeTypeMap() { + return _AdmissionregistrationV1ServiceReference.attributeTypeMap; + } + constructor() { + } +}; +AdmissionregistrationV1ServiceReference.discriminator = void 0; +AdmissionregistrationV1ServiceReference.mapping = void 0; +AdmissionregistrationV1ServiceReference.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/AdmissionregistrationV1WebhookClientConfig.js +var AdmissionregistrationV1WebhookClientConfig = class _AdmissionregistrationV1WebhookClientConfig { + static getAttributeTypeMap() { + return _AdmissionregistrationV1WebhookClientConfig.attributeTypeMap; + } + constructor() { + } +}; +AdmissionregistrationV1WebhookClientConfig.discriminator = void 0; +AdmissionregistrationV1WebhookClientConfig.mapping = void 0; +AdmissionregistrationV1WebhookClientConfig.attributeTypeMap = [ + { + "name": "caBundle", + "baseName": "caBundle", + "type": "string", + "format": "byte" + }, + { + "name": "service", + "baseName": "service", + "type": "AdmissionregistrationV1ServiceReference", + "format": "" + }, + { + "name": "url", + "baseName": "url", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/ApiextensionsV1ServiceReference.js +var ApiextensionsV1ServiceReference = class _ApiextensionsV1ServiceReference { + static getAttributeTypeMap() { + return _ApiextensionsV1ServiceReference.attributeTypeMap; + } + constructor() { + } +}; +ApiextensionsV1ServiceReference.discriminator = void 0; +ApiextensionsV1ServiceReference.mapping = void 0; +ApiextensionsV1ServiceReference.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/ApiextensionsV1WebhookClientConfig.js +var ApiextensionsV1WebhookClientConfig = class _ApiextensionsV1WebhookClientConfig { + static getAttributeTypeMap() { + return _ApiextensionsV1WebhookClientConfig.attributeTypeMap; + } + constructor() { + } +}; +ApiextensionsV1WebhookClientConfig.discriminator = void 0; +ApiextensionsV1WebhookClientConfig.mapping = void 0; +ApiextensionsV1WebhookClientConfig.attributeTypeMap = [ + { + "name": "caBundle", + "baseName": "caBundle", + "type": "string", + "format": "byte" + }, + { + "name": "service", + "baseName": "service", + "type": "ApiextensionsV1ServiceReference", + "format": "" + }, + { + "name": "url", + "baseName": "url", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/ApiregistrationV1ServiceReference.js +var ApiregistrationV1ServiceReference = class _ApiregistrationV1ServiceReference { + static getAttributeTypeMap() { + return _ApiregistrationV1ServiceReference.attributeTypeMap; + } + constructor() { + } +}; +ApiregistrationV1ServiceReference.discriminator = void 0; +ApiregistrationV1ServiceReference.mapping = void 0; +ApiregistrationV1ServiceReference.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/AuthenticationV1TokenRequest.js +var AuthenticationV1TokenRequest = class _AuthenticationV1TokenRequest { + static getAttributeTypeMap() { + return _AuthenticationV1TokenRequest.attributeTypeMap; + } + constructor() { + } +}; +AuthenticationV1TokenRequest.discriminator = void 0; +AuthenticationV1TokenRequest.mapping = void 0; +AuthenticationV1TokenRequest.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1TokenRequestSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1TokenRequestStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/CoreV1EndpointPort.js +var CoreV1EndpointPort = class _CoreV1EndpointPort { + static getAttributeTypeMap() { + return _CoreV1EndpointPort.attributeTypeMap; + } + constructor() { + } +}; +CoreV1EndpointPort.discriminator = void 0; +CoreV1EndpointPort.mapping = void 0; +CoreV1EndpointPort.attributeTypeMap = [ + { + "name": "appProtocol", + "baseName": "appProtocol", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/CoreV1Event.js +var CoreV1Event = class _CoreV1Event { + static getAttributeTypeMap() { + return _CoreV1Event.attributeTypeMap; + } + constructor() { + } +}; +CoreV1Event.discriminator = void 0; +CoreV1Event.mapping = void 0; +CoreV1Event.attributeTypeMap = [ + { + "name": "action", + "baseName": "action", + "type": "string", + "format": "" + }, + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int32" + }, + { + "name": "eventTime", + "baseName": "eventTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "firstTimestamp", + "baseName": "firstTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "involvedObject", + "baseName": "involvedObject", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "lastTimestamp", + "baseName": "lastTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "related", + "baseName": "related", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "reportingComponent", + "baseName": "reportingComponent", + "type": "string", + "format": "" + }, + { + "name": "reportingInstance", + "baseName": "reportingInstance", + "type": "string", + "format": "" + }, + { + "name": "series", + "baseName": "series", + "type": "CoreV1EventSeries", + "format": "" + }, + { + "name": "source", + "baseName": "source", + "type": "V1EventSource", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/CoreV1EventList.js +var CoreV1EventList = class _CoreV1EventList { + static getAttributeTypeMap() { + return _CoreV1EventList.attributeTypeMap; + } + constructor() { + } +}; +CoreV1EventList.discriminator = void 0; +CoreV1EventList.mapping = void 0; +CoreV1EventList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/CoreV1EventSeries.js +var CoreV1EventSeries = class _CoreV1EventSeries { + static getAttributeTypeMap() { + return _CoreV1EventSeries.attributeTypeMap; + } + constructor() { + } +}; +CoreV1EventSeries.discriminator = void 0; +CoreV1EventSeries.mapping = void 0; +CoreV1EventSeries.attributeTypeMap = [ + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int32" + }, + { + "name": "lastObservedTime", + "baseName": "lastObservedTime", + "type": "V1MicroTime", + "format": "date-time-micro" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/CoreV1ResourceClaim.js +var CoreV1ResourceClaim = class _CoreV1ResourceClaim { + static getAttributeTypeMap() { + return _CoreV1ResourceClaim.attributeTypeMap; + } + constructor() { + } +}; +CoreV1ResourceClaim.discriminator = void 0; +CoreV1ResourceClaim.mapping = void 0; +CoreV1ResourceClaim.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "request", + "baseName": "request", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/DiscoveryV1EndpointPort.js +var DiscoveryV1EndpointPort = class _DiscoveryV1EndpointPort { + static getAttributeTypeMap() { + return _DiscoveryV1EndpointPort.attributeTypeMap; + } + constructor() { + } +}; +DiscoveryV1EndpointPort.discriminator = void 0; +DiscoveryV1EndpointPort.mapping = void 0; +DiscoveryV1EndpointPort.attributeTypeMap = [ + { + "name": "appProtocol", + "baseName": "appProtocol", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/EventsV1Event.js +var EventsV1Event = class _EventsV1Event { + static getAttributeTypeMap() { + return _EventsV1Event.attributeTypeMap; + } + constructor() { + } +}; +EventsV1Event.discriminator = void 0; +EventsV1Event.mapping = void 0; +EventsV1Event.attributeTypeMap = [ + { + "name": "action", + "baseName": "action", + "type": "string", + "format": "" + }, + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "deprecatedCount", + "baseName": "deprecatedCount", + "type": "number", + "format": "int32" + }, + { + "name": "deprecatedFirstTimestamp", + "baseName": "deprecatedFirstTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "deprecatedLastTimestamp", + "baseName": "deprecatedLastTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "deprecatedSource", + "baseName": "deprecatedSource", + "type": "V1EventSource", + "format": "" + }, + { + "name": "eventTime", + "baseName": "eventTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "note", + "baseName": "note", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "regarding", + "baseName": "regarding", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "related", + "baseName": "related", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "reportingController", + "baseName": "reportingController", + "type": "string", + "format": "" + }, + { + "name": "reportingInstance", + "baseName": "reportingInstance", + "type": "string", + "format": "" + }, + { + "name": "series", + "baseName": "series", + "type": "EventsV1EventSeries", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/EventsV1EventList.js +var EventsV1EventList = class _EventsV1EventList { + static getAttributeTypeMap() { + return _EventsV1EventList.attributeTypeMap; + } + constructor() { + } +}; +EventsV1EventList.discriminator = void 0; +EventsV1EventList.mapping = void 0; +EventsV1EventList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/EventsV1EventSeries.js +var EventsV1EventSeries = class _EventsV1EventSeries { + static getAttributeTypeMap() { + return _EventsV1EventSeries.attributeTypeMap; + } + constructor() { + } +}; +EventsV1EventSeries.discriminator = void 0; +EventsV1EventSeries.mapping = void 0; +EventsV1EventSeries.attributeTypeMap = [ + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int32" + }, + { + "name": "lastObservedTime", + "baseName": "lastObservedTime", + "type": "V1MicroTime", + "format": "date-time-micro" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/FlowcontrolV1Subject.js +var FlowcontrolV1Subject = class _FlowcontrolV1Subject { + static getAttributeTypeMap() { + return _FlowcontrolV1Subject.attributeTypeMap; + } + constructor() { + } +}; +FlowcontrolV1Subject.discriminator = void 0; +FlowcontrolV1Subject.mapping = void 0; +FlowcontrolV1Subject.attributeTypeMap = [ + { + "name": "group", + "baseName": "group", + "type": "V1GroupSubject", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "serviceAccount", + "baseName": "serviceAccount", + "type": "V1ServiceAccountSubject", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "V1UserSubject", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/RbacV1Subject.js +var RbacV1Subject = class _RbacV1Subject { + static getAttributeTypeMap() { + return _RbacV1Subject.attributeTypeMap; + } + constructor() { + } +}; +RbacV1Subject.discriminator = void 0; +RbacV1Subject.mapping = void 0; +RbacV1Subject.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/ResourceV1ResourceClaim.js +var ResourceV1ResourceClaim = class _ResourceV1ResourceClaim { + static getAttributeTypeMap() { + return _ResourceV1ResourceClaim.attributeTypeMap; + } + constructor() { + } +}; +ResourceV1ResourceClaim.discriminator = void 0; +ResourceV1ResourceClaim.mapping = void 0; +ResourceV1ResourceClaim.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ResourceClaimSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ResourceClaimStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/StorageV1TokenRequest.js +var StorageV1TokenRequest = class _StorageV1TokenRequest { + static getAttributeTypeMap() { + return _StorageV1TokenRequest.attributeTypeMap; + } + constructor() { + } +}; +StorageV1TokenRequest.discriminator = void 0; +StorageV1TokenRequest.mapping = void 0; +StorageV1TokenRequest.attributeTypeMap = [ + { + "name": "audience", + "baseName": "audience", + "type": "string", + "format": "" + }, + { + "name": "expirationSeconds", + "baseName": "expirationSeconds", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIGroup.js +var V1APIGroup = class _V1APIGroup { + static getAttributeTypeMap() { + return _V1APIGroup.attributeTypeMap; + } + constructor() { + } +}; +V1APIGroup.discriminator = void 0; +V1APIGroup.mapping = void 0; +V1APIGroup.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "preferredVersion", + "baseName": "preferredVersion", + "type": "V1GroupVersionForDiscovery", + "format": "" + }, + { + "name": "serverAddressByClientCIDRs", + "baseName": "serverAddressByClientCIDRs", + "type": "Array", + "format": "" + }, + { + "name": "versions", + "baseName": "versions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIGroupList.js +var V1APIGroupList = class _V1APIGroupList { + static getAttributeTypeMap() { + return _V1APIGroupList.attributeTypeMap; + } + constructor() { + } +}; +V1APIGroupList.discriminator = void 0; +V1APIGroupList.mapping = void 0; +V1APIGroupList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "groups", + "baseName": "groups", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIResource.js +var V1APIResource = class _V1APIResource { + static getAttributeTypeMap() { + return _V1APIResource.attributeTypeMap; + } + constructor() { + } +}; +V1APIResource.discriminator = void 0; +V1APIResource.mapping = void 0; +V1APIResource.attributeTypeMap = [ + { + "name": "categories", + "baseName": "categories", + "type": "Array", + "format": "" + }, + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespaced", + "baseName": "namespaced", + "type": "boolean", + "format": "" + }, + { + "name": "shortNames", + "baseName": "shortNames", + "type": "Array", + "format": "" + }, + { + "name": "singularName", + "baseName": "singularName", + "type": "string", + "format": "" + }, + { + "name": "storageVersionHash", + "baseName": "storageVersionHash", + "type": "string", + "format": "" + }, + { + "name": "verbs", + "baseName": "verbs", + "type": "Array", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIResourceList.js +var V1APIResourceList = class _V1APIResourceList { + static getAttributeTypeMap() { + return _V1APIResourceList.attributeTypeMap; + } + constructor() { + } +}; +V1APIResourceList.discriminator = void 0; +V1APIResourceList.mapping = void 0; +V1APIResourceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "groupVersion", + "baseName": "groupVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIService.js +var V1APIService = class _V1APIService { + static getAttributeTypeMap() { + return _V1APIService.attributeTypeMap; + } + constructor() { + } +}; +V1APIService.discriminator = void 0; +V1APIService.mapping = void 0; +V1APIService.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1APIServiceSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1APIServiceStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIServiceCondition.js +var V1APIServiceCondition = class _V1APIServiceCondition { + static getAttributeTypeMap() { + return _V1APIServiceCondition.attributeTypeMap; + } + constructor() { + } +}; +V1APIServiceCondition.discriminator = void 0; +V1APIServiceCondition.mapping = void 0; +V1APIServiceCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIServiceList.js +var V1APIServiceList = class _V1APIServiceList { + static getAttributeTypeMap() { + return _V1APIServiceList.attributeTypeMap; + } + constructor() { + } +}; +V1APIServiceList.discriminator = void 0; +V1APIServiceList.mapping = void 0; +V1APIServiceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIServiceSpec.js +var V1APIServiceSpec = class _V1APIServiceSpec { + static getAttributeTypeMap() { + return _V1APIServiceSpec.attributeTypeMap; + } + constructor() { + } +}; +V1APIServiceSpec.discriminator = void 0; +V1APIServiceSpec.mapping = void 0; +V1APIServiceSpec.attributeTypeMap = [ + { + "name": "caBundle", + "baseName": "caBundle", + "type": "string", + "format": "byte" + }, + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "groupPriorityMinimum", + "baseName": "groupPriorityMinimum", + "type": "number", + "format": "int32" + }, + { + "name": "insecureSkipTLSVerify", + "baseName": "insecureSkipTLSVerify", + "type": "boolean", + "format": "" + }, + { + "name": "service", + "baseName": "service", + "type": "ApiregistrationV1ServiceReference", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + }, + { + "name": "versionPriority", + "baseName": "versionPriority", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIServiceStatus.js +var V1APIServiceStatus = class _V1APIServiceStatus { + static getAttributeTypeMap() { + return _V1APIServiceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1APIServiceStatus.discriminator = void 0; +V1APIServiceStatus.mapping = void 0; +V1APIServiceStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1APIVersions.js +var V1APIVersions = class _V1APIVersions { + static getAttributeTypeMap() { + return _V1APIVersions.attributeTypeMap; + } + constructor() { + } +}; +V1APIVersions.discriminator = void 0; +V1APIVersions.mapping = void 0; +V1APIVersions.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "serverAddressByClientCIDRs", + "baseName": "serverAddressByClientCIDRs", + "type": "Array", + "format": "" + }, + { + "name": "versions", + "baseName": "versions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AWSElasticBlockStoreVolumeSource.js +var V1AWSElasticBlockStoreVolumeSource = class _V1AWSElasticBlockStoreVolumeSource { + static getAttributeTypeMap() { + return _V1AWSElasticBlockStoreVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1AWSElasticBlockStoreVolumeSource.discriminator = void 0; +V1AWSElasticBlockStoreVolumeSource.mapping = void 0; +V1AWSElasticBlockStoreVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "partition", + "baseName": "partition", + "type": "number", + "format": "int32" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "volumeID", + "baseName": "volumeID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Affinity.js +var V1Affinity = class _V1Affinity { + static getAttributeTypeMap() { + return _V1Affinity.attributeTypeMap; + } + constructor() { + } +}; +V1Affinity.discriminator = void 0; +V1Affinity.mapping = void 0; +V1Affinity.attributeTypeMap = [ + { + "name": "nodeAffinity", + "baseName": "nodeAffinity", + "type": "V1NodeAffinity", + "format": "" + }, + { + "name": "podAffinity", + "baseName": "podAffinity", + "type": "V1PodAffinity", + "format": "" + }, + { + "name": "podAntiAffinity", + "baseName": "podAntiAffinity", + "type": "V1PodAntiAffinity", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AggregationRule.js +var V1AggregationRule = class _V1AggregationRule { + static getAttributeTypeMap() { + return _V1AggregationRule.attributeTypeMap; + } + constructor() { + } +}; +V1AggregationRule.discriminator = void 0; +V1AggregationRule.mapping = void 0; +V1AggregationRule.attributeTypeMap = [ + { + "name": "clusterRoleSelectors", + "baseName": "clusterRoleSelectors", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AllocatedDeviceStatus.js +var V1AllocatedDeviceStatus = class _V1AllocatedDeviceStatus { + static getAttributeTypeMap() { + return _V1AllocatedDeviceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1AllocatedDeviceStatus.discriminator = void 0; +V1AllocatedDeviceStatus.mapping = void 0; +V1AllocatedDeviceStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "data", + "baseName": "data", + "type": "any", + "format": "" + }, + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "networkData", + "baseName": "networkData", + "type": "V1NetworkDeviceData", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "shareID", + "baseName": "shareID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AllocationResult.js +var V1AllocationResult = class _V1AllocationResult { + static getAttributeTypeMap() { + return _V1AllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1AllocationResult.discriminator = void 0; +V1AllocationResult.mapping = void 0; +V1AllocationResult.attributeTypeMap = [ + { + "name": "allocationTimestamp", + "baseName": "allocationTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "devices", + "baseName": "devices", + "type": "V1DeviceAllocationResult", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AppArmorProfile.js +var V1AppArmorProfile = class _V1AppArmorProfile { + static getAttributeTypeMap() { + return _V1AppArmorProfile.attributeTypeMap; + } + constructor() { + } +}; +V1AppArmorProfile.discriminator = void 0; +V1AppArmorProfile.mapping = void 0; +V1AppArmorProfile.attributeTypeMap = [ + { + "name": "localhostProfile", + "baseName": "localhostProfile", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AttachedVolume.js +var V1AttachedVolume = class _V1AttachedVolume { + static getAttributeTypeMap() { + return _V1AttachedVolume.attributeTypeMap; + } + constructor() { + } +}; +V1AttachedVolume.discriminator = void 0; +V1AttachedVolume.mapping = void 0; +V1AttachedVolume.attributeTypeMap = [ + { + "name": "devicePath", + "baseName": "devicePath", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AuditAnnotation.js +var V1AuditAnnotation = class _V1AuditAnnotation { + static getAttributeTypeMap() { + return _V1AuditAnnotation.attributeTypeMap; + } + constructor() { + } +}; +V1AuditAnnotation.discriminator = void 0; +V1AuditAnnotation.mapping = void 0; +V1AuditAnnotation.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "valueExpression", + "baseName": "valueExpression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AzureDiskVolumeSource.js +var V1AzureDiskVolumeSource = class _V1AzureDiskVolumeSource { + static getAttributeTypeMap() { + return _V1AzureDiskVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1AzureDiskVolumeSource.discriminator = void 0; +V1AzureDiskVolumeSource.mapping = void 0; +V1AzureDiskVolumeSource.attributeTypeMap = [ + { + "name": "cachingMode", + "baseName": "cachingMode", + "type": "string", + "format": "" + }, + { + "name": "diskName", + "baseName": "diskName", + "type": "string", + "format": "" + }, + { + "name": "diskURI", + "baseName": "diskURI", + "type": "string", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AzureFilePersistentVolumeSource.js +var V1AzureFilePersistentVolumeSource = class _V1AzureFilePersistentVolumeSource { + static getAttributeTypeMap() { + return _V1AzureFilePersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1AzureFilePersistentVolumeSource.discriminator = void 0; +V1AzureFilePersistentVolumeSource.mapping = void 0; +V1AzureFilePersistentVolumeSource.attributeTypeMap = [ + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretName", + "baseName": "secretName", + "type": "string", + "format": "" + }, + { + "name": "secretNamespace", + "baseName": "secretNamespace", + "type": "string", + "format": "" + }, + { + "name": "shareName", + "baseName": "shareName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1AzureFileVolumeSource.js +var V1AzureFileVolumeSource = class _V1AzureFileVolumeSource { + static getAttributeTypeMap() { + return _V1AzureFileVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1AzureFileVolumeSource.discriminator = void 0; +V1AzureFileVolumeSource.mapping = void 0; +V1AzureFileVolumeSource.attributeTypeMap = [ + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretName", + "baseName": "secretName", + "type": "string", + "format": "" + }, + { + "name": "shareName", + "baseName": "shareName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Binding.js +var V1Binding = class _V1Binding { + static getAttributeTypeMap() { + return _V1Binding.attributeTypeMap; + } + constructor() { + } +}; +V1Binding.discriminator = void 0; +V1Binding.mapping = void 0; +V1Binding.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "target", + "baseName": "target", + "type": "V1ObjectReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1BoundObjectReference.js +var V1BoundObjectReference = class _V1BoundObjectReference { + static getAttributeTypeMap() { + return _V1BoundObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V1BoundObjectReference.discriminator = void 0; +V1BoundObjectReference.mapping = void 0; +V1BoundObjectReference.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CELDeviceSelector.js +var V1CELDeviceSelector = class _V1CELDeviceSelector { + static getAttributeTypeMap() { + return _V1CELDeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1CELDeviceSelector.discriminator = void 0; +V1CELDeviceSelector.mapping = void 0; +V1CELDeviceSelector.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIDriver.js +var V1CSIDriver = class _V1CSIDriver { + static getAttributeTypeMap() { + return _V1CSIDriver.attributeTypeMap; + } + constructor() { + } +}; +V1CSIDriver.discriminator = void 0; +V1CSIDriver.mapping = void 0; +V1CSIDriver.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1CSIDriverSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIDriverList.js +var V1CSIDriverList = class _V1CSIDriverList { + static getAttributeTypeMap() { + return _V1CSIDriverList.attributeTypeMap; + } + constructor() { + } +}; +V1CSIDriverList.discriminator = void 0; +V1CSIDriverList.mapping = void 0; +V1CSIDriverList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIDriverSpec.js +var V1CSIDriverSpec = class _V1CSIDriverSpec { + static getAttributeTypeMap() { + return _V1CSIDriverSpec.attributeTypeMap; + } + constructor() { + } +}; +V1CSIDriverSpec.discriminator = void 0; +V1CSIDriverSpec.mapping = void 0; +V1CSIDriverSpec.attributeTypeMap = [ + { + "name": "attachRequired", + "baseName": "attachRequired", + "type": "boolean", + "format": "" + }, + { + "name": "fsGroupPolicy", + "baseName": "fsGroupPolicy", + "type": "string", + "format": "" + }, + { + "name": "nodeAllocatableUpdatePeriodSeconds", + "baseName": "nodeAllocatableUpdatePeriodSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "podInfoOnMount", + "baseName": "podInfoOnMount", + "type": "boolean", + "format": "" + }, + { + "name": "requiresRepublish", + "baseName": "requiresRepublish", + "type": "boolean", + "format": "" + }, + { + "name": "seLinuxMount", + "baseName": "seLinuxMount", + "type": "boolean", + "format": "" + }, + { + "name": "storageCapacity", + "baseName": "storageCapacity", + "type": "boolean", + "format": "" + }, + { + "name": "tokenRequests", + "baseName": "tokenRequests", + "type": "Array", + "format": "" + }, + { + "name": "volumeLifecycleModes", + "baseName": "volumeLifecycleModes", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSINode.js +var V1CSINode = class _V1CSINode { + static getAttributeTypeMap() { + return _V1CSINode.attributeTypeMap; + } + constructor() { + } +}; +V1CSINode.discriminator = void 0; +V1CSINode.mapping = void 0; +V1CSINode.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1CSINodeSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSINodeDriver.js +var V1CSINodeDriver = class _V1CSINodeDriver { + static getAttributeTypeMap() { + return _V1CSINodeDriver.attributeTypeMap; + } + constructor() { + } +}; +V1CSINodeDriver.discriminator = void 0; +V1CSINodeDriver.mapping = void 0; +V1CSINodeDriver.attributeTypeMap = [ + { + "name": "allocatable", + "baseName": "allocatable", + "type": "V1VolumeNodeResources", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "nodeID", + "baseName": "nodeID", + "type": "string", + "format": "" + }, + { + "name": "topologyKeys", + "baseName": "topologyKeys", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSINodeList.js +var V1CSINodeList = class _V1CSINodeList { + static getAttributeTypeMap() { + return _V1CSINodeList.attributeTypeMap; + } + constructor() { + } +}; +V1CSINodeList.discriminator = void 0; +V1CSINodeList.mapping = void 0; +V1CSINodeList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSINodeSpec.js +var V1CSINodeSpec = class _V1CSINodeSpec { + static getAttributeTypeMap() { + return _V1CSINodeSpec.attributeTypeMap; + } + constructor() { + } +}; +V1CSINodeSpec.discriminator = void 0; +V1CSINodeSpec.mapping = void 0; +V1CSINodeSpec.attributeTypeMap = [ + { + "name": "drivers", + "baseName": "drivers", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIPersistentVolumeSource.js +var V1CSIPersistentVolumeSource = class _V1CSIPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1CSIPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1CSIPersistentVolumeSource.discriminator = void 0; +V1CSIPersistentVolumeSource.mapping = void 0; +V1CSIPersistentVolumeSource.attributeTypeMap = [ + { + "name": "controllerExpandSecretRef", + "baseName": "controllerExpandSecretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "controllerPublishSecretRef", + "baseName": "controllerPublishSecretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "nodeExpandSecretRef", + "baseName": "nodeExpandSecretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "nodePublishSecretRef", + "baseName": "nodePublishSecretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "nodeStageSecretRef", + "baseName": "nodeStageSecretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "volumeAttributes", + "baseName": "volumeAttributes", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "volumeHandle", + "baseName": "volumeHandle", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIStorageCapacity.js +var V1CSIStorageCapacity = class _V1CSIStorageCapacity { + static getAttributeTypeMap() { + return _V1CSIStorageCapacity.attributeTypeMap; + } + constructor() { + } +}; +V1CSIStorageCapacity.discriminator = void 0; +V1CSIStorageCapacity.mapping = void 0; +V1CSIStorageCapacity.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "maximumVolumeSize", + "baseName": "maximumVolumeSize", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "nodeTopology", + "baseName": "nodeTopology", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "storageClassName", + "baseName": "storageClassName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIStorageCapacityList.js +var V1CSIStorageCapacityList = class _V1CSIStorageCapacityList { + static getAttributeTypeMap() { + return _V1CSIStorageCapacityList.attributeTypeMap; + } + constructor() { + } +}; +V1CSIStorageCapacityList.discriminator = void 0; +V1CSIStorageCapacityList.mapping = void 0; +V1CSIStorageCapacityList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CSIVolumeSource.js +var V1CSIVolumeSource = class _V1CSIVolumeSource { + static getAttributeTypeMap() { + return _V1CSIVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1CSIVolumeSource.discriminator = void 0; +V1CSIVolumeSource.mapping = void 0; +V1CSIVolumeSource.attributeTypeMap = [ + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "nodePublishSecretRef", + "baseName": "nodePublishSecretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "volumeAttributes", + "baseName": "volumeAttributes", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Capabilities.js +var V1Capabilities = class _V1Capabilities { + static getAttributeTypeMap() { + return _V1Capabilities.attributeTypeMap; + } + constructor() { + } +}; +V1Capabilities.discriminator = void 0; +V1Capabilities.mapping = void 0; +V1Capabilities.attributeTypeMap = [ + { + "name": "add", + "baseName": "add", + "type": "Array", + "format": "" + }, + { + "name": "drop", + "baseName": "drop", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CapacityRequestPolicy.js +var V1CapacityRequestPolicy = class _V1CapacityRequestPolicy { + static getAttributeTypeMap() { + return _V1CapacityRequestPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1CapacityRequestPolicy.discriminator = void 0; +V1CapacityRequestPolicy.mapping = void 0; +V1CapacityRequestPolicy.attributeTypeMap = [ + { + "name": "_default", + "baseName": "default", + "type": "string", + "format": "" + }, + { + "name": "validRange", + "baseName": "validRange", + "type": "V1CapacityRequestPolicyRange", + "format": "" + }, + { + "name": "validValues", + "baseName": "validValues", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CapacityRequestPolicyRange.js +var V1CapacityRequestPolicyRange = class _V1CapacityRequestPolicyRange { + static getAttributeTypeMap() { + return _V1CapacityRequestPolicyRange.attributeTypeMap; + } + constructor() { + } +}; +V1CapacityRequestPolicyRange.discriminator = void 0; +V1CapacityRequestPolicyRange.mapping = void 0; +V1CapacityRequestPolicyRange.attributeTypeMap = [ + { + "name": "max", + "baseName": "max", + "type": "string", + "format": "" + }, + { + "name": "min", + "baseName": "min", + "type": "string", + "format": "" + }, + { + "name": "step", + "baseName": "step", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CapacityRequirements.js +var V1CapacityRequirements = class _V1CapacityRequirements { + static getAttributeTypeMap() { + return _V1CapacityRequirements.attributeTypeMap; + } + constructor() { + } +}; +V1CapacityRequirements.discriminator = void 0; +V1CapacityRequirements.mapping = void 0; +V1CapacityRequirements.attributeTypeMap = [ + { + "name": "requests", + "baseName": "requests", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CephFSPersistentVolumeSource.js +var V1CephFSPersistentVolumeSource = class _V1CephFSPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1CephFSPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1CephFSPersistentVolumeSource.discriminator = void 0; +V1CephFSPersistentVolumeSource.mapping = void 0; +V1CephFSPersistentVolumeSource.attributeTypeMap = [ + { + "name": "monitors", + "baseName": "monitors", + "type": "Array", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretFile", + "baseName": "secretFile", + "type": "string", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CephFSVolumeSource.js +var V1CephFSVolumeSource = class _V1CephFSVolumeSource { + static getAttributeTypeMap() { + return _V1CephFSVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1CephFSVolumeSource.discriminator = void 0; +V1CephFSVolumeSource.mapping = void 0; +V1CephFSVolumeSource.attributeTypeMap = [ + { + "name": "monitors", + "baseName": "monitors", + "type": "Array", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretFile", + "baseName": "secretFile", + "type": "string", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CertificateSigningRequest.js +var V1CertificateSigningRequest = class _V1CertificateSigningRequest { + static getAttributeTypeMap() { + return _V1CertificateSigningRequest.attributeTypeMap; + } + constructor() { + } +}; +V1CertificateSigningRequest.discriminator = void 0; +V1CertificateSigningRequest.mapping = void 0; +V1CertificateSigningRequest.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1CertificateSigningRequestSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1CertificateSigningRequestStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CertificateSigningRequestCondition.js +var V1CertificateSigningRequestCondition = class _V1CertificateSigningRequestCondition { + static getAttributeTypeMap() { + return _V1CertificateSigningRequestCondition.attributeTypeMap; + } + constructor() { + } +}; +V1CertificateSigningRequestCondition.discriminator = void 0; +V1CertificateSigningRequestCondition.mapping = void 0; +V1CertificateSigningRequestCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastUpdateTime", + "baseName": "lastUpdateTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CertificateSigningRequestList.js +var V1CertificateSigningRequestList = class _V1CertificateSigningRequestList { + static getAttributeTypeMap() { + return _V1CertificateSigningRequestList.attributeTypeMap; + } + constructor() { + } +}; +V1CertificateSigningRequestList.discriminator = void 0; +V1CertificateSigningRequestList.mapping = void 0; +V1CertificateSigningRequestList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CertificateSigningRequestSpec.js +var V1CertificateSigningRequestSpec = class _V1CertificateSigningRequestSpec { + static getAttributeTypeMap() { + return _V1CertificateSigningRequestSpec.attributeTypeMap; + } + constructor() { + } +}; +V1CertificateSigningRequestSpec.discriminator = void 0; +V1CertificateSigningRequestSpec.mapping = void 0; +V1CertificateSigningRequestSpec.attributeTypeMap = [ + { + "name": "expirationSeconds", + "baseName": "expirationSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "extra", + "baseName": "extra", + "type": "{ [key: string]: Array; }", + "format": "" + }, + { + "name": "groups", + "baseName": "groups", + "type": "Array", + "format": "" + }, + { + "name": "request", + "baseName": "request", + "type": "string", + "format": "byte" + }, + { + "name": "signerName", + "baseName": "signerName", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + }, + { + "name": "usages", + "baseName": "usages", + "type": "Array", + "format": "" + }, + { + "name": "username", + "baseName": "username", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CertificateSigningRequestStatus.js +var V1CertificateSigningRequestStatus = class _V1CertificateSigningRequestStatus { + static getAttributeTypeMap() { + return _V1CertificateSigningRequestStatus.attributeTypeMap; + } + constructor() { + } +}; +V1CertificateSigningRequestStatus.discriminator = void 0; +V1CertificateSigningRequestStatus.mapping = void 0; +V1CertificateSigningRequestStatus.attributeTypeMap = [ + { + "name": "certificate", + "baseName": "certificate", + "type": "string", + "format": "byte" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CinderPersistentVolumeSource.js +var V1CinderPersistentVolumeSource = class _V1CinderPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1CinderPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1CinderPersistentVolumeSource.discriminator = void 0; +V1CinderPersistentVolumeSource.mapping = void 0; +V1CinderPersistentVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "volumeID", + "baseName": "volumeID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CinderVolumeSource.js +var V1CinderVolumeSource = class _V1CinderVolumeSource { + static getAttributeTypeMap() { + return _V1CinderVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1CinderVolumeSource.discriminator = void 0; +V1CinderVolumeSource.mapping = void 0; +V1CinderVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "volumeID", + "baseName": "volumeID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ClientIPConfig.js +var V1ClientIPConfig = class _V1ClientIPConfig { + static getAttributeTypeMap() { + return _V1ClientIPConfig.attributeTypeMap; + } + constructor() { + } +}; +V1ClientIPConfig.discriminator = void 0; +V1ClientIPConfig.mapping = void 0; +V1ClientIPConfig.attributeTypeMap = [ + { + "name": "timeoutSeconds", + "baseName": "timeoutSeconds", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ClusterRole.js +var V1ClusterRole = class _V1ClusterRole { + static getAttributeTypeMap() { + return _V1ClusterRole.attributeTypeMap; + } + constructor() { + } +}; +V1ClusterRole.discriminator = void 0; +V1ClusterRole.mapping = void 0; +V1ClusterRole.attributeTypeMap = [ + { + "name": "aggregationRule", + "baseName": "aggregationRule", + "type": "V1AggregationRule", + "format": "" + }, + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ClusterRoleBinding.js +var V1ClusterRoleBinding = class _V1ClusterRoleBinding { + static getAttributeTypeMap() { + return _V1ClusterRoleBinding.attributeTypeMap; + } + constructor() { + } +}; +V1ClusterRoleBinding.discriminator = void 0; +V1ClusterRoleBinding.mapping = void 0; +V1ClusterRoleBinding.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "roleRef", + "baseName": "roleRef", + "type": "V1RoleRef", + "format": "" + }, + { + "name": "subjects", + "baseName": "subjects", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ClusterRoleBindingList.js +var V1ClusterRoleBindingList = class _V1ClusterRoleBindingList { + static getAttributeTypeMap() { + return _V1ClusterRoleBindingList.attributeTypeMap; + } + constructor() { + } +}; +V1ClusterRoleBindingList.discriminator = void 0; +V1ClusterRoleBindingList.mapping = void 0; +V1ClusterRoleBindingList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ClusterRoleList.js +var V1ClusterRoleList = class _V1ClusterRoleList { + static getAttributeTypeMap() { + return _V1ClusterRoleList.attributeTypeMap; + } + constructor() { + } +}; +V1ClusterRoleList.discriminator = void 0; +V1ClusterRoleList.mapping = void 0; +V1ClusterRoleList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ClusterTrustBundleProjection.js +var V1ClusterTrustBundleProjection = class _V1ClusterTrustBundleProjection { + static getAttributeTypeMap() { + return _V1ClusterTrustBundleProjection.attributeTypeMap; + } + constructor() { + } +}; +V1ClusterTrustBundleProjection.discriminator = void 0; +V1ClusterTrustBundleProjection.mapping = void 0; +V1ClusterTrustBundleProjection.attributeTypeMap = [ + { + "name": "labelSelector", + "baseName": "labelSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "signerName", + "baseName": "signerName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ComponentCondition.js +var V1ComponentCondition = class _V1ComponentCondition { + static getAttributeTypeMap() { + return _V1ComponentCondition.attributeTypeMap; + } + constructor() { + } +}; +V1ComponentCondition.discriminator = void 0; +V1ComponentCondition.mapping = void 0; +V1ComponentCondition.attributeTypeMap = [ + { + "name": "error", + "baseName": "error", + "type": "string", + "format": "" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ComponentStatus.js +var V1ComponentStatus = class _V1ComponentStatus { + static getAttributeTypeMap() { + return _V1ComponentStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ComponentStatus.discriminator = void 0; +V1ComponentStatus.mapping = void 0; +V1ComponentStatus.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ComponentStatusList.js +var V1ComponentStatusList = class _V1ComponentStatusList { + static getAttributeTypeMap() { + return _V1ComponentStatusList.attributeTypeMap; + } + constructor() { + } +}; +V1ComponentStatusList.discriminator = void 0; +V1ComponentStatusList.mapping = void 0; +V1ComponentStatusList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Condition.js +var V1Condition = class _V1Condition { + static getAttributeTypeMap() { + return _V1Condition.attributeTypeMap; + } + constructor() { + } +}; +V1Condition.discriminator = void 0; +V1Condition.mapping = void 0; +V1Condition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMap.js +var V1ConfigMap = class _V1ConfigMap { + static getAttributeTypeMap() { + return _V1ConfigMap.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMap.discriminator = void 0; +V1ConfigMap.mapping = void 0; +V1ConfigMap.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "binaryData", + "baseName": "binaryData", + "type": "{ [key: string]: string; }", + "format": "byte" + }, + { + "name": "data", + "baseName": "data", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "immutable", + "baseName": "immutable", + "type": "boolean", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMapEnvSource.js +var V1ConfigMapEnvSource = class _V1ConfigMapEnvSource { + static getAttributeTypeMap() { + return _V1ConfigMapEnvSource.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMapEnvSource.discriminator = void 0; +V1ConfigMapEnvSource.mapping = void 0; +V1ConfigMapEnvSource.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMapKeySelector.js +var V1ConfigMapKeySelector = class _V1ConfigMapKeySelector { + static getAttributeTypeMap() { + return _V1ConfigMapKeySelector.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMapKeySelector.discriminator = void 0; +V1ConfigMapKeySelector.mapping = void 0; +V1ConfigMapKeySelector.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMapList.js +var V1ConfigMapList = class _V1ConfigMapList { + static getAttributeTypeMap() { + return _V1ConfigMapList.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMapList.discriminator = void 0; +V1ConfigMapList.mapping = void 0; +V1ConfigMapList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMapNodeConfigSource.js +var V1ConfigMapNodeConfigSource = class _V1ConfigMapNodeConfigSource { + static getAttributeTypeMap() { + return _V1ConfigMapNodeConfigSource.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMapNodeConfigSource.discriminator = void 0; +V1ConfigMapNodeConfigSource.mapping = void 0; +V1ConfigMapNodeConfigSource.attributeTypeMap = [ + { + "name": "kubeletConfigKey", + "baseName": "kubeletConfigKey", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "resourceVersion", + "baseName": "resourceVersion", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMapProjection.js +var V1ConfigMapProjection = class _V1ConfigMapProjection { + static getAttributeTypeMap() { + return _V1ConfigMapProjection.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMapProjection.discriminator = void 0; +V1ConfigMapProjection.mapping = void 0; +V1ConfigMapProjection.attributeTypeMap = [ + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ConfigMapVolumeSource.js +var V1ConfigMapVolumeSource = class _V1ConfigMapVolumeSource { + static getAttributeTypeMap() { + return _V1ConfigMapVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ConfigMapVolumeSource.discriminator = void 0; +V1ConfigMapVolumeSource.mapping = void 0; +V1ConfigMapVolumeSource.attributeTypeMap = [ + { + "name": "defaultMode", + "baseName": "defaultMode", + "type": "number", + "format": "int32" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Container.js +var V1Container = class _V1Container { + static getAttributeTypeMap() { + return _V1Container.attributeTypeMap; + } + constructor() { + } +}; +V1Container.discriminator = void 0; +V1Container.mapping = void 0; +V1Container.attributeTypeMap = [ + { + "name": "args", + "baseName": "args", + "type": "Array", + "format": "" + }, + { + "name": "command", + "baseName": "command", + "type": "Array", + "format": "" + }, + { + "name": "env", + "baseName": "env", + "type": "Array", + "format": "" + }, + { + "name": "envFrom", + "baseName": "envFrom", + "type": "Array", + "format": "" + }, + { + "name": "image", + "baseName": "image", + "type": "string", + "format": "" + }, + { + "name": "imagePullPolicy", + "baseName": "imagePullPolicy", + "type": "string", + "format": "" + }, + { + "name": "lifecycle", + "baseName": "lifecycle", + "type": "V1Lifecycle", + "format": "" + }, + { + "name": "livenessProbe", + "baseName": "livenessProbe", + "type": "V1Probe", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + }, + { + "name": "readinessProbe", + "baseName": "readinessProbe", + "type": "V1Probe", + "format": "" + }, + { + "name": "resizePolicy", + "baseName": "resizePolicy", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "V1ResourceRequirements", + "format": "" + }, + { + "name": "restartPolicy", + "baseName": "restartPolicy", + "type": "string", + "format": "" + }, + { + "name": "restartPolicyRules", + "baseName": "restartPolicyRules", + "type": "Array", + "format": "" + }, + { + "name": "securityContext", + "baseName": "securityContext", + "type": "V1SecurityContext", + "format": "" + }, + { + "name": "startupProbe", + "baseName": "startupProbe", + "type": "V1Probe", + "format": "" + }, + { + "name": "stdin", + "baseName": "stdin", + "type": "boolean", + "format": "" + }, + { + "name": "stdinOnce", + "baseName": "stdinOnce", + "type": "boolean", + "format": "" + }, + { + "name": "terminationMessagePath", + "baseName": "terminationMessagePath", + "type": "string", + "format": "" + }, + { + "name": "terminationMessagePolicy", + "baseName": "terminationMessagePolicy", + "type": "string", + "format": "" + }, + { + "name": "tty", + "baseName": "tty", + "type": "boolean", + "format": "" + }, + { + "name": "volumeDevices", + "baseName": "volumeDevices", + "type": "Array", + "format": "" + }, + { + "name": "volumeMounts", + "baseName": "volumeMounts", + "type": "Array", + "format": "" + }, + { + "name": "workingDir", + "baseName": "workingDir", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerExtendedResourceRequest.js +var V1ContainerExtendedResourceRequest = class _V1ContainerExtendedResourceRequest { + static getAttributeTypeMap() { + return _V1ContainerExtendedResourceRequest.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerExtendedResourceRequest.discriminator = void 0; +V1ContainerExtendedResourceRequest.mapping = void 0; +V1ContainerExtendedResourceRequest.attributeTypeMap = [ + { + "name": "containerName", + "baseName": "containerName", + "type": "string", + "format": "" + }, + { + "name": "requestName", + "baseName": "requestName", + "type": "string", + "format": "" + }, + { + "name": "resourceName", + "baseName": "resourceName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerImage.js +var V1ContainerImage = class _V1ContainerImage { + static getAttributeTypeMap() { + return _V1ContainerImage.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerImage.discriminator = void 0; +V1ContainerImage.mapping = void 0; +V1ContainerImage.attributeTypeMap = [ + { + "name": "names", + "baseName": "names", + "type": "Array", + "format": "" + }, + { + "name": "sizeBytes", + "baseName": "sizeBytes", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerPort.js +var V1ContainerPort = class _V1ContainerPort { + static getAttributeTypeMap() { + return _V1ContainerPort.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerPort.discriminator = void 0; +V1ContainerPort.mapping = void 0; +V1ContainerPort.attributeTypeMap = [ + { + "name": "containerPort", + "baseName": "containerPort", + "type": "number", + "format": "int32" + }, + { + "name": "hostIP", + "baseName": "hostIP", + "type": "string", + "format": "" + }, + { + "name": "hostPort", + "baseName": "hostPort", + "type": "number", + "format": "int32" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerResizePolicy.js +var V1ContainerResizePolicy = class _V1ContainerResizePolicy { + static getAttributeTypeMap() { + return _V1ContainerResizePolicy.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerResizePolicy.discriminator = void 0; +V1ContainerResizePolicy.mapping = void 0; +V1ContainerResizePolicy.attributeTypeMap = [ + { + "name": "resourceName", + "baseName": "resourceName", + "type": "string", + "format": "" + }, + { + "name": "restartPolicy", + "baseName": "restartPolicy", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerRestartRule.js +var V1ContainerRestartRule = class _V1ContainerRestartRule { + static getAttributeTypeMap() { + return _V1ContainerRestartRule.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerRestartRule.discriminator = void 0; +V1ContainerRestartRule.mapping = void 0; +V1ContainerRestartRule.attributeTypeMap = [ + { + "name": "action", + "baseName": "action", + "type": "string", + "format": "" + }, + { + "name": "exitCodes", + "baseName": "exitCodes", + "type": "V1ContainerRestartRuleOnExitCodes", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerRestartRuleOnExitCodes.js +var V1ContainerRestartRuleOnExitCodes = class _V1ContainerRestartRuleOnExitCodes { + static getAttributeTypeMap() { + return _V1ContainerRestartRuleOnExitCodes.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerRestartRuleOnExitCodes.discriminator = void 0; +V1ContainerRestartRuleOnExitCodes.mapping = void 0; +V1ContainerRestartRuleOnExitCodes.attributeTypeMap = [ + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerState.js +var V1ContainerState = class _V1ContainerState { + static getAttributeTypeMap() { + return _V1ContainerState.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerState.discriminator = void 0; +V1ContainerState.mapping = void 0; +V1ContainerState.attributeTypeMap = [ + { + "name": "running", + "baseName": "running", + "type": "V1ContainerStateRunning", + "format": "" + }, + { + "name": "terminated", + "baseName": "terminated", + "type": "V1ContainerStateTerminated", + "format": "" + }, + { + "name": "waiting", + "baseName": "waiting", + "type": "V1ContainerStateWaiting", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerStateRunning.js +var V1ContainerStateRunning = class _V1ContainerStateRunning { + static getAttributeTypeMap() { + return _V1ContainerStateRunning.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerStateRunning.discriminator = void 0; +V1ContainerStateRunning.mapping = void 0; +V1ContainerStateRunning.attributeTypeMap = [ + { + "name": "startedAt", + "baseName": "startedAt", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerStateTerminated.js +var V1ContainerStateTerminated = class _V1ContainerStateTerminated { + static getAttributeTypeMap() { + return _V1ContainerStateTerminated.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerStateTerminated.discriminator = void 0; +V1ContainerStateTerminated.mapping = void 0; +V1ContainerStateTerminated.attributeTypeMap = [ + { + "name": "containerID", + "baseName": "containerID", + "type": "string", + "format": "" + }, + { + "name": "exitCode", + "baseName": "exitCode", + "type": "number", + "format": "int32" + }, + { + "name": "finishedAt", + "baseName": "finishedAt", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "signal", + "baseName": "signal", + "type": "number", + "format": "int32" + }, + { + "name": "startedAt", + "baseName": "startedAt", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerStateWaiting.js +var V1ContainerStateWaiting = class _V1ContainerStateWaiting { + static getAttributeTypeMap() { + return _V1ContainerStateWaiting.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerStateWaiting.discriminator = void 0; +V1ContainerStateWaiting.mapping = void 0; +V1ContainerStateWaiting.attributeTypeMap = [ + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerStatus.js +var V1ContainerStatus = class _V1ContainerStatus { + static getAttributeTypeMap() { + return _V1ContainerStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerStatus.discriminator = void 0; +V1ContainerStatus.mapping = void 0; +V1ContainerStatus.attributeTypeMap = [ + { + "name": "allocatedResources", + "baseName": "allocatedResources", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "allocatedResourcesStatus", + "baseName": "allocatedResourcesStatus", + "type": "Array", + "format": "" + }, + { + "name": "containerID", + "baseName": "containerID", + "type": "string", + "format": "" + }, + { + "name": "image", + "baseName": "image", + "type": "string", + "format": "" + }, + { + "name": "imageID", + "baseName": "imageID", + "type": "string", + "format": "" + }, + { + "name": "lastState", + "baseName": "lastState", + "type": "V1ContainerState", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "ready", + "baseName": "ready", + "type": "boolean", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "V1ResourceRequirements", + "format": "" + }, + { + "name": "restartCount", + "baseName": "restartCount", + "type": "number", + "format": "int32" + }, + { + "name": "started", + "baseName": "started", + "type": "boolean", + "format": "" + }, + { + "name": "state", + "baseName": "state", + "type": "V1ContainerState", + "format": "" + }, + { + "name": "stopSignal", + "baseName": "stopSignal", + "type": "string", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "V1ContainerUser", + "format": "" + }, + { + "name": "volumeMounts", + "baseName": "volumeMounts", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ContainerUser.js +var V1ContainerUser = class _V1ContainerUser { + static getAttributeTypeMap() { + return _V1ContainerUser.attributeTypeMap; + } + constructor() { + } +}; +V1ContainerUser.discriminator = void 0; +V1ContainerUser.mapping = void 0; +V1ContainerUser.attributeTypeMap = [ + { + "name": "linux", + "baseName": "linux", + "type": "V1LinuxContainerUser", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ControllerRevision.js +var V1ControllerRevision = class _V1ControllerRevision { + static getAttributeTypeMap() { + return _V1ControllerRevision.attributeTypeMap; + } + constructor() { + } +}; +V1ControllerRevision.discriminator = void 0; +V1ControllerRevision.mapping = void 0; +V1ControllerRevision.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "data", + "baseName": "data", + "type": "any", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "revision", + "baseName": "revision", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ControllerRevisionList.js +var V1ControllerRevisionList = class _V1ControllerRevisionList { + static getAttributeTypeMap() { + return _V1ControllerRevisionList.attributeTypeMap; + } + constructor() { + } +}; +V1ControllerRevisionList.discriminator = void 0; +V1ControllerRevisionList.mapping = void 0; +V1ControllerRevisionList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Counter.js +var V1Counter = class _V1Counter { + static getAttributeTypeMap() { + return _V1Counter.attributeTypeMap; + } + constructor() { + } +}; +V1Counter.discriminator = void 0; +V1Counter.mapping = void 0; +V1Counter.attributeTypeMap = [ + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CounterSet.js +var V1CounterSet = class _V1CounterSet { + static getAttributeTypeMap() { + return _V1CounterSet.attributeTypeMap; + } + constructor() { + } +}; +V1CounterSet.discriminator = void 0; +V1CounterSet.mapping = void 0; +V1CounterSet.attributeTypeMap = [ + { + "name": "counters", + "baseName": "counters", + "type": "{ [key: string]: V1Counter; }", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CronJob.js +var V1CronJob = class _V1CronJob { + static getAttributeTypeMap() { + return _V1CronJob.attributeTypeMap; + } + constructor() { + } +}; +V1CronJob.discriminator = void 0; +V1CronJob.mapping = void 0; +V1CronJob.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1CronJobSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1CronJobStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CronJobList.js +var V1CronJobList = class _V1CronJobList { + static getAttributeTypeMap() { + return _V1CronJobList.attributeTypeMap; + } + constructor() { + } +}; +V1CronJobList.discriminator = void 0; +V1CronJobList.mapping = void 0; +V1CronJobList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CronJobSpec.js +var V1CronJobSpec = class _V1CronJobSpec { + static getAttributeTypeMap() { + return _V1CronJobSpec.attributeTypeMap; + } + constructor() { + } +}; +V1CronJobSpec.discriminator = void 0; +V1CronJobSpec.mapping = void 0; +V1CronJobSpec.attributeTypeMap = [ + { + "name": "concurrencyPolicy", + "baseName": "concurrencyPolicy", + "type": "string", + "format": "" + }, + { + "name": "failedJobsHistoryLimit", + "baseName": "failedJobsHistoryLimit", + "type": "number", + "format": "int32" + }, + { + "name": "jobTemplate", + "baseName": "jobTemplate", + "type": "V1JobTemplateSpec", + "format": "" + }, + { + "name": "schedule", + "baseName": "schedule", + "type": "string", + "format": "" + }, + { + "name": "startingDeadlineSeconds", + "baseName": "startingDeadlineSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "successfulJobsHistoryLimit", + "baseName": "successfulJobsHistoryLimit", + "type": "number", + "format": "int32" + }, + { + "name": "suspend", + "baseName": "suspend", + "type": "boolean", + "format": "" + }, + { + "name": "timeZone", + "baseName": "timeZone", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CronJobStatus.js +var V1CronJobStatus = class _V1CronJobStatus { + static getAttributeTypeMap() { + return _V1CronJobStatus.attributeTypeMap; + } + constructor() { + } +}; +V1CronJobStatus.discriminator = void 0; +V1CronJobStatus.mapping = void 0; +V1CronJobStatus.attributeTypeMap = [ + { + "name": "active", + "baseName": "active", + "type": "Array", + "format": "" + }, + { + "name": "lastScheduleTime", + "baseName": "lastScheduleTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastSuccessfulTime", + "baseName": "lastSuccessfulTime", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CrossVersionObjectReference.js +var V1CrossVersionObjectReference = class _V1CrossVersionObjectReference { + static getAttributeTypeMap() { + return _V1CrossVersionObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V1CrossVersionObjectReference.discriminator = void 0; +V1CrossVersionObjectReference.mapping = void 0; +V1CrossVersionObjectReference.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceColumnDefinition.js +var V1CustomResourceColumnDefinition = class _V1CustomResourceColumnDefinition { + static getAttributeTypeMap() { + return _V1CustomResourceColumnDefinition.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceColumnDefinition.discriminator = void 0; +V1CustomResourceColumnDefinition.mapping = void 0; +V1CustomResourceColumnDefinition.attributeTypeMap = [ + { + "name": "description", + "baseName": "description", + "type": "string", + "format": "" + }, + { + "name": "format", + "baseName": "format", + "type": "string", + "format": "" + }, + { + "name": "jsonPath", + "baseName": "jsonPath", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "priority", + "baseName": "priority", + "type": "number", + "format": "int32" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceConversion.js +var V1CustomResourceConversion = class _V1CustomResourceConversion { + static getAttributeTypeMap() { + return _V1CustomResourceConversion.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceConversion.discriminator = void 0; +V1CustomResourceConversion.mapping = void 0; +V1CustomResourceConversion.attributeTypeMap = [ + { + "name": "strategy", + "baseName": "strategy", + "type": "string", + "format": "" + }, + { + "name": "webhook", + "baseName": "webhook", + "type": "V1WebhookConversion", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinition.js +var V1CustomResourceDefinition = class _V1CustomResourceDefinition { + static getAttributeTypeMap() { + return _V1CustomResourceDefinition.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinition.discriminator = void 0; +V1CustomResourceDefinition.mapping = void 0; +V1CustomResourceDefinition.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1CustomResourceDefinitionSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1CustomResourceDefinitionStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinitionCondition.js +var V1CustomResourceDefinitionCondition = class _V1CustomResourceDefinitionCondition { + static getAttributeTypeMap() { + return _V1CustomResourceDefinitionCondition.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinitionCondition.discriminator = void 0; +V1CustomResourceDefinitionCondition.mapping = void 0; +V1CustomResourceDefinitionCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinitionList.js +var V1CustomResourceDefinitionList = class _V1CustomResourceDefinitionList { + static getAttributeTypeMap() { + return _V1CustomResourceDefinitionList.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinitionList.discriminator = void 0; +V1CustomResourceDefinitionList.mapping = void 0; +V1CustomResourceDefinitionList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinitionNames.js +var V1CustomResourceDefinitionNames = class _V1CustomResourceDefinitionNames { + static getAttributeTypeMap() { + return _V1CustomResourceDefinitionNames.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinitionNames.discriminator = void 0; +V1CustomResourceDefinitionNames.mapping = void 0; +V1CustomResourceDefinitionNames.attributeTypeMap = [ + { + "name": "categories", + "baseName": "categories", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "listKind", + "baseName": "listKind", + "type": "string", + "format": "" + }, + { + "name": "plural", + "baseName": "plural", + "type": "string", + "format": "" + }, + { + "name": "shortNames", + "baseName": "shortNames", + "type": "Array", + "format": "" + }, + { + "name": "singular", + "baseName": "singular", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinitionSpec.js +var V1CustomResourceDefinitionSpec = class _V1CustomResourceDefinitionSpec { + static getAttributeTypeMap() { + return _V1CustomResourceDefinitionSpec.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinitionSpec.discriminator = void 0; +V1CustomResourceDefinitionSpec.mapping = void 0; +V1CustomResourceDefinitionSpec.attributeTypeMap = [ + { + "name": "conversion", + "baseName": "conversion", + "type": "V1CustomResourceConversion", + "format": "" + }, + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "names", + "baseName": "names", + "type": "V1CustomResourceDefinitionNames", + "format": "" + }, + { + "name": "preserveUnknownFields", + "baseName": "preserveUnknownFields", + "type": "boolean", + "format": "" + }, + { + "name": "scope", + "baseName": "scope", + "type": "string", + "format": "" + }, + { + "name": "versions", + "baseName": "versions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinitionStatus.js +var V1CustomResourceDefinitionStatus = class _V1CustomResourceDefinitionStatus { + static getAttributeTypeMap() { + return _V1CustomResourceDefinitionStatus.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinitionStatus.discriminator = void 0; +V1CustomResourceDefinitionStatus.mapping = void 0; +V1CustomResourceDefinitionStatus.attributeTypeMap = [ + { + "name": "acceptedNames", + "baseName": "acceptedNames", + "type": "V1CustomResourceDefinitionNames", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "storedVersions", + "baseName": "storedVersions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceDefinitionVersion.js +var V1CustomResourceDefinitionVersion = class _V1CustomResourceDefinitionVersion { + static getAttributeTypeMap() { + return _V1CustomResourceDefinitionVersion.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceDefinitionVersion.discriminator = void 0; +V1CustomResourceDefinitionVersion.mapping = void 0; +V1CustomResourceDefinitionVersion.attributeTypeMap = [ + { + "name": "additionalPrinterColumns", + "baseName": "additionalPrinterColumns", + "type": "Array", + "format": "" + }, + { + "name": "deprecated", + "baseName": "deprecated", + "type": "boolean", + "format": "" + }, + { + "name": "deprecationWarning", + "baseName": "deprecationWarning", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "schema", + "baseName": "schema", + "type": "V1CustomResourceValidation", + "format": "" + }, + { + "name": "selectableFields", + "baseName": "selectableFields", + "type": "Array", + "format": "" + }, + { + "name": "served", + "baseName": "served", + "type": "boolean", + "format": "" + }, + { + "name": "storage", + "baseName": "storage", + "type": "boolean", + "format": "" + }, + { + "name": "subresources", + "baseName": "subresources", + "type": "V1CustomResourceSubresources", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceSubresourceScale.js +var V1CustomResourceSubresourceScale = class _V1CustomResourceSubresourceScale { + static getAttributeTypeMap() { + return _V1CustomResourceSubresourceScale.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceSubresourceScale.discriminator = void 0; +V1CustomResourceSubresourceScale.mapping = void 0; +V1CustomResourceSubresourceScale.attributeTypeMap = [ + { + "name": "labelSelectorPath", + "baseName": "labelSelectorPath", + "type": "string", + "format": "" + }, + { + "name": "specReplicasPath", + "baseName": "specReplicasPath", + "type": "string", + "format": "" + }, + { + "name": "statusReplicasPath", + "baseName": "statusReplicasPath", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceSubresources.js +var V1CustomResourceSubresources = class _V1CustomResourceSubresources { + static getAttributeTypeMap() { + return _V1CustomResourceSubresources.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceSubresources.discriminator = void 0; +V1CustomResourceSubresources.mapping = void 0; +V1CustomResourceSubresources.attributeTypeMap = [ + { + "name": "scale", + "baseName": "scale", + "type": "V1CustomResourceSubresourceScale", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "any", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1CustomResourceValidation.js +var V1CustomResourceValidation = class _V1CustomResourceValidation { + static getAttributeTypeMap() { + return _V1CustomResourceValidation.attributeTypeMap; + } + constructor() { + } +}; +V1CustomResourceValidation.discriminator = void 0; +V1CustomResourceValidation.mapping = void 0; +V1CustomResourceValidation.attributeTypeMap = [ + { + "name": "openAPIV3Schema", + "baseName": "openAPIV3Schema", + "type": "V1JSONSchemaProps", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonEndpoint.js +var V1DaemonEndpoint = class _V1DaemonEndpoint { + static getAttributeTypeMap() { + return _V1DaemonEndpoint.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonEndpoint.discriminator = void 0; +V1DaemonEndpoint.mapping = void 0; +V1DaemonEndpoint.attributeTypeMap = [ + { + "name": "Port", + "baseName": "Port", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonSet.js +var V1DaemonSet = class _V1DaemonSet { + static getAttributeTypeMap() { + return _V1DaemonSet.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonSet.discriminator = void 0; +V1DaemonSet.mapping = void 0; +V1DaemonSet.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1DaemonSetSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1DaemonSetStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonSetCondition.js +var V1DaemonSetCondition = class _V1DaemonSetCondition { + static getAttributeTypeMap() { + return _V1DaemonSetCondition.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonSetCondition.discriminator = void 0; +V1DaemonSetCondition.mapping = void 0; +V1DaemonSetCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonSetList.js +var V1DaemonSetList = class _V1DaemonSetList { + static getAttributeTypeMap() { + return _V1DaemonSetList.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonSetList.discriminator = void 0; +V1DaemonSetList.mapping = void 0; +V1DaemonSetList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonSetSpec.js +var V1DaemonSetSpec = class _V1DaemonSetSpec { + static getAttributeTypeMap() { + return _V1DaemonSetSpec.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonSetSpec.discriminator = void 0; +V1DaemonSetSpec.mapping = void 0; +V1DaemonSetSpec.attributeTypeMap = [ + { + "name": "minReadySeconds", + "baseName": "minReadySeconds", + "type": "number", + "format": "int32" + }, + { + "name": "revisionHistoryLimit", + "baseName": "revisionHistoryLimit", + "type": "number", + "format": "int32" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + }, + { + "name": "updateStrategy", + "baseName": "updateStrategy", + "type": "V1DaemonSetUpdateStrategy", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonSetStatus.js +var V1DaemonSetStatus = class _V1DaemonSetStatus { + static getAttributeTypeMap() { + return _V1DaemonSetStatus.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonSetStatus.discriminator = void 0; +V1DaemonSetStatus.mapping = void 0; +V1DaemonSetStatus.attributeTypeMap = [ + { + "name": "collisionCount", + "baseName": "collisionCount", + "type": "number", + "format": "int32" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "currentNumberScheduled", + "baseName": "currentNumberScheduled", + "type": "number", + "format": "int32" + }, + { + "name": "desiredNumberScheduled", + "baseName": "desiredNumberScheduled", + "type": "number", + "format": "int32" + }, + { + "name": "numberAvailable", + "baseName": "numberAvailable", + "type": "number", + "format": "int32" + }, + { + "name": "numberMisscheduled", + "baseName": "numberMisscheduled", + "type": "number", + "format": "int32" + }, + { + "name": "numberReady", + "baseName": "numberReady", + "type": "number", + "format": "int32" + }, + { + "name": "numberUnavailable", + "baseName": "numberUnavailable", + "type": "number", + "format": "int32" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "updatedNumberScheduled", + "baseName": "updatedNumberScheduled", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DaemonSetUpdateStrategy.js +var V1DaemonSetUpdateStrategy = class _V1DaemonSetUpdateStrategy { + static getAttributeTypeMap() { + return _V1DaemonSetUpdateStrategy.attributeTypeMap; + } + constructor() { + } +}; +V1DaemonSetUpdateStrategy.discriminator = void 0; +V1DaemonSetUpdateStrategy.mapping = void 0; +V1DaemonSetUpdateStrategy.attributeTypeMap = [ + { + "name": "rollingUpdate", + "baseName": "rollingUpdate", + "type": "V1RollingUpdateDaemonSet", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeleteOptions.js +var V1DeleteOptions = class _V1DeleteOptions { + static getAttributeTypeMap() { + return _V1DeleteOptions.attributeTypeMap; + } + constructor() { + } +}; +V1DeleteOptions.discriminator = void 0; +V1DeleteOptions.mapping = void 0; +V1DeleteOptions.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "dryRun", + "baseName": "dryRun", + "type": "Array", + "format": "" + }, + { + "name": "gracePeriodSeconds", + "baseName": "gracePeriodSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "baseName": "ignoreStoreReadErrorWithClusterBreakingPotential", + "type": "boolean", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "orphanDependents", + "baseName": "orphanDependents", + "type": "boolean", + "format": "" + }, + { + "name": "preconditions", + "baseName": "preconditions", + "type": "V1Preconditions", + "format": "" + }, + { + "name": "propagationPolicy", + "baseName": "propagationPolicy", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Deployment.js +var V1Deployment = class _V1Deployment { + static getAttributeTypeMap() { + return _V1Deployment.attributeTypeMap; + } + constructor() { + } +}; +V1Deployment.discriminator = void 0; +V1Deployment.mapping = void 0; +V1Deployment.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1DeploymentSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1DeploymentStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeploymentCondition.js +var V1DeploymentCondition = class _V1DeploymentCondition { + static getAttributeTypeMap() { + return _V1DeploymentCondition.attributeTypeMap; + } + constructor() { + } +}; +V1DeploymentCondition.discriminator = void 0; +V1DeploymentCondition.mapping = void 0; +V1DeploymentCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastUpdateTime", + "baseName": "lastUpdateTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeploymentList.js +var V1DeploymentList = class _V1DeploymentList { + static getAttributeTypeMap() { + return _V1DeploymentList.attributeTypeMap; + } + constructor() { + } +}; +V1DeploymentList.discriminator = void 0; +V1DeploymentList.mapping = void 0; +V1DeploymentList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeploymentSpec.js +var V1DeploymentSpec = class _V1DeploymentSpec { + static getAttributeTypeMap() { + return _V1DeploymentSpec.attributeTypeMap; + } + constructor() { + } +}; +V1DeploymentSpec.discriminator = void 0; +V1DeploymentSpec.mapping = void 0; +V1DeploymentSpec.attributeTypeMap = [ + { + "name": "minReadySeconds", + "baseName": "minReadySeconds", + "type": "number", + "format": "int32" + }, + { + "name": "paused", + "baseName": "paused", + "type": "boolean", + "format": "" + }, + { + "name": "progressDeadlineSeconds", + "baseName": "progressDeadlineSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "revisionHistoryLimit", + "baseName": "revisionHistoryLimit", + "type": "number", + "format": "int32" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "strategy", + "baseName": "strategy", + "type": "V1DeploymentStrategy", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeploymentStatus.js +var V1DeploymentStatus = class _V1DeploymentStatus { + static getAttributeTypeMap() { + return _V1DeploymentStatus.attributeTypeMap; + } + constructor() { + } +}; +V1DeploymentStatus.discriminator = void 0; +V1DeploymentStatus.mapping = void 0; +V1DeploymentStatus.attributeTypeMap = [ + { + "name": "availableReplicas", + "baseName": "availableReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "collisionCount", + "baseName": "collisionCount", + "type": "number", + "format": "int32" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "readyReplicas", + "baseName": "readyReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "terminatingReplicas", + "baseName": "terminatingReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "unavailableReplicas", + "baseName": "unavailableReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "updatedReplicas", + "baseName": "updatedReplicas", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeploymentStrategy.js +var V1DeploymentStrategy = class _V1DeploymentStrategy { + static getAttributeTypeMap() { + return _V1DeploymentStrategy.attributeTypeMap; + } + constructor() { + } +}; +V1DeploymentStrategy.discriminator = void 0; +V1DeploymentStrategy.mapping = void 0; +V1DeploymentStrategy.attributeTypeMap = [ + { + "name": "rollingUpdate", + "baseName": "rollingUpdate", + "type": "V1RollingUpdateDeployment", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Device.js +var V1Device = class _V1Device { + static getAttributeTypeMap() { + return _V1Device.attributeTypeMap; + } + constructor() { + } +}; +V1Device.discriminator = void 0; +V1Device.mapping = void 0; +V1Device.attributeTypeMap = [ + { + "name": "allNodes", + "baseName": "allNodes", + "type": "boolean", + "format": "" + }, + { + "name": "allowMultipleAllocations", + "baseName": "allowMultipleAllocations", + "type": "boolean", + "format": "" + }, + { + "name": "attributes", + "baseName": "attributes", + "type": "{ [key: string]: V1DeviceAttribute; }", + "format": "" + }, + { + "name": "bindingConditions", + "baseName": "bindingConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindingFailureConditions", + "baseName": "bindingFailureConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindsToNode", + "baseName": "bindsToNode", + "type": "boolean", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "{ [key: string]: V1DeviceCapacity; }", + "format": "" + }, + { + "name": "consumesCounters", + "baseName": "consumesCounters", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + }, + { + "name": "taints", + "baseName": "taints", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceAllocationConfiguration.js +var V1DeviceAllocationConfiguration = class _V1DeviceAllocationConfiguration { + static getAttributeTypeMap() { + return _V1DeviceAllocationConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceAllocationConfiguration.discriminator = void 0; +V1DeviceAllocationConfiguration.mapping = void 0; +V1DeviceAllocationConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1OpaqueDeviceConfiguration", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + }, + { + "name": "source", + "baseName": "source", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceAllocationResult.js +var V1DeviceAllocationResult = class _V1DeviceAllocationResult { + static getAttributeTypeMap() { + return _V1DeviceAllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceAllocationResult.discriminator = void 0; +V1DeviceAllocationResult.mapping = void 0; +V1DeviceAllocationResult.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "results", + "baseName": "results", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceAttribute.js +var V1DeviceAttribute = class _V1DeviceAttribute { + static getAttributeTypeMap() { + return _V1DeviceAttribute.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceAttribute.discriminator = void 0; +V1DeviceAttribute.mapping = void 0; +V1DeviceAttribute.attributeTypeMap = [ + { + "name": "bool", + "baseName": "bool", + "type": "boolean", + "format": "" + }, + { + "name": "_int", + "baseName": "int", + "type": "number", + "format": "int64" + }, + { + "name": "string", + "baseName": "string", + "type": "string", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceCapacity.js +var V1DeviceCapacity = class _V1DeviceCapacity { + static getAttributeTypeMap() { + return _V1DeviceCapacity.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceCapacity.discriminator = void 0; +V1DeviceCapacity.mapping = void 0; +V1DeviceCapacity.attributeTypeMap = [ + { + "name": "requestPolicy", + "baseName": "requestPolicy", + "type": "V1CapacityRequestPolicy", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceClaim.js +var V1DeviceClaim = class _V1DeviceClaim { + static getAttributeTypeMap() { + return _V1DeviceClaim.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceClaim.discriminator = void 0; +V1DeviceClaim.mapping = void 0; +V1DeviceClaim.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "constraints", + "baseName": "constraints", + "type": "Array", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceClaimConfiguration.js +var V1DeviceClaimConfiguration = class _V1DeviceClaimConfiguration { + static getAttributeTypeMap() { + return _V1DeviceClaimConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceClaimConfiguration.discriminator = void 0; +V1DeviceClaimConfiguration.mapping = void 0; +V1DeviceClaimConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1OpaqueDeviceConfiguration", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceClass.js +var V1DeviceClass = class _V1DeviceClass { + static getAttributeTypeMap() { + return _V1DeviceClass.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceClass.discriminator = void 0; +V1DeviceClass.mapping = void 0; +V1DeviceClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1DeviceClassSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceClassConfiguration.js +var V1DeviceClassConfiguration = class _V1DeviceClassConfiguration { + static getAttributeTypeMap() { + return _V1DeviceClassConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceClassConfiguration.discriminator = void 0; +V1DeviceClassConfiguration.mapping = void 0; +V1DeviceClassConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1OpaqueDeviceConfiguration", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceClassList.js +var V1DeviceClassList = class _V1DeviceClassList { + static getAttributeTypeMap() { + return _V1DeviceClassList.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceClassList.discriminator = void 0; +V1DeviceClassList.mapping = void 0; +V1DeviceClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceClassSpec.js +var V1DeviceClassSpec = class _V1DeviceClassSpec { + static getAttributeTypeMap() { + return _V1DeviceClassSpec.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceClassSpec.discriminator = void 0; +V1DeviceClassSpec.mapping = void 0; +V1DeviceClassSpec.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "extendedResourceName", + "baseName": "extendedResourceName", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceConstraint.js +var V1DeviceConstraint = class _V1DeviceConstraint { + static getAttributeTypeMap() { + return _V1DeviceConstraint.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceConstraint.discriminator = void 0; +V1DeviceConstraint.mapping = void 0; +V1DeviceConstraint.attributeTypeMap = [ + { + "name": "distinctAttribute", + "baseName": "distinctAttribute", + "type": "string", + "format": "" + }, + { + "name": "matchAttribute", + "baseName": "matchAttribute", + "type": "string", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceCounterConsumption.js +var V1DeviceCounterConsumption = class _V1DeviceCounterConsumption { + static getAttributeTypeMap() { + return _V1DeviceCounterConsumption.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceCounterConsumption.discriminator = void 0; +V1DeviceCounterConsumption.mapping = void 0; +V1DeviceCounterConsumption.attributeTypeMap = [ + { + "name": "counterSet", + "baseName": "counterSet", + "type": "string", + "format": "" + }, + { + "name": "counters", + "baseName": "counters", + "type": "{ [key: string]: V1Counter; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceRequest.js +var V1DeviceRequest = class _V1DeviceRequest { + static getAttributeTypeMap() { + return _V1DeviceRequest.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceRequest.discriminator = void 0; +V1DeviceRequest.mapping = void 0; +V1DeviceRequest.attributeTypeMap = [ + { + "name": "exactly", + "baseName": "exactly", + "type": "V1ExactDeviceRequest", + "format": "" + }, + { + "name": "firstAvailable", + "baseName": "firstAvailable", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceRequestAllocationResult.js +var V1DeviceRequestAllocationResult = class _V1DeviceRequestAllocationResult { + static getAttributeTypeMap() { + return _V1DeviceRequestAllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceRequestAllocationResult.discriminator = void 0; +V1DeviceRequestAllocationResult.mapping = void 0; +V1DeviceRequestAllocationResult.attributeTypeMap = [ + { + "name": "adminAccess", + "baseName": "adminAccess", + "type": "boolean", + "format": "" + }, + { + "name": "bindingConditions", + "baseName": "bindingConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindingFailureConditions", + "baseName": "bindingFailureConditions", + "type": "Array", + "format": "" + }, + { + "name": "consumedCapacity", + "baseName": "consumedCapacity", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "request", + "baseName": "request", + "type": "string", + "format": "" + }, + { + "name": "shareID", + "baseName": "shareID", + "type": "string", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceSelector.js +var V1DeviceSelector = class _V1DeviceSelector { + static getAttributeTypeMap() { + return _V1DeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceSelector.discriminator = void 0; +V1DeviceSelector.mapping = void 0; +V1DeviceSelector.attributeTypeMap = [ + { + "name": "cel", + "baseName": "cel", + "type": "V1CELDeviceSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceSubRequest.js +var V1DeviceSubRequest = class _V1DeviceSubRequest { + static getAttributeTypeMap() { + return _V1DeviceSubRequest.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceSubRequest.discriminator = void 0; +V1DeviceSubRequest.mapping = void 0; +V1DeviceSubRequest.attributeTypeMap = [ + { + "name": "allocationMode", + "baseName": "allocationMode", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "V1CapacityRequirements", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int64" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceTaint.js +var V1DeviceTaint = class _V1DeviceTaint { + static getAttributeTypeMap() { + return _V1DeviceTaint.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceTaint.discriminator = void 0; +V1DeviceTaint.mapping = void 0; +V1DeviceTaint.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "timeAdded", + "baseName": "timeAdded", + "type": "Date", + "format": "date-time" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DeviceToleration.js +var V1DeviceToleration = class _V1DeviceToleration { + static getAttributeTypeMap() { + return _V1DeviceToleration.attributeTypeMap; + } + constructor() { + } +}; +V1DeviceToleration.discriminator = void 0; +V1DeviceToleration.mapping = void 0; +V1DeviceToleration.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "tolerationSeconds", + "baseName": "tolerationSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DownwardAPIProjection.js +var V1DownwardAPIProjection = class _V1DownwardAPIProjection { + static getAttributeTypeMap() { + return _V1DownwardAPIProjection.attributeTypeMap; + } + constructor() { + } +}; +V1DownwardAPIProjection.discriminator = void 0; +V1DownwardAPIProjection.mapping = void 0; +V1DownwardAPIProjection.attributeTypeMap = [ + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DownwardAPIVolumeFile.js +var V1DownwardAPIVolumeFile = class _V1DownwardAPIVolumeFile { + static getAttributeTypeMap() { + return _V1DownwardAPIVolumeFile.attributeTypeMap; + } + constructor() { + } +}; +V1DownwardAPIVolumeFile.discriminator = void 0; +V1DownwardAPIVolumeFile.mapping = void 0; +V1DownwardAPIVolumeFile.attributeTypeMap = [ + { + "name": "fieldRef", + "baseName": "fieldRef", + "type": "V1ObjectFieldSelector", + "format": "" + }, + { + "name": "mode", + "baseName": "mode", + "type": "number", + "format": "int32" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "resourceFieldRef", + "baseName": "resourceFieldRef", + "type": "V1ResourceFieldSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1DownwardAPIVolumeSource.js +var V1DownwardAPIVolumeSource = class _V1DownwardAPIVolumeSource { + static getAttributeTypeMap() { + return _V1DownwardAPIVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1DownwardAPIVolumeSource.discriminator = void 0; +V1DownwardAPIVolumeSource.mapping = void 0; +V1DownwardAPIVolumeSource.attributeTypeMap = [ + { + "name": "defaultMode", + "baseName": "defaultMode", + "type": "number", + "format": "int32" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EmptyDirVolumeSource.js +var V1EmptyDirVolumeSource = class _V1EmptyDirVolumeSource { + static getAttributeTypeMap() { + return _V1EmptyDirVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1EmptyDirVolumeSource.discriminator = void 0; +V1EmptyDirVolumeSource.mapping = void 0; +V1EmptyDirVolumeSource.attributeTypeMap = [ + { + "name": "medium", + "baseName": "medium", + "type": "string", + "format": "" + }, + { + "name": "sizeLimit", + "baseName": "sizeLimit", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Endpoint.js +var V1Endpoint = class _V1Endpoint { + static getAttributeTypeMap() { + return _V1Endpoint.attributeTypeMap; + } + constructor() { + } +}; +V1Endpoint.discriminator = void 0; +V1Endpoint.mapping = void 0; +V1Endpoint.attributeTypeMap = [ + { + "name": "addresses", + "baseName": "addresses", + "type": "Array", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "V1EndpointConditions", + "format": "" + }, + { + "name": "deprecatedTopology", + "baseName": "deprecatedTopology", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "hints", + "baseName": "hints", + "type": "V1EndpointHints", + "format": "" + }, + { + "name": "hostname", + "baseName": "hostname", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "targetRef", + "baseName": "targetRef", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "zone", + "baseName": "zone", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointAddress.js +var V1EndpointAddress = class _V1EndpointAddress { + static getAttributeTypeMap() { + return _V1EndpointAddress.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointAddress.discriminator = void 0; +V1EndpointAddress.mapping = void 0; +V1EndpointAddress.attributeTypeMap = [ + { + "name": "hostname", + "baseName": "hostname", + "type": "string", + "format": "" + }, + { + "name": "ip", + "baseName": "ip", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "targetRef", + "baseName": "targetRef", + "type": "V1ObjectReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointConditions.js +var V1EndpointConditions = class _V1EndpointConditions { + static getAttributeTypeMap() { + return _V1EndpointConditions.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointConditions.discriminator = void 0; +V1EndpointConditions.mapping = void 0; +V1EndpointConditions.attributeTypeMap = [ + { + "name": "ready", + "baseName": "ready", + "type": "boolean", + "format": "" + }, + { + "name": "serving", + "baseName": "serving", + "type": "boolean", + "format": "" + }, + { + "name": "terminating", + "baseName": "terminating", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointHints.js +var V1EndpointHints = class _V1EndpointHints { + static getAttributeTypeMap() { + return _V1EndpointHints.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointHints.discriminator = void 0; +V1EndpointHints.mapping = void 0; +V1EndpointHints.attributeTypeMap = [ + { + "name": "forNodes", + "baseName": "forNodes", + "type": "Array", + "format": "" + }, + { + "name": "forZones", + "baseName": "forZones", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointSlice.js +var V1EndpointSlice = class _V1EndpointSlice { + static getAttributeTypeMap() { + return _V1EndpointSlice.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointSlice.discriminator = void 0; +V1EndpointSlice.mapping = void 0; +V1EndpointSlice.attributeTypeMap = [ + { + "name": "addressType", + "baseName": "addressType", + "type": "string", + "format": "" + }, + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "endpoints", + "baseName": "endpoints", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointSliceList.js +var V1EndpointSliceList = class _V1EndpointSliceList { + static getAttributeTypeMap() { + return _V1EndpointSliceList.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointSliceList.discriminator = void 0; +V1EndpointSliceList.mapping = void 0; +V1EndpointSliceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointSubset.js +var V1EndpointSubset = class _V1EndpointSubset { + static getAttributeTypeMap() { + return _V1EndpointSubset.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointSubset.discriminator = void 0; +V1EndpointSubset.mapping = void 0; +V1EndpointSubset.attributeTypeMap = [ + { + "name": "addresses", + "baseName": "addresses", + "type": "Array", + "format": "" + }, + { + "name": "notReadyAddresses", + "baseName": "notReadyAddresses", + "type": "Array", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Endpoints.js +var V1Endpoints = class _V1Endpoints { + static getAttributeTypeMap() { + return _V1Endpoints.attributeTypeMap; + } + constructor() { + } +}; +V1Endpoints.discriminator = void 0; +V1Endpoints.mapping = void 0; +V1Endpoints.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "subsets", + "baseName": "subsets", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EndpointsList.js +var V1EndpointsList = class _V1EndpointsList { + static getAttributeTypeMap() { + return _V1EndpointsList.attributeTypeMap; + } + constructor() { + } +}; +V1EndpointsList.discriminator = void 0; +V1EndpointsList.mapping = void 0; +V1EndpointsList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EnvFromSource.js +var V1EnvFromSource = class _V1EnvFromSource { + static getAttributeTypeMap() { + return _V1EnvFromSource.attributeTypeMap; + } + constructor() { + } +}; +V1EnvFromSource.discriminator = void 0; +V1EnvFromSource.mapping = void 0; +V1EnvFromSource.attributeTypeMap = [ + { + "name": "configMapRef", + "baseName": "configMapRef", + "type": "V1ConfigMapEnvSource", + "format": "" + }, + { + "name": "prefix", + "baseName": "prefix", + "type": "string", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretEnvSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EnvVar.js +var V1EnvVar = class _V1EnvVar { + static getAttributeTypeMap() { + return _V1EnvVar.attributeTypeMap; + } + constructor() { + } +}; +V1EnvVar.discriminator = void 0; +V1EnvVar.mapping = void 0; +V1EnvVar.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + }, + { + "name": "valueFrom", + "baseName": "valueFrom", + "type": "V1EnvVarSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EnvVarSource.js +var V1EnvVarSource = class _V1EnvVarSource { + static getAttributeTypeMap() { + return _V1EnvVarSource.attributeTypeMap; + } + constructor() { + } +}; +V1EnvVarSource.discriminator = void 0; +V1EnvVarSource.mapping = void 0; +V1EnvVarSource.attributeTypeMap = [ + { + "name": "configMapKeyRef", + "baseName": "configMapKeyRef", + "type": "V1ConfigMapKeySelector", + "format": "" + }, + { + "name": "fieldRef", + "baseName": "fieldRef", + "type": "V1ObjectFieldSelector", + "format": "" + }, + { + "name": "fileKeyRef", + "baseName": "fileKeyRef", + "type": "V1FileKeySelector", + "format": "" + }, + { + "name": "resourceFieldRef", + "baseName": "resourceFieldRef", + "type": "V1ResourceFieldSelector", + "format": "" + }, + { + "name": "secretKeyRef", + "baseName": "secretKeyRef", + "type": "V1SecretKeySelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EphemeralContainer.js +var V1EphemeralContainer = class _V1EphemeralContainer { + static getAttributeTypeMap() { + return _V1EphemeralContainer.attributeTypeMap; + } + constructor() { + } +}; +V1EphemeralContainer.discriminator = void 0; +V1EphemeralContainer.mapping = void 0; +V1EphemeralContainer.attributeTypeMap = [ + { + "name": "args", + "baseName": "args", + "type": "Array", + "format": "" + }, + { + "name": "command", + "baseName": "command", + "type": "Array", + "format": "" + }, + { + "name": "env", + "baseName": "env", + "type": "Array", + "format": "" + }, + { + "name": "envFrom", + "baseName": "envFrom", + "type": "Array", + "format": "" + }, + { + "name": "image", + "baseName": "image", + "type": "string", + "format": "" + }, + { + "name": "imagePullPolicy", + "baseName": "imagePullPolicy", + "type": "string", + "format": "" + }, + { + "name": "lifecycle", + "baseName": "lifecycle", + "type": "V1Lifecycle", + "format": "" + }, + { + "name": "livenessProbe", + "baseName": "livenessProbe", + "type": "V1Probe", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + }, + { + "name": "readinessProbe", + "baseName": "readinessProbe", + "type": "V1Probe", + "format": "" + }, + { + "name": "resizePolicy", + "baseName": "resizePolicy", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "V1ResourceRequirements", + "format": "" + }, + { + "name": "restartPolicy", + "baseName": "restartPolicy", + "type": "string", + "format": "" + }, + { + "name": "restartPolicyRules", + "baseName": "restartPolicyRules", + "type": "Array", + "format": "" + }, + { + "name": "securityContext", + "baseName": "securityContext", + "type": "V1SecurityContext", + "format": "" + }, + { + "name": "startupProbe", + "baseName": "startupProbe", + "type": "V1Probe", + "format": "" + }, + { + "name": "stdin", + "baseName": "stdin", + "type": "boolean", + "format": "" + }, + { + "name": "stdinOnce", + "baseName": "stdinOnce", + "type": "boolean", + "format": "" + }, + { + "name": "targetContainerName", + "baseName": "targetContainerName", + "type": "string", + "format": "" + }, + { + "name": "terminationMessagePath", + "baseName": "terminationMessagePath", + "type": "string", + "format": "" + }, + { + "name": "terminationMessagePolicy", + "baseName": "terminationMessagePolicy", + "type": "string", + "format": "" + }, + { + "name": "tty", + "baseName": "tty", + "type": "boolean", + "format": "" + }, + { + "name": "volumeDevices", + "baseName": "volumeDevices", + "type": "Array", + "format": "" + }, + { + "name": "volumeMounts", + "baseName": "volumeMounts", + "type": "Array", + "format": "" + }, + { + "name": "workingDir", + "baseName": "workingDir", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EphemeralVolumeSource.js +var V1EphemeralVolumeSource = class _V1EphemeralVolumeSource { + static getAttributeTypeMap() { + return _V1EphemeralVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1EphemeralVolumeSource.discriminator = void 0; +V1EphemeralVolumeSource.mapping = void 0; +V1EphemeralVolumeSource.attributeTypeMap = [ + { + "name": "volumeClaimTemplate", + "baseName": "volumeClaimTemplate", + "type": "V1PersistentVolumeClaimTemplate", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1EventSource.js +var V1EventSource = class _V1EventSource { + static getAttributeTypeMap() { + return _V1EventSource.attributeTypeMap; + } + constructor() { + } +}; +V1EventSource.discriminator = void 0; +V1EventSource.mapping = void 0; +V1EventSource.attributeTypeMap = [ + { + "name": "component", + "baseName": "component", + "type": "string", + "format": "" + }, + { + "name": "host", + "baseName": "host", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Eviction.js +var V1Eviction = class _V1Eviction { + static getAttributeTypeMap() { + return _V1Eviction.attributeTypeMap; + } + constructor() { + } +}; +V1Eviction.discriminator = void 0; +V1Eviction.mapping = void 0; +V1Eviction.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "deleteOptions", + "baseName": "deleteOptions", + "type": "V1DeleteOptions", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ExactDeviceRequest.js +var V1ExactDeviceRequest = class _V1ExactDeviceRequest { + static getAttributeTypeMap() { + return _V1ExactDeviceRequest.attributeTypeMap; + } + constructor() { + } +}; +V1ExactDeviceRequest.discriminator = void 0; +V1ExactDeviceRequest.mapping = void 0; +V1ExactDeviceRequest.attributeTypeMap = [ + { + "name": "adminAccess", + "baseName": "adminAccess", + "type": "boolean", + "format": "" + }, + { + "name": "allocationMode", + "baseName": "allocationMode", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "V1CapacityRequirements", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int64" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ExecAction.js +var V1ExecAction = class _V1ExecAction { + static getAttributeTypeMap() { + return _V1ExecAction.attributeTypeMap; + } + constructor() { + } +}; +V1ExecAction.discriminator = void 0; +V1ExecAction.mapping = void 0; +V1ExecAction.attributeTypeMap = [ + { + "name": "command", + "baseName": "command", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ExemptPriorityLevelConfiguration.js +var V1ExemptPriorityLevelConfiguration = class _V1ExemptPriorityLevelConfiguration { + static getAttributeTypeMap() { + return _V1ExemptPriorityLevelConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1ExemptPriorityLevelConfiguration.discriminator = void 0; +V1ExemptPriorityLevelConfiguration.mapping = void 0; +V1ExemptPriorityLevelConfiguration.attributeTypeMap = [ + { + "name": "lendablePercent", + "baseName": "lendablePercent", + "type": "number", + "format": "int32" + }, + { + "name": "nominalConcurrencyShares", + "baseName": "nominalConcurrencyShares", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ExpressionWarning.js +var V1ExpressionWarning = class _V1ExpressionWarning { + static getAttributeTypeMap() { + return _V1ExpressionWarning.attributeTypeMap; + } + constructor() { + } +}; +V1ExpressionWarning.discriminator = void 0; +V1ExpressionWarning.mapping = void 0; +V1ExpressionWarning.attributeTypeMap = [ + { + "name": "fieldRef", + "baseName": "fieldRef", + "type": "string", + "format": "" + }, + { + "name": "warning", + "baseName": "warning", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ExternalDocumentation.js +var V1ExternalDocumentation = class _V1ExternalDocumentation { + static getAttributeTypeMap() { + return _V1ExternalDocumentation.attributeTypeMap; + } + constructor() { + } +}; +V1ExternalDocumentation.discriminator = void 0; +V1ExternalDocumentation.mapping = void 0; +V1ExternalDocumentation.attributeTypeMap = [ + { + "name": "description", + "baseName": "description", + "type": "string", + "format": "" + }, + { + "name": "url", + "baseName": "url", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FCVolumeSource.js +var V1FCVolumeSource = class _V1FCVolumeSource { + static getAttributeTypeMap() { + return _V1FCVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1FCVolumeSource.discriminator = void 0; +V1FCVolumeSource.mapping = void 0; +V1FCVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "lun", + "baseName": "lun", + "type": "number", + "format": "int32" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "targetWWNs", + "baseName": "targetWWNs", + "type": "Array", + "format": "" + }, + { + "name": "wwids", + "baseName": "wwids", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FieldSelectorAttributes.js +var V1FieldSelectorAttributes = class _V1FieldSelectorAttributes { + static getAttributeTypeMap() { + return _V1FieldSelectorAttributes.attributeTypeMap; + } + constructor() { + } +}; +V1FieldSelectorAttributes.discriminator = void 0; +V1FieldSelectorAttributes.mapping = void 0; +V1FieldSelectorAttributes.attributeTypeMap = [ + { + "name": "rawSelector", + "baseName": "rawSelector", + "type": "string", + "format": "" + }, + { + "name": "requirements", + "baseName": "requirements", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FieldSelectorRequirement.js +var V1FieldSelectorRequirement = class _V1FieldSelectorRequirement { + static getAttributeTypeMap() { + return _V1FieldSelectorRequirement.attributeTypeMap; + } + constructor() { + } +}; +V1FieldSelectorRequirement.discriminator = void 0; +V1FieldSelectorRequirement.mapping = void 0; +V1FieldSelectorRequirement.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FileKeySelector.js +var V1FileKeySelector = class _V1FileKeySelector { + static getAttributeTypeMap() { + return _V1FileKeySelector.attributeTypeMap; + } + constructor() { + } +}; +V1FileKeySelector.discriminator = void 0; +V1FileKeySelector.mapping = void 0; +V1FileKeySelector.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "volumeName", + "baseName": "volumeName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlexPersistentVolumeSource.js +var V1FlexPersistentVolumeSource = class _V1FlexPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1FlexPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1FlexPersistentVolumeSource.discriminator = void 0; +V1FlexPersistentVolumeSource.mapping = void 0; +V1FlexPersistentVolumeSource.attributeTypeMap = [ + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "options", + "baseName": "options", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlexVolumeSource.js +var V1FlexVolumeSource = class _V1FlexVolumeSource { + static getAttributeTypeMap() { + return _V1FlexVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1FlexVolumeSource.discriminator = void 0; +V1FlexVolumeSource.mapping = void 0; +V1FlexVolumeSource.attributeTypeMap = [ + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "options", + "baseName": "options", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlockerVolumeSource.js +var V1FlockerVolumeSource = class _V1FlockerVolumeSource { + static getAttributeTypeMap() { + return _V1FlockerVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1FlockerVolumeSource.discriminator = void 0; +V1FlockerVolumeSource.mapping = void 0; +V1FlockerVolumeSource.attributeTypeMap = [ + { + "name": "datasetName", + "baseName": "datasetName", + "type": "string", + "format": "" + }, + { + "name": "datasetUUID", + "baseName": "datasetUUID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlowDistinguisherMethod.js +var V1FlowDistinguisherMethod = class _V1FlowDistinguisherMethod { + static getAttributeTypeMap() { + return _V1FlowDistinguisherMethod.attributeTypeMap; + } + constructor() { + } +}; +V1FlowDistinguisherMethod.discriminator = void 0; +V1FlowDistinguisherMethod.mapping = void 0; +V1FlowDistinguisherMethod.attributeTypeMap = [ + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlowSchema.js +var V1FlowSchema = class _V1FlowSchema { + static getAttributeTypeMap() { + return _V1FlowSchema.attributeTypeMap; + } + constructor() { + } +}; +V1FlowSchema.discriminator = void 0; +V1FlowSchema.mapping = void 0; +V1FlowSchema.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1FlowSchemaSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1FlowSchemaStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlowSchemaCondition.js +var V1FlowSchemaCondition = class _V1FlowSchemaCondition { + static getAttributeTypeMap() { + return _V1FlowSchemaCondition.attributeTypeMap; + } + constructor() { + } +}; +V1FlowSchemaCondition.discriminator = void 0; +V1FlowSchemaCondition.mapping = void 0; +V1FlowSchemaCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlowSchemaList.js +var V1FlowSchemaList = class _V1FlowSchemaList { + static getAttributeTypeMap() { + return _V1FlowSchemaList.attributeTypeMap; + } + constructor() { + } +}; +V1FlowSchemaList.discriminator = void 0; +V1FlowSchemaList.mapping = void 0; +V1FlowSchemaList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlowSchemaSpec.js +var V1FlowSchemaSpec = class _V1FlowSchemaSpec { + static getAttributeTypeMap() { + return _V1FlowSchemaSpec.attributeTypeMap; + } + constructor() { + } +}; +V1FlowSchemaSpec.discriminator = void 0; +V1FlowSchemaSpec.mapping = void 0; +V1FlowSchemaSpec.attributeTypeMap = [ + { + "name": "distinguisherMethod", + "baseName": "distinguisherMethod", + "type": "V1FlowDistinguisherMethod", + "format": "" + }, + { + "name": "matchingPrecedence", + "baseName": "matchingPrecedence", + "type": "number", + "format": "int32" + }, + { + "name": "priorityLevelConfiguration", + "baseName": "priorityLevelConfiguration", + "type": "V1PriorityLevelConfigurationReference", + "format": "" + }, + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1FlowSchemaStatus.js +var V1FlowSchemaStatus = class _V1FlowSchemaStatus { + static getAttributeTypeMap() { + return _V1FlowSchemaStatus.attributeTypeMap; + } + constructor() { + } +}; +V1FlowSchemaStatus.discriminator = void 0; +V1FlowSchemaStatus.mapping = void 0; +V1FlowSchemaStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ForNode.js +var V1ForNode = class _V1ForNode { + static getAttributeTypeMap() { + return _V1ForNode.attributeTypeMap; + } + constructor() { + } +}; +V1ForNode.discriminator = void 0; +V1ForNode.mapping = void 0; +V1ForNode.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ForZone.js +var V1ForZone = class _V1ForZone { + static getAttributeTypeMap() { + return _V1ForZone.attributeTypeMap; + } + constructor() { + } +}; +V1ForZone.discriminator = void 0; +V1ForZone.mapping = void 0; +V1ForZone.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GCEPersistentDiskVolumeSource.js +var V1GCEPersistentDiskVolumeSource = class _V1GCEPersistentDiskVolumeSource { + static getAttributeTypeMap() { + return _V1GCEPersistentDiskVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1GCEPersistentDiskVolumeSource.discriminator = void 0; +V1GCEPersistentDiskVolumeSource.mapping = void 0; +V1GCEPersistentDiskVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "partition", + "baseName": "partition", + "type": "number", + "format": "int32" + }, + { + "name": "pdName", + "baseName": "pdName", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GRPCAction.js +var V1GRPCAction = class _V1GRPCAction { + static getAttributeTypeMap() { + return _V1GRPCAction.attributeTypeMap; + } + constructor() { + } +}; +V1GRPCAction.discriminator = void 0; +V1GRPCAction.mapping = void 0; +V1GRPCAction.attributeTypeMap = [ + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + }, + { + "name": "service", + "baseName": "service", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GitRepoVolumeSource.js +var V1GitRepoVolumeSource = class _V1GitRepoVolumeSource { + static getAttributeTypeMap() { + return _V1GitRepoVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1GitRepoVolumeSource.discriminator = void 0; +V1GitRepoVolumeSource.mapping = void 0; +V1GitRepoVolumeSource.attributeTypeMap = [ + { + "name": "directory", + "baseName": "directory", + "type": "string", + "format": "" + }, + { + "name": "repository", + "baseName": "repository", + "type": "string", + "format": "" + }, + { + "name": "revision", + "baseName": "revision", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GlusterfsPersistentVolumeSource.js +var V1GlusterfsPersistentVolumeSource = class _V1GlusterfsPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1GlusterfsPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1GlusterfsPersistentVolumeSource.discriminator = void 0; +V1GlusterfsPersistentVolumeSource.mapping = void 0; +V1GlusterfsPersistentVolumeSource.attributeTypeMap = [ + { + "name": "endpoints", + "baseName": "endpoints", + "type": "string", + "format": "" + }, + { + "name": "endpointsNamespace", + "baseName": "endpointsNamespace", + "type": "string", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GlusterfsVolumeSource.js +var V1GlusterfsVolumeSource = class _V1GlusterfsVolumeSource { + static getAttributeTypeMap() { + return _V1GlusterfsVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1GlusterfsVolumeSource.discriminator = void 0; +V1GlusterfsVolumeSource.mapping = void 0; +V1GlusterfsVolumeSource.attributeTypeMap = [ + { + "name": "endpoints", + "baseName": "endpoints", + "type": "string", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GroupSubject.js +var V1GroupSubject = class _V1GroupSubject { + static getAttributeTypeMap() { + return _V1GroupSubject.attributeTypeMap; + } + constructor() { + } +}; +V1GroupSubject.discriminator = void 0; +V1GroupSubject.mapping = void 0; +V1GroupSubject.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1GroupVersionForDiscovery.js +var V1GroupVersionForDiscovery = class _V1GroupVersionForDiscovery { + static getAttributeTypeMap() { + return _V1GroupVersionForDiscovery.attributeTypeMap; + } + constructor() { + } +}; +V1GroupVersionForDiscovery.discriminator = void 0; +V1GroupVersionForDiscovery.mapping = void 0; +V1GroupVersionForDiscovery.attributeTypeMap = [ + { + "name": "groupVersion", + "baseName": "groupVersion", + "type": "string", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HTTPGetAction.js +var V1HTTPGetAction = class _V1HTTPGetAction { + static getAttributeTypeMap() { + return _V1HTTPGetAction.attributeTypeMap; + } + constructor() { + } +}; +V1HTTPGetAction.discriminator = void 0; +V1HTTPGetAction.mapping = void 0; +V1HTTPGetAction.attributeTypeMap = [ + { + "name": "host", + "baseName": "host", + "type": "string", + "format": "" + }, + { + "name": "httpHeaders", + "baseName": "httpHeaders", + "type": "Array", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "scheme", + "baseName": "scheme", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HTTPHeader.js +var V1HTTPHeader = class _V1HTTPHeader { + static getAttributeTypeMap() { + return _V1HTTPHeader.attributeTypeMap; + } + constructor() { + } +}; +V1HTTPHeader.discriminator = void 0; +V1HTTPHeader.mapping = void 0; +V1HTTPHeader.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HTTPIngressPath.js +var V1HTTPIngressPath = class _V1HTTPIngressPath { + static getAttributeTypeMap() { + return _V1HTTPIngressPath.attributeTypeMap; + } + constructor() { + } +}; +V1HTTPIngressPath.discriminator = void 0; +V1HTTPIngressPath.mapping = void 0; +V1HTTPIngressPath.attributeTypeMap = [ + { + "name": "backend", + "baseName": "backend", + "type": "V1IngressBackend", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "pathType", + "baseName": "pathType", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HTTPIngressRuleValue.js +var V1HTTPIngressRuleValue = class _V1HTTPIngressRuleValue { + static getAttributeTypeMap() { + return _V1HTTPIngressRuleValue.attributeTypeMap; + } + constructor() { + } +}; +V1HTTPIngressRuleValue.discriminator = void 0; +V1HTTPIngressRuleValue.mapping = void 0; +V1HTTPIngressRuleValue.attributeTypeMap = [ + { + "name": "paths", + "baseName": "paths", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HorizontalPodAutoscaler.js +var V1HorizontalPodAutoscaler = class _V1HorizontalPodAutoscaler { + static getAttributeTypeMap() { + return _V1HorizontalPodAutoscaler.attributeTypeMap; + } + constructor() { + } +}; +V1HorizontalPodAutoscaler.discriminator = void 0; +V1HorizontalPodAutoscaler.mapping = void 0; +V1HorizontalPodAutoscaler.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1HorizontalPodAutoscalerSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1HorizontalPodAutoscalerStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HorizontalPodAutoscalerList.js +var V1HorizontalPodAutoscalerList = class _V1HorizontalPodAutoscalerList { + static getAttributeTypeMap() { + return _V1HorizontalPodAutoscalerList.attributeTypeMap; + } + constructor() { + } +}; +V1HorizontalPodAutoscalerList.discriminator = void 0; +V1HorizontalPodAutoscalerList.mapping = void 0; +V1HorizontalPodAutoscalerList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HorizontalPodAutoscalerSpec.js +var V1HorizontalPodAutoscalerSpec = class _V1HorizontalPodAutoscalerSpec { + static getAttributeTypeMap() { + return _V1HorizontalPodAutoscalerSpec.attributeTypeMap; + } + constructor() { + } +}; +V1HorizontalPodAutoscalerSpec.discriminator = void 0; +V1HorizontalPodAutoscalerSpec.mapping = void 0; +V1HorizontalPodAutoscalerSpec.attributeTypeMap = [ + { + "name": "maxReplicas", + "baseName": "maxReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "minReplicas", + "baseName": "minReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "scaleTargetRef", + "baseName": "scaleTargetRef", + "type": "V1CrossVersionObjectReference", + "format": "" + }, + { + "name": "targetCPUUtilizationPercentage", + "baseName": "targetCPUUtilizationPercentage", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HorizontalPodAutoscalerStatus.js +var V1HorizontalPodAutoscalerStatus = class _V1HorizontalPodAutoscalerStatus { + static getAttributeTypeMap() { + return _V1HorizontalPodAutoscalerStatus.attributeTypeMap; + } + constructor() { + } +}; +V1HorizontalPodAutoscalerStatus.discriminator = void 0; +V1HorizontalPodAutoscalerStatus.mapping = void 0; +V1HorizontalPodAutoscalerStatus.attributeTypeMap = [ + { + "name": "currentCPUUtilizationPercentage", + "baseName": "currentCPUUtilizationPercentage", + "type": "number", + "format": "int32" + }, + { + "name": "currentReplicas", + "baseName": "currentReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "desiredReplicas", + "baseName": "desiredReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "lastScaleTime", + "baseName": "lastScaleTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HostAlias.js +var V1HostAlias = class _V1HostAlias { + static getAttributeTypeMap() { + return _V1HostAlias.attributeTypeMap; + } + constructor() { + } +}; +V1HostAlias.discriminator = void 0; +V1HostAlias.mapping = void 0; +V1HostAlias.attributeTypeMap = [ + { + "name": "hostnames", + "baseName": "hostnames", + "type": "Array", + "format": "" + }, + { + "name": "ip", + "baseName": "ip", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HostIP.js +var V1HostIP = class _V1HostIP { + static getAttributeTypeMap() { + return _V1HostIP.attributeTypeMap; + } + constructor() { + } +}; +V1HostIP.discriminator = void 0; +V1HostIP.mapping = void 0; +V1HostIP.attributeTypeMap = [ + { + "name": "ip", + "baseName": "ip", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1HostPathVolumeSource.js +var V1HostPathVolumeSource = class _V1HostPathVolumeSource { + static getAttributeTypeMap() { + return _V1HostPathVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1HostPathVolumeSource.discriminator = void 0; +V1HostPathVolumeSource.mapping = void 0; +V1HostPathVolumeSource.attributeTypeMap = [ + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IPAddress.js +var V1IPAddress = class _V1IPAddress { + static getAttributeTypeMap() { + return _V1IPAddress.attributeTypeMap; + } + constructor() { + } +}; +V1IPAddress.discriminator = void 0; +V1IPAddress.mapping = void 0; +V1IPAddress.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1IPAddressSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IPAddressList.js +var V1IPAddressList = class _V1IPAddressList { + static getAttributeTypeMap() { + return _V1IPAddressList.attributeTypeMap; + } + constructor() { + } +}; +V1IPAddressList.discriminator = void 0; +V1IPAddressList.mapping = void 0; +V1IPAddressList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IPAddressSpec.js +var V1IPAddressSpec = class _V1IPAddressSpec { + static getAttributeTypeMap() { + return _V1IPAddressSpec.attributeTypeMap; + } + constructor() { + } +}; +V1IPAddressSpec.discriminator = void 0; +V1IPAddressSpec.mapping = void 0; +V1IPAddressSpec.attributeTypeMap = [ + { + "name": "parentRef", + "baseName": "parentRef", + "type": "V1ParentReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IPBlock.js +var V1IPBlock = class _V1IPBlock { + static getAttributeTypeMap() { + return _V1IPBlock.attributeTypeMap; + } + constructor() { + } +}; +V1IPBlock.discriminator = void 0; +V1IPBlock.mapping = void 0; +V1IPBlock.attributeTypeMap = [ + { + "name": "cidr", + "baseName": "cidr", + "type": "string", + "format": "" + }, + { + "name": "except", + "baseName": "except", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ISCSIPersistentVolumeSource.js +var V1ISCSIPersistentVolumeSource = class _V1ISCSIPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1ISCSIPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ISCSIPersistentVolumeSource.discriminator = void 0; +V1ISCSIPersistentVolumeSource.mapping = void 0; +V1ISCSIPersistentVolumeSource.attributeTypeMap = [ + { + "name": "chapAuthDiscovery", + "baseName": "chapAuthDiscovery", + "type": "boolean", + "format": "" + }, + { + "name": "chapAuthSession", + "baseName": "chapAuthSession", + "type": "boolean", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "initiatorName", + "baseName": "initiatorName", + "type": "string", + "format": "" + }, + { + "name": "iqn", + "baseName": "iqn", + "type": "string", + "format": "" + }, + { + "name": "iscsiInterface", + "baseName": "iscsiInterface", + "type": "string", + "format": "" + }, + { + "name": "lun", + "baseName": "lun", + "type": "number", + "format": "int32" + }, + { + "name": "portals", + "baseName": "portals", + "type": "Array", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "targetPortal", + "baseName": "targetPortal", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ISCSIVolumeSource.js +var V1ISCSIVolumeSource = class _V1ISCSIVolumeSource { + static getAttributeTypeMap() { + return _V1ISCSIVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ISCSIVolumeSource.discriminator = void 0; +V1ISCSIVolumeSource.mapping = void 0; +V1ISCSIVolumeSource.attributeTypeMap = [ + { + "name": "chapAuthDiscovery", + "baseName": "chapAuthDiscovery", + "type": "boolean", + "format": "" + }, + { + "name": "chapAuthSession", + "baseName": "chapAuthSession", + "type": "boolean", + "format": "" + }, + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "initiatorName", + "baseName": "initiatorName", + "type": "string", + "format": "" + }, + { + "name": "iqn", + "baseName": "iqn", + "type": "string", + "format": "" + }, + { + "name": "iscsiInterface", + "baseName": "iscsiInterface", + "type": "string", + "format": "" + }, + { + "name": "lun", + "baseName": "lun", + "type": "number", + "format": "int32" + }, + { + "name": "portals", + "baseName": "portals", + "type": "Array", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "targetPortal", + "baseName": "targetPortal", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ImageVolumeSource.js +var V1ImageVolumeSource = class _V1ImageVolumeSource { + static getAttributeTypeMap() { + return _V1ImageVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ImageVolumeSource.discriminator = void 0; +V1ImageVolumeSource.mapping = void 0; +V1ImageVolumeSource.attributeTypeMap = [ + { + "name": "pullPolicy", + "baseName": "pullPolicy", + "type": "string", + "format": "" + }, + { + "name": "reference", + "baseName": "reference", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Ingress.js +var V1Ingress = class _V1Ingress { + static getAttributeTypeMap() { + return _V1Ingress.attributeTypeMap; + } + constructor() { + } +}; +V1Ingress.discriminator = void 0; +V1Ingress.mapping = void 0; +V1Ingress.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1IngressSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1IngressStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressBackend.js +var V1IngressBackend = class _V1IngressBackend { + static getAttributeTypeMap() { + return _V1IngressBackend.attributeTypeMap; + } + constructor() { + } +}; +V1IngressBackend.discriminator = void 0; +V1IngressBackend.mapping = void 0; +V1IngressBackend.attributeTypeMap = [ + { + "name": "resource", + "baseName": "resource", + "type": "V1TypedLocalObjectReference", + "format": "" + }, + { + "name": "service", + "baseName": "service", + "type": "V1IngressServiceBackend", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressClass.js +var V1IngressClass = class _V1IngressClass { + static getAttributeTypeMap() { + return _V1IngressClass.attributeTypeMap; + } + constructor() { + } +}; +V1IngressClass.discriminator = void 0; +V1IngressClass.mapping = void 0; +V1IngressClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1IngressClassSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressClassList.js +var V1IngressClassList = class _V1IngressClassList { + static getAttributeTypeMap() { + return _V1IngressClassList.attributeTypeMap; + } + constructor() { + } +}; +V1IngressClassList.discriminator = void 0; +V1IngressClassList.mapping = void 0; +V1IngressClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressClassParametersReference.js +var V1IngressClassParametersReference = class _V1IngressClassParametersReference { + static getAttributeTypeMap() { + return _V1IngressClassParametersReference.attributeTypeMap; + } + constructor() { + } +}; +V1IngressClassParametersReference.discriminator = void 0; +V1IngressClassParametersReference.mapping = void 0; +V1IngressClassParametersReference.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "scope", + "baseName": "scope", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressClassSpec.js +var V1IngressClassSpec = class _V1IngressClassSpec { + static getAttributeTypeMap() { + return _V1IngressClassSpec.attributeTypeMap; + } + constructor() { + } +}; +V1IngressClassSpec.discriminator = void 0; +V1IngressClassSpec.mapping = void 0; +V1IngressClassSpec.attributeTypeMap = [ + { + "name": "controller", + "baseName": "controller", + "type": "string", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "V1IngressClassParametersReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressList.js +var V1IngressList = class _V1IngressList { + static getAttributeTypeMap() { + return _V1IngressList.attributeTypeMap; + } + constructor() { + } +}; +V1IngressList.discriminator = void 0; +V1IngressList.mapping = void 0; +V1IngressList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressLoadBalancerIngress.js +var V1IngressLoadBalancerIngress = class _V1IngressLoadBalancerIngress { + static getAttributeTypeMap() { + return _V1IngressLoadBalancerIngress.attributeTypeMap; + } + constructor() { + } +}; +V1IngressLoadBalancerIngress.discriminator = void 0; +V1IngressLoadBalancerIngress.mapping = void 0; +V1IngressLoadBalancerIngress.attributeTypeMap = [ + { + "name": "hostname", + "baseName": "hostname", + "type": "string", + "format": "" + }, + { + "name": "ip", + "baseName": "ip", + "type": "string", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressLoadBalancerStatus.js +var V1IngressLoadBalancerStatus = class _V1IngressLoadBalancerStatus { + static getAttributeTypeMap() { + return _V1IngressLoadBalancerStatus.attributeTypeMap; + } + constructor() { + } +}; +V1IngressLoadBalancerStatus.discriminator = void 0; +V1IngressLoadBalancerStatus.mapping = void 0; +V1IngressLoadBalancerStatus.attributeTypeMap = [ + { + "name": "ingress", + "baseName": "ingress", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressPortStatus.js +var V1IngressPortStatus = class _V1IngressPortStatus { + static getAttributeTypeMap() { + return _V1IngressPortStatus.attributeTypeMap; + } + constructor() { + } +}; +V1IngressPortStatus.discriminator = void 0; +V1IngressPortStatus.mapping = void 0; +V1IngressPortStatus.attributeTypeMap = [ + { + "name": "error", + "baseName": "error", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressRule.js +var V1IngressRule = class _V1IngressRule { + static getAttributeTypeMap() { + return _V1IngressRule.attributeTypeMap; + } + constructor() { + } +}; +V1IngressRule.discriminator = void 0; +V1IngressRule.mapping = void 0; +V1IngressRule.attributeTypeMap = [ + { + "name": "host", + "baseName": "host", + "type": "string", + "format": "" + }, + { + "name": "http", + "baseName": "http", + "type": "V1HTTPIngressRuleValue", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressServiceBackend.js +var V1IngressServiceBackend = class _V1IngressServiceBackend { + static getAttributeTypeMap() { + return _V1IngressServiceBackend.attributeTypeMap; + } + constructor() { + } +}; +V1IngressServiceBackend.discriminator = void 0; +V1IngressServiceBackend.mapping = void 0; +V1IngressServiceBackend.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "V1ServiceBackendPort", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressSpec.js +var V1IngressSpec = class _V1IngressSpec { + static getAttributeTypeMap() { + return _V1IngressSpec.attributeTypeMap; + } + constructor() { + } +}; +V1IngressSpec.discriminator = void 0; +V1IngressSpec.mapping = void 0; +V1IngressSpec.attributeTypeMap = [ + { + "name": "defaultBackend", + "baseName": "defaultBackend", + "type": "V1IngressBackend", + "format": "" + }, + { + "name": "ingressClassName", + "baseName": "ingressClassName", + "type": "string", + "format": "" + }, + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + }, + { + "name": "tls", + "baseName": "tls", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressStatus.js +var V1IngressStatus = class _V1IngressStatus { + static getAttributeTypeMap() { + return _V1IngressStatus.attributeTypeMap; + } + constructor() { + } +}; +V1IngressStatus.discriminator = void 0; +V1IngressStatus.mapping = void 0; +V1IngressStatus.attributeTypeMap = [ + { + "name": "loadBalancer", + "baseName": "loadBalancer", + "type": "V1IngressLoadBalancerStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1IngressTLS.js +var V1IngressTLS = class _V1IngressTLS { + static getAttributeTypeMap() { + return _V1IngressTLS.attributeTypeMap; + } + constructor() { + } +}; +V1IngressTLS.discriminator = void 0; +V1IngressTLS.mapping = void 0; +V1IngressTLS.attributeTypeMap = [ + { + "name": "hosts", + "baseName": "hosts", + "type": "Array", + "format": "" + }, + { + "name": "secretName", + "baseName": "secretName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1JSONSchemaProps.js +var V1JSONSchemaProps = class _V1JSONSchemaProps { + static getAttributeTypeMap() { + return _V1JSONSchemaProps.attributeTypeMap; + } + constructor() { + } +}; +V1JSONSchemaProps.discriminator = void 0; +V1JSONSchemaProps.mapping = void 0; +V1JSONSchemaProps.attributeTypeMap = [ + { + "name": "ref", + "baseName": "$ref", + "type": "string", + "format": "" + }, + { + "name": "schema", + "baseName": "$schema", + "type": "string", + "format": "" + }, + { + "name": "additionalItems", + "baseName": "additionalItems", + "type": "any", + "format": "" + }, + { + "name": "additionalProperties", + "baseName": "additionalProperties", + "type": "any", + "format": "" + }, + { + "name": "allOf", + "baseName": "allOf", + "type": "Array", + "format": "" + }, + { + "name": "anyOf", + "baseName": "anyOf", + "type": "Array", + "format": "" + }, + { + "name": "_default", + "baseName": "default", + "type": "any", + "format": "" + }, + { + "name": "definitions", + "baseName": "definitions", + "type": "{ [key: string]: V1JSONSchemaProps; }", + "format": "" + }, + { + "name": "dependencies", + "baseName": "dependencies", + "type": "{ [key: string]: any; }", + "format": "" + }, + { + "name": "description", + "baseName": "description", + "type": "string", + "format": "" + }, + { + "name": "_enum", + "baseName": "enum", + "type": "Array", + "format": "" + }, + { + "name": "example", + "baseName": "example", + "type": "any", + "format": "" + }, + { + "name": "exclusiveMaximum", + "baseName": "exclusiveMaximum", + "type": "boolean", + "format": "" + }, + { + "name": "exclusiveMinimum", + "baseName": "exclusiveMinimum", + "type": "boolean", + "format": "" + }, + { + "name": "externalDocs", + "baseName": "externalDocs", + "type": "V1ExternalDocumentation", + "format": "" + }, + { + "name": "format", + "baseName": "format", + "type": "string", + "format": "" + }, + { + "name": "id", + "baseName": "id", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "any", + "format": "" + }, + { + "name": "maxItems", + "baseName": "maxItems", + "type": "number", + "format": "int64" + }, + { + "name": "maxLength", + "baseName": "maxLength", + "type": "number", + "format": "int64" + }, + { + "name": "maxProperties", + "baseName": "maxProperties", + "type": "number", + "format": "int64" + }, + { + "name": "maximum", + "baseName": "maximum", + "type": "number", + "format": "double" + }, + { + "name": "minItems", + "baseName": "minItems", + "type": "number", + "format": "int64" + }, + { + "name": "minLength", + "baseName": "minLength", + "type": "number", + "format": "int64" + }, + { + "name": "minProperties", + "baseName": "minProperties", + "type": "number", + "format": "int64" + }, + { + "name": "minimum", + "baseName": "minimum", + "type": "number", + "format": "double" + }, + { + "name": "multipleOf", + "baseName": "multipleOf", + "type": "number", + "format": "double" + }, + { + "name": "not", + "baseName": "not", + "type": "V1JSONSchemaProps", + "format": "" + }, + { + "name": "nullable", + "baseName": "nullable", + "type": "boolean", + "format": "" + }, + { + "name": "oneOf", + "baseName": "oneOf", + "type": "Array", + "format": "" + }, + { + "name": "pattern", + "baseName": "pattern", + "type": "string", + "format": "" + }, + { + "name": "patternProperties", + "baseName": "patternProperties", + "type": "{ [key: string]: V1JSONSchemaProps; }", + "format": "" + }, + { + "name": "properties", + "baseName": "properties", + "type": "{ [key: string]: V1JSONSchemaProps; }", + "format": "" + }, + { + "name": "required", + "baseName": "required", + "type": "Array", + "format": "" + }, + { + "name": "title", + "baseName": "title", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + }, + { + "name": "uniqueItems", + "baseName": "uniqueItems", + "type": "boolean", + "format": "" + }, + { + "name": "x_kubernetes_embedded_resource", + "baseName": "x-kubernetes-embedded-resource", + "type": "boolean", + "format": "" + }, + { + "name": "x_kubernetes_int_or_string", + "baseName": "x-kubernetes-int-or-string", + "type": "boolean", + "format": "" + }, + { + "name": "x_kubernetes_list_map_keys", + "baseName": "x-kubernetes-list-map-keys", + "type": "Array", + "format": "" + }, + { + "name": "x_kubernetes_list_type", + "baseName": "x-kubernetes-list-type", + "type": "string", + "format": "" + }, + { + "name": "x_kubernetes_map_type", + "baseName": "x-kubernetes-map-type", + "type": "string", + "format": "" + }, + { + "name": "x_kubernetes_preserve_unknown_fields", + "baseName": "x-kubernetes-preserve-unknown-fields", + "type": "boolean", + "format": "" + }, + { + "name": "x_kubernetes_validations", + "baseName": "x-kubernetes-validations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Job.js +var V1Job = class _V1Job { + static getAttributeTypeMap() { + return _V1Job.attributeTypeMap; + } + constructor() { + } +}; +V1Job.discriminator = void 0; +V1Job.mapping = void 0; +V1Job.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1JobSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1JobStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1JobCondition.js +var V1JobCondition = class _V1JobCondition { + static getAttributeTypeMap() { + return _V1JobCondition.attributeTypeMap; + } + constructor() { + } +}; +V1JobCondition.discriminator = void 0; +V1JobCondition.mapping = void 0; +V1JobCondition.attributeTypeMap = [ + { + "name": "lastProbeTime", + "baseName": "lastProbeTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1JobList.js +var V1JobList = class _V1JobList { + static getAttributeTypeMap() { + return _V1JobList.attributeTypeMap; + } + constructor() { + } +}; +V1JobList.discriminator = void 0; +V1JobList.mapping = void 0; +V1JobList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1JobSpec.js +var V1JobSpec = class _V1JobSpec { + static getAttributeTypeMap() { + return _V1JobSpec.attributeTypeMap; + } + constructor() { + } +}; +V1JobSpec.discriminator = void 0; +V1JobSpec.mapping = void 0; +V1JobSpec.attributeTypeMap = [ + { + "name": "activeDeadlineSeconds", + "baseName": "activeDeadlineSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "backoffLimit", + "baseName": "backoffLimit", + "type": "number", + "format": "int32" + }, + { + "name": "backoffLimitPerIndex", + "baseName": "backoffLimitPerIndex", + "type": "number", + "format": "int32" + }, + { + "name": "completionMode", + "baseName": "completionMode", + "type": "string", + "format": "" + }, + { + "name": "completions", + "baseName": "completions", + "type": "number", + "format": "int32" + }, + { + "name": "managedBy", + "baseName": "managedBy", + "type": "string", + "format": "" + }, + { + "name": "manualSelector", + "baseName": "manualSelector", + "type": "boolean", + "format": "" + }, + { + "name": "maxFailedIndexes", + "baseName": "maxFailedIndexes", + "type": "number", + "format": "int32" + }, + { + "name": "parallelism", + "baseName": "parallelism", + "type": "number", + "format": "int32" + }, + { + "name": "podFailurePolicy", + "baseName": "podFailurePolicy", + "type": "V1PodFailurePolicy", + "format": "" + }, + { + "name": "podReplacementPolicy", + "baseName": "podReplacementPolicy", + "type": "string", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "successPolicy", + "baseName": "successPolicy", + "type": "V1SuccessPolicy", + "format": "" + }, + { + "name": "suspend", + "baseName": "suspend", + "type": "boolean", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + }, + { + "name": "ttlSecondsAfterFinished", + "baseName": "ttlSecondsAfterFinished", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1JobStatus.js +var V1JobStatus = class _V1JobStatus { + static getAttributeTypeMap() { + return _V1JobStatus.attributeTypeMap; + } + constructor() { + } +}; +V1JobStatus.discriminator = void 0; +V1JobStatus.mapping = void 0; +V1JobStatus.attributeTypeMap = [ + { + "name": "active", + "baseName": "active", + "type": "number", + "format": "int32" + }, + { + "name": "completedIndexes", + "baseName": "completedIndexes", + "type": "string", + "format": "" + }, + { + "name": "completionTime", + "baseName": "completionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "failed", + "baseName": "failed", + "type": "number", + "format": "int32" + }, + { + "name": "failedIndexes", + "baseName": "failedIndexes", + "type": "string", + "format": "" + }, + { + "name": "ready", + "baseName": "ready", + "type": "number", + "format": "int32" + }, + { + "name": "startTime", + "baseName": "startTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "succeeded", + "baseName": "succeeded", + "type": "number", + "format": "int32" + }, + { + "name": "terminating", + "baseName": "terminating", + "type": "number", + "format": "int32" + }, + { + "name": "uncountedTerminatedPods", + "baseName": "uncountedTerminatedPods", + "type": "V1UncountedTerminatedPods", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1JobTemplateSpec.js +var V1JobTemplateSpec = class _V1JobTemplateSpec { + static getAttributeTypeMap() { + return _V1JobTemplateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1JobTemplateSpec.discriminator = void 0; +V1JobTemplateSpec.mapping = void 0; +V1JobTemplateSpec.attributeTypeMap = [ + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1JobSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1KeyToPath.js +var V1KeyToPath = class _V1KeyToPath { + static getAttributeTypeMap() { + return _V1KeyToPath.attributeTypeMap; + } + constructor() { + } +}; +V1KeyToPath.discriminator = void 0; +V1KeyToPath.mapping = void 0; +V1KeyToPath.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "mode", + "baseName": "mode", + "type": "number", + "format": "int32" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LabelSelector.js +var V1LabelSelector = class _V1LabelSelector { + static getAttributeTypeMap() { + return _V1LabelSelector.attributeTypeMap; + } + constructor() { + } +}; +V1LabelSelector.discriminator = void 0; +V1LabelSelector.mapping = void 0; +V1LabelSelector.attributeTypeMap = [ + { + "name": "matchExpressions", + "baseName": "matchExpressions", + "type": "Array", + "format": "" + }, + { + "name": "matchLabels", + "baseName": "matchLabels", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LabelSelectorAttributes.js +var V1LabelSelectorAttributes = class _V1LabelSelectorAttributes { + static getAttributeTypeMap() { + return _V1LabelSelectorAttributes.attributeTypeMap; + } + constructor() { + } +}; +V1LabelSelectorAttributes.discriminator = void 0; +V1LabelSelectorAttributes.mapping = void 0; +V1LabelSelectorAttributes.attributeTypeMap = [ + { + "name": "rawSelector", + "baseName": "rawSelector", + "type": "string", + "format": "" + }, + { + "name": "requirements", + "baseName": "requirements", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LabelSelectorRequirement.js +var V1LabelSelectorRequirement = class _V1LabelSelectorRequirement { + static getAttributeTypeMap() { + return _V1LabelSelectorRequirement.attributeTypeMap; + } + constructor() { + } +}; +V1LabelSelectorRequirement.discriminator = void 0; +V1LabelSelectorRequirement.mapping = void 0; +V1LabelSelectorRequirement.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Lease.js +var V1Lease = class _V1Lease { + static getAttributeTypeMap() { + return _V1Lease.attributeTypeMap; + } + constructor() { + } +}; +V1Lease.discriminator = void 0; +V1Lease.mapping = void 0; +V1Lease.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1LeaseSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LeaseList.js +var V1LeaseList = class _V1LeaseList { + static getAttributeTypeMap() { + return _V1LeaseList.attributeTypeMap; + } + constructor() { + } +}; +V1LeaseList.discriminator = void 0; +V1LeaseList.mapping = void 0; +V1LeaseList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LeaseSpec.js +var V1LeaseSpec = class _V1LeaseSpec { + static getAttributeTypeMap() { + return _V1LeaseSpec.attributeTypeMap; + } + constructor() { + } +}; +V1LeaseSpec.discriminator = void 0; +V1LeaseSpec.mapping = void 0; +V1LeaseSpec.attributeTypeMap = [ + { + "name": "acquireTime", + "baseName": "acquireTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "holderIdentity", + "baseName": "holderIdentity", + "type": "string", + "format": "" + }, + { + "name": "leaseDurationSeconds", + "baseName": "leaseDurationSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "leaseTransitions", + "baseName": "leaseTransitions", + "type": "number", + "format": "int32" + }, + { + "name": "preferredHolder", + "baseName": "preferredHolder", + "type": "string", + "format": "" + }, + { + "name": "renewTime", + "baseName": "renewTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "strategy", + "baseName": "strategy", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Lifecycle.js +var V1Lifecycle = class _V1Lifecycle { + static getAttributeTypeMap() { + return _V1Lifecycle.attributeTypeMap; + } + constructor() { + } +}; +V1Lifecycle.discriminator = void 0; +V1Lifecycle.mapping = void 0; +V1Lifecycle.attributeTypeMap = [ + { + "name": "postStart", + "baseName": "postStart", + "type": "V1LifecycleHandler", + "format": "" + }, + { + "name": "preStop", + "baseName": "preStop", + "type": "V1LifecycleHandler", + "format": "" + }, + { + "name": "stopSignal", + "baseName": "stopSignal", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LifecycleHandler.js +var V1LifecycleHandler = class _V1LifecycleHandler { + static getAttributeTypeMap() { + return _V1LifecycleHandler.attributeTypeMap; + } + constructor() { + } +}; +V1LifecycleHandler.discriminator = void 0; +V1LifecycleHandler.mapping = void 0; +V1LifecycleHandler.attributeTypeMap = [ + { + "name": "exec", + "baseName": "exec", + "type": "V1ExecAction", + "format": "" + }, + { + "name": "httpGet", + "baseName": "httpGet", + "type": "V1HTTPGetAction", + "format": "" + }, + { + "name": "sleep", + "baseName": "sleep", + "type": "V1SleepAction", + "format": "" + }, + { + "name": "tcpSocket", + "baseName": "tcpSocket", + "type": "V1TCPSocketAction", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LimitRange.js +var V1LimitRange = class _V1LimitRange { + static getAttributeTypeMap() { + return _V1LimitRange.attributeTypeMap; + } + constructor() { + } +}; +V1LimitRange.discriminator = void 0; +V1LimitRange.mapping = void 0; +V1LimitRange.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1LimitRangeSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LimitRangeItem.js +var V1LimitRangeItem = class _V1LimitRangeItem { + static getAttributeTypeMap() { + return _V1LimitRangeItem.attributeTypeMap; + } + constructor() { + } +}; +V1LimitRangeItem.discriminator = void 0; +V1LimitRangeItem.mapping = void 0; +V1LimitRangeItem.attributeTypeMap = [ + { + "name": "_default", + "baseName": "default", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "defaultRequest", + "baseName": "defaultRequest", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "max", + "baseName": "max", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "maxLimitRequestRatio", + "baseName": "maxLimitRequestRatio", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "min", + "baseName": "min", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LimitRangeList.js +var V1LimitRangeList = class _V1LimitRangeList { + static getAttributeTypeMap() { + return _V1LimitRangeList.attributeTypeMap; + } + constructor() { + } +}; +V1LimitRangeList.discriminator = void 0; +V1LimitRangeList.mapping = void 0; +V1LimitRangeList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LimitRangeSpec.js +var V1LimitRangeSpec = class _V1LimitRangeSpec { + static getAttributeTypeMap() { + return _V1LimitRangeSpec.attributeTypeMap; + } + constructor() { + } +}; +V1LimitRangeSpec.discriminator = void 0; +V1LimitRangeSpec.mapping = void 0; +V1LimitRangeSpec.attributeTypeMap = [ + { + "name": "limits", + "baseName": "limits", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LimitResponse.js +var V1LimitResponse = class _V1LimitResponse { + static getAttributeTypeMap() { + return _V1LimitResponse.attributeTypeMap; + } + constructor() { + } +}; +V1LimitResponse.discriminator = void 0; +V1LimitResponse.mapping = void 0; +V1LimitResponse.attributeTypeMap = [ + { + "name": "queuing", + "baseName": "queuing", + "type": "V1QueuingConfiguration", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LimitedPriorityLevelConfiguration.js +var V1LimitedPriorityLevelConfiguration = class _V1LimitedPriorityLevelConfiguration { + static getAttributeTypeMap() { + return _V1LimitedPriorityLevelConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1LimitedPriorityLevelConfiguration.discriminator = void 0; +V1LimitedPriorityLevelConfiguration.mapping = void 0; +V1LimitedPriorityLevelConfiguration.attributeTypeMap = [ + { + "name": "borrowingLimitPercent", + "baseName": "borrowingLimitPercent", + "type": "number", + "format": "int32" + }, + { + "name": "lendablePercent", + "baseName": "lendablePercent", + "type": "number", + "format": "int32" + }, + { + "name": "limitResponse", + "baseName": "limitResponse", + "type": "V1LimitResponse", + "format": "" + }, + { + "name": "nominalConcurrencyShares", + "baseName": "nominalConcurrencyShares", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LinuxContainerUser.js +var V1LinuxContainerUser = class _V1LinuxContainerUser { + static getAttributeTypeMap() { + return _V1LinuxContainerUser.attributeTypeMap; + } + constructor() { + } +}; +V1LinuxContainerUser.discriminator = void 0; +V1LinuxContainerUser.mapping = void 0; +V1LinuxContainerUser.attributeTypeMap = [ + { + "name": "gid", + "baseName": "gid", + "type": "number", + "format": "int64" + }, + { + "name": "supplementalGroups", + "baseName": "supplementalGroups", + "type": "Array", + "format": "int64" + }, + { + "name": "uid", + "baseName": "uid", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ListMeta.js +var V1ListMeta = class _V1ListMeta { + static getAttributeTypeMap() { + return _V1ListMeta.attributeTypeMap; + } + constructor() { + } +}; +V1ListMeta.discriminator = void 0; +V1ListMeta.mapping = void 0; +V1ListMeta.attributeTypeMap = [ + { + "name": "_continue", + "baseName": "continue", + "type": "string", + "format": "" + }, + { + "name": "remainingItemCount", + "baseName": "remainingItemCount", + "type": "number", + "format": "int64" + }, + { + "name": "resourceVersion", + "baseName": "resourceVersion", + "type": "string", + "format": "" + }, + { + "name": "selfLink", + "baseName": "selfLink", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LoadBalancerIngress.js +var V1LoadBalancerIngress = class _V1LoadBalancerIngress { + static getAttributeTypeMap() { + return _V1LoadBalancerIngress.attributeTypeMap; + } + constructor() { + } +}; +V1LoadBalancerIngress.discriminator = void 0; +V1LoadBalancerIngress.mapping = void 0; +V1LoadBalancerIngress.attributeTypeMap = [ + { + "name": "hostname", + "baseName": "hostname", + "type": "string", + "format": "" + }, + { + "name": "ip", + "baseName": "ip", + "type": "string", + "format": "" + }, + { + "name": "ipMode", + "baseName": "ipMode", + "type": "string", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LoadBalancerStatus.js +var V1LoadBalancerStatus = class _V1LoadBalancerStatus { + static getAttributeTypeMap() { + return _V1LoadBalancerStatus.attributeTypeMap; + } + constructor() { + } +}; +V1LoadBalancerStatus.discriminator = void 0; +V1LoadBalancerStatus.mapping = void 0; +V1LoadBalancerStatus.attributeTypeMap = [ + { + "name": "ingress", + "baseName": "ingress", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LocalObjectReference.js +var V1LocalObjectReference = class _V1LocalObjectReference { + static getAttributeTypeMap() { + return _V1LocalObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V1LocalObjectReference.discriminator = void 0; +V1LocalObjectReference.mapping = void 0; +V1LocalObjectReference.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LocalSubjectAccessReview.js +var V1LocalSubjectAccessReview = class _V1LocalSubjectAccessReview { + static getAttributeTypeMap() { + return _V1LocalSubjectAccessReview.attributeTypeMap; + } + constructor() { + } +}; +V1LocalSubjectAccessReview.discriminator = void 0; +V1LocalSubjectAccessReview.mapping = void 0; +V1LocalSubjectAccessReview.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1SubjectAccessReviewSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1SubjectAccessReviewStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1LocalVolumeSource.js +var V1LocalVolumeSource = class _V1LocalVolumeSource { + static getAttributeTypeMap() { + return _V1LocalVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1LocalVolumeSource.discriminator = void 0; +V1LocalVolumeSource.mapping = void 0; +V1LocalVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ManagedFieldsEntry.js +var V1ManagedFieldsEntry = class _V1ManagedFieldsEntry { + static getAttributeTypeMap() { + return _V1ManagedFieldsEntry.attributeTypeMap; + } + constructor() { + } +}; +V1ManagedFieldsEntry.discriminator = void 0; +V1ManagedFieldsEntry.mapping = void 0; +V1ManagedFieldsEntry.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "fieldsType", + "baseName": "fieldsType", + "type": "string", + "format": "" + }, + { + "name": "fieldsV1", + "baseName": "fieldsV1", + "type": "any", + "format": "" + }, + { + "name": "manager", + "baseName": "manager", + "type": "string", + "format": "" + }, + { + "name": "operation", + "baseName": "operation", + "type": "string", + "format": "" + }, + { + "name": "subresource", + "baseName": "subresource", + "type": "string", + "format": "" + }, + { + "name": "time", + "baseName": "time", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1MatchCondition.js +var V1MatchCondition = class _V1MatchCondition { + static getAttributeTypeMap() { + return _V1MatchCondition.attributeTypeMap; + } + constructor() { + } +}; +V1MatchCondition.discriminator = void 0; +V1MatchCondition.mapping = void 0; +V1MatchCondition.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1MatchResources.js +var V1MatchResources = class _V1MatchResources { + static getAttributeTypeMap() { + return _V1MatchResources.attributeTypeMap; + } + constructor() { + } +}; +V1MatchResources.discriminator = void 0; +V1MatchResources.mapping = void 0; +V1MatchResources.attributeTypeMap = [ + { + "name": "excludeResourceRules", + "baseName": "excludeResourceRules", + "type": "Array", + "format": "" + }, + { + "name": "matchPolicy", + "baseName": "matchPolicy", + "type": "string", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "objectSelector", + "baseName": "objectSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "resourceRules", + "baseName": "resourceRules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ModifyVolumeStatus.js +var V1ModifyVolumeStatus = class _V1ModifyVolumeStatus { + static getAttributeTypeMap() { + return _V1ModifyVolumeStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ModifyVolumeStatus.discriminator = void 0; +V1ModifyVolumeStatus.mapping = void 0; +V1ModifyVolumeStatus.attributeTypeMap = [ + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "targetVolumeAttributesClassName", + "baseName": "targetVolumeAttributesClassName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1MutatingWebhook.js +var V1MutatingWebhook = class _V1MutatingWebhook { + static getAttributeTypeMap() { + return _V1MutatingWebhook.attributeTypeMap; + } + constructor() { + } +}; +V1MutatingWebhook.discriminator = void 0; +V1MutatingWebhook.mapping = void 0; +V1MutatingWebhook.attributeTypeMap = [ + { + "name": "admissionReviewVersions", + "baseName": "admissionReviewVersions", + "type": "Array", + "format": "" + }, + { + "name": "clientConfig", + "baseName": "clientConfig", + "type": "AdmissionregistrationV1WebhookClientConfig", + "format": "" + }, + { + "name": "failurePolicy", + "baseName": "failurePolicy", + "type": "string", + "format": "" + }, + { + "name": "matchConditions", + "baseName": "matchConditions", + "type": "Array", + "format": "" + }, + { + "name": "matchPolicy", + "baseName": "matchPolicy", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "objectSelector", + "baseName": "objectSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "reinvocationPolicy", + "baseName": "reinvocationPolicy", + "type": "string", + "format": "" + }, + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + }, + { + "name": "sideEffects", + "baseName": "sideEffects", + "type": "string", + "format": "" + }, + { + "name": "timeoutSeconds", + "baseName": "timeoutSeconds", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1MutatingWebhookConfiguration.js +var V1MutatingWebhookConfiguration = class _V1MutatingWebhookConfiguration { + static getAttributeTypeMap() { + return _V1MutatingWebhookConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1MutatingWebhookConfiguration.discriminator = void 0; +V1MutatingWebhookConfiguration.mapping = void 0; +V1MutatingWebhookConfiguration.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "webhooks", + "baseName": "webhooks", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1MutatingWebhookConfigurationList.js +var V1MutatingWebhookConfigurationList = class _V1MutatingWebhookConfigurationList { + static getAttributeTypeMap() { + return _V1MutatingWebhookConfigurationList.attributeTypeMap; + } + constructor() { + } +}; +V1MutatingWebhookConfigurationList.discriminator = void 0; +V1MutatingWebhookConfigurationList.mapping = void 0; +V1MutatingWebhookConfigurationList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NFSVolumeSource.js +var V1NFSVolumeSource = class _V1NFSVolumeSource { + static getAttributeTypeMap() { + return _V1NFSVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1NFSVolumeSource.discriminator = void 0; +V1NFSVolumeSource.mapping = void 0; +V1NFSVolumeSource.attributeTypeMap = [ + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "server", + "baseName": "server", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NamedRuleWithOperations.js +var V1NamedRuleWithOperations = class _V1NamedRuleWithOperations { + static getAttributeTypeMap() { + return _V1NamedRuleWithOperations.attributeTypeMap; + } + constructor() { + } +}; +V1NamedRuleWithOperations.discriminator = void 0; +V1NamedRuleWithOperations.mapping = void 0; +V1NamedRuleWithOperations.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "apiVersions", + "baseName": "apiVersions", + "type": "Array", + "format": "" + }, + { + "name": "operations", + "baseName": "operations", + "type": "Array", + "format": "" + }, + { + "name": "resourceNames", + "baseName": "resourceNames", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "scope", + "baseName": "scope", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Namespace.js +var V1Namespace = class _V1Namespace { + static getAttributeTypeMap() { + return _V1Namespace.attributeTypeMap; + } + constructor() { + } +}; +V1Namespace.discriminator = void 0; +V1Namespace.mapping = void 0; +V1Namespace.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1NamespaceSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1NamespaceStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NamespaceCondition.js +var V1NamespaceCondition = class _V1NamespaceCondition { + static getAttributeTypeMap() { + return _V1NamespaceCondition.attributeTypeMap; + } + constructor() { + } +}; +V1NamespaceCondition.discriminator = void 0; +V1NamespaceCondition.mapping = void 0; +V1NamespaceCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NamespaceList.js +var V1NamespaceList = class _V1NamespaceList { + static getAttributeTypeMap() { + return _V1NamespaceList.attributeTypeMap; + } + constructor() { + } +}; +V1NamespaceList.discriminator = void 0; +V1NamespaceList.mapping = void 0; +V1NamespaceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NamespaceSpec.js +var V1NamespaceSpec = class _V1NamespaceSpec { + static getAttributeTypeMap() { + return _V1NamespaceSpec.attributeTypeMap; + } + constructor() { + } +}; +V1NamespaceSpec.discriminator = void 0; +V1NamespaceSpec.mapping = void 0; +V1NamespaceSpec.attributeTypeMap = [ + { + "name": "finalizers", + "baseName": "finalizers", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NamespaceStatus.js +var V1NamespaceStatus = class _V1NamespaceStatus { + static getAttributeTypeMap() { + return _V1NamespaceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1NamespaceStatus.discriminator = void 0; +V1NamespaceStatus.mapping = void 0; +V1NamespaceStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "phase", + "baseName": "phase", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkDeviceData.js +var V1NetworkDeviceData = class _V1NetworkDeviceData { + static getAttributeTypeMap() { + return _V1NetworkDeviceData.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkDeviceData.discriminator = void 0; +V1NetworkDeviceData.mapping = void 0; +V1NetworkDeviceData.attributeTypeMap = [ + { + "name": "hardwareAddress", + "baseName": "hardwareAddress", + "type": "string", + "format": "" + }, + { + "name": "interfaceName", + "baseName": "interfaceName", + "type": "string", + "format": "" + }, + { + "name": "ips", + "baseName": "ips", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicy.js +var V1NetworkPolicy = class _V1NetworkPolicy { + static getAttributeTypeMap() { + return _V1NetworkPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicy.discriminator = void 0; +V1NetworkPolicy.mapping = void 0; +V1NetworkPolicy.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1NetworkPolicySpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicyEgressRule.js +var V1NetworkPolicyEgressRule = class _V1NetworkPolicyEgressRule { + static getAttributeTypeMap() { + return _V1NetworkPolicyEgressRule.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicyEgressRule.discriminator = void 0; +V1NetworkPolicyEgressRule.mapping = void 0; +V1NetworkPolicyEgressRule.attributeTypeMap = [ + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + }, + { + "name": "to", + "baseName": "to", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicyIngressRule.js +var V1NetworkPolicyIngressRule = class _V1NetworkPolicyIngressRule { + static getAttributeTypeMap() { + return _V1NetworkPolicyIngressRule.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicyIngressRule.discriminator = void 0; +V1NetworkPolicyIngressRule.mapping = void 0; +V1NetworkPolicyIngressRule.attributeTypeMap = [ + { + "name": "_from", + "baseName": "from", + "type": "Array", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicyList.js +var V1NetworkPolicyList = class _V1NetworkPolicyList { + static getAttributeTypeMap() { + return _V1NetworkPolicyList.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicyList.discriminator = void 0; +V1NetworkPolicyList.mapping = void 0; +V1NetworkPolicyList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicyPeer.js +var V1NetworkPolicyPeer = class _V1NetworkPolicyPeer { + static getAttributeTypeMap() { + return _V1NetworkPolicyPeer.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicyPeer.discriminator = void 0; +V1NetworkPolicyPeer.mapping = void 0; +V1NetworkPolicyPeer.attributeTypeMap = [ + { + "name": "ipBlock", + "baseName": "ipBlock", + "type": "V1IPBlock", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "podSelector", + "baseName": "podSelector", + "type": "V1LabelSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicyPort.js +var V1NetworkPolicyPort = class _V1NetworkPolicyPort { + static getAttributeTypeMap() { + return _V1NetworkPolicyPort.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicyPort.discriminator = void 0; +V1NetworkPolicyPort.mapping = void 0; +V1NetworkPolicyPort.attributeTypeMap = [ + { + "name": "endPort", + "baseName": "endPort", + "type": "number", + "format": "int32" + }, + { + "name": "port", + "baseName": "port", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NetworkPolicySpec.js +var V1NetworkPolicySpec = class _V1NetworkPolicySpec { + static getAttributeTypeMap() { + return _V1NetworkPolicySpec.attributeTypeMap; + } + constructor() { + } +}; +V1NetworkPolicySpec.discriminator = void 0; +V1NetworkPolicySpec.mapping = void 0; +V1NetworkPolicySpec.attributeTypeMap = [ + { + "name": "egress", + "baseName": "egress", + "type": "Array", + "format": "" + }, + { + "name": "ingress", + "baseName": "ingress", + "type": "Array", + "format": "" + }, + { + "name": "podSelector", + "baseName": "podSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "policyTypes", + "baseName": "policyTypes", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Node.js +var V1Node = class _V1Node { + static getAttributeTypeMap() { + return _V1Node.attributeTypeMap; + } + constructor() { + } +}; +V1Node.discriminator = void 0; +V1Node.mapping = void 0; +V1Node.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1NodeSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1NodeStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeAddress.js +var V1NodeAddress = class _V1NodeAddress { + static getAttributeTypeMap() { + return _V1NodeAddress.attributeTypeMap; + } + constructor() { + } +}; +V1NodeAddress.discriminator = void 0; +V1NodeAddress.mapping = void 0; +V1NodeAddress.attributeTypeMap = [ + { + "name": "address", + "baseName": "address", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeAffinity.js +var V1NodeAffinity = class _V1NodeAffinity { + static getAttributeTypeMap() { + return _V1NodeAffinity.attributeTypeMap; + } + constructor() { + } +}; +V1NodeAffinity.discriminator = void 0; +V1NodeAffinity.mapping = void 0; +V1NodeAffinity.attributeTypeMap = [ + { + "name": "preferredDuringSchedulingIgnoredDuringExecution", + "baseName": "preferredDuringSchedulingIgnoredDuringExecution", + "type": "Array", + "format": "" + }, + { + "name": "requiredDuringSchedulingIgnoredDuringExecution", + "baseName": "requiredDuringSchedulingIgnoredDuringExecution", + "type": "V1NodeSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeCondition.js +var V1NodeCondition = class _V1NodeCondition { + static getAttributeTypeMap() { + return _V1NodeCondition.attributeTypeMap; + } + constructor() { + } +}; +V1NodeCondition.discriminator = void 0; +V1NodeCondition.mapping = void 0; +V1NodeCondition.attributeTypeMap = [ + { + "name": "lastHeartbeatTime", + "baseName": "lastHeartbeatTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeConfigSource.js +var V1NodeConfigSource = class _V1NodeConfigSource { + static getAttributeTypeMap() { + return _V1NodeConfigSource.attributeTypeMap; + } + constructor() { + } +}; +V1NodeConfigSource.discriminator = void 0; +V1NodeConfigSource.mapping = void 0; +V1NodeConfigSource.attributeTypeMap = [ + { + "name": "configMap", + "baseName": "configMap", + "type": "V1ConfigMapNodeConfigSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeConfigStatus.js +var V1NodeConfigStatus = class _V1NodeConfigStatus { + static getAttributeTypeMap() { + return _V1NodeConfigStatus.attributeTypeMap; + } + constructor() { + } +}; +V1NodeConfigStatus.discriminator = void 0; +V1NodeConfigStatus.mapping = void 0; +V1NodeConfigStatus.attributeTypeMap = [ + { + "name": "active", + "baseName": "active", + "type": "V1NodeConfigSource", + "format": "" + }, + { + "name": "assigned", + "baseName": "assigned", + "type": "V1NodeConfigSource", + "format": "" + }, + { + "name": "error", + "baseName": "error", + "type": "string", + "format": "" + }, + { + "name": "lastKnownGood", + "baseName": "lastKnownGood", + "type": "V1NodeConfigSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeDaemonEndpoints.js +var V1NodeDaemonEndpoints = class _V1NodeDaemonEndpoints { + static getAttributeTypeMap() { + return _V1NodeDaemonEndpoints.attributeTypeMap; + } + constructor() { + } +}; +V1NodeDaemonEndpoints.discriminator = void 0; +V1NodeDaemonEndpoints.mapping = void 0; +V1NodeDaemonEndpoints.attributeTypeMap = [ + { + "name": "kubeletEndpoint", + "baseName": "kubeletEndpoint", + "type": "V1DaemonEndpoint", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeFeatures.js +var V1NodeFeatures = class _V1NodeFeatures { + static getAttributeTypeMap() { + return _V1NodeFeatures.attributeTypeMap; + } + constructor() { + } +}; +V1NodeFeatures.discriminator = void 0; +V1NodeFeatures.mapping = void 0; +V1NodeFeatures.attributeTypeMap = [ + { + "name": "supplementalGroupsPolicy", + "baseName": "supplementalGroupsPolicy", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeList.js +var V1NodeList = class _V1NodeList { + static getAttributeTypeMap() { + return _V1NodeList.attributeTypeMap; + } + constructor() { + } +}; +V1NodeList.discriminator = void 0; +V1NodeList.mapping = void 0; +V1NodeList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeRuntimeHandler.js +var V1NodeRuntimeHandler = class _V1NodeRuntimeHandler { + static getAttributeTypeMap() { + return _V1NodeRuntimeHandler.attributeTypeMap; + } + constructor() { + } +}; +V1NodeRuntimeHandler.discriminator = void 0; +V1NodeRuntimeHandler.mapping = void 0; +V1NodeRuntimeHandler.attributeTypeMap = [ + { + "name": "features", + "baseName": "features", + "type": "V1NodeRuntimeHandlerFeatures", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeRuntimeHandlerFeatures.js +var V1NodeRuntimeHandlerFeatures = class _V1NodeRuntimeHandlerFeatures { + static getAttributeTypeMap() { + return _V1NodeRuntimeHandlerFeatures.attributeTypeMap; + } + constructor() { + } +}; +V1NodeRuntimeHandlerFeatures.discriminator = void 0; +V1NodeRuntimeHandlerFeatures.mapping = void 0; +V1NodeRuntimeHandlerFeatures.attributeTypeMap = [ + { + "name": "recursiveReadOnlyMounts", + "baseName": "recursiveReadOnlyMounts", + "type": "boolean", + "format": "" + }, + { + "name": "userNamespaces", + "baseName": "userNamespaces", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeSelector.js +var V1NodeSelector = class _V1NodeSelector { + static getAttributeTypeMap() { + return _V1NodeSelector.attributeTypeMap; + } + constructor() { + } +}; +V1NodeSelector.discriminator = void 0; +V1NodeSelector.mapping = void 0; +V1NodeSelector.attributeTypeMap = [ + { + "name": "nodeSelectorTerms", + "baseName": "nodeSelectorTerms", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeSelectorRequirement.js +var V1NodeSelectorRequirement = class _V1NodeSelectorRequirement { + static getAttributeTypeMap() { + return _V1NodeSelectorRequirement.attributeTypeMap; + } + constructor() { + } +}; +V1NodeSelectorRequirement.discriminator = void 0; +V1NodeSelectorRequirement.mapping = void 0; +V1NodeSelectorRequirement.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeSelectorTerm.js +var V1NodeSelectorTerm = class _V1NodeSelectorTerm { + static getAttributeTypeMap() { + return _V1NodeSelectorTerm.attributeTypeMap; + } + constructor() { + } +}; +V1NodeSelectorTerm.discriminator = void 0; +V1NodeSelectorTerm.mapping = void 0; +V1NodeSelectorTerm.attributeTypeMap = [ + { + "name": "matchExpressions", + "baseName": "matchExpressions", + "type": "Array", + "format": "" + }, + { + "name": "matchFields", + "baseName": "matchFields", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeSpec.js +var V1NodeSpec = class _V1NodeSpec { + static getAttributeTypeMap() { + return _V1NodeSpec.attributeTypeMap; + } + constructor() { + } +}; +V1NodeSpec.discriminator = void 0; +V1NodeSpec.mapping = void 0; +V1NodeSpec.attributeTypeMap = [ + { + "name": "configSource", + "baseName": "configSource", + "type": "V1NodeConfigSource", + "format": "" + }, + { + "name": "externalID", + "baseName": "externalID", + "type": "string", + "format": "" + }, + { + "name": "podCIDR", + "baseName": "podCIDR", + "type": "string", + "format": "" + }, + { + "name": "podCIDRs", + "baseName": "podCIDRs", + "type": "Array", + "format": "" + }, + { + "name": "providerID", + "baseName": "providerID", + "type": "string", + "format": "" + }, + { + "name": "taints", + "baseName": "taints", + "type": "Array", + "format": "" + }, + { + "name": "unschedulable", + "baseName": "unschedulable", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeStatus.js +var V1NodeStatus = class _V1NodeStatus { + static getAttributeTypeMap() { + return _V1NodeStatus.attributeTypeMap; + } + constructor() { + } +}; +V1NodeStatus.discriminator = void 0; +V1NodeStatus.mapping = void 0; +V1NodeStatus.attributeTypeMap = [ + { + "name": "addresses", + "baseName": "addresses", + "type": "Array", + "format": "" + }, + { + "name": "allocatable", + "baseName": "allocatable", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "config", + "baseName": "config", + "type": "V1NodeConfigStatus", + "format": "" + }, + { + "name": "daemonEndpoints", + "baseName": "daemonEndpoints", + "type": "V1NodeDaemonEndpoints", + "format": "" + }, + { + "name": "features", + "baseName": "features", + "type": "V1NodeFeatures", + "format": "" + }, + { + "name": "images", + "baseName": "images", + "type": "Array", + "format": "" + }, + { + "name": "nodeInfo", + "baseName": "nodeInfo", + "type": "V1NodeSystemInfo", + "format": "" + }, + { + "name": "phase", + "baseName": "phase", + "type": "string", + "format": "" + }, + { + "name": "runtimeHandlers", + "baseName": "runtimeHandlers", + "type": "Array", + "format": "" + }, + { + "name": "volumesAttached", + "baseName": "volumesAttached", + "type": "Array", + "format": "" + }, + { + "name": "volumesInUse", + "baseName": "volumesInUse", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeSwapStatus.js +var V1NodeSwapStatus = class _V1NodeSwapStatus { + static getAttributeTypeMap() { + return _V1NodeSwapStatus.attributeTypeMap; + } + constructor() { + } +}; +V1NodeSwapStatus.discriminator = void 0; +V1NodeSwapStatus.mapping = void 0; +V1NodeSwapStatus.attributeTypeMap = [ + { + "name": "capacity", + "baseName": "capacity", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NodeSystemInfo.js +var V1NodeSystemInfo = class _V1NodeSystemInfo { + static getAttributeTypeMap() { + return _V1NodeSystemInfo.attributeTypeMap; + } + constructor() { + } +}; +V1NodeSystemInfo.discriminator = void 0; +V1NodeSystemInfo.mapping = void 0; +V1NodeSystemInfo.attributeTypeMap = [ + { + "name": "architecture", + "baseName": "architecture", + "type": "string", + "format": "" + }, + { + "name": "bootID", + "baseName": "bootID", + "type": "string", + "format": "" + }, + { + "name": "containerRuntimeVersion", + "baseName": "containerRuntimeVersion", + "type": "string", + "format": "" + }, + { + "name": "kernelVersion", + "baseName": "kernelVersion", + "type": "string", + "format": "" + }, + { + "name": "kubeProxyVersion", + "baseName": "kubeProxyVersion", + "type": "string", + "format": "" + }, + { + "name": "kubeletVersion", + "baseName": "kubeletVersion", + "type": "string", + "format": "" + }, + { + "name": "machineID", + "baseName": "machineID", + "type": "string", + "format": "" + }, + { + "name": "operatingSystem", + "baseName": "operatingSystem", + "type": "string", + "format": "" + }, + { + "name": "osImage", + "baseName": "osImage", + "type": "string", + "format": "" + }, + { + "name": "swap", + "baseName": "swap", + "type": "V1NodeSwapStatus", + "format": "" + }, + { + "name": "systemUUID", + "baseName": "systemUUID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NonResourceAttributes.js +var V1NonResourceAttributes = class _V1NonResourceAttributes { + static getAttributeTypeMap() { + return _V1NonResourceAttributes.attributeTypeMap; + } + constructor() { + } +}; +V1NonResourceAttributes.discriminator = void 0; +V1NonResourceAttributes.mapping = void 0; +V1NonResourceAttributes.attributeTypeMap = [ + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + }, + { + "name": "verb", + "baseName": "verb", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NonResourcePolicyRule.js +var V1NonResourcePolicyRule = class _V1NonResourcePolicyRule { + static getAttributeTypeMap() { + return _V1NonResourcePolicyRule.attributeTypeMap; + } + constructor() { + } +}; +V1NonResourcePolicyRule.discriminator = void 0; +V1NonResourcePolicyRule.mapping = void 0; +V1NonResourcePolicyRule.attributeTypeMap = [ + { + "name": "nonResourceURLs", + "baseName": "nonResourceURLs", + "type": "Array", + "format": "" + }, + { + "name": "verbs", + "baseName": "verbs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1NonResourceRule.js +var V1NonResourceRule = class _V1NonResourceRule { + static getAttributeTypeMap() { + return _V1NonResourceRule.attributeTypeMap; + } + constructor() { + } +}; +V1NonResourceRule.discriminator = void 0; +V1NonResourceRule.mapping = void 0; +V1NonResourceRule.attributeTypeMap = [ + { + "name": "nonResourceURLs", + "baseName": "nonResourceURLs", + "type": "Array", + "format": "" + }, + { + "name": "verbs", + "baseName": "verbs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ObjectFieldSelector.js +var V1ObjectFieldSelector = class _V1ObjectFieldSelector { + static getAttributeTypeMap() { + return _V1ObjectFieldSelector.attributeTypeMap; + } + constructor() { + } +}; +V1ObjectFieldSelector.discriminator = void 0; +V1ObjectFieldSelector.mapping = void 0; +V1ObjectFieldSelector.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "fieldPath", + "baseName": "fieldPath", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ObjectMeta.js +var V1ObjectMeta = class _V1ObjectMeta { + static getAttributeTypeMap() { + return _V1ObjectMeta.attributeTypeMap; + } + constructor() { + } +}; +V1ObjectMeta.discriminator = void 0; +V1ObjectMeta.mapping = void 0; +V1ObjectMeta.attributeTypeMap = [ + { + "name": "annotations", + "baseName": "annotations", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "creationTimestamp", + "baseName": "creationTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "deletionGracePeriodSeconds", + "baseName": "deletionGracePeriodSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "deletionTimestamp", + "baseName": "deletionTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "finalizers", + "baseName": "finalizers", + "type": "Array", + "format": "" + }, + { + "name": "generateName", + "baseName": "generateName", + "type": "string", + "format": "" + }, + { + "name": "generation", + "baseName": "generation", + "type": "number", + "format": "int64" + }, + { + "name": "labels", + "baseName": "labels", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "managedFields", + "baseName": "managedFields", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "ownerReferences", + "baseName": "ownerReferences", + "type": "Array", + "format": "" + }, + { + "name": "resourceVersion", + "baseName": "resourceVersion", + "type": "string", + "format": "" + }, + { + "name": "selfLink", + "baseName": "selfLink", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ObjectReference.js +var V1ObjectReference = class _V1ObjectReference { + static getAttributeTypeMap() { + return _V1ObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V1ObjectReference.discriminator = void 0; +V1ObjectReference.mapping = void 0; +V1ObjectReference.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "fieldPath", + "baseName": "fieldPath", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "resourceVersion", + "baseName": "resourceVersion", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1OpaqueDeviceConfiguration.js +var V1OpaqueDeviceConfiguration = class _V1OpaqueDeviceConfiguration { + static getAttributeTypeMap() { + return _V1OpaqueDeviceConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1OpaqueDeviceConfiguration.discriminator = void 0; +V1OpaqueDeviceConfiguration.mapping = void 0; +V1OpaqueDeviceConfiguration.attributeTypeMap = [ + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "any", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Overhead.js +var V1Overhead = class _V1Overhead { + static getAttributeTypeMap() { + return _V1Overhead.attributeTypeMap; + } + constructor() { + } +}; +V1Overhead.discriminator = void 0; +V1Overhead.mapping = void 0; +V1Overhead.attributeTypeMap = [ + { + "name": "podFixed", + "baseName": "podFixed", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1OwnerReference.js +var V1OwnerReference = class _V1OwnerReference { + static getAttributeTypeMap() { + return _V1OwnerReference.attributeTypeMap; + } + constructor() { + } +}; +V1OwnerReference.discriminator = void 0; +V1OwnerReference.mapping = void 0; +V1OwnerReference.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "blockOwnerDeletion", + "baseName": "blockOwnerDeletion", + "type": "boolean", + "format": "" + }, + { + "name": "controller", + "baseName": "controller", + "type": "boolean", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ParamKind.js +var V1ParamKind = class _V1ParamKind { + static getAttributeTypeMap() { + return _V1ParamKind.attributeTypeMap; + } + constructor() { + } +}; +V1ParamKind.discriminator = void 0; +V1ParamKind.mapping = void 0; +V1ParamKind.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ParamRef.js +var V1ParamRef = class _V1ParamRef { + static getAttributeTypeMap() { + return _V1ParamRef.attributeTypeMap; + } + constructor() { + } +}; +V1ParamRef.discriminator = void 0; +V1ParamRef.mapping = void 0; +V1ParamRef.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "parameterNotFoundAction", + "baseName": "parameterNotFoundAction", + "type": "string", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ParentReference.js +var V1ParentReference = class _V1ParentReference { + static getAttributeTypeMap() { + return _V1ParentReference.attributeTypeMap; + } + constructor() { + } +}; +V1ParentReference.discriminator = void 0; +V1ParentReference.mapping = void 0; +V1ParentReference.attributeTypeMap = [ + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolume.js +var V1PersistentVolume = class _V1PersistentVolume { + static getAttributeTypeMap() { + return _V1PersistentVolume.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolume.discriminator = void 0; +V1PersistentVolume.mapping = void 0; +V1PersistentVolume.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PersistentVolumeSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1PersistentVolumeStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaim.js +var V1PersistentVolumeClaim = class _V1PersistentVolumeClaim { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaim.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaim.discriminator = void 0; +V1PersistentVolumeClaim.mapping = void 0; +V1PersistentVolumeClaim.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PersistentVolumeClaimSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1PersistentVolumeClaimStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaimCondition.js +var V1PersistentVolumeClaimCondition = class _V1PersistentVolumeClaimCondition { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaimCondition.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaimCondition.discriminator = void 0; +V1PersistentVolumeClaimCondition.mapping = void 0; +V1PersistentVolumeClaimCondition.attributeTypeMap = [ + { + "name": "lastProbeTime", + "baseName": "lastProbeTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaimList.js +var V1PersistentVolumeClaimList = class _V1PersistentVolumeClaimList { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaimList.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaimList.discriminator = void 0; +V1PersistentVolumeClaimList.mapping = void 0; +V1PersistentVolumeClaimList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaimSpec.js +var V1PersistentVolumeClaimSpec = class _V1PersistentVolumeClaimSpec { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaimSpec.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaimSpec.discriminator = void 0; +V1PersistentVolumeClaimSpec.mapping = void 0; +V1PersistentVolumeClaimSpec.attributeTypeMap = [ + { + "name": "accessModes", + "baseName": "accessModes", + "type": "Array", + "format": "" + }, + { + "name": "dataSource", + "baseName": "dataSource", + "type": "V1TypedLocalObjectReference", + "format": "" + }, + { + "name": "dataSourceRef", + "baseName": "dataSourceRef", + "type": "V1TypedObjectReference", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "V1VolumeResourceRequirements", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "storageClassName", + "baseName": "storageClassName", + "type": "string", + "format": "" + }, + { + "name": "volumeAttributesClassName", + "baseName": "volumeAttributesClassName", + "type": "string", + "format": "" + }, + { + "name": "volumeMode", + "baseName": "volumeMode", + "type": "string", + "format": "" + }, + { + "name": "volumeName", + "baseName": "volumeName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaimStatus.js +var V1PersistentVolumeClaimStatus = class _V1PersistentVolumeClaimStatus { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaimStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaimStatus.discriminator = void 0; +V1PersistentVolumeClaimStatus.mapping = void 0; +V1PersistentVolumeClaimStatus.attributeTypeMap = [ + { + "name": "accessModes", + "baseName": "accessModes", + "type": "Array", + "format": "" + }, + { + "name": "allocatedResourceStatuses", + "baseName": "allocatedResourceStatuses", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "allocatedResources", + "baseName": "allocatedResources", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "currentVolumeAttributesClassName", + "baseName": "currentVolumeAttributesClassName", + "type": "string", + "format": "" + }, + { + "name": "modifyVolumeStatus", + "baseName": "modifyVolumeStatus", + "type": "V1ModifyVolumeStatus", + "format": "" + }, + { + "name": "phase", + "baseName": "phase", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaimTemplate.js +var V1PersistentVolumeClaimTemplate = class _V1PersistentVolumeClaimTemplate { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaimTemplate.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaimTemplate.discriminator = void 0; +V1PersistentVolumeClaimTemplate.mapping = void 0; +V1PersistentVolumeClaimTemplate.attributeTypeMap = [ + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PersistentVolumeClaimSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeClaimVolumeSource.js +var V1PersistentVolumeClaimVolumeSource = class _V1PersistentVolumeClaimVolumeSource { + static getAttributeTypeMap() { + return _V1PersistentVolumeClaimVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeClaimVolumeSource.discriminator = void 0; +V1PersistentVolumeClaimVolumeSource.mapping = void 0; +V1PersistentVolumeClaimVolumeSource.attributeTypeMap = [ + { + "name": "claimName", + "baseName": "claimName", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeList.js +var V1PersistentVolumeList = class _V1PersistentVolumeList { + static getAttributeTypeMap() { + return _V1PersistentVolumeList.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeList.discriminator = void 0; +V1PersistentVolumeList.mapping = void 0; +V1PersistentVolumeList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeSpec.js +var V1PersistentVolumeSpec = class _V1PersistentVolumeSpec { + static getAttributeTypeMap() { + return _V1PersistentVolumeSpec.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeSpec.discriminator = void 0; +V1PersistentVolumeSpec.mapping = void 0; +V1PersistentVolumeSpec.attributeTypeMap = [ + { + "name": "accessModes", + "baseName": "accessModes", + "type": "Array", + "format": "" + }, + { + "name": "awsElasticBlockStore", + "baseName": "awsElasticBlockStore", + "type": "V1AWSElasticBlockStoreVolumeSource", + "format": "" + }, + { + "name": "azureDisk", + "baseName": "azureDisk", + "type": "V1AzureDiskVolumeSource", + "format": "" + }, + { + "name": "azureFile", + "baseName": "azureFile", + "type": "V1AzureFilePersistentVolumeSource", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "cephfs", + "baseName": "cephfs", + "type": "V1CephFSPersistentVolumeSource", + "format": "" + }, + { + "name": "cinder", + "baseName": "cinder", + "type": "V1CinderPersistentVolumeSource", + "format": "" + }, + { + "name": "claimRef", + "baseName": "claimRef", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "csi", + "baseName": "csi", + "type": "V1CSIPersistentVolumeSource", + "format": "" + }, + { + "name": "fc", + "baseName": "fc", + "type": "V1FCVolumeSource", + "format": "" + }, + { + "name": "flexVolume", + "baseName": "flexVolume", + "type": "V1FlexPersistentVolumeSource", + "format": "" + }, + { + "name": "flocker", + "baseName": "flocker", + "type": "V1FlockerVolumeSource", + "format": "" + }, + { + "name": "gcePersistentDisk", + "baseName": "gcePersistentDisk", + "type": "V1GCEPersistentDiskVolumeSource", + "format": "" + }, + { + "name": "glusterfs", + "baseName": "glusterfs", + "type": "V1GlusterfsPersistentVolumeSource", + "format": "" + }, + { + "name": "hostPath", + "baseName": "hostPath", + "type": "V1HostPathVolumeSource", + "format": "" + }, + { + "name": "iscsi", + "baseName": "iscsi", + "type": "V1ISCSIPersistentVolumeSource", + "format": "" + }, + { + "name": "local", + "baseName": "local", + "type": "V1LocalVolumeSource", + "format": "" + }, + { + "name": "mountOptions", + "baseName": "mountOptions", + "type": "Array", + "format": "" + }, + { + "name": "nfs", + "baseName": "nfs", + "type": "V1NFSVolumeSource", + "format": "" + }, + { + "name": "nodeAffinity", + "baseName": "nodeAffinity", + "type": "V1VolumeNodeAffinity", + "format": "" + }, + { + "name": "persistentVolumeReclaimPolicy", + "baseName": "persistentVolumeReclaimPolicy", + "type": "string", + "format": "" + }, + { + "name": "photonPersistentDisk", + "baseName": "photonPersistentDisk", + "type": "V1PhotonPersistentDiskVolumeSource", + "format": "" + }, + { + "name": "portworxVolume", + "baseName": "portworxVolume", + "type": "V1PortworxVolumeSource", + "format": "" + }, + { + "name": "quobyte", + "baseName": "quobyte", + "type": "V1QuobyteVolumeSource", + "format": "" + }, + { + "name": "rbd", + "baseName": "rbd", + "type": "V1RBDPersistentVolumeSource", + "format": "" + }, + { + "name": "scaleIO", + "baseName": "scaleIO", + "type": "V1ScaleIOPersistentVolumeSource", + "format": "" + }, + { + "name": "storageClassName", + "baseName": "storageClassName", + "type": "string", + "format": "" + }, + { + "name": "storageos", + "baseName": "storageos", + "type": "V1StorageOSPersistentVolumeSource", + "format": "" + }, + { + "name": "volumeAttributesClassName", + "baseName": "volumeAttributesClassName", + "type": "string", + "format": "" + }, + { + "name": "volumeMode", + "baseName": "volumeMode", + "type": "string", + "format": "" + }, + { + "name": "vsphereVolume", + "baseName": "vsphereVolume", + "type": "V1VsphereVirtualDiskVolumeSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PersistentVolumeStatus.js +var V1PersistentVolumeStatus = class _V1PersistentVolumeStatus { + static getAttributeTypeMap() { + return _V1PersistentVolumeStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PersistentVolumeStatus.discriminator = void 0; +V1PersistentVolumeStatus.mapping = void 0; +V1PersistentVolumeStatus.attributeTypeMap = [ + { + "name": "lastPhaseTransitionTime", + "baseName": "lastPhaseTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "phase", + "baseName": "phase", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PhotonPersistentDiskVolumeSource.js +var V1PhotonPersistentDiskVolumeSource = class _V1PhotonPersistentDiskVolumeSource { + static getAttributeTypeMap() { + return _V1PhotonPersistentDiskVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1PhotonPersistentDiskVolumeSource.discriminator = void 0; +V1PhotonPersistentDiskVolumeSource.mapping = void 0; +V1PhotonPersistentDiskVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "pdID", + "baseName": "pdID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Pod.js +var V1Pod = class _V1Pod { + static getAttributeTypeMap() { + return _V1Pod.attributeTypeMap; + } + constructor() { + } +}; +V1Pod.discriminator = void 0; +V1Pod.mapping = void 0; +V1Pod.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PodSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1PodStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodAffinity.js +var V1PodAffinity = class _V1PodAffinity { + static getAttributeTypeMap() { + return _V1PodAffinity.attributeTypeMap; + } + constructor() { + } +}; +V1PodAffinity.discriminator = void 0; +V1PodAffinity.mapping = void 0; +V1PodAffinity.attributeTypeMap = [ + { + "name": "preferredDuringSchedulingIgnoredDuringExecution", + "baseName": "preferredDuringSchedulingIgnoredDuringExecution", + "type": "Array", + "format": "" + }, + { + "name": "requiredDuringSchedulingIgnoredDuringExecution", + "baseName": "requiredDuringSchedulingIgnoredDuringExecution", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodAffinityTerm.js +var V1PodAffinityTerm = class _V1PodAffinityTerm { + static getAttributeTypeMap() { + return _V1PodAffinityTerm.attributeTypeMap; + } + constructor() { + } +}; +V1PodAffinityTerm.discriminator = void 0; +V1PodAffinityTerm.mapping = void 0; +V1PodAffinityTerm.attributeTypeMap = [ + { + "name": "labelSelector", + "baseName": "labelSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "matchLabelKeys", + "baseName": "matchLabelKeys", + "type": "Array", + "format": "" + }, + { + "name": "mismatchLabelKeys", + "baseName": "mismatchLabelKeys", + "type": "Array", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "namespaces", + "baseName": "namespaces", + "type": "Array", + "format": "" + }, + { + "name": "topologyKey", + "baseName": "topologyKey", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodAntiAffinity.js +var V1PodAntiAffinity = class _V1PodAntiAffinity { + static getAttributeTypeMap() { + return _V1PodAntiAffinity.attributeTypeMap; + } + constructor() { + } +}; +V1PodAntiAffinity.discriminator = void 0; +V1PodAntiAffinity.mapping = void 0; +V1PodAntiAffinity.attributeTypeMap = [ + { + "name": "preferredDuringSchedulingIgnoredDuringExecution", + "baseName": "preferredDuringSchedulingIgnoredDuringExecution", + "type": "Array", + "format": "" + }, + { + "name": "requiredDuringSchedulingIgnoredDuringExecution", + "baseName": "requiredDuringSchedulingIgnoredDuringExecution", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodCertificateProjection.js +var V1PodCertificateProjection = class _V1PodCertificateProjection { + static getAttributeTypeMap() { + return _V1PodCertificateProjection.attributeTypeMap; + } + constructor() { + } +}; +V1PodCertificateProjection.discriminator = void 0; +V1PodCertificateProjection.mapping = void 0; +V1PodCertificateProjection.attributeTypeMap = [ + { + "name": "certificateChainPath", + "baseName": "certificateChainPath", + "type": "string", + "format": "" + }, + { + "name": "credentialBundlePath", + "baseName": "credentialBundlePath", + "type": "string", + "format": "" + }, + { + "name": "keyPath", + "baseName": "keyPath", + "type": "string", + "format": "" + }, + { + "name": "keyType", + "baseName": "keyType", + "type": "string", + "format": "" + }, + { + "name": "maxExpirationSeconds", + "baseName": "maxExpirationSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "signerName", + "baseName": "signerName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodCondition.js +var V1PodCondition = class _V1PodCondition { + static getAttributeTypeMap() { + return _V1PodCondition.attributeTypeMap; + } + constructor() { + } +}; +V1PodCondition.discriminator = void 0; +V1PodCondition.mapping = void 0; +V1PodCondition.attributeTypeMap = [ + { + "name": "lastProbeTime", + "baseName": "lastProbeTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodDNSConfig.js +var V1PodDNSConfig = class _V1PodDNSConfig { + static getAttributeTypeMap() { + return _V1PodDNSConfig.attributeTypeMap; + } + constructor() { + } +}; +V1PodDNSConfig.discriminator = void 0; +V1PodDNSConfig.mapping = void 0; +V1PodDNSConfig.attributeTypeMap = [ + { + "name": "nameservers", + "baseName": "nameservers", + "type": "Array", + "format": "" + }, + { + "name": "options", + "baseName": "options", + "type": "Array", + "format": "" + }, + { + "name": "searches", + "baseName": "searches", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodDNSConfigOption.js +var V1PodDNSConfigOption = class _V1PodDNSConfigOption { + static getAttributeTypeMap() { + return _V1PodDNSConfigOption.attributeTypeMap; + } + constructor() { + } +}; +V1PodDNSConfigOption.discriminator = void 0; +V1PodDNSConfigOption.mapping = void 0; +V1PodDNSConfigOption.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodDisruptionBudget.js +var V1PodDisruptionBudget = class _V1PodDisruptionBudget { + static getAttributeTypeMap() { + return _V1PodDisruptionBudget.attributeTypeMap; + } + constructor() { + } +}; +V1PodDisruptionBudget.discriminator = void 0; +V1PodDisruptionBudget.mapping = void 0; +V1PodDisruptionBudget.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PodDisruptionBudgetSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1PodDisruptionBudgetStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodDisruptionBudgetList.js +var V1PodDisruptionBudgetList = class _V1PodDisruptionBudgetList { + static getAttributeTypeMap() { + return _V1PodDisruptionBudgetList.attributeTypeMap; + } + constructor() { + } +}; +V1PodDisruptionBudgetList.discriminator = void 0; +V1PodDisruptionBudgetList.mapping = void 0; +V1PodDisruptionBudgetList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodDisruptionBudgetSpec.js +var V1PodDisruptionBudgetSpec = class _V1PodDisruptionBudgetSpec { + static getAttributeTypeMap() { + return _V1PodDisruptionBudgetSpec.attributeTypeMap; + } + constructor() { + } +}; +V1PodDisruptionBudgetSpec.discriminator = void 0; +V1PodDisruptionBudgetSpec.mapping = void 0; +V1PodDisruptionBudgetSpec.attributeTypeMap = [ + { + "name": "maxUnavailable", + "baseName": "maxUnavailable", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "minAvailable", + "baseName": "minAvailable", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "unhealthyPodEvictionPolicy", + "baseName": "unhealthyPodEvictionPolicy", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodDisruptionBudgetStatus.js +var V1PodDisruptionBudgetStatus = class _V1PodDisruptionBudgetStatus { + static getAttributeTypeMap() { + return _V1PodDisruptionBudgetStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PodDisruptionBudgetStatus.discriminator = void 0; +V1PodDisruptionBudgetStatus.mapping = void 0; +V1PodDisruptionBudgetStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "currentHealthy", + "baseName": "currentHealthy", + "type": "number", + "format": "int32" + }, + { + "name": "desiredHealthy", + "baseName": "desiredHealthy", + "type": "number", + "format": "int32" + }, + { + "name": "disruptedPods", + "baseName": "disruptedPods", + "type": "{ [key: string]: Date; }", + "format": "date-time" + }, + { + "name": "disruptionsAllowed", + "baseName": "disruptionsAllowed", + "type": "number", + "format": "int32" + }, + { + "name": "expectedPods", + "baseName": "expectedPods", + "type": "number", + "format": "int32" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodExtendedResourceClaimStatus.js +var V1PodExtendedResourceClaimStatus = class _V1PodExtendedResourceClaimStatus { + static getAttributeTypeMap() { + return _V1PodExtendedResourceClaimStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PodExtendedResourceClaimStatus.discriminator = void 0; +V1PodExtendedResourceClaimStatus.mapping = void 0; +V1PodExtendedResourceClaimStatus.attributeTypeMap = [ + { + "name": "requestMappings", + "baseName": "requestMappings", + "type": "Array", + "format": "" + }, + { + "name": "resourceClaimName", + "baseName": "resourceClaimName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodFailurePolicy.js +var V1PodFailurePolicy = class _V1PodFailurePolicy { + static getAttributeTypeMap() { + return _V1PodFailurePolicy.attributeTypeMap; + } + constructor() { + } +}; +V1PodFailurePolicy.discriminator = void 0; +V1PodFailurePolicy.mapping = void 0; +V1PodFailurePolicy.attributeTypeMap = [ + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodFailurePolicyOnExitCodesRequirement.js +var V1PodFailurePolicyOnExitCodesRequirement = class _V1PodFailurePolicyOnExitCodesRequirement { + static getAttributeTypeMap() { + return _V1PodFailurePolicyOnExitCodesRequirement.attributeTypeMap; + } + constructor() { + } +}; +V1PodFailurePolicyOnExitCodesRequirement.discriminator = void 0; +V1PodFailurePolicyOnExitCodesRequirement.mapping = void 0; +V1PodFailurePolicyOnExitCodesRequirement.attributeTypeMap = [ + { + "name": "containerName", + "baseName": "containerName", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodFailurePolicyOnPodConditionsPattern.js +var V1PodFailurePolicyOnPodConditionsPattern = class _V1PodFailurePolicyOnPodConditionsPattern { + static getAttributeTypeMap() { + return _V1PodFailurePolicyOnPodConditionsPattern.attributeTypeMap; + } + constructor() { + } +}; +V1PodFailurePolicyOnPodConditionsPattern.discriminator = void 0; +V1PodFailurePolicyOnPodConditionsPattern.mapping = void 0; +V1PodFailurePolicyOnPodConditionsPattern.attributeTypeMap = [ + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodFailurePolicyRule.js +var V1PodFailurePolicyRule = class _V1PodFailurePolicyRule { + static getAttributeTypeMap() { + return _V1PodFailurePolicyRule.attributeTypeMap; + } + constructor() { + } +}; +V1PodFailurePolicyRule.discriminator = void 0; +V1PodFailurePolicyRule.mapping = void 0; +V1PodFailurePolicyRule.attributeTypeMap = [ + { + "name": "action", + "baseName": "action", + "type": "string", + "format": "" + }, + { + "name": "onExitCodes", + "baseName": "onExitCodes", + "type": "V1PodFailurePolicyOnExitCodesRequirement", + "format": "" + }, + { + "name": "onPodConditions", + "baseName": "onPodConditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodIP.js +var V1PodIP = class _V1PodIP { + static getAttributeTypeMap() { + return _V1PodIP.attributeTypeMap; + } + constructor() { + } +}; +V1PodIP.discriminator = void 0; +V1PodIP.mapping = void 0; +V1PodIP.attributeTypeMap = [ + { + "name": "ip", + "baseName": "ip", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodList.js +var V1PodList = class _V1PodList { + static getAttributeTypeMap() { + return _V1PodList.attributeTypeMap; + } + constructor() { + } +}; +V1PodList.discriminator = void 0; +V1PodList.mapping = void 0; +V1PodList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodOS.js +var V1PodOS = class _V1PodOS { + static getAttributeTypeMap() { + return _V1PodOS.attributeTypeMap; + } + constructor() { + } +}; +V1PodOS.discriminator = void 0; +V1PodOS.mapping = void 0; +V1PodOS.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodReadinessGate.js +var V1PodReadinessGate = class _V1PodReadinessGate { + static getAttributeTypeMap() { + return _V1PodReadinessGate.attributeTypeMap; + } + constructor() { + } +}; +V1PodReadinessGate.discriminator = void 0; +V1PodReadinessGate.mapping = void 0; +V1PodReadinessGate.attributeTypeMap = [ + { + "name": "conditionType", + "baseName": "conditionType", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodResourceClaim.js +var V1PodResourceClaim = class _V1PodResourceClaim { + static getAttributeTypeMap() { + return _V1PodResourceClaim.attributeTypeMap; + } + constructor() { + } +}; +V1PodResourceClaim.discriminator = void 0; +V1PodResourceClaim.mapping = void 0; +V1PodResourceClaim.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resourceClaimName", + "baseName": "resourceClaimName", + "type": "string", + "format": "" + }, + { + "name": "resourceClaimTemplateName", + "baseName": "resourceClaimTemplateName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodResourceClaimStatus.js +var V1PodResourceClaimStatus = class _V1PodResourceClaimStatus { + static getAttributeTypeMap() { + return _V1PodResourceClaimStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PodResourceClaimStatus.discriminator = void 0; +V1PodResourceClaimStatus.mapping = void 0; +V1PodResourceClaimStatus.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resourceClaimName", + "baseName": "resourceClaimName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodSchedulingGate.js +var V1PodSchedulingGate = class _V1PodSchedulingGate { + static getAttributeTypeMap() { + return _V1PodSchedulingGate.attributeTypeMap; + } + constructor() { + } +}; +V1PodSchedulingGate.discriminator = void 0; +V1PodSchedulingGate.mapping = void 0; +V1PodSchedulingGate.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodSecurityContext.js +var V1PodSecurityContext = class _V1PodSecurityContext { + static getAttributeTypeMap() { + return _V1PodSecurityContext.attributeTypeMap; + } + constructor() { + } +}; +V1PodSecurityContext.discriminator = void 0; +V1PodSecurityContext.mapping = void 0; +V1PodSecurityContext.attributeTypeMap = [ + { + "name": "appArmorProfile", + "baseName": "appArmorProfile", + "type": "V1AppArmorProfile", + "format": "" + }, + { + "name": "fsGroup", + "baseName": "fsGroup", + "type": "number", + "format": "int64" + }, + { + "name": "fsGroupChangePolicy", + "baseName": "fsGroupChangePolicy", + "type": "string", + "format": "" + }, + { + "name": "runAsGroup", + "baseName": "runAsGroup", + "type": "number", + "format": "int64" + }, + { + "name": "runAsNonRoot", + "baseName": "runAsNonRoot", + "type": "boolean", + "format": "" + }, + { + "name": "runAsUser", + "baseName": "runAsUser", + "type": "number", + "format": "int64" + }, + { + "name": "seLinuxChangePolicy", + "baseName": "seLinuxChangePolicy", + "type": "string", + "format": "" + }, + { + "name": "seLinuxOptions", + "baseName": "seLinuxOptions", + "type": "V1SELinuxOptions", + "format": "" + }, + { + "name": "seccompProfile", + "baseName": "seccompProfile", + "type": "V1SeccompProfile", + "format": "" + }, + { + "name": "supplementalGroups", + "baseName": "supplementalGroups", + "type": "Array", + "format": "int64" + }, + { + "name": "supplementalGroupsPolicy", + "baseName": "supplementalGroupsPolicy", + "type": "string", + "format": "" + }, + { + "name": "sysctls", + "baseName": "sysctls", + "type": "Array", + "format": "" + }, + { + "name": "windowsOptions", + "baseName": "windowsOptions", + "type": "V1WindowsSecurityContextOptions", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodSpec.js +var V1PodSpec = class _V1PodSpec { + static getAttributeTypeMap() { + return _V1PodSpec.attributeTypeMap; + } + constructor() { + } +}; +V1PodSpec.discriminator = void 0; +V1PodSpec.mapping = void 0; +V1PodSpec.attributeTypeMap = [ + { + "name": "activeDeadlineSeconds", + "baseName": "activeDeadlineSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "affinity", + "baseName": "affinity", + "type": "V1Affinity", + "format": "" + }, + { + "name": "automountServiceAccountToken", + "baseName": "automountServiceAccountToken", + "type": "boolean", + "format": "" + }, + { + "name": "containers", + "baseName": "containers", + "type": "Array", + "format": "" + }, + { + "name": "dnsConfig", + "baseName": "dnsConfig", + "type": "V1PodDNSConfig", + "format": "" + }, + { + "name": "dnsPolicy", + "baseName": "dnsPolicy", + "type": "string", + "format": "" + }, + { + "name": "enableServiceLinks", + "baseName": "enableServiceLinks", + "type": "boolean", + "format": "" + }, + { + "name": "ephemeralContainers", + "baseName": "ephemeralContainers", + "type": "Array", + "format": "" + }, + { + "name": "hostAliases", + "baseName": "hostAliases", + "type": "Array", + "format": "" + }, + { + "name": "hostIPC", + "baseName": "hostIPC", + "type": "boolean", + "format": "" + }, + { + "name": "hostNetwork", + "baseName": "hostNetwork", + "type": "boolean", + "format": "" + }, + { + "name": "hostPID", + "baseName": "hostPID", + "type": "boolean", + "format": "" + }, + { + "name": "hostUsers", + "baseName": "hostUsers", + "type": "boolean", + "format": "" + }, + { + "name": "hostname", + "baseName": "hostname", + "type": "string", + "format": "" + }, + { + "name": "hostnameOverride", + "baseName": "hostnameOverride", + "type": "string", + "format": "" + }, + { + "name": "imagePullSecrets", + "baseName": "imagePullSecrets", + "type": "Array", + "format": "" + }, + { + "name": "initContainers", + "baseName": "initContainers", + "type": "Array", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "os", + "baseName": "os", + "type": "V1PodOS", + "format": "" + }, + { + "name": "overhead", + "baseName": "overhead", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "preemptionPolicy", + "baseName": "preemptionPolicy", + "type": "string", + "format": "" + }, + { + "name": "priority", + "baseName": "priority", + "type": "number", + "format": "int32" + }, + { + "name": "priorityClassName", + "baseName": "priorityClassName", + "type": "string", + "format": "" + }, + { + "name": "readinessGates", + "baseName": "readinessGates", + "type": "Array", + "format": "" + }, + { + "name": "resourceClaims", + "baseName": "resourceClaims", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "V1ResourceRequirements", + "format": "" + }, + { + "name": "restartPolicy", + "baseName": "restartPolicy", + "type": "string", + "format": "" + }, + { + "name": "runtimeClassName", + "baseName": "runtimeClassName", + "type": "string", + "format": "" + }, + { + "name": "schedulerName", + "baseName": "schedulerName", + "type": "string", + "format": "" + }, + { + "name": "schedulingGates", + "baseName": "schedulingGates", + "type": "Array", + "format": "" + }, + { + "name": "securityContext", + "baseName": "securityContext", + "type": "V1PodSecurityContext", + "format": "" + }, + { + "name": "serviceAccount", + "baseName": "serviceAccount", + "type": "string", + "format": "" + }, + { + "name": "serviceAccountName", + "baseName": "serviceAccountName", + "type": "string", + "format": "" + }, + { + "name": "setHostnameAsFQDN", + "baseName": "setHostnameAsFQDN", + "type": "boolean", + "format": "" + }, + { + "name": "shareProcessNamespace", + "baseName": "shareProcessNamespace", + "type": "boolean", + "format": "" + }, + { + "name": "subdomain", + "baseName": "subdomain", + "type": "string", + "format": "" + }, + { + "name": "terminationGracePeriodSeconds", + "baseName": "terminationGracePeriodSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + }, + { + "name": "topologySpreadConstraints", + "baseName": "topologySpreadConstraints", + "type": "Array", + "format": "" + }, + { + "name": "volumes", + "baseName": "volumes", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodStatus.js +var V1PodStatus = class _V1PodStatus { + static getAttributeTypeMap() { + return _V1PodStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PodStatus.discriminator = void 0; +V1PodStatus.mapping = void 0; +V1PodStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "containerStatuses", + "baseName": "containerStatuses", + "type": "Array", + "format": "" + }, + { + "name": "ephemeralContainerStatuses", + "baseName": "ephemeralContainerStatuses", + "type": "Array", + "format": "" + }, + { + "name": "extendedResourceClaimStatus", + "baseName": "extendedResourceClaimStatus", + "type": "V1PodExtendedResourceClaimStatus", + "format": "" + }, + { + "name": "hostIP", + "baseName": "hostIP", + "type": "string", + "format": "" + }, + { + "name": "hostIPs", + "baseName": "hostIPs", + "type": "Array", + "format": "" + }, + { + "name": "initContainerStatuses", + "baseName": "initContainerStatuses", + "type": "Array", + "format": "" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "nominatedNodeName", + "baseName": "nominatedNodeName", + "type": "string", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "phase", + "baseName": "phase", + "type": "string", + "format": "" + }, + { + "name": "podIP", + "baseName": "podIP", + "type": "string", + "format": "" + }, + { + "name": "podIPs", + "baseName": "podIPs", + "type": "Array", + "format": "" + }, + { + "name": "qosClass", + "baseName": "qosClass", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "resize", + "baseName": "resize", + "type": "string", + "format": "" + }, + { + "name": "resourceClaimStatuses", + "baseName": "resourceClaimStatuses", + "type": "Array", + "format": "" + }, + { + "name": "startTime", + "baseName": "startTime", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodTemplate.js +var V1PodTemplate = class _V1PodTemplate { + static getAttributeTypeMap() { + return _V1PodTemplate.attributeTypeMap; + } + constructor() { + } +}; +V1PodTemplate.discriminator = void 0; +V1PodTemplate.mapping = void 0; +V1PodTemplate.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodTemplateList.js +var V1PodTemplateList = class _V1PodTemplateList { + static getAttributeTypeMap() { + return _V1PodTemplateList.attributeTypeMap; + } + constructor() { + } +}; +V1PodTemplateList.discriminator = void 0; +V1PodTemplateList.mapping = void 0; +V1PodTemplateList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PodTemplateSpec.js +var V1PodTemplateSpec = class _V1PodTemplateSpec { + static getAttributeTypeMap() { + return _V1PodTemplateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1PodTemplateSpec.discriminator = void 0; +V1PodTemplateSpec.mapping = void 0; +V1PodTemplateSpec.attributeTypeMap = [ + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PodSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PolicyRule.js +var V1PolicyRule = class _V1PolicyRule { + static getAttributeTypeMap() { + return _V1PolicyRule.attributeTypeMap; + } + constructor() { + } +}; +V1PolicyRule.discriminator = void 0; +V1PolicyRule.mapping = void 0; +V1PolicyRule.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "nonResourceURLs", + "baseName": "nonResourceURLs", + "type": "Array", + "format": "" + }, + { + "name": "resourceNames", + "baseName": "resourceNames", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "verbs", + "baseName": "verbs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PolicyRulesWithSubjects.js +var V1PolicyRulesWithSubjects = class _V1PolicyRulesWithSubjects { + static getAttributeTypeMap() { + return _V1PolicyRulesWithSubjects.attributeTypeMap; + } + constructor() { + } +}; +V1PolicyRulesWithSubjects.discriminator = void 0; +V1PolicyRulesWithSubjects.mapping = void 0; +V1PolicyRulesWithSubjects.attributeTypeMap = [ + { + "name": "nonResourceRules", + "baseName": "nonResourceRules", + "type": "Array", + "format": "" + }, + { + "name": "resourceRules", + "baseName": "resourceRules", + "type": "Array", + "format": "" + }, + { + "name": "subjects", + "baseName": "subjects", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PortStatus.js +var V1PortStatus = class _V1PortStatus { + static getAttributeTypeMap() { + return _V1PortStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PortStatus.discriminator = void 0; +V1PortStatus.mapping = void 0; +V1PortStatus.attributeTypeMap = [ + { + "name": "error", + "baseName": "error", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PortworxVolumeSource.js +var V1PortworxVolumeSource = class _V1PortworxVolumeSource { + static getAttributeTypeMap() { + return _V1PortworxVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1PortworxVolumeSource.discriminator = void 0; +V1PortworxVolumeSource.mapping = void 0; +V1PortworxVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "volumeID", + "baseName": "volumeID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Preconditions.js +var V1Preconditions = class _V1Preconditions { + static getAttributeTypeMap() { + return _V1Preconditions.attributeTypeMap; + } + constructor() { + } +}; +V1Preconditions.discriminator = void 0; +V1Preconditions.mapping = void 0; +V1Preconditions.attributeTypeMap = [ + { + "name": "resourceVersion", + "baseName": "resourceVersion", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PreferredSchedulingTerm.js +var V1PreferredSchedulingTerm = class _V1PreferredSchedulingTerm { + static getAttributeTypeMap() { + return _V1PreferredSchedulingTerm.attributeTypeMap; + } + constructor() { + } +}; +V1PreferredSchedulingTerm.discriminator = void 0; +V1PreferredSchedulingTerm.mapping = void 0; +V1PreferredSchedulingTerm.attributeTypeMap = [ + { + "name": "preference", + "baseName": "preference", + "type": "V1NodeSelectorTerm", + "format": "" + }, + { + "name": "weight", + "baseName": "weight", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityClass.js +var V1PriorityClass = class _V1PriorityClass { + static getAttributeTypeMap() { + return _V1PriorityClass.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityClass.discriminator = void 0; +V1PriorityClass.mapping = void 0; +V1PriorityClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "description", + "baseName": "description", + "type": "string", + "format": "" + }, + { + "name": "globalDefault", + "baseName": "globalDefault", + "type": "boolean", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "preemptionPolicy", + "baseName": "preemptionPolicy", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityClassList.js +var V1PriorityClassList = class _V1PriorityClassList { + static getAttributeTypeMap() { + return _V1PriorityClassList.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityClassList.discriminator = void 0; +V1PriorityClassList.mapping = void 0; +V1PriorityClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityLevelConfiguration.js +var V1PriorityLevelConfiguration = class _V1PriorityLevelConfiguration { + static getAttributeTypeMap() { + return _V1PriorityLevelConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityLevelConfiguration.discriminator = void 0; +V1PriorityLevelConfiguration.mapping = void 0; +V1PriorityLevelConfiguration.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1PriorityLevelConfigurationSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1PriorityLevelConfigurationStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityLevelConfigurationCondition.js +var V1PriorityLevelConfigurationCondition = class _V1PriorityLevelConfigurationCondition { + static getAttributeTypeMap() { + return _V1PriorityLevelConfigurationCondition.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityLevelConfigurationCondition.discriminator = void 0; +V1PriorityLevelConfigurationCondition.mapping = void 0; +V1PriorityLevelConfigurationCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityLevelConfigurationList.js +var V1PriorityLevelConfigurationList = class _V1PriorityLevelConfigurationList { + static getAttributeTypeMap() { + return _V1PriorityLevelConfigurationList.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityLevelConfigurationList.discriminator = void 0; +V1PriorityLevelConfigurationList.mapping = void 0; +V1PriorityLevelConfigurationList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityLevelConfigurationReference.js +var V1PriorityLevelConfigurationReference = class _V1PriorityLevelConfigurationReference { + static getAttributeTypeMap() { + return _V1PriorityLevelConfigurationReference.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityLevelConfigurationReference.discriminator = void 0; +V1PriorityLevelConfigurationReference.mapping = void 0; +V1PriorityLevelConfigurationReference.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityLevelConfigurationSpec.js +var V1PriorityLevelConfigurationSpec = class _V1PriorityLevelConfigurationSpec { + static getAttributeTypeMap() { + return _V1PriorityLevelConfigurationSpec.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityLevelConfigurationSpec.discriminator = void 0; +V1PriorityLevelConfigurationSpec.mapping = void 0; +V1PriorityLevelConfigurationSpec.attributeTypeMap = [ + { + "name": "exempt", + "baseName": "exempt", + "type": "V1ExemptPriorityLevelConfiguration", + "format": "" + }, + { + "name": "limited", + "baseName": "limited", + "type": "V1LimitedPriorityLevelConfiguration", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1PriorityLevelConfigurationStatus.js +var V1PriorityLevelConfigurationStatus = class _V1PriorityLevelConfigurationStatus { + static getAttributeTypeMap() { + return _V1PriorityLevelConfigurationStatus.attributeTypeMap; + } + constructor() { + } +}; +V1PriorityLevelConfigurationStatus.discriminator = void 0; +V1PriorityLevelConfigurationStatus.mapping = void 0; +V1PriorityLevelConfigurationStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Probe.js +var V1Probe = class _V1Probe { + static getAttributeTypeMap() { + return _V1Probe.attributeTypeMap; + } + constructor() { + } +}; +V1Probe.discriminator = void 0; +V1Probe.mapping = void 0; +V1Probe.attributeTypeMap = [ + { + "name": "exec", + "baseName": "exec", + "type": "V1ExecAction", + "format": "" + }, + { + "name": "failureThreshold", + "baseName": "failureThreshold", + "type": "number", + "format": "int32" + }, + { + "name": "grpc", + "baseName": "grpc", + "type": "V1GRPCAction", + "format": "" + }, + { + "name": "httpGet", + "baseName": "httpGet", + "type": "V1HTTPGetAction", + "format": "" + }, + { + "name": "initialDelaySeconds", + "baseName": "initialDelaySeconds", + "type": "number", + "format": "int32" + }, + { + "name": "periodSeconds", + "baseName": "periodSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "successThreshold", + "baseName": "successThreshold", + "type": "number", + "format": "int32" + }, + { + "name": "tcpSocket", + "baseName": "tcpSocket", + "type": "V1TCPSocketAction", + "format": "" + }, + { + "name": "terminationGracePeriodSeconds", + "baseName": "terminationGracePeriodSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "timeoutSeconds", + "baseName": "timeoutSeconds", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ProjectedVolumeSource.js +var V1ProjectedVolumeSource = class _V1ProjectedVolumeSource { + static getAttributeTypeMap() { + return _V1ProjectedVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ProjectedVolumeSource.discriminator = void 0; +V1ProjectedVolumeSource.mapping = void 0; +V1ProjectedVolumeSource.attributeTypeMap = [ + { + "name": "defaultMode", + "baseName": "defaultMode", + "type": "number", + "format": "int32" + }, + { + "name": "sources", + "baseName": "sources", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1QueuingConfiguration.js +var V1QueuingConfiguration = class _V1QueuingConfiguration { + static getAttributeTypeMap() { + return _V1QueuingConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1QueuingConfiguration.discriminator = void 0; +V1QueuingConfiguration.mapping = void 0; +V1QueuingConfiguration.attributeTypeMap = [ + { + "name": "handSize", + "baseName": "handSize", + "type": "number", + "format": "int32" + }, + { + "name": "queueLengthLimit", + "baseName": "queueLengthLimit", + "type": "number", + "format": "int32" + }, + { + "name": "queues", + "baseName": "queues", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1QuobyteVolumeSource.js +var V1QuobyteVolumeSource = class _V1QuobyteVolumeSource { + static getAttributeTypeMap() { + return _V1QuobyteVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1QuobyteVolumeSource.discriminator = void 0; +V1QuobyteVolumeSource.mapping = void 0; +V1QuobyteVolumeSource.attributeTypeMap = [ + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "registry", + "baseName": "registry", + "type": "string", + "format": "" + }, + { + "name": "tenant", + "baseName": "tenant", + "type": "string", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + }, + { + "name": "volume", + "baseName": "volume", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RBDPersistentVolumeSource.js +var V1RBDPersistentVolumeSource = class _V1RBDPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1RBDPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1RBDPersistentVolumeSource.discriminator = void 0; +V1RBDPersistentVolumeSource.mapping = void 0; +V1RBDPersistentVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "image", + "baseName": "image", + "type": "string", + "format": "" + }, + { + "name": "keyring", + "baseName": "keyring", + "type": "string", + "format": "" + }, + { + "name": "monitors", + "baseName": "monitors", + "type": "Array", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RBDVolumeSource.js +var V1RBDVolumeSource = class _V1RBDVolumeSource { + static getAttributeTypeMap() { + return _V1RBDVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1RBDVolumeSource.discriminator = void 0; +V1RBDVolumeSource.mapping = void 0; +V1RBDVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "image", + "baseName": "image", + "type": "string", + "format": "" + }, + { + "name": "keyring", + "baseName": "keyring", + "type": "string", + "format": "" + }, + { + "name": "monitors", + "baseName": "monitors", + "type": "Array", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicaSet.js +var V1ReplicaSet = class _V1ReplicaSet { + static getAttributeTypeMap() { + return _V1ReplicaSet.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicaSet.discriminator = void 0; +V1ReplicaSet.mapping = void 0; +V1ReplicaSet.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ReplicaSetSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ReplicaSetStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicaSetCondition.js +var V1ReplicaSetCondition = class _V1ReplicaSetCondition { + static getAttributeTypeMap() { + return _V1ReplicaSetCondition.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicaSetCondition.discriminator = void 0; +V1ReplicaSetCondition.mapping = void 0; +V1ReplicaSetCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicaSetList.js +var V1ReplicaSetList = class _V1ReplicaSetList { + static getAttributeTypeMap() { + return _V1ReplicaSetList.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicaSetList.discriminator = void 0; +V1ReplicaSetList.mapping = void 0; +V1ReplicaSetList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicaSetSpec.js +var V1ReplicaSetSpec = class _V1ReplicaSetSpec { + static getAttributeTypeMap() { + return _V1ReplicaSetSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicaSetSpec.discriminator = void 0; +V1ReplicaSetSpec.mapping = void 0; +V1ReplicaSetSpec.attributeTypeMap = [ + { + "name": "minReadySeconds", + "baseName": "minReadySeconds", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicaSetStatus.js +var V1ReplicaSetStatus = class _V1ReplicaSetStatus { + static getAttributeTypeMap() { + return _V1ReplicaSetStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicaSetStatus.discriminator = void 0; +V1ReplicaSetStatus.mapping = void 0; +V1ReplicaSetStatus.attributeTypeMap = [ + { + "name": "availableReplicas", + "baseName": "availableReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "fullyLabeledReplicas", + "baseName": "fullyLabeledReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "readyReplicas", + "baseName": "readyReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "terminatingReplicas", + "baseName": "terminatingReplicas", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicationController.js +var V1ReplicationController = class _V1ReplicationController { + static getAttributeTypeMap() { + return _V1ReplicationController.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicationController.discriminator = void 0; +V1ReplicationController.mapping = void 0; +V1ReplicationController.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ReplicationControllerSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ReplicationControllerStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicationControllerCondition.js +var V1ReplicationControllerCondition = class _V1ReplicationControllerCondition { + static getAttributeTypeMap() { + return _V1ReplicationControllerCondition.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicationControllerCondition.discriminator = void 0; +V1ReplicationControllerCondition.mapping = void 0; +V1ReplicationControllerCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicationControllerList.js +var V1ReplicationControllerList = class _V1ReplicationControllerList { + static getAttributeTypeMap() { + return _V1ReplicationControllerList.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicationControllerList.discriminator = void 0; +V1ReplicationControllerList.mapping = void 0; +V1ReplicationControllerList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicationControllerSpec.js +var V1ReplicationControllerSpec = class _V1ReplicationControllerSpec { + static getAttributeTypeMap() { + return _V1ReplicationControllerSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicationControllerSpec.discriminator = void 0; +V1ReplicationControllerSpec.mapping = void 0; +V1ReplicationControllerSpec.attributeTypeMap = [ + { + "name": "minReadySeconds", + "baseName": "minReadySeconds", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "selector", + "baseName": "selector", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ReplicationControllerStatus.js +var V1ReplicationControllerStatus = class _V1ReplicationControllerStatus { + static getAttributeTypeMap() { + return _V1ReplicationControllerStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ReplicationControllerStatus.discriminator = void 0; +V1ReplicationControllerStatus.mapping = void 0; +V1ReplicationControllerStatus.attributeTypeMap = [ + { + "name": "availableReplicas", + "baseName": "availableReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "fullyLabeledReplicas", + "baseName": "fullyLabeledReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "readyReplicas", + "baseName": "readyReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceAttributes.js +var V1ResourceAttributes = class _V1ResourceAttributes { + static getAttributeTypeMap() { + return _V1ResourceAttributes.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceAttributes.discriminator = void 0; +V1ResourceAttributes.mapping = void 0; +V1ResourceAttributes.attributeTypeMap = [ + { + "name": "fieldSelector", + "baseName": "fieldSelector", + "type": "V1FieldSelectorAttributes", + "format": "" + }, + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "labelSelector", + "baseName": "labelSelector", + "type": "V1LabelSelectorAttributes", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + }, + { + "name": "subresource", + "baseName": "subresource", + "type": "string", + "format": "" + }, + { + "name": "verb", + "baseName": "verb", + "type": "string", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimConsumerReference.js +var V1ResourceClaimConsumerReference = class _V1ResourceClaimConsumerReference { + static getAttributeTypeMap() { + return _V1ResourceClaimConsumerReference.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimConsumerReference.discriminator = void 0; +V1ResourceClaimConsumerReference.mapping = void 0; +V1ResourceClaimConsumerReference.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimList.js +var V1ResourceClaimList = class _V1ResourceClaimList { + static getAttributeTypeMap() { + return _V1ResourceClaimList.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimList.discriminator = void 0; +V1ResourceClaimList.mapping = void 0; +V1ResourceClaimList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimSpec.js +var V1ResourceClaimSpec = class _V1ResourceClaimSpec { + static getAttributeTypeMap() { + return _V1ResourceClaimSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimSpec.discriminator = void 0; +V1ResourceClaimSpec.mapping = void 0; +V1ResourceClaimSpec.attributeTypeMap = [ + { + "name": "devices", + "baseName": "devices", + "type": "V1DeviceClaim", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimStatus.js +var V1ResourceClaimStatus = class _V1ResourceClaimStatus { + static getAttributeTypeMap() { + return _V1ResourceClaimStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimStatus.discriminator = void 0; +V1ResourceClaimStatus.mapping = void 0; +V1ResourceClaimStatus.attributeTypeMap = [ + { + "name": "allocation", + "baseName": "allocation", + "type": "V1AllocationResult", + "format": "" + }, + { + "name": "devices", + "baseName": "devices", + "type": "Array", + "format": "" + }, + { + "name": "reservedFor", + "baseName": "reservedFor", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimTemplate.js +var V1ResourceClaimTemplate = class _V1ResourceClaimTemplate { + static getAttributeTypeMap() { + return _V1ResourceClaimTemplate.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimTemplate.discriminator = void 0; +V1ResourceClaimTemplate.mapping = void 0; +V1ResourceClaimTemplate.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ResourceClaimTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimTemplateList.js +var V1ResourceClaimTemplateList = class _V1ResourceClaimTemplateList { + static getAttributeTypeMap() { + return _V1ResourceClaimTemplateList.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimTemplateList.discriminator = void 0; +V1ResourceClaimTemplateList.mapping = void 0; +V1ResourceClaimTemplateList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceClaimTemplateSpec.js +var V1ResourceClaimTemplateSpec = class _V1ResourceClaimTemplateSpec { + static getAttributeTypeMap() { + return _V1ResourceClaimTemplateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceClaimTemplateSpec.discriminator = void 0; +V1ResourceClaimTemplateSpec.mapping = void 0; +V1ResourceClaimTemplateSpec.attributeTypeMap = [ + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ResourceClaimSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceFieldSelector.js +var V1ResourceFieldSelector = class _V1ResourceFieldSelector { + static getAttributeTypeMap() { + return _V1ResourceFieldSelector.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceFieldSelector.discriminator = void 0; +V1ResourceFieldSelector.mapping = void 0; +V1ResourceFieldSelector.attributeTypeMap = [ + { + "name": "containerName", + "baseName": "containerName", + "type": "string", + "format": "" + }, + { + "name": "divisor", + "baseName": "divisor", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceHealth.js +var V1ResourceHealth = class _V1ResourceHealth { + static getAttributeTypeMap() { + return _V1ResourceHealth.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceHealth.discriminator = void 0; +V1ResourceHealth.mapping = void 0; +V1ResourceHealth.attributeTypeMap = [ + { + "name": "health", + "baseName": "health", + "type": "string", + "format": "" + }, + { + "name": "resourceID", + "baseName": "resourceID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourcePolicyRule.js +var V1ResourcePolicyRule = class _V1ResourcePolicyRule { + static getAttributeTypeMap() { + return _V1ResourcePolicyRule.attributeTypeMap; + } + constructor() { + } +}; +V1ResourcePolicyRule.discriminator = void 0; +V1ResourcePolicyRule.mapping = void 0; +V1ResourcePolicyRule.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "clusterScope", + "baseName": "clusterScope", + "type": "boolean", + "format": "" + }, + { + "name": "namespaces", + "baseName": "namespaces", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "verbs", + "baseName": "verbs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourcePool.js +var V1ResourcePool = class _V1ResourcePool { + static getAttributeTypeMap() { + return _V1ResourcePool.attributeTypeMap; + } + constructor() { + } +}; +V1ResourcePool.discriminator = void 0; +V1ResourcePool.mapping = void 0; +V1ResourcePool.attributeTypeMap = [ + { + "name": "generation", + "baseName": "generation", + "type": "number", + "format": "int64" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resourceSliceCount", + "baseName": "resourceSliceCount", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceQuota.js +var V1ResourceQuota = class _V1ResourceQuota { + static getAttributeTypeMap() { + return _V1ResourceQuota.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceQuota.discriminator = void 0; +V1ResourceQuota.mapping = void 0; +V1ResourceQuota.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ResourceQuotaSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ResourceQuotaStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceQuotaList.js +var V1ResourceQuotaList = class _V1ResourceQuotaList { + static getAttributeTypeMap() { + return _V1ResourceQuotaList.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceQuotaList.discriminator = void 0; +V1ResourceQuotaList.mapping = void 0; +V1ResourceQuotaList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceQuotaSpec.js +var V1ResourceQuotaSpec = class _V1ResourceQuotaSpec { + static getAttributeTypeMap() { + return _V1ResourceQuotaSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceQuotaSpec.discriminator = void 0; +V1ResourceQuotaSpec.mapping = void 0; +V1ResourceQuotaSpec.attributeTypeMap = [ + { + "name": "hard", + "baseName": "hard", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "scopeSelector", + "baseName": "scopeSelector", + "type": "V1ScopeSelector", + "format": "" + }, + { + "name": "scopes", + "baseName": "scopes", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceQuotaStatus.js +var V1ResourceQuotaStatus = class _V1ResourceQuotaStatus { + static getAttributeTypeMap() { + return _V1ResourceQuotaStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceQuotaStatus.discriminator = void 0; +V1ResourceQuotaStatus.mapping = void 0; +V1ResourceQuotaStatus.attributeTypeMap = [ + { + "name": "hard", + "baseName": "hard", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "used", + "baseName": "used", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceRequirements.js +var V1ResourceRequirements = class _V1ResourceRequirements { + static getAttributeTypeMap() { + return _V1ResourceRequirements.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceRequirements.discriminator = void 0; +V1ResourceRequirements.mapping = void 0; +V1ResourceRequirements.attributeTypeMap = [ + { + "name": "claims", + "baseName": "claims", + "type": "Array", + "format": "" + }, + { + "name": "limits", + "baseName": "limits", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceRule.js +var V1ResourceRule = class _V1ResourceRule { + static getAttributeTypeMap() { + return _V1ResourceRule.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceRule.discriminator = void 0; +V1ResourceRule.mapping = void 0; +V1ResourceRule.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "resourceNames", + "baseName": "resourceNames", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "verbs", + "baseName": "verbs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceSlice.js +var V1ResourceSlice = class _V1ResourceSlice { + static getAttributeTypeMap() { + return _V1ResourceSlice.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceSlice.discriminator = void 0; +V1ResourceSlice.mapping = void 0; +V1ResourceSlice.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ResourceSliceSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceSliceList.js +var V1ResourceSliceList = class _V1ResourceSliceList { + static getAttributeTypeMap() { + return _V1ResourceSliceList.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceSliceList.discriminator = void 0; +V1ResourceSliceList.mapping = void 0; +V1ResourceSliceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceSliceSpec.js +var V1ResourceSliceSpec = class _V1ResourceSliceSpec { + static getAttributeTypeMap() { + return _V1ResourceSliceSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceSliceSpec.discriminator = void 0; +V1ResourceSliceSpec.mapping = void 0; +V1ResourceSliceSpec.attributeTypeMap = [ + { + "name": "allNodes", + "baseName": "allNodes", + "type": "boolean", + "format": "" + }, + { + "name": "devices", + "baseName": "devices", + "type": "Array", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + }, + { + "name": "perDeviceNodeSelection", + "baseName": "perDeviceNodeSelection", + "type": "boolean", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "V1ResourcePool", + "format": "" + }, + { + "name": "sharedCounters", + "baseName": "sharedCounters", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ResourceStatus.js +var V1ResourceStatus = class _V1ResourceStatus { + static getAttributeTypeMap() { + return _V1ResourceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ResourceStatus.discriminator = void 0; +V1ResourceStatus.mapping = void 0; +V1ResourceStatus.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Role.js +var V1Role = class _V1Role { + static getAttributeTypeMap() { + return _V1Role.attributeTypeMap; + } + constructor() { + } +}; +V1Role.discriminator = void 0; +V1Role.mapping = void 0; +V1Role.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RoleBinding.js +var V1RoleBinding = class _V1RoleBinding { + static getAttributeTypeMap() { + return _V1RoleBinding.attributeTypeMap; + } + constructor() { + } +}; +V1RoleBinding.discriminator = void 0; +V1RoleBinding.mapping = void 0; +V1RoleBinding.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "roleRef", + "baseName": "roleRef", + "type": "V1RoleRef", + "format": "" + }, + { + "name": "subjects", + "baseName": "subjects", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RoleBindingList.js +var V1RoleBindingList = class _V1RoleBindingList { + static getAttributeTypeMap() { + return _V1RoleBindingList.attributeTypeMap; + } + constructor() { + } +}; +V1RoleBindingList.discriminator = void 0; +V1RoleBindingList.mapping = void 0; +V1RoleBindingList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RoleList.js +var V1RoleList = class _V1RoleList { + static getAttributeTypeMap() { + return _V1RoleList.attributeTypeMap; + } + constructor() { + } +}; +V1RoleList.discriminator = void 0; +V1RoleList.mapping = void 0; +V1RoleList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RoleRef.js +var V1RoleRef = class _V1RoleRef { + static getAttributeTypeMap() { + return _V1RoleRef.attributeTypeMap; + } + constructor() { + } +}; +V1RoleRef.discriminator = void 0; +V1RoleRef.mapping = void 0; +V1RoleRef.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RollingUpdateDaemonSet.js +var V1RollingUpdateDaemonSet = class _V1RollingUpdateDaemonSet { + static getAttributeTypeMap() { + return _V1RollingUpdateDaemonSet.attributeTypeMap; + } + constructor() { + } +}; +V1RollingUpdateDaemonSet.discriminator = void 0; +V1RollingUpdateDaemonSet.mapping = void 0; +V1RollingUpdateDaemonSet.attributeTypeMap = [ + { + "name": "maxSurge", + "baseName": "maxSurge", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "maxUnavailable", + "baseName": "maxUnavailable", + "type": "IntOrString", + "format": "int-or-string" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RollingUpdateDeployment.js +var V1RollingUpdateDeployment = class _V1RollingUpdateDeployment { + static getAttributeTypeMap() { + return _V1RollingUpdateDeployment.attributeTypeMap; + } + constructor() { + } +}; +V1RollingUpdateDeployment.discriminator = void 0; +V1RollingUpdateDeployment.mapping = void 0; +V1RollingUpdateDeployment.attributeTypeMap = [ + { + "name": "maxSurge", + "baseName": "maxSurge", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "maxUnavailable", + "baseName": "maxUnavailable", + "type": "IntOrString", + "format": "int-or-string" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RollingUpdateStatefulSetStrategy.js +var V1RollingUpdateStatefulSetStrategy = class _V1RollingUpdateStatefulSetStrategy { + static getAttributeTypeMap() { + return _V1RollingUpdateStatefulSetStrategy.attributeTypeMap; + } + constructor() { + } +}; +V1RollingUpdateStatefulSetStrategy.discriminator = void 0; +V1RollingUpdateStatefulSetStrategy.mapping = void 0; +V1RollingUpdateStatefulSetStrategy.attributeTypeMap = [ + { + "name": "maxUnavailable", + "baseName": "maxUnavailable", + "type": "IntOrString", + "format": "int-or-string" + }, + { + "name": "partition", + "baseName": "partition", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RuleWithOperations.js +var V1RuleWithOperations = class _V1RuleWithOperations { + static getAttributeTypeMap() { + return _V1RuleWithOperations.attributeTypeMap; + } + constructor() { + } +}; +V1RuleWithOperations.discriminator = void 0; +V1RuleWithOperations.mapping = void 0; +V1RuleWithOperations.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "apiVersions", + "baseName": "apiVersions", + "type": "Array", + "format": "" + }, + { + "name": "operations", + "baseName": "operations", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "scope", + "baseName": "scope", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RuntimeClass.js +var V1RuntimeClass = class _V1RuntimeClass { + static getAttributeTypeMap() { + return _V1RuntimeClass.attributeTypeMap; + } + constructor() { + } +}; +V1RuntimeClass.discriminator = void 0; +V1RuntimeClass.mapping = void 0; +V1RuntimeClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "handler", + "baseName": "handler", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "overhead", + "baseName": "overhead", + "type": "V1Overhead", + "format": "" + }, + { + "name": "scheduling", + "baseName": "scheduling", + "type": "V1Scheduling", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1RuntimeClassList.js +var V1RuntimeClassList = class _V1RuntimeClassList { + static getAttributeTypeMap() { + return _V1RuntimeClassList.attributeTypeMap; + } + constructor() { + } +}; +V1RuntimeClassList.discriminator = void 0; +V1RuntimeClassList.mapping = void 0; +V1RuntimeClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SELinuxOptions.js +var V1SELinuxOptions = class _V1SELinuxOptions { + static getAttributeTypeMap() { + return _V1SELinuxOptions.attributeTypeMap; + } + constructor() { + } +}; +V1SELinuxOptions.discriminator = void 0; +V1SELinuxOptions.mapping = void 0; +V1SELinuxOptions.attributeTypeMap = [ + { + "name": "level", + "baseName": "level", + "type": "string", + "format": "" + }, + { + "name": "role", + "baseName": "role", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Scale.js +var V1Scale = class _V1Scale { + static getAttributeTypeMap() { + return _V1Scale.attributeTypeMap; + } + constructor() { + } +}; +V1Scale.discriminator = void 0; +V1Scale.mapping = void 0; +V1Scale.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ScaleSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ScaleStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ScaleIOPersistentVolumeSource.js +var V1ScaleIOPersistentVolumeSource = class _V1ScaleIOPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1ScaleIOPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ScaleIOPersistentVolumeSource.discriminator = void 0; +V1ScaleIOPersistentVolumeSource.mapping = void 0; +V1ScaleIOPersistentVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "gateway", + "baseName": "gateway", + "type": "string", + "format": "" + }, + { + "name": "protectionDomain", + "baseName": "protectionDomain", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1SecretReference", + "format": "" + }, + { + "name": "sslEnabled", + "baseName": "sslEnabled", + "type": "boolean", + "format": "" + }, + { + "name": "storageMode", + "baseName": "storageMode", + "type": "string", + "format": "" + }, + { + "name": "storagePool", + "baseName": "storagePool", + "type": "string", + "format": "" + }, + { + "name": "system", + "baseName": "system", + "type": "string", + "format": "" + }, + { + "name": "volumeName", + "baseName": "volumeName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ScaleIOVolumeSource.js +var V1ScaleIOVolumeSource = class _V1ScaleIOVolumeSource { + static getAttributeTypeMap() { + return _V1ScaleIOVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1ScaleIOVolumeSource.discriminator = void 0; +V1ScaleIOVolumeSource.mapping = void 0; +V1ScaleIOVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "gateway", + "baseName": "gateway", + "type": "string", + "format": "" + }, + { + "name": "protectionDomain", + "baseName": "protectionDomain", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "sslEnabled", + "baseName": "sslEnabled", + "type": "boolean", + "format": "" + }, + { + "name": "storageMode", + "baseName": "storageMode", + "type": "string", + "format": "" + }, + { + "name": "storagePool", + "baseName": "storagePool", + "type": "string", + "format": "" + }, + { + "name": "system", + "baseName": "system", + "type": "string", + "format": "" + }, + { + "name": "volumeName", + "baseName": "volumeName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ScaleSpec.js +var V1ScaleSpec = class _V1ScaleSpec { + static getAttributeTypeMap() { + return _V1ScaleSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ScaleSpec.discriminator = void 0; +V1ScaleSpec.mapping = void 0; +V1ScaleSpec.attributeTypeMap = [ + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ScaleStatus.js +var V1ScaleStatus = class _V1ScaleStatus { + static getAttributeTypeMap() { + return _V1ScaleStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ScaleStatus.discriminator = void 0; +V1ScaleStatus.mapping = void 0; +V1ScaleStatus.attributeTypeMap = [ + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "selector", + "baseName": "selector", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Scheduling.js +var V1Scheduling = class _V1Scheduling { + static getAttributeTypeMap() { + return _V1Scheduling.attributeTypeMap; + } + constructor() { + } +}; +V1Scheduling.discriminator = void 0; +V1Scheduling.mapping = void 0; +V1Scheduling.attributeTypeMap = [ + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ScopeSelector.js +var V1ScopeSelector = class _V1ScopeSelector { + static getAttributeTypeMap() { + return _V1ScopeSelector.attributeTypeMap; + } + constructor() { + } +}; +V1ScopeSelector.discriminator = void 0; +V1ScopeSelector.mapping = void 0; +V1ScopeSelector.attributeTypeMap = [ + { + "name": "matchExpressions", + "baseName": "matchExpressions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ScopedResourceSelectorRequirement.js +var V1ScopedResourceSelectorRequirement = class _V1ScopedResourceSelectorRequirement { + static getAttributeTypeMap() { + return _V1ScopedResourceSelectorRequirement.attributeTypeMap; + } + constructor() { + } +}; +V1ScopedResourceSelectorRequirement.discriminator = void 0; +V1ScopedResourceSelectorRequirement.mapping = void 0; +V1ScopedResourceSelectorRequirement.attributeTypeMap = [ + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "scopeName", + "baseName": "scopeName", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SeccompProfile.js +var V1SeccompProfile = class _V1SeccompProfile { + static getAttributeTypeMap() { + return _V1SeccompProfile.attributeTypeMap; + } + constructor() { + } +}; +V1SeccompProfile.discriminator = void 0; +V1SeccompProfile.mapping = void 0; +V1SeccompProfile.attributeTypeMap = [ + { + "name": "localhostProfile", + "baseName": "localhostProfile", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Secret.js +var V1Secret = class _V1Secret { + static getAttributeTypeMap() { + return _V1Secret.attributeTypeMap; + } + constructor() { + } +}; +V1Secret.discriminator = void 0; +V1Secret.mapping = void 0; +V1Secret.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "data", + "baseName": "data", + "type": "{ [key: string]: string; }", + "format": "byte" + }, + { + "name": "immutable", + "baseName": "immutable", + "type": "boolean", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "stringData", + "baseName": "stringData", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecretEnvSource.js +var V1SecretEnvSource = class _V1SecretEnvSource { + static getAttributeTypeMap() { + return _V1SecretEnvSource.attributeTypeMap; + } + constructor() { + } +}; +V1SecretEnvSource.discriminator = void 0; +V1SecretEnvSource.mapping = void 0; +V1SecretEnvSource.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecretKeySelector.js +var V1SecretKeySelector = class _V1SecretKeySelector { + static getAttributeTypeMap() { + return _V1SecretKeySelector.attributeTypeMap; + } + constructor() { + } +}; +V1SecretKeySelector.discriminator = void 0; +V1SecretKeySelector.mapping = void 0; +V1SecretKeySelector.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecretList.js +var V1SecretList = class _V1SecretList { + static getAttributeTypeMap() { + return _V1SecretList.attributeTypeMap; + } + constructor() { + } +}; +V1SecretList.discriminator = void 0; +V1SecretList.mapping = void 0; +V1SecretList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecretProjection.js +var V1SecretProjection = class _V1SecretProjection { + static getAttributeTypeMap() { + return _V1SecretProjection.attributeTypeMap; + } + constructor() { + } +}; +V1SecretProjection.discriminator = void 0; +V1SecretProjection.mapping = void 0; +V1SecretProjection.attributeTypeMap = [ + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecretReference.js +var V1SecretReference = class _V1SecretReference { + static getAttributeTypeMap() { + return _V1SecretReference.attributeTypeMap; + } + constructor() { + } +}; +V1SecretReference.discriminator = void 0; +V1SecretReference.mapping = void 0; +V1SecretReference.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecretVolumeSource.js +var V1SecretVolumeSource = class _V1SecretVolumeSource { + static getAttributeTypeMap() { + return _V1SecretVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1SecretVolumeSource.discriminator = void 0; +V1SecretVolumeSource.mapping = void 0; +V1SecretVolumeSource.attributeTypeMap = [ + { + "name": "defaultMode", + "baseName": "defaultMode", + "type": "number", + "format": "int32" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "optional", + "baseName": "optional", + "type": "boolean", + "format": "" + }, + { + "name": "secretName", + "baseName": "secretName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SecurityContext.js +var V1SecurityContext = class _V1SecurityContext { + static getAttributeTypeMap() { + return _V1SecurityContext.attributeTypeMap; + } + constructor() { + } +}; +V1SecurityContext.discriminator = void 0; +V1SecurityContext.mapping = void 0; +V1SecurityContext.attributeTypeMap = [ + { + "name": "allowPrivilegeEscalation", + "baseName": "allowPrivilegeEscalation", + "type": "boolean", + "format": "" + }, + { + "name": "appArmorProfile", + "baseName": "appArmorProfile", + "type": "V1AppArmorProfile", + "format": "" + }, + { + "name": "capabilities", + "baseName": "capabilities", + "type": "V1Capabilities", + "format": "" + }, + { + "name": "privileged", + "baseName": "privileged", + "type": "boolean", + "format": "" + }, + { + "name": "procMount", + "baseName": "procMount", + "type": "string", + "format": "" + }, + { + "name": "readOnlyRootFilesystem", + "baseName": "readOnlyRootFilesystem", + "type": "boolean", + "format": "" + }, + { + "name": "runAsGroup", + "baseName": "runAsGroup", + "type": "number", + "format": "int64" + }, + { + "name": "runAsNonRoot", + "baseName": "runAsNonRoot", + "type": "boolean", + "format": "" + }, + { + "name": "runAsUser", + "baseName": "runAsUser", + "type": "number", + "format": "int64" + }, + { + "name": "seLinuxOptions", + "baseName": "seLinuxOptions", + "type": "V1SELinuxOptions", + "format": "" + }, + { + "name": "seccompProfile", + "baseName": "seccompProfile", + "type": "V1SeccompProfile", + "format": "" + }, + { + "name": "windowsOptions", + "baseName": "windowsOptions", + "type": "V1WindowsSecurityContextOptions", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelectableField.js +var V1SelectableField = class _V1SelectableField { + static getAttributeTypeMap() { + return _V1SelectableField.attributeTypeMap; + } + constructor() { + } +}; +V1SelectableField.discriminator = void 0; +V1SelectableField.mapping = void 0; +V1SelectableField.attributeTypeMap = [ + { + "name": "jsonPath", + "baseName": "jsonPath", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelfSubjectAccessReview.js +var V1SelfSubjectAccessReview = class _V1SelfSubjectAccessReview { + static getAttributeTypeMap() { + return _V1SelfSubjectAccessReview.attributeTypeMap; + } + constructor() { + } +}; +V1SelfSubjectAccessReview.discriminator = void 0; +V1SelfSubjectAccessReview.mapping = void 0; +V1SelfSubjectAccessReview.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1SelfSubjectAccessReviewSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1SubjectAccessReviewStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelfSubjectAccessReviewSpec.js +var V1SelfSubjectAccessReviewSpec = class _V1SelfSubjectAccessReviewSpec { + static getAttributeTypeMap() { + return _V1SelfSubjectAccessReviewSpec.attributeTypeMap; + } + constructor() { + } +}; +V1SelfSubjectAccessReviewSpec.discriminator = void 0; +V1SelfSubjectAccessReviewSpec.mapping = void 0; +V1SelfSubjectAccessReviewSpec.attributeTypeMap = [ + { + "name": "nonResourceAttributes", + "baseName": "nonResourceAttributes", + "type": "V1NonResourceAttributes", + "format": "" + }, + { + "name": "resourceAttributes", + "baseName": "resourceAttributes", + "type": "V1ResourceAttributes", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelfSubjectReview.js +var V1SelfSubjectReview = class _V1SelfSubjectReview { + static getAttributeTypeMap() { + return _V1SelfSubjectReview.attributeTypeMap; + } + constructor() { + } +}; +V1SelfSubjectReview.discriminator = void 0; +V1SelfSubjectReview.mapping = void 0; +V1SelfSubjectReview.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1SelfSubjectReviewStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelfSubjectReviewStatus.js +var V1SelfSubjectReviewStatus = class _V1SelfSubjectReviewStatus { + static getAttributeTypeMap() { + return _V1SelfSubjectReviewStatus.attributeTypeMap; + } + constructor() { + } +}; +V1SelfSubjectReviewStatus.discriminator = void 0; +V1SelfSubjectReviewStatus.mapping = void 0; +V1SelfSubjectReviewStatus.attributeTypeMap = [ + { + "name": "userInfo", + "baseName": "userInfo", + "type": "V1UserInfo", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelfSubjectRulesReview.js +var V1SelfSubjectRulesReview = class _V1SelfSubjectRulesReview { + static getAttributeTypeMap() { + return _V1SelfSubjectRulesReview.attributeTypeMap; + } + constructor() { + } +}; +V1SelfSubjectRulesReview.discriminator = void 0; +V1SelfSubjectRulesReview.mapping = void 0; +V1SelfSubjectRulesReview.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1SelfSubjectRulesReviewSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1SubjectRulesReviewStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SelfSubjectRulesReviewSpec.js +var V1SelfSubjectRulesReviewSpec = class _V1SelfSubjectRulesReviewSpec { + static getAttributeTypeMap() { + return _V1SelfSubjectRulesReviewSpec.attributeTypeMap; + } + constructor() { + } +}; +V1SelfSubjectRulesReviewSpec.discriminator = void 0; +V1SelfSubjectRulesReviewSpec.mapping = void 0; +V1SelfSubjectRulesReviewSpec.attributeTypeMap = [ + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServerAddressByClientCIDR.js +var V1ServerAddressByClientCIDR = class _V1ServerAddressByClientCIDR { + static getAttributeTypeMap() { + return _V1ServerAddressByClientCIDR.attributeTypeMap; + } + constructor() { + } +}; +V1ServerAddressByClientCIDR.discriminator = void 0; +V1ServerAddressByClientCIDR.mapping = void 0; +V1ServerAddressByClientCIDR.attributeTypeMap = [ + { + "name": "clientCIDR", + "baseName": "clientCIDR", + "type": "string", + "format": "" + }, + { + "name": "serverAddress", + "baseName": "serverAddress", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Service.js +var V1Service = class _V1Service { + static getAttributeTypeMap() { + return _V1Service.attributeTypeMap; + } + constructor() { + } +}; +V1Service.discriminator = void 0; +V1Service.mapping = void 0; +V1Service.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ServiceSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ServiceStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceAccount.js +var V1ServiceAccount = class _V1ServiceAccount { + static getAttributeTypeMap() { + return _V1ServiceAccount.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceAccount.discriminator = void 0; +V1ServiceAccount.mapping = void 0; +V1ServiceAccount.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "automountServiceAccountToken", + "baseName": "automountServiceAccountToken", + "type": "boolean", + "format": "" + }, + { + "name": "imagePullSecrets", + "baseName": "imagePullSecrets", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "secrets", + "baseName": "secrets", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceAccountList.js +var V1ServiceAccountList = class _V1ServiceAccountList { + static getAttributeTypeMap() { + return _V1ServiceAccountList.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceAccountList.discriminator = void 0; +V1ServiceAccountList.mapping = void 0; +V1ServiceAccountList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceAccountSubject.js +var V1ServiceAccountSubject = class _V1ServiceAccountSubject { + static getAttributeTypeMap() { + return _V1ServiceAccountSubject.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceAccountSubject.discriminator = void 0; +V1ServiceAccountSubject.mapping = void 0; +V1ServiceAccountSubject.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceAccountTokenProjection.js +var V1ServiceAccountTokenProjection = class _V1ServiceAccountTokenProjection { + static getAttributeTypeMap() { + return _V1ServiceAccountTokenProjection.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceAccountTokenProjection.discriminator = void 0; +V1ServiceAccountTokenProjection.mapping = void 0; +V1ServiceAccountTokenProjection.attributeTypeMap = [ + { + "name": "audience", + "baseName": "audience", + "type": "string", + "format": "" + }, + { + "name": "expirationSeconds", + "baseName": "expirationSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "path", + "baseName": "path", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceBackendPort.js +var V1ServiceBackendPort = class _V1ServiceBackendPort { + static getAttributeTypeMap() { + return _V1ServiceBackendPort.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceBackendPort.discriminator = void 0; +V1ServiceBackendPort.mapping = void 0; +V1ServiceBackendPort.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "number", + "baseName": "number", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceCIDR.js +var V1ServiceCIDR = class _V1ServiceCIDR { + static getAttributeTypeMap() { + return _V1ServiceCIDR.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceCIDR.discriminator = void 0; +V1ServiceCIDR.mapping = void 0; +V1ServiceCIDR.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ServiceCIDRSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ServiceCIDRStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceCIDRList.js +var V1ServiceCIDRList = class _V1ServiceCIDRList { + static getAttributeTypeMap() { + return _V1ServiceCIDRList.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceCIDRList.discriminator = void 0; +V1ServiceCIDRList.mapping = void 0; +V1ServiceCIDRList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceCIDRSpec.js +var V1ServiceCIDRSpec = class _V1ServiceCIDRSpec { + static getAttributeTypeMap() { + return _V1ServiceCIDRSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceCIDRSpec.discriminator = void 0; +V1ServiceCIDRSpec.mapping = void 0; +V1ServiceCIDRSpec.attributeTypeMap = [ + { + "name": "cidrs", + "baseName": "cidrs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceCIDRStatus.js +var V1ServiceCIDRStatus = class _V1ServiceCIDRStatus { + static getAttributeTypeMap() { + return _V1ServiceCIDRStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceCIDRStatus.discriminator = void 0; +V1ServiceCIDRStatus.mapping = void 0; +V1ServiceCIDRStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceList.js +var V1ServiceList = class _V1ServiceList { + static getAttributeTypeMap() { + return _V1ServiceList.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceList.discriminator = void 0; +V1ServiceList.mapping = void 0; +V1ServiceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServicePort.js +var V1ServicePort = class _V1ServicePort { + static getAttributeTypeMap() { + return _V1ServicePort.attributeTypeMap; + } + constructor() { + } +}; +V1ServicePort.discriminator = void 0; +V1ServicePort.mapping = void 0; +V1ServicePort.attributeTypeMap = [ + { + "name": "appProtocol", + "baseName": "appProtocol", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "nodePort", + "baseName": "nodePort", + "type": "number", + "format": "int32" + }, + { + "name": "port", + "baseName": "port", + "type": "number", + "format": "int32" + }, + { + "name": "protocol", + "baseName": "protocol", + "type": "string", + "format": "" + }, + { + "name": "targetPort", + "baseName": "targetPort", + "type": "IntOrString", + "format": "int-or-string" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceSpec.js +var V1ServiceSpec = class _V1ServiceSpec { + static getAttributeTypeMap() { + return _V1ServiceSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceSpec.discriminator = void 0; +V1ServiceSpec.mapping = void 0; +V1ServiceSpec.attributeTypeMap = [ + { + "name": "allocateLoadBalancerNodePorts", + "baseName": "allocateLoadBalancerNodePorts", + "type": "boolean", + "format": "" + }, + { + "name": "clusterIP", + "baseName": "clusterIP", + "type": "string", + "format": "" + }, + { + "name": "clusterIPs", + "baseName": "clusterIPs", + "type": "Array", + "format": "" + }, + { + "name": "externalIPs", + "baseName": "externalIPs", + "type": "Array", + "format": "" + }, + { + "name": "externalName", + "baseName": "externalName", + "type": "string", + "format": "" + }, + { + "name": "externalTrafficPolicy", + "baseName": "externalTrafficPolicy", + "type": "string", + "format": "" + }, + { + "name": "healthCheckNodePort", + "baseName": "healthCheckNodePort", + "type": "number", + "format": "int32" + }, + { + "name": "internalTrafficPolicy", + "baseName": "internalTrafficPolicy", + "type": "string", + "format": "" + }, + { + "name": "ipFamilies", + "baseName": "ipFamilies", + "type": "Array", + "format": "" + }, + { + "name": "ipFamilyPolicy", + "baseName": "ipFamilyPolicy", + "type": "string", + "format": "" + }, + { + "name": "loadBalancerClass", + "baseName": "loadBalancerClass", + "type": "string", + "format": "" + }, + { + "name": "loadBalancerIP", + "baseName": "loadBalancerIP", + "type": "string", + "format": "" + }, + { + "name": "loadBalancerSourceRanges", + "baseName": "loadBalancerSourceRanges", + "type": "Array", + "format": "" + }, + { + "name": "ports", + "baseName": "ports", + "type": "Array", + "format": "" + }, + { + "name": "publishNotReadyAddresses", + "baseName": "publishNotReadyAddresses", + "type": "boolean", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "sessionAffinity", + "baseName": "sessionAffinity", + "type": "string", + "format": "" + }, + { + "name": "sessionAffinityConfig", + "baseName": "sessionAffinityConfig", + "type": "V1SessionAffinityConfig", + "format": "" + }, + { + "name": "trafficDistribution", + "baseName": "trafficDistribution", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ServiceStatus.js +var V1ServiceStatus = class _V1ServiceStatus { + static getAttributeTypeMap() { + return _V1ServiceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ServiceStatus.discriminator = void 0; +V1ServiceStatus.mapping = void 0; +V1ServiceStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "loadBalancer", + "baseName": "loadBalancer", + "type": "V1LoadBalancerStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SessionAffinityConfig.js +var V1SessionAffinityConfig = class _V1SessionAffinityConfig { + static getAttributeTypeMap() { + return _V1SessionAffinityConfig.attributeTypeMap; + } + constructor() { + } +}; +V1SessionAffinityConfig.discriminator = void 0; +V1SessionAffinityConfig.mapping = void 0; +V1SessionAffinityConfig.attributeTypeMap = [ + { + "name": "clientIP", + "baseName": "clientIP", + "type": "V1ClientIPConfig", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SleepAction.js +var V1SleepAction = class _V1SleepAction { + static getAttributeTypeMap() { + return _V1SleepAction.attributeTypeMap; + } + constructor() { + } +}; +V1SleepAction.discriminator = void 0; +V1SleepAction.mapping = void 0; +V1SleepAction.attributeTypeMap = [ + { + "name": "seconds", + "baseName": "seconds", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSet.js +var V1StatefulSet = class _V1StatefulSet { + static getAttributeTypeMap() { + return _V1StatefulSet.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSet.discriminator = void 0; +V1StatefulSet.mapping = void 0; +V1StatefulSet.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1StatefulSetSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1StatefulSetStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetCondition.js +var V1StatefulSetCondition = class _V1StatefulSetCondition { + static getAttributeTypeMap() { + return _V1StatefulSetCondition.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetCondition.discriminator = void 0; +V1StatefulSetCondition.mapping = void 0; +V1StatefulSetCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetList.js +var V1StatefulSetList = class _V1StatefulSetList { + static getAttributeTypeMap() { + return _V1StatefulSetList.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetList.discriminator = void 0; +V1StatefulSetList.mapping = void 0; +V1StatefulSetList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetOrdinals.js +var V1StatefulSetOrdinals = class _V1StatefulSetOrdinals { + static getAttributeTypeMap() { + return _V1StatefulSetOrdinals.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetOrdinals.discriminator = void 0; +V1StatefulSetOrdinals.mapping = void 0; +V1StatefulSetOrdinals.attributeTypeMap = [ + { + "name": "start", + "baseName": "start", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetPersistentVolumeClaimRetentionPolicy.js +var V1StatefulSetPersistentVolumeClaimRetentionPolicy = class _V1StatefulSetPersistentVolumeClaimRetentionPolicy { + static getAttributeTypeMap() { + return _V1StatefulSetPersistentVolumeClaimRetentionPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetPersistentVolumeClaimRetentionPolicy.discriminator = void 0; +V1StatefulSetPersistentVolumeClaimRetentionPolicy.mapping = void 0; +V1StatefulSetPersistentVolumeClaimRetentionPolicy.attributeTypeMap = [ + { + "name": "whenDeleted", + "baseName": "whenDeleted", + "type": "string", + "format": "" + }, + { + "name": "whenScaled", + "baseName": "whenScaled", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetSpec.js +var V1StatefulSetSpec = class _V1StatefulSetSpec { + static getAttributeTypeMap() { + return _V1StatefulSetSpec.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetSpec.discriminator = void 0; +V1StatefulSetSpec.mapping = void 0; +V1StatefulSetSpec.attributeTypeMap = [ + { + "name": "minReadySeconds", + "baseName": "minReadySeconds", + "type": "number", + "format": "int32" + }, + { + "name": "ordinals", + "baseName": "ordinals", + "type": "V1StatefulSetOrdinals", + "format": "" + }, + { + "name": "persistentVolumeClaimRetentionPolicy", + "baseName": "persistentVolumeClaimRetentionPolicy", + "type": "V1StatefulSetPersistentVolumeClaimRetentionPolicy", + "format": "" + }, + { + "name": "podManagementPolicy", + "baseName": "podManagementPolicy", + "type": "string", + "format": "" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "revisionHistoryLimit", + "baseName": "revisionHistoryLimit", + "type": "number", + "format": "int32" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "serviceName", + "baseName": "serviceName", + "type": "string", + "format": "" + }, + { + "name": "template", + "baseName": "template", + "type": "V1PodTemplateSpec", + "format": "" + }, + { + "name": "updateStrategy", + "baseName": "updateStrategy", + "type": "V1StatefulSetUpdateStrategy", + "format": "" + }, + { + "name": "volumeClaimTemplates", + "baseName": "volumeClaimTemplates", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetStatus.js +var V1StatefulSetStatus = class _V1StatefulSetStatus { + static getAttributeTypeMap() { + return _V1StatefulSetStatus.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetStatus.discriminator = void 0; +V1StatefulSetStatus.mapping = void 0; +V1StatefulSetStatus.attributeTypeMap = [ + { + "name": "availableReplicas", + "baseName": "availableReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "collisionCount", + "baseName": "collisionCount", + "type": "number", + "format": "int32" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "currentReplicas", + "baseName": "currentReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "currentRevision", + "baseName": "currentRevision", + "type": "string", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "readyReplicas", + "baseName": "readyReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "replicas", + "baseName": "replicas", + "type": "number", + "format": "int32" + }, + { + "name": "updateRevision", + "baseName": "updateRevision", + "type": "string", + "format": "" + }, + { + "name": "updatedReplicas", + "baseName": "updatedReplicas", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatefulSetUpdateStrategy.js +var V1StatefulSetUpdateStrategy = class _V1StatefulSetUpdateStrategy { + static getAttributeTypeMap() { + return _V1StatefulSetUpdateStrategy.attributeTypeMap; + } + constructor() { + } +}; +V1StatefulSetUpdateStrategy.discriminator = void 0; +V1StatefulSetUpdateStrategy.mapping = void 0; +V1StatefulSetUpdateStrategy.attributeTypeMap = [ + { + "name": "rollingUpdate", + "baseName": "rollingUpdate", + "type": "V1RollingUpdateStatefulSetStrategy", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Status.js +var V1Status = class _V1Status { + static getAttributeTypeMap() { + return _V1Status.attributeTypeMap; + } + constructor() { + } +}; +V1Status.discriminator = void 0; +V1Status.mapping = void 0; +V1Status.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "code", + "baseName": "code", + "type": "number", + "format": "int32" + }, + { + "name": "details", + "baseName": "details", + "type": "V1StatusDetails", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatusCause.js +var V1StatusCause = class _V1StatusCause { + static getAttributeTypeMap() { + return _V1StatusCause.attributeTypeMap; + } + constructor() { + } +}; +V1StatusCause.discriminator = void 0; +V1StatusCause.mapping = void 0; +V1StatusCause.attributeTypeMap = [ + { + "name": "field", + "baseName": "field", + "type": "string", + "format": "" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StatusDetails.js +var V1StatusDetails = class _V1StatusDetails { + static getAttributeTypeMap() { + return _V1StatusDetails.attributeTypeMap; + } + constructor() { + } +}; +V1StatusDetails.discriminator = void 0; +V1StatusDetails.mapping = void 0; +V1StatusDetails.attributeTypeMap = [ + { + "name": "causes", + "baseName": "causes", + "type": "Array", + "format": "" + }, + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "retryAfterSeconds", + "baseName": "retryAfterSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StorageClass.js +var V1StorageClass = class _V1StorageClass { + static getAttributeTypeMap() { + return _V1StorageClass.attributeTypeMap; + } + constructor() { + } +}; +V1StorageClass.discriminator = void 0; +V1StorageClass.mapping = void 0; +V1StorageClass.attributeTypeMap = [ + { + "name": "allowVolumeExpansion", + "baseName": "allowVolumeExpansion", + "type": "boolean", + "format": "" + }, + { + "name": "allowedTopologies", + "baseName": "allowedTopologies", + "type": "Array", + "format": "" + }, + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "mountOptions", + "baseName": "mountOptions", + "type": "Array", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "provisioner", + "baseName": "provisioner", + "type": "string", + "format": "" + }, + { + "name": "reclaimPolicy", + "baseName": "reclaimPolicy", + "type": "string", + "format": "" + }, + { + "name": "volumeBindingMode", + "baseName": "volumeBindingMode", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StorageClassList.js +var V1StorageClassList = class _V1StorageClassList { + static getAttributeTypeMap() { + return _V1StorageClassList.attributeTypeMap; + } + constructor() { + } +}; +V1StorageClassList.discriminator = void 0; +V1StorageClassList.mapping = void 0; +V1StorageClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StorageOSPersistentVolumeSource.js +var V1StorageOSPersistentVolumeSource = class _V1StorageOSPersistentVolumeSource { + static getAttributeTypeMap() { + return _V1StorageOSPersistentVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1StorageOSPersistentVolumeSource.discriminator = void 0; +V1StorageOSPersistentVolumeSource.mapping = void 0; +V1StorageOSPersistentVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1ObjectReference", + "format": "" + }, + { + "name": "volumeName", + "baseName": "volumeName", + "type": "string", + "format": "" + }, + { + "name": "volumeNamespace", + "baseName": "volumeNamespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1StorageOSVolumeSource.js +var V1StorageOSVolumeSource = class _V1StorageOSVolumeSource { + static getAttributeTypeMap() { + return _V1StorageOSVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1StorageOSVolumeSource.discriminator = void 0; +V1StorageOSVolumeSource.mapping = void 0; +V1StorageOSVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "secretRef", + "baseName": "secretRef", + "type": "V1LocalObjectReference", + "format": "" + }, + { + "name": "volumeName", + "baseName": "volumeName", + "type": "string", + "format": "" + }, + { + "name": "volumeNamespace", + "baseName": "volumeNamespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SubjectAccessReview.js +var V1SubjectAccessReview = class _V1SubjectAccessReview { + static getAttributeTypeMap() { + return _V1SubjectAccessReview.attributeTypeMap; + } + constructor() { + } +}; +V1SubjectAccessReview.discriminator = void 0; +V1SubjectAccessReview.mapping = void 0; +V1SubjectAccessReview.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1SubjectAccessReviewSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1SubjectAccessReviewStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SubjectAccessReviewSpec.js +var V1SubjectAccessReviewSpec = class _V1SubjectAccessReviewSpec { + static getAttributeTypeMap() { + return _V1SubjectAccessReviewSpec.attributeTypeMap; + } + constructor() { + } +}; +V1SubjectAccessReviewSpec.discriminator = void 0; +V1SubjectAccessReviewSpec.mapping = void 0; +V1SubjectAccessReviewSpec.attributeTypeMap = [ + { + "name": "extra", + "baseName": "extra", + "type": "{ [key: string]: Array; }", + "format": "" + }, + { + "name": "groups", + "baseName": "groups", + "type": "Array", + "format": "" + }, + { + "name": "nonResourceAttributes", + "baseName": "nonResourceAttributes", + "type": "V1NonResourceAttributes", + "format": "" + }, + { + "name": "resourceAttributes", + "baseName": "resourceAttributes", + "type": "V1ResourceAttributes", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SubjectAccessReviewStatus.js +var V1SubjectAccessReviewStatus = class _V1SubjectAccessReviewStatus { + static getAttributeTypeMap() { + return _V1SubjectAccessReviewStatus.attributeTypeMap; + } + constructor() { + } +}; +V1SubjectAccessReviewStatus.discriminator = void 0; +V1SubjectAccessReviewStatus.mapping = void 0; +V1SubjectAccessReviewStatus.attributeTypeMap = [ + { + "name": "allowed", + "baseName": "allowed", + "type": "boolean", + "format": "" + }, + { + "name": "denied", + "baseName": "denied", + "type": "boolean", + "format": "" + }, + { + "name": "evaluationError", + "baseName": "evaluationError", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SubjectRulesReviewStatus.js +var V1SubjectRulesReviewStatus = class _V1SubjectRulesReviewStatus { + static getAttributeTypeMap() { + return _V1SubjectRulesReviewStatus.attributeTypeMap; + } + constructor() { + } +}; +V1SubjectRulesReviewStatus.discriminator = void 0; +V1SubjectRulesReviewStatus.mapping = void 0; +V1SubjectRulesReviewStatus.attributeTypeMap = [ + { + "name": "evaluationError", + "baseName": "evaluationError", + "type": "string", + "format": "" + }, + { + "name": "incomplete", + "baseName": "incomplete", + "type": "boolean", + "format": "" + }, + { + "name": "nonResourceRules", + "baseName": "nonResourceRules", + "type": "Array", + "format": "" + }, + { + "name": "resourceRules", + "baseName": "resourceRules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SuccessPolicy.js +var V1SuccessPolicy = class _V1SuccessPolicy { + static getAttributeTypeMap() { + return _V1SuccessPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1SuccessPolicy.discriminator = void 0; +V1SuccessPolicy.mapping = void 0; +V1SuccessPolicy.attributeTypeMap = [ + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1SuccessPolicyRule.js +var V1SuccessPolicyRule = class _V1SuccessPolicyRule { + static getAttributeTypeMap() { + return _V1SuccessPolicyRule.attributeTypeMap; + } + constructor() { + } +}; +V1SuccessPolicyRule.discriminator = void 0; +V1SuccessPolicyRule.mapping = void 0; +V1SuccessPolicyRule.attributeTypeMap = [ + { + "name": "succeededCount", + "baseName": "succeededCount", + "type": "number", + "format": "int32" + }, + { + "name": "succeededIndexes", + "baseName": "succeededIndexes", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Sysctl.js +var V1Sysctl = class _V1Sysctl { + static getAttributeTypeMap() { + return _V1Sysctl.attributeTypeMap; + } + constructor() { + } +}; +V1Sysctl.discriminator = void 0; +V1Sysctl.mapping = void 0; +V1Sysctl.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TCPSocketAction.js +var V1TCPSocketAction = class _V1TCPSocketAction { + static getAttributeTypeMap() { + return _V1TCPSocketAction.attributeTypeMap; + } + constructor() { + } +}; +V1TCPSocketAction.discriminator = void 0; +V1TCPSocketAction.mapping = void 0; +V1TCPSocketAction.attributeTypeMap = [ + { + "name": "host", + "baseName": "host", + "type": "string", + "format": "" + }, + { + "name": "port", + "baseName": "port", + "type": "IntOrString", + "format": "int-or-string" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Taint.js +var V1Taint = class _V1Taint { + static getAttributeTypeMap() { + return _V1Taint.attributeTypeMap; + } + constructor() { + } +}; +V1Taint.discriminator = void 0; +V1Taint.mapping = void 0; +V1Taint.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "timeAdded", + "baseName": "timeAdded", + "type": "Date", + "format": "date-time" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TokenRequestSpec.js +var V1TokenRequestSpec = class _V1TokenRequestSpec { + static getAttributeTypeMap() { + return _V1TokenRequestSpec.attributeTypeMap; + } + constructor() { + } +}; +V1TokenRequestSpec.discriminator = void 0; +V1TokenRequestSpec.mapping = void 0; +V1TokenRequestSpec.attributeTypeMap = [ + { + "name": "audiences", + "baseName": "audiences", + "type": "Array", + "format": "" + }, + { + "name": "boundObjectRef", + "baseName": "boundObjectRef", + "type": "V1BoundObjectReference", + "format": "" + }, + { + "name": "expirationSeconds", + "baseName": "expirationSeconds", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TokenRequestStatus.js +var V1TokenRequestStatus = class _V1TokenRequestStatus { + static getAttributeTypeMap() { + return _V1TokenRequestStatus.attributeTypeMap; + } + constructor() { + } +}; +V1TokenRequestStatus.discriminator = void 0; +V1TokenRequestStatus.mapping = void 0; +V1TokenRequestStatus.attributeTypeMap = [ + { + "name": "expirationTimestamp", + "baseName": "expirationTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "token", + "baseName": "token", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TokenReview.js +var V1TokenReview = class _V1TokenReview { + static getAttributeTypeMap() { + return _V1TokenReview.attributeTypeMap; + } + constructor() { + } +}; +V1TokenReview.discriminator = void 0; +V1TokenReview.mapping = void 0; +V1TokenReview.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1TokenReviewSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1TokenReviewStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TokenReviewSpec.js +var V1TokenReviewSpec = class _V1TokenReviewSpec { + static getAttributeTypeMap() { + return _V1TokenReviewSpec.attributeTypeMap; + } + constructor() { + } +}; +V1TokenReviewSpec.discriminator = void 0; +V1TokenReviewSpec.mapping = void 0; +V1TokenReviewSpec.attributeTypeMap = [ + { + "name": "audiences", + "baseName": "audiences", + "type": "Array", + "format": "" + }, + { + "name": "token", + "baseName": "token", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TokenReviewStatus.js +var V1TokenReviewStatus = class _V1TokenReviewStatus { + static getAttributeTypeMap() { + return _V1TokenReviewStatus.attributeTypeMap; + } + constructor() { + } +}; +V1TokenReviewStatus.discriminator = void 0; +V1TokenReviewStatus.mapping = void 0; +V1TokenReviewStatus.attributeTypeMap = [ + { + "name": "audiences", + "baseName": "audiences", + "type": "Array", + "format": "" + }, + { + "name": "authenticated", + "baseName": "authenticated", + "type": "boolean", + "format": "" + }, + { + "name": "error", + "baseName": "error", + "type": "string", + "format": "" + }, + { + "name": "user", + "baseName": "user", + "type": "V1UserInfo", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Toleration.js +var V1Toleration = class _V1Toleration { + static getAttributeTypeMap() { + return _V1Toleration.attributeTypeMap; + } + constructor() { + } +}; +V1Toleration.discriminator = void 0; +V1Toleration.mapping = void 0; +V1Toleration.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "tolerationSeconds", + "baseName": "tolerationSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TopologySelectorLabelRequirement.js +var V1TopologySelectorLabelRequirement = class _V1TopologySelectorLabelRequirement { + static getAttributeTypeMap() { + return _V1TopologySelectorLabelRequirement.attributeTypeMap; + } + constructor() { + } +}; +V1TopologySelectorLabelRequirement.discriminator = void 0; +V1TopologySelectorLabelRequirement.mapping = void 0; +V1TopologySelectorLabelRequirement.attributeTypeMap = [ + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "values", + "baseName": "values", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TopologySelectorTerm.js +var V1TopologySelectorTerm = class _V1TopologySelectorTerm { + static getAttributeTypeMap() { + return _V1TopologySelectorTerm.attributeTypeMap; + } + constructor() { + } +}; +V1TopologySelectorTerm.discriminator = void 0; +V1TopologySelectorTerm.mapping = void 0; +V1TopologySelectorTerm.attributeTypeMap = [ + { + "name": "matchLabelExpressions", + "baseName": "matchLabelExpressions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TopologySpreadConstraint.js +var V1TopologySpreadConstraint = class _V1TopologySpreadConstraint { + static getAttributeTypeMap() { + return _V1TopologySpreadConstraint.attributeTypeMap; + } + constructor() { + } +}; +V1TopologySpreadConstraint.discriminator = void 0; +V1TopologySpreadConstraint.mapping = void 0; +V1TopologySpreadConstraint.attributeTypeMap = [ + { + "name": "labelSelector", + "baseName": "labelSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "matchLabelKeys", + "baseName": "matchLabelKeys", + "type": "Array", + "format": "" + }, + { + "name": "maxSkew", + "baseName": "maxSkew", + "type": "number", + "format": "int32" + }, + { + "name": "minDomains", + "baseName": "minDomains", + "type": "number", + "format": "int32" + }, + { + "name": "nodeAffinityPolicy", + "baseName": "nodeAffinityPolicy", + "type": "string", + "format": "" + }, + { + "name": "nodeTaintsPolicy", + "baseName": "nodeTaintsPolicy", + "type": "string", + "format": "" + }, + { + "name": "topologyKey", + "baseName": "topologyKey", + "type": "string", + "format": "" + }, + { + "name": "whenUnsatisfiable", + "baseName": "whenUnsatisfiable", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TypeChecking.js +var V1TypeChecking = class _V1TypeChecking { + static getAttributeTypeMap() { + return _V1TypeChecking.attributeTypeMap; + } + constructor() { + } +}; +V1TypeChecking.discriminator = void 0; +V1TypeChecking.mapping = void 0; +V1TypeChecking.attributeTypeMap = [ + { + "name": "expressionWarnings", + "baseName": "expressionWarnings", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TypedLocalObjectReference.js +var V1TypedLocalObjectReference = class _V1TypedLocalObjectReference { + static getAttributeTypeMap() { + return _V1TypedLocalObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V1TypedLocalObjectReference.discriminator = void 0; +V1TypedLocalObjectReference.mapping = void 0; +V1TypedLocalObjectReference.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1TypedObjectReference.js +var V1TypedObjectReference = class _V1TypedObjectReference { + static getAttributeTypeMap() { + return _V1TypedObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V1TypedObjectReference.discriminator = void 0; +V1TypedObjectReference.mapping = void 0; +V1TypedObjectReference.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1UncountedTerminatedPods.js +var V1UncountedTerminatedPods = class _V1UncountedTerminatedPods { + static getAttributeTypeMap() { + return _V1UncountedTerminatedPods.attributeTypeMap; + } + constructor() { + } +}; +V1UncountedTerminatedPods.discriminator = void 0; +V1UncountedTerminatedPods.mapping = void 0; +V1UncountedTerminatedPods.attributeTypeMap = [ + { + "name": "failed", + "baseName": "failed", + "type": "Array", + "format": "" + }, + { + "name": "succeeded", + "baseName": "succeeded", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1UserInfo.js +var V1UserInfo = class _V1UserInfo { + static getAttributeTypeMap() { + return _V1UserInfo.attributeTypeMap; + } + constructor() { + } +}; +V1UserInfo.discriminator = void 0; +V1UserInfo.mapping = void 0; +V1UserInfo.attributeTypeMap = [ + { + "name": "extra", + "baseName": "extra", + "type": "{ [key: string]: Array; }", + "format": "" + }, + { + "name": "groups", + "baseName": "groups", + "type": "Array", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + }, + { + "name": "username", + "baseName": "username", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1UserSubject.js +var V1UserSubject = class _V1UserSubject { + static getAttributeTypeMap() { + return _V1UserSubject.attributeTypeMap; + } + constructor() { + } +}; +V1UserSubject.discriminator = void 0; +V1UserSubject.mapping = void 0; +V1UserSubject.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicy.js +var V1ValidatingAdmissionPolicy = class _V1ValidatingAdmissionPolicy { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicy.discriminator = void 0; +V1ValidatingAdmissionPolicy.mapping = void 0; +V1ValidatingAdmissionPolicy.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ValidatingAdmissionPolicySpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1ValidatingAdmissionPolicyStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicyBinding.js +var V1ValidatingAdmissionPolicyBinding = class _V1ValidatingAdmissionPolicyBinding { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicyBinding.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicyBinding.discriminator = void 0; +V1ValidatingAdmissionPolicyBinding.mapping = void 0; +V1ValidatingAdmissionPolicyBinding.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1ValidatingAdmissionPolicyBindingSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicyBindingList.js +var V1ValidatingAdmissionPolicyBindingList = class _V1ValidatingAdmissionPolicyBindingList { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicyBindingList.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicyBindingList.discriminator = void 0; +V1ValidatingAdmissionPolicyBindingList.mapping = void 0; +V1ValidatingAdmissionPolicyBindingList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicyBindingSpec.js +var V1ValidatingAdmissionPolicyBindingSpec = class _V1ValidatingAdmissionPolicyBindingSpec { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicyBindingSpec.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicyBindingSpec.discriminator = void 0; +V1ValidatingAdmissionPolicyBindingSpec.mapping = void 0; +V1ValidatingAdmissionPolicyBindingSpec.attributeTypeMap = [ + { + "name": "matchResources", + "baseName": "matchResources", + "type": "V1MatchResources", + "format": "" + }, + { + "name": "paramRef", + "baseName": "paramRef", + "type": "V1ParamRef", + "format": "" + }, + { + "name": "policyName", + "baseName": "policyName", + "type": "string", + "format": "" + }, + { + "name": "validationActions", + "baseName": "validationActions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicyList.js +var V1ValidatingAdmissionPolicyList = class _V1ValidatingAdmissionPolicyList { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicyList.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicyList.discriminator = void 0; +V1ValidatingAdmissionPolicyList.mapping = void 0; +V1ValidatingAdmissionPolicyList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicySpec.js +var V1ValidatingAdmissionPolicySpec = class _V1ValidatingAdmissionPolicySpec { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicySpec.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicySpec.discriminator = void 0; +V1ValidatingAdmissionPolicySpec.mapping = void 0; +V1ValidatingAdmissionPolicySpec.attributeTypeMap = [ + { + "name": "auditAnnotations", + "baseName": "auditAnnotations", + "type": "Array", + "format": "" + }, + { + "name": "failurePolicy", + "baseName": "failurePolicy", + "type": "string", + "format": "" + }, + { + "name": "matchConditions", + "baseName": "matchConditions", + "type": "Array", + "format": "" + }, + { + "name": "matchConstraints", + "baseName": "matchConstraints", + "type": "V1MatchResources", + "format": "" + }, + { + "name": "paramKind", + "baseName": "paramKind", + "type": "V1ParamKind", + "format": "" + }, + { + "name": "validations", + "baseName": "validations", + "type": "Array", + "format": "" + }, + { + "name": "variables", + "baseName": "variables", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingAdmissionPolicyStatus.js +var V1ValidatingAdmissionPolicyStatus = class _V1ValidatingAdmissionPolicyStatus { + static getAttributeTypeMap() { + return _V1ValidatingAdmissionPolicyStatus.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingAdmissionPolicyStatus.discriminator = void 0; +V1ValidatingAdmissionPolicyStatus.mapping = void 0; +V1ValidatingAdmissionPolicyStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "typeChecking", + "baseName": "typeChecking", + "type": "V1TypeChecking", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingWebhook.js +var V1ValidatingWebhook = class _V1ValidatingWebhook { + static getAttributeTypeMap() { + return _V1ValidatingWebhook.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingWebhook.discriminator = void 0; +V1ValidatingWebhook.mapping = void 0; +V1ValidatingWebhook.attributeTypeMap = [ + { + "name": "admissionReviewVersions", + "baseName": "admissionReviewVersions", + "type": "Array", + "format": "" + }, + { + "name": "clientConfig", + "baseName": "clientConfig", + "type": "AdmissionregistrationV1WebhookClientConfig", + "format": "" + }, + { + "name": "failurePolicy", + "baseName": "failurePolicy", + "type": "string", + "format": "" + }, + { + "name": "matchConditions", + "baseName": "matchConditions", + "type": "Array", + "format": "" + }, + { + "name": "matchPolicy", + "baseName": "matchPolicy", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "objectSelector", + "baseName": "objectSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "rules", + "baseName": "rules", + "type": "Array", + "format": "" + }, + { + "name": "sideEffects", + "baseName": "sideEffects", + "type": "string", + "format": "" + }, + { + "name": "timeoutSeconds", + "baseName": "timeoutSeconds", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingWebhookConfiguration.js +var V1ValidatingWebhookConfiguration = class _V1ValidatingWebhookConfiguration { + static getAttributeTypeMap() { + return _V1ValidatingWebhookConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingWebhookConfiguration.discriminator = void 0; +V1ValidatingWebhookConfiguration.mapping = void 0; +V1ValidatingWebhookConfiguration.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "webhooks", + "baseName": "webhooks", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidatingWebhookConfigurationList.js +var V1ValidatingWebhookConfigurationList = class _V1ValidatingWebhookConfigurationList { + static getAttributeTypeMap() { + return _V1ValidatingWebhookConfigurationList.attributeTypeMap; + } + constructor() { + } +}; +V1ValidatingWebhookConfigurationList.discriminator = void 0; +V1ValidatingWebhookConfigurationList.mapping = void 0; +V1ValidatingWebhookConfigurationList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Validation.js +var V1Validation = class _V1Validation { + static getAttributeTypeMap() { + return _V1Validation.attributeTypeMap; + } + constructor() { + } +}; +V1Validation.discriminator = void 0; +V1Validation.mapping = void 0; +V1Validation.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "messageExpression", + "baseName": "messageExpression", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1ValidationRule.js +var V1ValidationRule = class _V1ValidationRule { + static getAttributeTypeMap() { + return _V1ValidationRule.attributeTypeMap; + } + constructor() { + } +}; +V1ValidationRule.discriminator = void 0; +V1ValidationRule.mapping = void 0; +V1ValidationRule.attributeTypeMap = [ + { + "name": "fieldPath", + "baseName": "fieldPath", + "type": "string", + "format": "" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "messageExpression", + "baseName": "messageExpression", + "type": "string", + "format": "" + }, + { + "name": "optionalOldSelf", + "baseName": "optionalOldSelf", + "type": "boolean", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "rule", + "baseName": "rule", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Variable.js +var V1Variable = class _V1Variable { + static getAttributeTypeMap() { + return _V1Variable.attributeTypeMap; + } + constructor() { + } +}; +V1Variable.discriminator = void 0; +V1Variable.mapping = void 0; +V1Variable.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1Volume.js +var V1Volume = class _V1Volume { + static getAttributeTypeMap() { + return _V1Volume.attributeTypeMap; + } + constructor() { + } +}; +V1Volume.discriminator = void 0; +V1Volume.mapping = void 0; +V1Volume.attributeTypeMap = [ + { + "name": "awsElasticBlockStore", + "baseName": "awsElasticBlockStore", + "type": "V1AWSElasticBlockStoreVolumeSource", + "format": "" + }, + { + "name": "azureDisk", + "baseName": "azureDisk", + "type": "V1AzureDiskVolumeSource", + "format": "" + }, + { + "name": "azureFile", + "baseName": "azureFile", + "type": "V1AzureFileVolumeSource", + "format": "" + }, + { + "name": "cephfs", + "baseName": "cephfs", + "type": "V1CephFSVolumeSource", + "format": "" + }, + { + "name": "cinder", + "baseName": "cinder", + "type": "V1CinderVolumeSource", + "format": "" + }, + { + "name": "configMap", + "baseName": "configMap", + "type": "V1ConfigMapVolumeSource", + "format": "" + }, + { + "name": "csi", + "baseName": "csi", + "type": "V1CSIVolumeSource", + "format": "" + }, + { + "name": "downwardAPI", + "baseName": "downwardAPI", + "type": "V1DownwardAPIVolumeSource", + "format": "" + }, + { + "name": "emptyDir", + "baseName": "emptyDir", + "type": "V1EmptyDirVolumeSource", + "format": "" + }, + { + "name": "ephemeral", + "baseName": "ephemeral", + "type": "V1EphemeralVolumeSource", + "format": "" + }, + { + "name": "fc", + "baseName": "fc", + "type": "V1FCVolumeSource", + "format": "" + }, + { + "name": "flexVolume", + "baseName": "flexVolume", + "type": "V1FlexVolumeSource", + "format": "" + }, + { + "name": "flocker", + "baseName": "flocker", + "type": "V1FlockerVolumeSource", + "format": "" + }, + { + "name": "gcePersistentDisk", + "baseName": "gcePersistentDisk", + "type": "V1GCEPersistentDiskVolumeSource", + "format": "" + }, + { + "name": "gitRepo", + "baseName": "gitRepo", + "type": "V1GitRepoVolumeSource", + "format": "" + }, + { + "name": "glusterfs", + "baseName": "glusterfs", + "type": "V1GlusterfsVolumeSource", + "format": "" + }, + { + "name": "hostPath", + "baseName": "hostPath", + "type": "V1HostPathVolumeSource", + "format": "" + }, + { + "name": "image", + "baseName": "image", + "type": "V1ImageVolumeSource", + "format": "" + }, + { + "name": "iscsi", + "baseName": "iscsi", + "type": "V1ISCSIVolumeSource", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "nfs", + "baseName": "nfs", + "type": "V1NFSVolumeSource", + "format": "" + }, + { + "name": "persistentVolumeClaim", + "baseName": "persistentVolumeClaim", + "type": "V1PersistentVolumeClaimVolumeSource", + "format": "" + }, + { + "name": "photonPersistentDisk", + "baseName": "photonPersistentDisk", + "type": "V1PhotonPersistentDiskVolumeSource", + "format": "" + }, + { + "name": "portworxVolume", + "baseName": "portworxVolume", + "type": "V1PortworxVolumeSource", + "format": "" + }, + { + "name": "projected", + "baseName": "projected", + "type": "V1ProjectedVolumeSource", + "format": "" + }, + { + "name": "quobyte", + "baseName": "quobyte", + "type": "V1QuobyteVolumeSource", + "format": "" + }, + { + "name": "rbd", + "baseName": "rbd", + "type": "V1RBDVolumeSource", + "format": "" + }, + { + "name": "scaleIO", + "baseName": "scaleIO", + "type": "V1ScaleIOVolumeSource", + "format": "" + }, + { + "name": "secret", + "baseName": "secret", + "type": "V1SecretVolumeSource", + "format": "" + }, + { + "name": "storageos", + "baseName": "storageos", + "type": "V1StorageOSVolumeSource", + "format": "" + }, + { + "name": "vsphereVolume", + "baseName": "vsphereVolume", + "type": "V1VsphereVirtualDiskVolumeSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttachment.js +var V1VolumeAttachment = class _V1VolumeAttachment { + static getAttributeTypeMap() { + return _V1VolumeAttachment.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttachment.discriminator = void 0; +V1VolumeAttachment.mapping = void 0; +V1VolumeAttachment.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1VolumeAttachmentSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1VolumeAttachmentStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttachmentList.js +var V1VolumeAttachmentList = class _V1VolumeAttachmentList { + static getAttributeTypeMap() { + return _V1VolumeAttachmentList.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttachmentList.discriminator = void 0; +V1VolumeAttachmentList.mapping = void 0; +V1VolumeAttachmentList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttachmentSource.js +var V1VolumeAttachmentSource = class _V1VolumeAttachmentSource { + static getAttributeTypeMap() { + return _V1VolumeAttachmentSource.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttachmentSource.discriminator = void 0; +V1VolumeAttachmentSource.mapping = void 0; +V1VolumeAttachmentSource.attributeTypeMap = [ + { + "name": "inlineVolumeSpec", + "baseName": "inlineVolumeSpec", + "type": "V1PersistentVolumeSpec", + "format": "" + }, + { + "name": "persistentVolumeName", + "baseName": "persistentVolumeName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttachmentSpec.js +var V1VolumeAttachmentSpec = class _V1VolumeAttachmentSpec { + static getAttributeTypeMap() { + return _V1VolumeAttachmentSpec.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttachmentSpec.discriminator = void 0; +V1VolumeAttachmentSpec.mapping = void 0; +V1VolumeAttachmentSpec.attributeTypeMap = [ + { + "name": "attacher", + "baseName": "attacher", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "source", + "baseName": "source", + "type": "V1VolumeAttachmentSource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttachmentStatus.js +var V1VolumeAttachmentStatus = class _V1VolumeAttachmentStatus { + static getAttributeTypeMap() { + return _V1VolumeAttachmentStatus.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttachmentStatus.discriminator = void 0; +V1VolumeAttachmentStatus.mapping = void 0; +V1VolumeAttachmentStatus.attributeTypeMap = [ + { + "name": "attachError", + "baseName": "attachError", + "type": "V1VolumeError", + "format": "" + }, + { + "name": "attached", + "baseName": "attached", + "type": "boolean", + "format": "" + }, + { + "name": "attachmentMetadata", + "baseName": "attachmentMetadata", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "detachError", + "baseName": "detachError", + "type": "V1VolumeError", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttributesClass.js +var V1VolumeAttributesClass = class _V1VolumeAttributesClass { + static getAttributeTypeMap() { + return _V1VolumeAttributesClass.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttributesClass.discriminator = void 0; +V1VolumeAttributesClass.mapping = void 0; +V1VolumeAttributesClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "driverName", + "baseName": "driverName", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeAttributesClassList.js +var V1VolumeAttributesClassList = class _V1VolumeAttributesClassList { + static getAttributeTypeMap() { + return _V1VolumeAttributesClassList.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeAttributesClassList.discriminator = void 0; +V1VolumeAttributesClassList.mapping = void 0; +V1VolumeAttributesClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeDevice.js +var V1VolumeDevice = class _V1VolumeDevice { + static getAttributeTypeMap() { + return _V1VolumeDevice.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeDevice.discriminator = void 0; +V1VolumeDevice.mapping = void 0; +V1VolumeDevice.attributeTypeMap = [ + { + "name": "devicePath", + "baseName": "devicePath", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeError.js +var V1VolumeError = class _V1VolumeError { + static getAttributeTypeMap() { + return _V1VolumeError.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeError.discriminator = void 0; +V1VolumeError.mapping = void 0; +V1VolumeError.attributeTypeMap = [ + { + "name": "errorCode", + "baseName": "errorCode", + "type": "number", + "format": "int32" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "time", + "baseName": "time", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeMount.js +var V1VolumeMount = class _V1VolumeMount { + static getAttributeTypeMap() { + return _V1VolumeMount.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeMount.discriminator = void 0; +V1VolumeMount.mapping = void 0; +V1VolumeMount.attributeTypeMap = [ + { + "name": "mountPath", + "baseName": "mountPath", + "type": "string", + "format": "" + }, + { + "name": "mountPropagation", + "baseName": "mountPropagation", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "recursiveReadOnly", + "baseName": "recursiveReadOnly", + "type": "string", + "format": "" + }, + { + "name": "subPath", + "baseName": "subPath", + "type": "string", + "format": "" + }, + { + "name": "subPathExpr", + "baseName": "subPathExpr", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeMountStatus.js +var V1VolumeMountStatus = class _V1VolumeMountStatus { + static getAttributeTypeMap() { + return _V1VolumeMountStatus.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeMountStatus.discriminator = void 0; +V1VolumeMountStatus.mapping = void 0; +V1VolumeMountStatus.attributeTypeMap = [ + { + "name": "mountPath", + "baseName": "mountPath", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "readOnly", + "baseName": "readOnly", + "type": "boolean", + "format": "" + }, + { + "name": "recursiveReadOnly", + "baseName": "recursiveReadOnly", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeNodeAffinity.js +var V1VolumeNodeAffinity = class _V1VolumeNodeAffinity { + static getAttributeTypeMap() { + return _V1VolumeNodeAffinity.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeNodeAffinity.discriminator = void 0; +V1VolumeNodeAffinity.mapping = void 0; +V1VolumeNodeAffinity.attributeTypeMap = [ + { + "name": "required", + "baseName": "required", + "type": "V1NodeSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeNodeResources.js +var V1VolumeNodeResources = class _V1VolumeNodeResources { + static getAttributeTypeMap() { + return _V1VolumeNodeResources.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeNodeResources.discriminator = void 0; +V1VolumeNodeResources.mapping = void 0; +V1VolumeNodeResources.attributeTypeMap = [ + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeProjection.js +var V1VolumeProjection = class _V1VolumeProjection { + static getAttributeTypeMap() { + return _V1VolumeProjection.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeProjection.discriminator = void 0; +V1VolumeProjection.mapping = void 0; +V1VolumeProjection.attributeTypeMap = [ + { + "name": "clusterTrustBundle", + "baseName": "clusterTrustBundle", + "type": "V1ClusterTrustBundleProjection", + "format": "" + }, + { + "name": "configMap", + "baseName": "configMap", + "type": "V1ConfigMapProjection", + "format": "" + }, + { + "name": "downwardAPI", + "baseName": "downwardAPI", + "type": "V1DownwardAPIProjection", + "format": "" + }, + { + "name": "podCertificate", + "baseName": "podCertificate", + "type": "V1PodCertificateProjection", + "format": "" + }, + { + "name": "secret", + "baseName": "secret", + "type": "V1SecretProjection", + "format": "" + }, + { + "name": "serviceAccountToken", + "baseName": "serviceAccountToken", + "type": "V1ServiceAccountTokenProjection", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VolumeResourceRequirements.js +var V1VolumeResourceRequirements = class _V1VolumeResourceRequirements { + static getAttributeTypeMap() { + return _V1VolumeResourceRequirements.attributeTypeMap; + } + constructor() { + } +}; +V1VolumeResourceRequirements.discriminator = void 0; +V1VolumeResourceRequirements.mapping = void 0; +V1VolumeResourceRequirements.attributeTypeMap = [ + { + "name": "limits", + "baseName": "limits", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1VsphereVirtualDiskVolumeSource.js +var V1VsphereVirtualDiskVolumeSource = class _V1VsphereVirtualDiskVolumeSource { + static getAttributeTypeMap() { + return _V1VsphereVirtualDiskVolumeSource.attributeTypeMap; + } + constructor() { + } +}; +V1VsphereVirtualDiskVolumeSource.discriminator = void 0; +V1VsphereVirtualDiskVolumeSource.mapping = void 0; +V1VsphereVirtualDiskVolumeSource.attributeTypeMap = [ + { + "name": "fsType", + "baseName": "fsType", + "type": "string", + "format": "" + }, + { + "name": "storagePolicyID", + "baseName": "storagePolicyID", + "type": "string", + "format": "" + }, + { + "name": "storagePolicyName", + "baseName": "storagePolicyName", + "type": "string", + "format": "" + }, + { + "name": "volumePath", + "baseName": "volumePath", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1WatchEvent.js +var V1WatchEvent = class _V1WatchEvent { + static getAttributeTypeMap() { + return _V1WatchEvent.attributeTypeMap; + } + constructor() { + } +}; +V1WatchEvent.discriminator = void 0; +V1WatchEvent.mapping = void 0; +V1WatchEvent.attributeTypeMap = [ + { + "name": "object", + "baseName": "object", + "type": "any", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1WebhookConversion.js +var V1WebhookConversion = class _V1WebhookConversion { + static getAttributeTypeMap() { + return _V1WebhookConversion.attributeTypeMap; + } + constructor() { + } +}; +V1WebhookConversion.discriminator = void 0; +V1WebhookConversion.mapping = void 0; +V1WebhookConversion.attributeTypeMap = [ + { + "name": "clientConfig", + "baseName": "clientConfig", + "type": "ApiextensionsV1WebhookClientConfig", + "format": "" + }, + { + "name": "conversionReviewVersions", + "baseName": "conversionReviewVersions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1WeightedPodAffinityTerm.js +var V1WeightedPodAffinityTerm = class _V1WeightedPodAffinityTerm { + static getAttributeTypeMap() { + return _V1WeightedPodAffinityTerm.attributeTypeMap; + } + constructor() { + } +}; +V1WeightedPodAffinityTerm.discriminator = void 0; +V1WeightedPodAffinityTerm.mapping = void 0; +V1WeightedPodAffinityTerm.attributeTypeMap = [ + { + "name": "podAffinityTerm", + "baseName": "podAffinityTerm", + "type": "V1PodAffinityTerm", + "format": "" + }, + { + "name": "weight", + "baseName": "weight", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1WindowsSecurityContextOptions.js +var V1WindowsSecurityContextOptions = class _V1WindowsSecurityContextOptions { + static getAttributeTypeMap() { + return _V1WindowsSecurityContextOptions.attributeTypeMap; + } + constructor() { + } +}; +V1WindowsSecurityContextOptions.discriminator = void 0; +V1WindowsSecurityContextOptions.mapping = void 0; +V1WindowsSecurityContextOptions.attributeTypeMap = [ + { + "name": "gmsaCredentialSpec", + "baseName": "gmsaCredentialSpec", + "type": "string", + "format": "" + }, + { + "name": "gmsaCredentialSpecName", + "baseName": "gmsaCredentialSpecName", + "type": "string", + "format": "" + }, + { + "name": "hostProcess", + "baseName": "hostProcess", + "type": "boolean", + "format": "" + }, + { + "name": "runAsUserName", + "baseName": "runAsUserName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ApplyConfiguration.js +var V1alpha1ApplyConfiguration = class _V1alpha1ApplyConfiguration { + static getAttributeTypeMap() { + return _V1alpha1ApplyConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ApplyConfiguration.discriminator = void 0; +V1alpha1ApplyConfiguration.mapping = void 0; +V1alpha1ApplyConfiguration.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ClusterTrustBundle.js +var V1alpha1ClusterTrustBundle = class _V1alpha1ClusterTrustBundle { + static getAttributeTypeMap() { + return _V1alpha1ClusterTrustBundle.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ClusterTrustBundle.discriminator = void 0; +V1alpha1ClusterTrustBundle.mapping = void 0; +V1alpha1ClusterTrustBundle.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha1ClusterTrustBundleSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ClusterTrustBundleList.js +var V1alpha1ClusterTrustBundleList = class _V1alpha1ClusterTrustBundleList { + static getAttributeTypeMap() { + return _V1alpha1ClusterTrustBundleList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ClusterTrustBundleList.discriminator = void 0; +V1alpha1ClusterTrustBundleList.mapping = void 0; +V1alpha1ClusterTrustBundleList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ClusterTrustBundleSpec.js +var V1alpha1ClusterTrustBundleSpec = class _V1alpha1ClusterTrustBundleSpec { + static getAttributeTypeMap() { + return _V1alpha1ClusterTrustBundleSpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ClusterTrustBundleSpec.discriminator = void 0; +V1alpha1ClusterTrustBundleSpec.mapping = void 0; +V1alpha1ClusterTrustBundleSpec.attributeTypeMap = [ + { + "name": "signerName", + "baseName": "signerName", + "type": "string", + "format": "" + }, + { + "name": "trustBundle", + "baseName": "trustBundle", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1GroupVersionResource.js +var V1alpha1GroupVersionResource = class _V1alpha1GroupVersionResource { + static getAttributeTypeMap() { + return _V1alpha1GroupVersionResource.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1GroupVersionResource.discriminator = void 0; +V1alpha1GroupVersionResource.mapping = void 0; +V1alpha1GroupVersionResource.attributeTypeMap = [ + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1JSONPatch.js +var V1alpha1JSONPatch = class _V1alpha1JSONPatch { + static getAttributeTypeMap() { + return _V1alpha1JSONPatch.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1JSONPatch.discriminator = void 0; +V1alpha1JSONPatch.mapping = void 0; +V1alpha1JSONPatch.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MatchCondition.js +var V1alpha1MatchCondition = class _V1alpha1MatchCondition { + static getAttributeTypeMap() { + return _V1alpha1MatchCondition.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MatchCondition.discriminator = void 0; +V1alpha1MatchCondition.mapping = void 0; +V1alpha1MatchCondition.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MatchResources.js +var V1alpha1MatchResources = class _V1alpha1MatchResources { + static getAttributeTypeMap() { + return _V1alpha1MatchResources.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MatchResources.discriminator = void 0; +V1alpha1MatchResources.mapping = void 0; +V1alpha1MatchResources.attributeTypeMap = [ + { + "name": "excludeResourceRules", + "baseName": "excludeResourceRules", + "type": "Array", + "format": "" + }, + { + "name": "matchPolicy", + "baseName": "matchPolicy", + "type": "string", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "objectSelector", + "baseName": "objectSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "resourceRules", + "baseName": "resourceRules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MigrationCondition.js +var V1alpha1MigrationCondition = class _V1alpha1MigrationCondition { + static getAttributeTypeMap() { + return _V1alpha1MigrationCondition.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MigrationCondition.discriminator = void 0; +V1alpha1MigrationCondition.mapping = void 0; +V1alpha1MigrationCondition.attributeTypeMap = [ + { + "name": "lastUpdateTime", + "baseName": "lastUpdateTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MutatingAdmissionPolicy.js +var V1alpha1MutatingAdmissionPolicy = class _V1alpha1MutatingAdmissionPolicy { + static getAttributeTypeMap() { + return _V1alpha1MutatingAdmissionPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MutatingAdmissionPolicy.discriminator = void 0; +V1alpha1MutatingAdmissionPolicy.mapping = void 0; +V1alpha1MutatingAdmissionPolicy.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha1MutatingAdmissionPolicySpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MutatingAdmissionPolicyBinding.js +var V1alpha1MutatingAdmissionPolicyBinding = class _V1alpha1MutatingAdmissionPolicyBinding { + static getAttributeTypeMap() { + return _V1alpha1MutatingAdmissionPolicyBinding.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MutatingAdmissionPolicyBinding.discriminator = void 0; +V1alpha1MutatingAdmissionPolicyBinding.mapping = void 0; +V1alpha1MutatingAdmissionPolicyBinding.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha1MutatingAdmissionPolicyBindingSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MutatingAdmissionPolicyBindingList.js +var V1alpha1MutatingAdmissionPolicyBindingList = class _V1alpha1MutatingAdmissionPolicyBindingList { + static getAttributeTypeMap() { + return _V1alpha1MutatingAdmissionPolicyBindingList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MutatingAdmissionPolicyBindingList.discriminator = void 0; +V1alpha1MutatingAdmissionPolicyBindingList.mapping = void 0; +V1alpha1MutatingAdmissionPolicyBindingList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MutatingAdmissionPolicyBindingSpec.js +var V1alpha1MutatingAdmissionPolicyBindingSpec = class _V1alpha1MutatingAdmissionPolicyBindingSpec { + static getAttributeTypeMap() { + return _V1alpha1MutatingAdmissionPolicyBindingSpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MutatingAdmissionPolicyBindingSpec.discriminator = void 0; +V1alpha1MutatingAdmissionPolicyBindingSpec.mapping = void 0; +V1alpha1MutatingAdmissionPolicyBindingSpec.attributeTypeMap = [ + { + "name": "matchResources", + "baseName": "matchResources", + "type": "V1alpha1MatchResources", + "format": "" + }, + { + "name": "paramRef", + "baseName": "paramRef", + "type": "V1alpha1ParamRef", + "format": "" + }, + { + "name": "policyName", + "baseName": "policyName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MutatingAdmissionPolicyList.js +var V1alpha1MutatingAdmissionPolicyList = class _V1alpha1MutatingAdmissionPolicyList { + static getAttributeTypeMap() { + return _V1alpha1MutatingAdmissionPolicyList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MutatingAdmissionPolicyList.discriminator = void 0; +V1alpha1MutatingAdmissionPolicyList.mapping = void 0; +V1alpha1MutatingAdmissionPolicyList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1MutatingAdmissionPolicySpec.js +var V1alpha1MutatingAdmissionPolicySpec = class _V1alpha1MutatingAdmissionPolicySpec { + static getAttributeTypeMap() { + return _V1alpha1MutatingAdmissionPolicySpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1MutatingAdmissionPolicySpec.discriminator = void 0; +V1alpha1MutatingAdmissionPolicySpec.mapping = void 0; +V1alpha1MutatingAdmissionPolicySpec.attributeTypeMap = [ + { + "name": "failurePolicy", + "baseName": "failurePolicy", + "type": "string", + "format": "" + }, + { + "name": "matchConditions", + "baseName": "matchConditions", + "type": "Array", + "format": "" + }, + { + "name": "matchConstraints", + "baseName": "matchConstraints", + "type": "V1alpha1MatchResources", + "format": "" + }, + { + "name": "mutations", + "baseName": "mutations", + "type": "Array", + "format": "" + }, + { + "name": "paramKind", + "baseName": "paramKind", + "type": "V1alpha1ParamKind", + "format": "" + }, + { + "name": "reinvocationPolicy", + "baseName": "reinvocationPolicy", + "type": "string", + "format": "" + }, + { + "name": "variables", + "baseName": "variables", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1Mutation.js +var V1alpha1Mutation = class _V1alpha1Mutation { + static getAttributeTypeMap() { + return _V1alpha1Mutation.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1Mutation.discriminator = void 0; +V1alpha1Mutation.mapping = void 0; +V1alpha1Mutation.attributeTypeMap = [ + { + "name": "applyConfiguration", + "baseName": "applyConfiguration", + "type": "V1alpha1ApplyConfiguration", + "format": "" + }, + { + "name": "jsonPatch", + "baseName": "jsonPatch", + "type": "V1alpha1JSONPatch", + "format": "" + }, + { + "name": "patchType", + "baseName": "patchType", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1NamedRuleWithOperations.js +var V1alpha1NamedRuleWithOperations = class _V1alpha1NamedRuleWithOperations { + static getAttributeTypeMap() { + return _V1alpha1NamedRuleWithOperations.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1NamedRuleWithOperations.discriminator = void 0; +V1alpha1NamedRuleWithOperations.mapping = void 0; +V1alpha1NamedRuleWithOperations.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "apiVersions", + "baseName": "apiVersions", + "type": "Array", + "format": "" + }, + { + "name": "operations", + "baseName": "operations", + "type": "Array", + "format": "" + }, + { + "name": "resourceNames", + "baseName": "resourceNames", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "scope", + "baseName": "scope", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ParamKind.js +var V1alpha1ParamKind = class _V1alpha1ParamKind { + static getAttributeTypeMap() { + return _V1alpha1ParamKind.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ParamKind.discriminator = void 0; +V1alpha1ParamKind.mapping = void 0; +V1alpha1ParamKind.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ParamRef.js +var V1alpha1ParamRef = class _V1alpha1ParamRef { + static getAttributeTypeMap() { + return _V1alpha1ParamRef.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ParamRef.discriminator = void 0; +V1alpha1ParamRef.mapping = void 0; +V1alpha1ParamRef.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "parameterNotFoundAction", + "baseName": "parameterNotFoundAction", + "type": "string", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1PodCertificateRequest.js +var V1alpha1PodCertificateRequest = class _V1alpha1PodCertificateRequest { + static getAttributeTypeMap() { + return _V1alpha1PodCertificateRequest.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1PodCertificateRequest.discriminator = void 0; +V1alpha1PodCertificateRequest.mapping = void 0; +V1alpha1PodCertificateRequest.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha1PodCertificateRequestSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1alpha1PodCertificateRequestStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1PodCertificateRequestList.js +var V1alpha1PodCertificateRequestList = class _V1alpha1PodCertificateRequestList { + static getAttributeTypeMap() { + return _V1alpha1PodCertificateRequestList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1PodCertificateRequestList.discriminator = void 0; +V1alpha1PodCertificateRequestList.mapping = void 0; +V1alpha1PodCertificateRequestList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1PodCertificateRequestSpec.js +var V1alpha1PodCertificateRequestSpec = class _V1alpha1PodCertificateRequestSpec { + static getAttributeTypeMap() { + return _V1alpha1PodCertificateRequestSpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1PodCertificateRequestSpec.discriminator = void 0; +V1alpha1PodCertificateRequestSpec.mapping = void 0; +V1alpha1PodCertificateRequestSpec.attributeTypeMap = [ + { + "name": "maxExpirationSeconds", + "baseName": "maxExpirationSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeUID", + "baseName": "nodeUID", + "type": "string", + "format": "" + }, + { + "name": "pkixPublicKey", + "baseName": "pkixPublicKey", + "type": "string", + "format": "byte" + }, + { + "name": "podName", + "baseName": "podName", + "type": "string", + "format": "" + }, + { + "name": "podUID", + "baseName": "podUID", + "type": "string", + "format": "" + }, + { + "name": "proofOfPossession", + "baseName": "proofOfPossession", + "type": "string", + "format": "byte" + }, + { + "name": "serviceAccountName", + "baseName": "serviceAccountName", + "type": "string", + "format": "" + }, + { + "name": "serviceAccountUID", + "baseName": "serviceAccountUID", + "type": "string", + "format": "" + }, + { + "name": "signerName", + "baseName": "signerName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1PodCertificateRequestStatus.js +var V1alpha1PodCertificateRequestStatus = class _V1alpha1PodCertificateRequestStatus { + static getAttributeTypeMap() { + return _V1alpha1PodCertificateRequestStatus.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1PodCertificateRequestStatus.discriminator = void 0; +V1alpha1PodCertificateRequestStatus.mapping = void 0; +V1alpha1PodCertificateRequestStatus.attributeTypeMap = [ + { + "name": "beginRefreshAt", + "baseName": "beginRefreshAt", + "type": "Date", + "format": "date-time" + }, + { + "name": "certificateChain", + "baseName": "certificateChain", + "type": "string", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "notAfter", + "baseName": "notAfter", + "type": "Date", + "format": "date-time" + }, + { + "name": "notBefore", + "baseName": "notBefore", + "type": "Date", + "format": "date-time" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1ServerStorageVersion.js +var V1alpha1ServerStorageVersion = class _V1alpha1ServerStorageVersion { + static getAttributeTypeMap() { + return _V1alpha1ServerStorageVersion.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1ServerStorageVersion.discriminator = void 0; +V1alpha1ServerStorageVersion.mapping = void 0; +V1alpha1ServerStorageVersion.attributeTypeMap = [ + { + "name": "apiServerID", + "baseName": "apiServerID", + "type": "string", + "format": "" + }, + { + "name": "decodableVersions", + "baseName": "decodableVersions", + "type": "Array", + "format": "" + }, + { + "name": "encodingVersion", + "baseName": "encodingVersion", + "type": "string", + "format": "" + }, + { + "name": "servedVersions", + "baseName": "servedVersions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersion.js +var V1alpha1StorageVersion = class _V1alpha1StorageVersion { + static getAttributeTypeMap() { + return _V1alpha1StorageVersion.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersion.discriminator = void 0; +V1alpha1StorageVersion.mapping = void 0; +V1alpha1StorageVersion.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "any", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1alpha1StorageVersionStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionCondition.js +var V1alpha1StorageVersionCondition = class _V1alpha1StorageVersionCondition { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionCondition.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionCondition.discriminator = void 0; +V1alpha1StorageVersionCondition.mapping = void 0; +V1alpha1StorageVersionCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionList.js +var V1alpha1StorageVersionList = class _V1alpha1StorageVersionList { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionList.discriminator = void 0; +V1alpha1StorageVersionList.mapping = void 0; +V1alpha1StorageVersionList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionMigration.js +var V1alpha1StorageVersionMigration = class _V1alpha1StorageVersionMigration { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionMigration.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionMigration.discriminator = void 0; +V1alpha1StorageVersionMigration.mapping = void 0; +V1alpha1StorageVersionMigration.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha1StorageVersionMigrationSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1alpha1StorageVersionMigrationStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionMigrationList.js +var V1alpha1StorageVersionMigrationList = class _V1alpha1StorageVersionMigrationList { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionMigrationList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionMigrationList.discriminator = void 0; +V1alpha1StorageVersionMigrationList.mapping = void 0; +V1alpha1StorageVersionMigrationList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionMigrationSpec.js +var V1alpha1StorageVersionMigrationSpec = class _V1alpha1StorageVersionMigrationSpec { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionMigrationSpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionMigrationSpec.discriminator = void 0; +V1alpha1StorageVersionMigrationSpec.mapping = void 0; +V1alpha1StorageVersionMigrationSpec.attributeTypeMap = [ + { + "name": "continueToken", + "baseName": "continueToken", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "V1alpha1GroupVersionResource", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionMigrationStatus.js +var V1alpha1StorageVersionMigrationStatus = class _V1alpha1StorageVersionMigrationStatus { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionMigrationStatus.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionMigrationStatus.discriminator = void 0; +V1alpha1StorageVersionMigrationStatus.mapping = void 0; +V1alpha1StorageVersionMigrationStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "resourceVersion", + "baseName": "resourceVersion", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1StorageVersionStatus.js +var V1alpha1StorageVersionStatus = class _V1alpha1StorageVersionStatus { + static getAttributeTypeMap() { + return _V1alpha1StorageVersionStatus.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1StorageVersionStatus.discriminator = void 0; +V1alpha1StorageVersionStatus.mapping = void 0; +V1alpha1StorageVersionStatus.attributeTypeMap = [ + { + "name": "commonEncodingVersion", + "baseName": "commonEncodingVersion", + "type": "string", + "format": "" + }, + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "storageVersions", + "baseName": "storageVersions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1Variable.js +var V1alpha1Variable = class _V1alpha1Variable { + static getAttributeTypeMap() { + return _V1alpha1Variable.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1Variable.discriminator = void 0; +V1alpha1Variable.mapping = void 0; +V1alpha1Variable.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1VolumeAttributesClass.js +var V1alpha1VolumeAttributesClass = class _V1alpha1VolumeAttributesClass { + static getAttributeTypeMap() { + return _V1alpha1VolumeAttributesClass.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1VolumeAttributesClass.discriminator = void 0; +V1alpha1VolumeAttributesClass.mapping = void 0; +V1alpha1VolumeAttributesClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "driverName", + "baseName": "driverName", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha1VolumeAttributesClassList.js +var V1alpha1VolumeAttributesClassList = class _V1alpha1VolumeAttributesClassList { + static getAttributeTypeMap() { + return _V1alpha1VolumeAttributesClassList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha1VolumeAttributesClassList.discriminator = void 0; +V1alpha1VolumeAttributesClassList.mapping = void 0; +V1alpha1VolumeAttributesClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha2LeaseCandidate.js +var V1alpha2LeaseCandidate = class _V1alpha2LeaseCandidate { + static getAttributeTypeMap() { + return _V1alpha2LeaseCandidate.attributeTypeMap; + } + constructor() { + } +}; +V1alpha2LeaseCandidate.discriminator = void 0; +V1alpha2LeaseCandidate.mapping = void 0; +V1alpha2LeaseCandidate.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha2LeaseCandidateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha2LeaseCandidateList.js +var V1alpha2LeaseCandidateList = class _V1alpha2LeaseCandidateList { + static getAttributeTypeMap() { + return _V1alpha2LeaseCandidateList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha2LeaseCandidateList.discriminator = void 0; +V1alpha2LeaseCandidateList.mapping = void 0; +V1alpha2LeaseCandidateList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha2LeaseCandidateSpec.js +var V1alpha2LeaseCandidateSpec = class _V1alpha2LeaseCandidateSpec { + static getAttributeTypeMap() { + return _V1alpha2LeaseCandidateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha2LeaseCandidateSpec.discriminator = void 0; +V1alpha2LeaseCandidateSpec.mapping = void 0; +V1alpha2LeaseCandidateSpec.attributeTypeMap = [ + { + "name": "binaryVersion", + "baseName": "binaryVersion", + "type": "string", + "format": "" + }, + { + "name": "emulationVersion", + "baseName": "emulationVersion", + "type": "string", + "format": "" + }, + { + "name": "leaseName", + "baseName": "leaseName", + "type": "string", + "format": "" + }, + { + "name": "pingTime", + "baseName": "pingTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "renewTime", + "baseName": "renewTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "strategy", + "baseName": "strategy", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3CELDeviceSelector.js +var V1alpha3CELDeviceSelector = class _V1alpha3CELDeviceSelector { + static getAttributeTypeMap() { + return _V1alpha3CELDeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3CELDeviceSelector.discriminator = void 0; +V1alpha3CELDeviceSelector.mapping = void 0; +V1alpha3CELDeviceSelector.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3DeviceSelector.js +var V1alpha3DeviceSelector = class _V1alpha3DeviceSelector { + static getAttributeTypeMap() { + return _V1alpha3DeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3DeviceSelector.discriminator = void 0; +V1alpha3DeviceSelector.mapping = void 0; +V1alpha3DeviceSelector.attributeTypeMap = [ + { + "name": "cel", + "baseName": "cel", + "type": "V1alpha3CELDeviceSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3DeviceTaint.js +var V1alpha3DeviceTaint = class _V1alpha3DeviceTaint { + static getAttributeTypeMap() { + return _V1alpha3DeviceTaint.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3DeviceTaint.discriminator = void 0; +V1alpha3DeviceTaint.mapping = void 0; +V1alpha3DeviceTaint.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "timeAdded", + "baseName": "timeAdded", + "type": "Date", + "format": "date-time" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3DeviceTaintRule.js +var V1alpha3DeviceTaintRule = class _V1alpha3DeviceTaintRule { + static getAttributeTypeMap() { + return _V1alpha3DeviceTaintRule.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3DeviceTaintRule.discriminator = void 0; +V1alpha3DeviceTaintRule.mapping = void 0; +V1alpha3DeviceTaintRule.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1alpha3DeviceTaintRuleSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3DeviceTaintRuleList.js +var V1alpha3DeviceTaintRuleList = class _V1alpha3DeviceTaintRuleList { + static getAttributeTypeMap() { + return _V1alpha3DeviceTaintRuleList.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3DeviceTaintRuleList.discriminator = void 0; +V1alpha3DeviceTaintRuleList.mapping = void 0; +V1alpha3DeviceTaintRuleList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3DeviceTaintRuleSpec.js +var V1alpha3DeviceTaintRuleSpec = class _V1alpha3DeviceTaintRuleSpec { + static getAttributeTypeMap() { + return _V1alpha3DeviceTaintRuleSpec.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3DeviceTaintRuleSpec.discriminator = void 0; +V1alpha3DeviceTaintRuleSpec.mapping = void 0; +V1alpha3DeviceTaintRuleSpec.attributeTypeMap = [ + { + "name": "deviceSelector", + "baseName": "deviceSelector", + "type": "V1alpha3DeviceTaintSelector", + "format": "" + }, + { + "name": "taint", + "baseName": "taint", + "type": "V1alpha3DeviceTaint", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1alpha3DeviceTaintSelector.js +var V1alpha3DeviceTaintSelector = class _V1alpha3DeviceTaintSelector { + static getAttributeTypeMap() { + return _V1alpha3DeviceTaintSelector.attributeTypeMap; + } + constructor() { + } +}; +V1alpha3DeviceTaintSelector.discriminator = void 0; +V1alpha3DeviceTaintSelector.mapping = void 0; +V1alpha3DeviceTaintSelector.attributeTypeMap = [ + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1AllocatedDeviceStatus.js +var V1beta1AllocatedDeviceStatus = class _V1beta1AllocatedDeviceStatus { + static getAttributeTypeMap() { + return _V1beta1AllocatedDeviceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1beta1AllocatedDeviceStatus.discriminator = void 0; +V1beta1AllocatedDeviceStatus.mapping = void 0; +V1beta1AllocatedDeviceStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "data", + "baseName": "data", + "type": "any", + "format": "" + }, + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "networkData", + "baseName": "networkData", + "type": "V1beta1NetworkDeviceData", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "shareID", + "baseName": "shareID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1AllocationResult.js +var V1beta1AllocationResult = class _V1beta1AllocationResult { + static getAttributeTypeMap() { + return _V1beta1AllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1beta1AllocationResult.discriminator = void 0; +V1beta1AllocationResult.mapping = void 0; +V1beta1AllocationResult.attributeTypeMap = [ + { + "name": "allocationTimestamp", + "baseName": "allocationTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "devices", + "baseName": "devices", + "type": "V1beta1DeviceAllocationResult", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ApplyConfiguration.js +var V1beta1ApplyConfiguration = class _V1beta1ApplyConfiguration { + static getAttributeTypeMap() { + return _V1beta1ApplyConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ApplyConfiguration.discriminator = void 0; +V1beta1ApplyConfiguration.mapping = void 0; +V1beta1ApplyConfiguration.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1BasicDevice.js +var V1beta1BasicDevice = class _V1beta1BasicDevice { + static getAttributeTypeMap() { + return _V1beta1BasicDevice.attributeTypeMap; + } + constructor() { + } +}; +V1beta1BasicDevice.discriminator = void 0; +V1beta1BasicDevice.mapping = void 0; +V1beta1BasicDevice.attributeTypeMap = [ + { + "name": "allNodes", + "baseName": "allNodes", + "type": "boolean", + "format": "" + }, + { + "name": "allowMultipleAllocations", + "baseName": "allowMultipleAllocations", + "type": "boolean", + "format": "" + }, + { + "name": "attributes", + "baseName": "attributes", + "type": "{ [key: string]: V1beta1DeviceAttribute; }", + "format": "" + }, + { + "name": "bindingConditions", + "baseName": "bindingConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindingFailureConditions", + "baseName": "bindingFailureConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindsToNode", + "baseName": "bindsToNode", + "type": "boolean", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "{ [key: string]: V1beta1DeviceCapacity; }", + "format": "" + }, + { + "name": "consumesCounters", + "baseName": "consumesCounters", + "type": "Array", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + }, + { + "name": "taints", + "baseName": "taints", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1CELDeviceSelector.js +var V1beta1CELDeviceSelector = class _V1beta1CELDeviceSelector { + static getAttributeTypeMap() { + return _V1beta1CELDeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1beta1CELDeviceSelector.discriminator = void 0; +V1beta1CELDeviceSelector.mapping = void 0; +V1beta1CELDeviceSelector.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1CapacityRequestPolicy.js +var V1beta1CapacityRequestPolicy = class _V1beta1CapacityRequestPolicy { + static getAttributeTypeMap() { + return _V1beta1CapacityRequestPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1beta1CapacityRequestPolicy.discriminator = void 0; +V1beta1CapacityRequestPolicy.mapping = void 0; +V1beta1CapacityRequestPolicy.attributeTypeMap = [ + { + "name": "_default", + "baseName": "default", + "type": "string", + "format": "" + }, + { + "name": "validRange", + "baseName": "validRange", + "type": "V1beta1CapacityRequestPolicyRange", + "format": "" + }, + { + "name": "validValues", + "baseName": "validValues", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1CapacityRequestPolicyRange.js +var V1beta1CapacityRequestPolicyRange = class _V1beta1CapacityRequestPolicyRange { + static getAttributeTypeMap() { + return _V1beta1CapacityRequestPolicyRange.attributeTypeMap; + } + constructor() { + } +}; +V1beta1CapacityRequestPolicyRange.discriminator = void 0; +V1beta1CapacityRequestPolicyRange.mapping = void 0; +V1beta1CapacityRequestPolicyRange.attributeTypeMap = [ + { + "name": "max", + "baseName": "max", + "type": "string", + "format": "" + }, + { + "name": "min", + "baseName": "min", + "type": "string", + "format": "" + }, + { + "name": "step", + "baseName": "step", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1CapacityRequirements.js +var V1beta1CapacityRequirements = class _V1beta1CapacityRequirements { + static getAttributeTypeMap() { + return _V1beta1CapacityRequirements.attributeTypeMap; + } + constructor() { + } +}; +V1beta1CapacityRequirements.discriminator = void 0; +V1beta1CapacityRequirements.mapping = void 0; +V1beta1CapacityRequirements.attributeTypeMap = [ + { + "name": "requests", + "baseName": "requests", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ClusterTrustBundle.js +var V1beta1ClusterTrustBundle = class _V1beta1ClusterTrustBundle { + static getAttributeTypeMap() { + return _V1beta1ClusterTrustBundle.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ClusterTrustBundle.discriminator = void 0; +V1beta1ClusterTrustBundle.mapping = void 0; +V1beta1ClusterTrustBundle.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1ClusterTrustBundleSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ClusterTrustBundleList.js +var V1beta1ClusterTrustBundleList = class _V1beta1ClusterTrustBundleList { + static getAttributeTypeMap() { + return _V1beta1ClusterTrustBundleList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ClusterTrustBundleList.discriminator = void 0; +V1beta1ClusterTrustBundleList.mapping = void 0; +V1beta1ClusterTrustBundleList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ClusterTrustBundleSpec.js +var V1beta1ClusterTrustBundleSpec = class _V1beta1ClusterTrustBundleSpec { + static getAttributeTypeMap() { + return _V1beta1ClusterTrustBundleSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ClusterTrustBundleSpec.discriminator = void 0; +V1beta1ClusterTrustBundleSpec.mapping = void 0; +V1beta1ClusterTrustBundleSpec.attributeTypeMap = [ + { + "name": "signerName", + "baseName": "signerName", + "type": "string", + "format": "" + }, + { + "name": "trustBundle", + "baseName": "trustBundle", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1Counter.js +var V1beta1Counter = class _V1beta1Counter { + static getAttributeTypeMap() { + return _V1beta1Counter.attributeTypeMap; + } + constructor() { + } +}; +V1beta1Counter.discriminator = void 0; +V1beta1Counter.mapping = void 0; +V1beta1Counter.attributeTypeMap = [ + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1CounterSet.js +var V1beta1CounterSet = class _V1beta1CounterSet { + static getAttributeTypeMap() { + return _V1beta1CounterSet.attributeTypeMap; + } + constructor() { + } +}; +V1beta1CounterSet.discriminator = void 0; +V1beta1CounterSet.mapping = void 0; +V1beta1CounterSet.attributeTypeMap = [ + { + "name": "counters", + "baseName": "counters", + "type": "{ [key: string]: V1beta1Counter; }", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1Device.js +var V1beta1Device = class _V1beta1Device { + static getAttributeTypeMap() { + return _V1beta1Device.attributeTypeMap; + } + constructor() { + } +}; +V1beta1Device.discriminator = void 0; +V1beta1Device.mapping = void 0; +V1beta1Device.attributeTypeMap = [ + { + "name": "basic", + "baseName": "basic", + "type": "V1beta1BasicDevice", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceAllocationConfiguration.js +var V1beta1DeviceAllocationConfiguration = class _V1beta1DeviceAllocationConfiguration { + static getAttributeTypeMap() { + return _V1beta1DeviceAllocationConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceAllocationConfiguration.discriminator = void 0; +V1beta1DeviceAllocationConfiguration.mapping = void 0; +V1beta1DeviceAllocationConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1beta1OpaqueDeviceConfiguration", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + }, + { + "name": "source", + "baseName": "source", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceAllocationResult.js +var V1beta1DeviceAllocationResult = class _V1beta1DeviceAllocationResult { + static getAttributeTypeMap() { + return _V1beta1DeviceAllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceAllocationResult.discriminator = void 0; +V1beta1DeviceAllocationResult.mapping = void 0; +V1beta1DeviceAllocationResult.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "results", + "baseName": "results", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceAttribute.js +var V1beta1DeviceAttribute = class _V1beta1DeviceAttribute { + static getAttributeTypeMap() { + return _V1beta1DeviceAttribute.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceAttribute.discriminator = void 0; +V1beta1DeviceAttribute.mapping = void 0; +V1beta1DeviceAttribute.attributeTypeMap = [ + { + "name": "bool", + "baseName": "bool", + "type": "boolean", + "format": "" + }, + { + "name": "_int", + "baseName": "int", + "type": "number", + "format": "int64" + }, + { + "name": "string", + "baseName": "string", + "type": "string", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceCapacity.js +var V1beta1DeviceCapacity = class _V1beta1DeviceCapacity { + static getAttributeTypeMap() { + return _V1beta1DeviceCapacity.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceCapacity.discriminator = void 0; +V1beta1DeviceCapacity.mapping = void 0; +V1beta1DeviceCapacity.attributeTypeMap = [ + { + "name": "requestPolicy", + "baseName": "requestPolicy", + "type": "V1beta1CapacityRequestPolicy", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceClaim.js +var V1beta1DeviceClaim = class _V1beta1DeviceClaim { + static getAttributeTypeMap() { + return _V1beta1DeviceClaim.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceClaim.discriminator = void 0; +V1beta1DeviceClaim.mapping = void 0; +V1beta1DeviceClaim.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "constraints", + "baseName": "constraints", + "type": "Array", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceClaimConfiguration.js +var V1beta1DeviceClaimConfiguration = class _V1beta1DeviceClaimConfiguration { + static getAttributeTypeMap() { + return _V1beta1DeviceClaimConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceClaimConfiguration.discriminator = void 0; +V1beta1DeviceClaimConfiguration.mapping = void 0; +V1beta1DeviceClaimConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1beta1OpaqueDeviceConfiguration", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceClass.js +var V1beta1DeviceClass = class _V1beta1DeviceClass { + static getAttributeTypeMap() { + return _V1beta1DeviceClass.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceClass.discriminator = void 0; +V1beta1DeviceClass.mapping = void 0; +V1beta1DeviceClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1DeviceClassSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceClassConfiguration.js +var V1beta1DeviceClassConfiguration = class _V1beta1DeviceClassConfiguration { + static getAttributeTypeMap() { + return _V1beta1DeviceClassConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceClassConfiguration.discriminator = void 0; +V1beta1DeviceClassConfiguration.mapping = void 0; +V1beta1DeviceClassConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1beta1OpaqueDeviceConfiguration", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceClassList.js +var V1beta1DeviceClassList = class _V1beta1DeviceClassList { + static getAttributeTypeMap() { + return _V1beta1DeviceClassList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceClassList.discriminator = void 0; +V1beta1DeviceClassList.mapping = void 0; +V1beta1DeviceClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceClassSpec.js +var V1beta1DeviceClassSpec = class _V1beta1DeviceClassSpec { + static getAttributeTypeMap() { + return _V1beta1DeviceClassSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceClassSpec.discriminator = void 0; +V1beta1DeviceClassSpec.mapping = void 0; +V1beta1DeviceClassSpec.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "extendedResourceName", + "baseName": "extendedResourceName", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceConstraint.js +var V1beta1DeviceConstraint = class _V1beta1DeviceConstraint { + static getAttributeTypeMap() { + return _V1beta1DeviceConstraint.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceConstraint.discriminator = void 0; +V1beta1DeviceConstraint.mapping = void 0; +V1beta1DeviceConstraint.attributeTypeMap = [ + { + "name": "distinctAttribute", + "baseName": "distinctAttribute", + "type": "string", + "format": "" + }, + { + "name": "matchAttribute", + "baseName": "matchAttribute", + "type": "string", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceCounterConsumption.js +var V1beta1DeviceCounterConsumption = class _V1beta1DeviceCounterConsumption { + static getAttributeTypeMap() { + return _V1beta1DeviceCounterConsumption.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceCounterConsumption.discriminator = void 0; +V1beta1DeviceCounterConsumption.mapping = void 0; +V1beta1DeviceCounterConsumption.attributeTypeMap = [ + { + "name": "counterSet", + "baseName": "counterSet", + "type": "string", + "format": "" + }, + { + "name": "counters", + "baseName": "counters", + "type": "{ [key: string]: V1beta1Counter; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceRequest.js +var V1beta1DeviceRequest = class _V1beta1DeviceRequest { + static getAttributeTypeMap() { + return _V1beta1DeviceRequest.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceRequest.discriminator = void 0; +V1beta1DeviceRequest.mapping = void 0; +V1beta1DeviceRequest.attributeTypeMap = [ + { + "name": "adminAccess", + "baseName": "adminAccess", + "type": "boolean", + "format": "" + }, + { + "name": "allocationMode", + "baseName": "allocationMode", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "V1beta1CapacityRequirements", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int64" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "firstAvailable", + "baseName": "firstAvailable", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceRequestAllocationResult.js +var V1beta1DeviceRequestAllocationResult = class _V1beta1DeviceRequestAllocationResult { + static getAttributeTypeMap() { + return _V1beta1DeviceRequestAllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceRequestAllocationResult.discriminator = void 0; +V1beta1DeviceRequestAllocationResult.mapping = void 0; +V1beta1DeviceRequestAllocationResult.attributeTypeMap = [ + { + "name": "adminAccess", + "baseName": "adminAccess", + "type": "boolean", + "format": "" + }, + { + "name": "bindingConditions", + "baseName": "bindingConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindingFailureConditions", + "baseName": "bindingFailureConditions", + "type": "Array", + "format": "" + }, + { + "name": "consumedCapacity", + "baseName": "consumedCapacity", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "request", + "baseName": "request", + "type": "string", + "format": "" + }, + { + "name": "shareID", + "baseName": "shareID", + "type": "string", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceSelector.js +var V1beta1DeviceSelector = class _V1beta1DeviceSelector { + static getAttributeTypeMap() { + return _V1beta1DeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceSelector.discriminator = void 0; +V1beta1DeviceSelector.mapping = void 0; +V1beta1DeviceSelector.attributeTypeMap = [ + { + "name": "cel", + "baseName": "cel", + "type": "V1beta1CELDeviceSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceSubRequest.js +var V1beta1DeviceSubRequest = class _V1beta1DeviceSubRequest { + static getAttributeTypeMap() { + return _V1beta1DeviceSubRequest.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceSubRequest.discriminator = void 0; +V1beta1DeviceSubRequest.mapping = void 0; +V1beta1DeviceSubRequest.attributeTypeMap = [ + { + "name": "allocationMode", + "baseName": "allocationMode", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "V1beta1CapacityRequirements", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int64" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceTaint.js +var V1beta1DeviceTaint = class _V1beta1DeviceTaint { + static getAttributeTypeMap() { + return _V1beta1DeviceTaint.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceTaint.discriminator = void 0; +V1beta1DeviceTaint.mapping = void 0; +V1beta1DeviceTaint.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "timeAdded", + "baseName": "timeAdded", + "type": "Date", + "format": "date-time" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1DeviceToleration.js +var V1beta1DeviceToleration = class _V1beta1DeviceToleration { + static getAttributeTypeMap() { + return _V1beta1DeviceToleration.attributeTypeMap; + } + constructor() { + } +}; +V1beta1DeviceToleration.discriminator = void 0; +V1beta1DeviceToleration.mapping = void 0; +V1beta1DeviceToleration.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "tolerationSeconds", + "baseName": "tolerationSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1IPAddress.js +var V1beta1IPAddress = class _V1beta1IPAddress { + static getAttributeTypeMap() { + return _V1beta1IPAddress.attributeTypeMap; + } + constructor() { + } +}; +V1beta1IPAddress.discriminator = void 0; +V1beta1IPAddress.mapping = void 0; +V1beta1IPAddress.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1IPAddressSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1IPAddressList.js +var V1beta1IPAddressList = class _V1beta1IPAddressList { + static getAttributeTypeMap() { + return _V1beta1IPAddressList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1IPAddressList.discriminator = void 0; +V1beta1IPAddressList.mapping = void 0; +V1beta1IPAddressList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1IPAddressSpec.js +var V1beta1IPAddressSpec = class _V1beta1IPAddressSpec { + static getAttributeTypeMap() { + return _V1beta1IPAddressSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1IPAddressSpec.discriminator = void 0; +V1beta1IPAddressSpec.mapping = void 0; +V1beta1IPAddressSpec.attributeTypeMap = [ + { + "name": "parentRef", + "baseName": "parentRef", + "type": "V1beta1ParentReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1JSONPatch.js +var V1beta1JSONPatch = class _V1beta1JSONPatch { + static getAttributeTypeMap() { + return _V1beta1JSONPatch.attributeTypeMap; + } + constructor() { + } +}; +V1beta1JSONPatch.discriminator = void 0; +V1beta1JSONPatch.mapping = void 0; +V1beta1JSONPatch.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1LeaseCandidate.js +var V1beta1LeaseCandidate = class _V1beta1LeaseCandidate { + static getAttributeTypeMap() { + return _V1beta1LeaseCandidate.attributeTypeMap; + } + constructor() { + } +}; +V1beta1LeaseCandidate.discriminator = void 0; +V1beta1LeaseCandidate.mapping = void 0; +V1beta1LeaseCandidate.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1LeaseCandidateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1LeaseCandidateList.js +var V1beta1LeaseCandidateList = class _V1beta1LeaseCandidateList { + static getAttributeTypeMap() { + return _V1beta1LeaseCandidateList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1LeaseCandidateList.discriminator = void 0; +V1beta1LeaseCandidateList.mapping = void 0; +V1beta1LeaseCandidateList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1LeaseCandidateSpec.js +var V1beta1LeaseCandidateSpec = class _V1beta1LeaseCandidateSpec { + static getAttributeTypeMap() { + return _V1beta1LeaseCandidateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1LeaseCandidateSpec.discriminator = void 0; +V1beta1LeaseCandidateSpec.mapping = void 0; +V1beta1LeaseCandidateSpec.attributeTypeMap = [ + { + "name": "binaryVersion", + "baseName": "binaryVersion", + "type": "string", + "format": "" + }, + { + "name": "emulationVersion", + "baseName": "emulationVersion", + "type": "string", + "format": "" + }, + { + "name": "leaseName", + "baseName": "leaseName", + "type": "string", + "format": "" + }, + { + "name": "pingTime", + "baseName": "pingTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "renewTime", + "baseName": "renewTime", + "type": "V1MicroTime", + "format": "date-time-micro" + }, + { + "name": "strategy", + "baseName": "strategy", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MatchCondition.js +var V1beta1MatchCondition = class _V1beta1MatchCondition { + static getAttributeTypeMap() { + return _V1beta1MatchCondition.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MatchCondition.discriminator = void 0; +V1beta1MatchCondition.mapping = void 0; +V1beta1MatchCondition.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MatchResources.js +var V1beta1MatchResources = class _V1beta1MatchResources { + static getAttributeTypeMap() { + return _V1beta1MatchResources.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MatchResources.discriminator = void 0; +V1beta1MatchResources.mapping = void 0; +V1beta1MatchResources.attributeTypeMap = [ + { + "name": "excludeResourceRules", + "baseName": "excludeResourceRules", + "type": "Array", + "format": "" + }, + { + "name": "matchPolicy", + "baseName": "matchPolicy", + "type": "string", + "format": "" + }, + { + "name": "namespaceSelector", + "baseName": "namespaceSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "objectSelector", + "baseName": "objectSelector", + "type": "V1LabelSelector", + "format": "" + }, + { + "name": "resourceRules", + "baseName": "resourceRules", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MutatingAdmissionPolicy.js +var V1beta1MutatingAdmissionPolicy = class _V1beta1MutatingAdmissionPolicy { + static getAttributeTypeMap() { + return _V1beta1MutatingAdmissionPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MutatingAdmissionPolicy.discriminator = void 0; +V1beta1MutatingAdmissionPolicy.mapping = void 0; +V1beta1MutatingAdmissionPolicy.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1MutatingAdmissionPolicySpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MutatingAdmissionPolicyBinding.js +var V1beta1MutatingAdmissionPolicyBinding = class _V1beta1MutatingAdmissionPolicyBinding { + static getAttributeTypeMap() { + return _V1beta1MutatingAdmissionPolicyBinding.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MutatingAdmissionPolicyBinding.discriminator = void 0; +V1beta1MutatingAdmissionPolicyBinding.mapping = void 0; +V1beta1MutatingAdmissionPolicyBinding.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1MutatingAdmissionPolicyBindingSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MutatingAdmissionPolicyBindingList.js +var V1beta1MutatingAdmissionPolicyBindingList = class _V1beta1MutatingAdmissionPolicyBindingList { + static getAttributeTypeMap() { + return _V1beta1MutatingAdmissionPolicyBindingList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MutatingAdmissionPolicyBindingList.discriminator = void 0; +V1beta1MutatingAdmissionPolicyBindingList.mapping = void 0; +V1beta1MutatingAdmissionPolicyBindingList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MutatingAdmissionPolicyBindingSpec.js +var V1beta1MutatingAdmissionPolicyBindingSpec = class _V1beta1MutatingAdmissionPolicyBindingSpec { + static getAttributeTypeMap() { + return _V1beta1MutatingAdmissionPolicyBindingSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MutatingAdmissionPolicyBindingSpec.discriminator = void 0; +V1beta1MutatingAdmissionPolicyBindingSpec.mapping = void 0; +V1beta1MutatingAdmissionPolicyBindingSpec.attributeTypeMap = [ + { + "name": "matchResources", + "baseName": "matchResources", + "type": "V1beta1MatchResources", + "format": "" + }, + { + "name": "paramRef", + "baseName": "paramRef", + "type": "V1beta1ParamRef", + "format": "" + }, + { + "name": "policyName", + "baseName": "policyName", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MutatingAdmissionPolicyList.js +var V1beta1MutatingAdmissionPolicyList = class _V1beta1MutatingAdmissionPolicyList { + static getAttributeTypeMap() { + return _V1beta1MutatingAdmissionPolicyList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MutatingAdmissionPolicyList.discriminator = void 0; +V1beta1MutatingAdmissionPolicyList.mapping = void 0; +V1beta1MutatingAdmissionPolicyList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1MutatingAdmissionPolicySpec.js +var V1beta1MutatingAdmissionPolicySpec = class _V1beta1MutatingAdmissionPolicySpec { + static getAttributeTypeMap() { + return _V1beta1MutatingAdmissionPolicySpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1MutatingAdmissionPolicySpec.discriminator = void 0; +V1beta1MutatingAdmissionPolicySpec.mapping = void 0; +V1beta1MutatingAdmissionPolicySpec.attributeTypeMap = [ + { + "name": "failurePolicy", + "baseName": "failurePolicy", + "type": "string", + "format": "" + }, + { + "name": "matchConditions", + "baseName": "matchConditions", + "type": "Array", + "format": "" + }, + { + "name": "matchConstraints", + "baseName": "matchConstraints", + "type": "V1beta1MatchResources", + "format": "" + }, + { + "name": "mutations", + "baseName": "mutations", + "type": "Array", + "format": "" + }, + { + "name": "paramKind", + "baseName": "paramKind", + "type": "V1beta1ParamKind", + "format": "" + }, + { + "name": "reinvocationPolicy", + "baseName": "reinvocationPolicy", + "type": "string", + "format": "" + }, + { + "name": "variables", + "baseName": "variables", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1Mutation.js +var V1beta1Mutation = class _V1beta1Mutation { + static getAttributeTypeMap() { + return _V1beta1Mutation.attributeTypeMap; + } + constructor() { + } +}; +V1beta1Mutation.discriminator = void 0; +V1beta1Mutation.mapping = void 0; +V1beta1Mutation.attributeTypeMap = [ + { + "name": "applyConfiguration", + "baseName": "applyConfiguration", + "type": "V1beta1ApplyConfiguration", + "format": "" + }, + { + "name": "jsonPatch", + "baseName": "jsonPatch", + "type": "V1beta1JSONPatch", + "format": "" + }, + { + "name": "patchType", + "baseName": "patchType", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1NamedRuleWithOperations.js +var V1beta1NamedRuleWithOperations = class _V1beta1NamedRuleWithOperations { + static getAttributeTypeMap() { + return _V1beta1NamedRuleWithOperations.attributeTypeMap; + } + constructor() { + } +}; +V1beta1NamedRuleWithOperations.discriminator = void 0; +V1beta1NamedRuleWithOperations.mapping = void 0; +V1beta1NamedRuleWithOperations.attributeTypeMap = [ + { + "name": "apiGroups", + "baseName": "apiGroups", + "type": "Array", + "format": "" + }, + { + "name": "apiVersions", + "baseName": "apiVersions", + "type": "Array", + "format": "" + }, + { + "name": "operations", + "baseName": "operations", + "type": "Array", + "format": "" + }, + { + "name": "resourceNames", + "baseName": "resourceNames", + "type": "Array", + "format": "" + }, + { + "name": "resources", + "baseName": "resources", + "type": "Array", + "format": "" + }, + { + "name": "scope", + "baseName": "scope", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1NetworkDeviceData.js +var V1beta1NetworkDeviceData = class _V1beta1NetworkDeviceData { + static getAttributeTypeMap() { + return _V1beta1NetworkDeviceData.attributeTypeMap; + } + constructor() { + } +}; +V1beta1NetworkDeviceData.discriminator = void 0; +V1beta1NetworkDeviceData.mapping = void 0; +V1beta1NetworkDeviceData.attributeTypeMap = [ + { + "name": "hardwareAddress", + "baseName": "hardwareAddress", + "type": "string", + "format": "" + }, + { + "name": "interfaceName", + "baseName": "interfaceName", + "type": "string", + "format": "" + }, + { + "name": "ips", + "baseName": "ips", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1OpaqueDeviceConfiguration.js +var V1beta1OpaqueDeviceConfiguration = class _V1beta1OpaqueDeviceConfiguration { + static getAttributeTypeMap() { + return _V1beta1OpaqueDeviceConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta1OpaqueDeviceConfiguration.discriminator = void 0; +V1beta1OpaqueDeviceConfiguration.mapping = void 0; +V1beta1OpaqueDeviceConfiguration.attributeTypeMap = [ + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "any", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ParamKind.js +var V1beta1ParamKind = class _V1beta1ParamKind { + static getAttributeTypeMap() { + return _V1beta1ParamKind.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ParamKind.discriminator = void 0; +V1beta1ParamKind.mapping = void 0; +V1beta1ParamKind.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ParamRef.js +var V1beta1ParamRef = class _V1beta1ParamRef { + static getAttributeTypeMap() { + return _V1beta1ParamRef.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ParamRef.discriminator = void 0; +V1beta1ParamRef.mapping = void 0; +V1beta1ParamRef.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "parameterNotFoundAction", + "baseName": "parameterNotFoundAction", + "type": "string", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ParentReference.js +var V1beta1ParentReference = class _V1beta1ParentReference { + static getAttributeTypeMap() { + return _V1beta1ParentReference.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ParentReference.discriminator = void 0; +V1beta1ParentReference.mapping = void 0; +V1beta1ParentReference.attributeTypeMap = [ + { + "name": "group", + "baseName": "group", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "namespace", + "baseName": "namespace", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaim.js +var V1beta1ResourceClaim = class _V1beta1ResourceClaim { + static getAttributeTypeMap() { + return _V1beta1ResourceClaim.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaim.discriminator = void 0; +V1beta1ResourceClaim.mapping = void 0; +V1beta1ResourceClaim.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1ResourceClaimSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1beta1ResourceClaimStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimConsumerReference.js +var V1beta1ResourceClaimConsumerReference = class _V1beta1ResourceClaimConsumerReference { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimConsumerReference.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimConsumerReference.discriminator = void 0; +V1beta1ResourceClaimConsumerReference.mapping = void 0; +V1beta1ResourceClaimConsumerReference.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimList.js +var V1beta1ResourceClaimList = class _V1beta1ResourceClaimList { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimList.discriminator = void 0; +V1beta1ResourceClaimList.mapping = void 0; +V1beta1ResourceClaimList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimSpec.js +var V1beta1ResourceClaimSpec = class _V1beta1ResourceClaimSpec { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimSpec.discriminator = void 0; +V1beta1ResourceClaimSpec.mapping = void 0; +V1beta1ResourceClaimSpec.attributeTypeMap = [ + { + "name": "devices", + "baseName": "devices", + "type": "V1beta1DeviceClaim", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimStatus.js +var V1beta1ResourceClaimStatus = class _V1beta1ResourceClaimStatus { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimStatus.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimStatus.discriminator = void 0; +V1beta1ResourceClaimStatus.mapping = void 0; +V1beta1ResourceClaimStatus.attributeTypeMap = [ + { + "name": "allocation", + "baseName": "allocation", + "type": "V1beta1AllocationResult", + "format": "" + }, + { + "name": "devices", + "baseName": "devices", + "type": "Array", + "format": "" + }, + { + "name": "reservedFor", + "baseName": "reservedFor", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimTemplate.js +var V1beta1ResourceClaimTemplate = class _V1beta1ResourceClaimTemplate { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimTemplate.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimTemplate.discriminator = void 0; +V1beta1ResourceClaimTemplate.mapping = void 0; +V1beta1ResourceClaimTemplate.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1ResourceClaimTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimTemplateList.js +var V1beta1ResourceClaimTemplateList = class _V1beta1ResourceClaimTemplateList { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimTemplateList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimTemplateList.discriminator = void 0; +V1beta1ResourceClaimTemplateList.mapping = void 0; +V1beta1ResourceClaimTemplateList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceClaimTemplateSpec.js +var V1beta1ResourceClaimTemplateSpec = class _V1beta1ResourceClaimTemplateSpec { + static getAttributeTypeMap() { + return _V1beta1ResourceClaimTemplateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceClaimTemplateSpec.discriminator = void 0; +V1beta1ResourceClaimTemplateSpec.mapping = void 0; +V1beta1ResourceClaimTemplateSpec.attributeTypeMap = [ + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1ResourceClaimSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourcePool.js +var V1beta1ResourcePool = class _V1beta1ResourcePool { + static getAttributeTypeMap() { + return _V1beta1ResourcePool.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourcePool.discriminator = void 0; +V1beta1ResourcePool.mapping = void 0; +V1beta1ResourcePool.attributeTypeMap = [ + { + "name": "generation", + "baseName": "generation", + "type": "number", + "format": "int64" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resourceSliceCount", + "baseName": "resourceSliceCount", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceSlice.js +var V1beta1ResourceSlice = class _V1beta1ResourceSlice { + static getAttributeTypeMap() { + return _V1beta1ResourceSlice.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceSlice.discriminator = void 0; +V1beta1ResourceSlice.mapping = void 0; +V1beta1ResourceSlice.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1ResourceSliceSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceSliceList.js +var V1beta1ResourceSliceList = class _V1beta1ResourceSliceList { + static getAttributeTypeMap() { + return _V1beta1ResourceSliceList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceSliceList.discriminator = void 0; +V1beta1ResourceSliceList.mapping = void 0; +V1beta1ResourceSliceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ResourceSliceSpec.js +var V1beta1ResourceSliceSpec = class _V1beta1ResourceSliceSpec { + static getAttributeTypeMap() { + return _V1beta1ResourceSliceSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ResourceSliceSpec.discriminator = void 0; +V1beta1ResourceSliceSpec.mapping = void 0; +V1beta1ResourceSliceSpec.attributeTypeMap = [ + { + "name": "allNodes", + "baseName": "allNodes", + "type": "boolean", + "format": "" + }, + { + "name": "devices", + "baseName": "devices", + "type": "Array", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + }, + { + "name": "perDeviceNodeSelection", + "baseName": "perDeviceNodeSelection", + "type": "boolean", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "V1beta1ResourcePool", + "format": "" + }, + { + "name": "sharedCounters", + "baseName": "sharedCounters", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ServiceCIDR.js +var V1beta1ServiceCIDR = class _V1beta1ServiceCIDR { + static getAttributeTypeMap() { + return _V1beta1ServiceCIDR.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ServiceCIDR.discriminator = void 0; +V1beta1ServiceCIDR.mapping = void 0; +V1beta1ServiceCIDR.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta1ServiceCIDRSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1beta1ServiceCIDRStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ServiceCIDRList.js +var V1beta1ServiceCIDRList = class _V1beta1ServiceCIDRList { + static getAttributeTypeMap() { + return _V1beta1ServiceCIDRList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ServiceCIDRList.discriminator = void 0; +V1beta1ServiceCIDRList.mapping = void 0; +V1beta1ServiceCIDRList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ServiceCIDRSpec.js +var V1beta1ServiceCIDRSpec = class _V1beta1ServiceCIDRSpec { + static getAttributeTypeMap() { + return _V1beta1ServiceCIDRSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ServiceCIDRSpec.discriminator = void 0; +V1beta1ServiceCIDRSpec.mapping = void 0; +V1beta1ServiceCIDRSpec.attributeTypeMap = [ + { + "name": "cidrs", + "baseName": "cidrs", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1ServiceCIDRStatus.js +var V1beta1ServiceCIDRStatus = class _V1beta1ServiceCIDRStatus { + static getAttributeTypeMap() { + return _V1beta1ServiceCIDRStatus.attributeTypeMap; + } + constructor() { + } +}; +V1beta1ServiceCIDRStatus.discriminator = void 0; +V1beta1ServiceCIDRStatus.mapping = void 0; +V1beta1ServiceCIDRStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1Variable.js +var V1beta1Variable = class _V1beta1Variable { + static getAttributeTypeMap() { + return _V1beta1Variable.attributeTypeMap; + } + constructor() { + } +}; +V1beta1Variable.discriminator = void 0; +V1beta1Variable.mapping = void 0; +V1beta1Variable.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1VolumeAttributesClass.js +var V1beta1VolumeAttributesClass = class _V1beta1VolumeAttributesClass { + static getAttributeTypeMap() { + return _V1beta1VolumeAttributesClass.attributeTypeMap; + } + constructor() { + } +}; +V1beta1VolumeAttributesClass.discriminator = void 0; +V1beta1VolumeAttributesClass.mapping = void 0; +V1beta1VolumeAttributesClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "driverName", + "baseName": "driverName", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta1VolumeAttributesClassList.js +var V1beta1VolumeAttributesClassList = class _V1beta1VolumeAttributesClassList { + static getAttributeTypeMap() { + return _V1beta1VolumeAttributesClassList.attributeTypeMap; + } + constructor() { + } +}; +V1beta1VolumeAttributesClassList.discriminator = void 0; +V1beta1VolumeAttributesClassList.mapping = void 0; +V1beta1VolumeAttributesClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2AllocatedDeviceStatus.js +var V1beta2AllocatedDeviceStatus = class _V1beta2AllocatedDeviceStatus { + static getAttributeTypeMap() { + return _V1beta2AllocatedDeviceStatus.attributeTypeMap; + } + constructor() { + } +}; +V1beta2AllocatedDeviceStatus.discriminator = void 0; +V1beta2AllocatedDeviceStatus.mapping = void 0; +V1beta2AllocatedDeviceStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "data", + "baseName": "data", + "type": "any", + "format": "" + }, + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "networkData", + "baseName": "networkData", + "type": "V1beta2NetworkDeviceData", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "shareID", + "baseName": "shareID", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2AllocationResult.js +var V1beta2AllocationResult = class _V1beta2AllocationResult { + static getAttributeTypeMap() { + return _V1beta2AllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1beta2AllocationResult.discriminator = void 0; +V1beta2AllocationResult.mapping = void 0; +V1beta2AllocationResult.attributeTypeMap = [ + { + "name": "allocationTimestamp", + "baseName": "allocationTimestamp", + "type": "Date", + "format": "date-time" + }, + { + "name": "devices", + "baseName": "devices", + "type": "V1beta2DeviceAllocationResult", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2CELDeviceSelector.js +var V1beta2CELDeviceSelector = class _V1beta2CELDeviceSelector { + static getAttributeTypeMap() { + return _V1beta2CELDeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1beta2CELDeviceSelector.discriminator = void 0; +V1beta2CELDeviceSelector.mapping = void 0; +V1beta2CELDeviceSelector.attributeTypeMap = [ + { + "name": "expression", + "baseName": "expression", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2CapacityRequestPolicy.js +var V1beta2CapacityRequestPolicy = class _V1beta2CapacityRequestPolicy { + static getAttributeTypeMap() { + return _V1beta2CapacityRequestPolicy.attributeTypeMap; + } + constructor() { + } +}; +V1beta2CapacityRequestPolicy.discriminator = void 0; +V1beta2CapacityRequestPolicy.mapping = void 0; +V1beta2CapacityRequestPolicy.attributeTypeMap = [ + { + "name": "_default", + "baseName": "default", + "type": "string", + "format": "" + }, + { + "name": "validRange", + "baseName": "validRange", + "type": "V1beta2CapacityRequestPolicyRange", + "format": "" + }, + { + "name": "validValues", + "baseName": "validValues", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2CapacityRequestPolicyRange.js +var V1beta2CapacityRequestPolicyRange = class _V1beta2CapacityRequestPolicyRange { + static getAttributeTypeMap() { + return _V1beta2CapacityRequestPolicyRange.attributeTypeMap; + } + constructor() { + } +}; +V1beta2CapacityRequestPolicyRange.discriminator = void 0; +V1beta2CapacityRequestPolicyRange.mapping = void 0; +V1beta2CapacityRequestPolicyRange.attributeTypeMap = [ + { + "name": "max", + "baseName": "max", + "type": "string", + "format": "" + }, + { + "name": "min", + "baseName": "min", + "type": "string", + "format": "" + }, + { + "name": "step", + "baseName": "step", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2CapacityRequirements.js +var V1beta2CapacityRequirements = class _V1beta2CapacityRequirements { + static getAttributeTypeMap() { + return _V1beta2CapacityRequirements.attributeTypeMap; + } + constructor() { + } +}; +V1beta2CapacityRequirements.discriminator = void 0; +V1beta2CapacityRequirements.mapping = void 0; +V1beta2CapacityRequirements.attributeTypeMap = [ + { + "name": "requests", + "baseName": "requests", + "type": "{ [key: string]: string; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2Counter.js +var V1beta2Counter = class _V1beta2Counter { + static getAttributeTypeMap() { + return _V1beta2Counter.attributeTypeMap; + } + constructor() { + } +}; +V1beta2Counter.discriminator = void 0; +V1beta2Counter.mapping = void 0; +V1beta2Counter.attributeTypeMap = [ + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2CounterSet.js +var V1beta2CounterSet = class _V1beta2CounterSet { + static getAttributeTypeMap() { + return _V1beta2CounterSet.attributeTypeMap; + } + constructor() { + } +}; +V1beta2CounterSet.discriminator = void 0; +V1beta2CounterSet.mapping = void 0; +V1beta2CounterSet.attributeTypeMap = [ + { + "name": "counters", + "baseName": "counters", + "type": "{ [key: string]: V1beta2Counter; }", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2Device.js +var V1beta2Device = class _V1beta2Device { + static getAttributeTypeMap() { + return _V1beta2Device.attributeTypeMap; + } + constructor() { + } +}; +V1beta2Device.discriminator = void 0; +V1beta2Device.mapping = void 0; +V1beta2Device.attributeTypeMap = [ + { + "name": "allNodes", + "baseName": "allNodes", + "type": "boolean", + "format": "" + }, + { + "name": "allowMultipleAllocations", + "baseName": "allowMultipleAllocations", + "type": "boolean", + "format": "" + }, + { + "name": "attributes", + "baseName": "attributes", + "type": "{ [key: string]: V1beta2DeviceAttribute; }", + "format": "" + }, + { + "name": "bindingConditions", + "baseName": "bindingConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindingFailureConditions", + "baseName": "bindingFailureConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindsToNode", + "baseName": "bindsToNode", + "type": "boolean", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "{ [key: string]: V1beta2DeviceCapacity; }", + "format": "" + }, + { + "name": "consumesCounters", + "baseName": "consumesCounters", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + }, + { + "name": "taints", + "baseName": "taints", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceAllocationConfiguration.js +var V1beta2DeviceAllocationConfiguration = class _V1beta2DeviceAllocationConfiguration { + static getAttributeTypeMap() { + return _V1beta2DeviceAllocationConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceAllocationConfiguration.discriminator = void 0; +V1beta2DeviceAllocationConfiguration.mapping = void 0; +V1beta2DeviceAllocationConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1beta2OpaqueDeviceConfiguration", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + }, + { + "name": "source", + "baseName": "source", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceAllocationResult.js +var V1beta2DeviceAllocationResult = class _V1beta2DeviceAllocationResult { + static getAttributeTypeMap() { + return _V1beta2DeviceAllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceAllocationResult.discriminator = void 0; +V1beta2DeviceAllocationResult.mapping = void 0; +V1beta2DeviceAllocationResult.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "results", + "baseName": "results", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceAttribute.js +var V1beta2DeviceAttribute = class _V1beta2DeviceAttribute { + static getAttributeTypeMap() { + return _V1beta2DeviceAttribute.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceAttribute.discriminator = void 0; +V1beta2DeviceAttribute.mapping = void 0; +V1beta2DeviceAttribute.attributeTypeMap = [ + { + "name": "bool", + "baseName": "bool", + "type": "boolean", + "format": "" + }, + { + "name": "_int", + "baseName": "int", + "type": "number", + "format": "int64" + }, + { + "name": "string", + "baseName": "string", + "type": "string", + "format": "" + }, + { + "name": "version", + "baseName": "version", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceCapacity.js +var V1beta2DeviceCapacity = class _V1beta2DeviceCapacity { + static getAttributeTypeMap() { + return _V1beta2DeviceCapacity.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceCapacity.discriminator = void 0; +V1beta2DeviceCapacity.mapping = void 0; +V1beta2DeviceCapacity.attributeTypeMap = [ + { + "name": "requestPolicy", + "baseName": "requestPolicy", + "type": "V1beta2CapacityRequestPolicy", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceClaim.js +var V1beta2DeviceClaim = class _V1beta2DeviceClaim { + static getAttributeTypeMap() { + return _V1beta2DeviceClaim.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceClaim.discriminator = void 0; +V1beta2DeviceClaim.mapping = void 0; +V1beta2DeviceClaim.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "constraints", + "baseName": "constraints", + "type": "Array", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceClaimConfiguration.js +var V1beta2DeviceClaimConfiguration = class _V1beta2DeviceClaimConfiguration { + static getAttributeTypeMap() { + return _V1beta2DeviceClaimConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceClaimConfiguration.discriminator = void 0; +V1beta2DeviceClaimConfiguration.mapping = void 0; +V1beta2DeviceClaimConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1beta2OpaqueDeviceConfiguration", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceClass.js +var V1beta2DeviceClass = class _V1beta2DeviceClass { + static getAttributeTypeMap() { + return _V1beta2DeviceClass.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceClass.discriminator = void 0; +V1beta2DeviceClass.mapping = void 0; +V1beta2DeviceClass.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta2DeviceClassSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceClassConfiguration.js +var V1beta2DeviceClassConfiguration = class _V1beta2DeviceClassConfiguration { + static getAttributeTypeMap() { + return _V1beta2DeviceClassConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceClassConfiguration.discriminator = void 0; +V1beta2DeviceClassConfiguration.mapping = void 0; +V1beta2DeviceClassConfiguration.attributeTypeMap = [ + { + "name": "opaque", + "baseName": "opaque", + "type": "V1beta2OpaqueDeviceConfiguration", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceClassList.js +var V1beta2DeviceClassList = class _V1beta2DeviceClassList { + static getAttributeTypeMap() { + return _V1beta2DeviceClassList.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceClassList.discriminator = void 0; +V1beta2DeviceClassList.mapping = void 0; +V1beta2DeviceClassList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceClassSpec.js +var V1beta2DeviceClassSpec = class _V1beta2DeviceClassSpec { + static getAttributeTypeMap() { + return _V1beta2DeviceClassSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceClassSpec.discriminator = void 0; +V1beta2DeviceClassSpec.mapping = void 0; +V1beta2DeviceClassSpec.attributeTypeMap = [ + { + "name": "config", + "baseName": "config", + "type": "Array", + "format": "" + }, + { + "name": "extendedResourceName", + "baseName": "extendedResourceName", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceConstraint.js +var V1beta2DeviceConstraint = class _V1beta2DeviceConstraint { + static getAttributeTypeMap() { + return _V1beta2DeviceConstraint.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceConstraint.discriminator = void 0; +V1beta2DeviceConstraint.mapping = void 0; +V1beta2DeviceConstraint.attributeTypeMap = [ + { + "name": "distinctAttribute", + "baseName": "distinctAttribute", + "type": "string", + "format": "" + }, + { + "name": "matchAttribute", + "baseName": "matchAttribute", + "type": "string", + "format": "" + }, + { + "name": "requests", + "baseName": "requests", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceCounterConsumption.js +var V1beta2DeviceCounterConsumption = class _V1beta2DeviceCounterConsumption { + static getAttributeTypeMap() { + return _V1beta2DeviceCounterConsumption.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceCounterConsumption.discriminator = void 0; +V1beta2DeviceCounterConsumption.mapping = void 0; +V1beta2DeviceCounterConsumption.attributeTypeMap = [ + { + "name": "counterSet", + "baseName": "counterSet", + "type": "string", + "format": "" + }, + { + "name": "counters", + "baseName": "counters", + "type": "{ [key: string]: V1beta2Counter; }", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceRequest.js +var V1beta2DeviceRequest = class _V1beta2DeviceRequest { + static getAttributeTypeMap() { + return _V1beta2DeviceRequest.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceRequest.discriminator = void 0; +V1beta2DeviceRequest.mapping = void 0; +V1beta2DeviceRequest.attributeTypeMap = [ + { + "name": "exactly", + "baseName": "exactly", + "type": "V1beta2ExactDeviceRequest", + "format": "" + }, + { + "name": "firstAvailable", + "baseName": "firstAvailable", + "type": "Array", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceRequestAllocationResult.js +var V1beta2DeviceRequestAllocationResult = class _V1beta2DeviceRequestAllocationResult { + static getAttributeTypeMap() { + return _V1beta2DeviceRequestAllocationResult.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceRequestAllocationResult.discriminator = void 0; +V1beta2DeviceRequestAllocationResult.mapping = void 0; +V1beta2DeviceRequestAllocationResult.attributeTypeMap = [ + { + "name": "adminAccess", + "baseName": "adminAccess", + "type": "boolean", + "format": "" + }, + { + "name": "bindingConditions", + "baseName": "bindingConditions", + "type": "Array", + "format": "" + }, + { + "name": "bindingFailureConditions", + "baseName": "bindingFailureConditions", + "type": "Array", + "format": "" + }, + { + "name": "consumedCapacity", + "baseName": "consumedCapacity", + "type": "{ [key: string]: string; }", + "format": "" + }, + { + "name": "device", + "baseName": "device", + "type": "string", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "string", + "format": "" + }, + { + "name": "request", + "baseName": "request", + "type": "string", + "format": "" + }, + { + "name": "shareID", + "baseName": "shareID", + "type": "string", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceSelector.js +var V1beta2DeviceSelector = class _V1beta2DeviceSelector { + static getAttributeTypeMap() { + return _V1beta2DeviceSelector.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceSelector.discriminator = void 0; +V1beta2DeviceSelector.mapping = void 0; +V1beta2DeviceSelector.attributeTypeMap = [ + { + "name": "cel", + "baseName": "cel", + "type": "V1beta2CELDeviceSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceSubRequest.js +var V1beta2DeviceSubRequest = class _V1beta2DeviceSubRequest { + static getAttributeTypeMap() { + return _V1beta2DeviceSubRequest.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceSubRequest.discriminator = void 0; +V1beta2DeviceSubRequest.mapping = void 0; +V1beta2DeviceSubRequest.attributeTypeMap = [ + { + "name": "allocationMode", + "baseName": "allocationMode", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "V1beta2CapacityRequirements", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int64" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceTaint.js +var V1beta2DeviceTaint = class _V1beta2DeviceTaint { + static getAttributeTypeMap() { + return _V1beta2DeviceTaint.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceTaint.discriminator = void 0; +V1beta2DeviceTaint.mapping = void 0; +V1beta2DeviceTaint.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "timeAdded", + "baseName": "timeAdded", + "type": "Date", + "format": "date-time" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2DeviceToleration.js +var V1beta2DeviceToleration = class _V1beta2DeviceToleration { + static getAttributeTypeMap() { + return _V1beta2DeviceToleration.attributeTypeMap; + } + constructor() { + } +}; +V1beta2DeviceToleration.discriminator = void 0; +V1beta2DeviceToleration.mapping = void 0; +V1beta2DeviceToleration.attributeTypeMap = [ + { + "name": "effect", + "baseName": "effect", + "type": "string", + "format": "" + }, + { + "name": "key", + "baseName": "key", + "type": "string", + "format": "" + }, + { + "name": "operator", + "baseName": "operator", + "type": "string", + "format": "" + }, + { + "name": "tolerationSeconds", + "baseName": "tolerationSeconds", + "type": "number", + "format": "int64" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ExactDeviceRequest.js +var V1beta2ExactDeviceRequest = class _V1beta2ExactDeviceRequest { + static getAttributeTypeMap() { + return _V1beta2ExactDeviceRequest.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ExactDeviceRequest.discriminator = void 0; +V1beta2ExactDeviceRequest.mapping = void 0; +V1beta2ExactDeviceRequest.attributeTypeMap = [ + { + "name": "adminAccess", + "baseName": "adminAccess", + "type": "boolean", + "format": "" + }, + { + "name": "allocationMode", + "baseName": "allocationMode", + "type": "string", + "format": "" + }, + { + "name": "capacity", + "baseName": "capacity", + "type": "V1beta2CapacityRequirements", + "format": "" + }, + { + "name": "count", + "baseName": "count", + "type": "number", + "format": "int64" + }, + { + "name": "deviceClassName", + "baseName": "deviceClassName", + "type": "string", + "format": "" + }, + { + "name": "selectors", + "baseName": "selectors", + "type": "Array", + "format": "" + }, + { + "name": "tolerations", + "baseName": "tolerations", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2NetworkDeviceData.js +var V1beta2NetworkDeviceData = class _V1beta2NetworkDeviceData { + static getAttributeTypeMap() { + return _V1beta2NetworkDeviceData.attributeTypeMap; + } + constructor() { + } +}; +V1beta2NetworkDeviceData.discriminator = void 0; +V1beta2NetworkDeviceData.mapping = void 0; +V1beta2NetworkDeviceData.attributeTypeMap = [ + { + "name": "hardwareAddress", + "baseName": "hardwareAddress", + "type": "string", + "format": "" + }, + { + "name": "interfaceName", + "baseName": "interfaceName", + "type": "string", + "format": "" + }, + { + "name": "ips", + "baseName": "ips", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2OpaqueDeviceConfiguration.js +var V1beta2OpaqueDeviceConfiguration = class _V1beta2OpaqueDeviceConfiguration { + static getAttributeTypeMap() { + return _V1beta2OpaqueDeviceConfiguration.attributeTypeMap; + } + constructor() { + } +}; +V1beta2OpaqueDeviceConfiguration.discriminator = void 0; +V1beta2OpaqueDeviceConfiguration.mapping = void 0; +V1beta2OpaqueDeviceConfiguration.attributeTypeMap = [ + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "parameters", + "baseName": "parameters", + "type": "any", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaim.js +var V1beta2ResourceClaim = class _V1beta2ResourceClaim { + static getAttributeTypeMap() { + return _V1beta2ResourceClaim.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaim.discriminator = void 0; +V1beta2ResourceClaim.mapping = void 0; +V1beta2ResourceClaim.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta2ResourceClaimSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V1beta2ResourceClaimStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimConsumerReference.js +var V1beta2ResourceClaimConsumerReference = class _V1beta2ResourceClaimConsumerReference { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimConsumerReference.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimConsumerReference.discriminator = void 0; +V1beta2ResourceClaimConsumerReference.mapping = void 0; +V1beta2ResourceClaimConsumerReference.attributeTypeMap = [ + { + "name": "apiGroup", + "baseName": "apiGroup", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "string", + "format": "" + }, + { + "name": "uid", + "baseName": "uid", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimList.js +var V1beta2ResourceClaimList = class _V1beta2ResourceClaimList { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimList.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimList.discriminator = void 0; +V1beta2ResourceClaimList.mapping = void 0; +V1beta2ResourceClaimList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimSpec.js +var V1beta2ResourceClaimSpec = class _V1beta2ResourceClaimSpec { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimSpec.discriminator = void 0; +V1beta2ResourceClaimSpec.mapping = void 0; +V1beta2ResourceClaimSpec.attributeTypeMap = [ + { + "name": "devices", + "baseName": "devices", + "type": "V1beta2DeviceClaim", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimStatus.js +var V1beta2ResourceClaimStatus = class _V1beta2ResourceClaimStatus { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimStatus.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimStatus.discriminator = void 0; +V1beta2ResourceClaimStatus.mapping = void 0; +V1beta2ResourceClaimStatus.attributeTypeMap = [ + { + "name": "allocation", + "baseName": "allocation", + "type": "V1beta2AllocationResult", + "format": "" + }, + { + "name": "devices", + "baseName": "devices", + "type": "Array", + "format": "" + }, + { + "name": "reservedFor", + "baseName": "reservedFor", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimTemplate.js +var V1beta2ResourceClaimTemplate = class _V1beta2ResourceClaimTemplate { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimTemplate.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimTemplate.discriminator = void 0; +V1beta2ResourceClaimTemplate.mapping = void 0; +V1beta2ResourceClaimTemplate.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta2ResourceClaimTemplateSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimTemplateList.js +var V1beta2ResourceClaimTemplateList = class _V1beta2ResourceClaimTemplateList { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimTemplateList.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimTemplateList.discriminator = void 0; +V1beta2ResourceClaimTemplateList.mapping = void 0; +V1beta2ResourceClaimTemplateList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceClaimTemplateSpec.js +var V1beta2ResourceClaimTemplateSpec = class _V1beta2ResourceClaimTemplateSpec { + static getAttributeTypeMap() { + return _V1beta2ResourceClaimTemplateSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceClaimTemplateSpec.discriminator = void 0; +V1beta2ResourceClaimTemplateSpec.mapping = void 0; +V1beta2ResourceClaimTemplateSpec.attributeTypeMap = [ + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta2ResourceClaimSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourcePool.js +var V1beta2ResourcePool = class _V1beta2ResourcePool { + static getAttributeTypeMap() { + return _V1beta2ResourcePool.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourcePool.discriminator = void 0; +V1beta2ResourcePool.mapping = void 0; +V1beta2ResourcePool.attributeTypeMap = [ + { + "name": "generation", + "baseName": "generation", + "type": "number", + "format": "int64" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "resourceSliceCount", + "baseName": "resourceSliceCount", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceSlice.js +var V1beta2ResourceSlice = class _V1beta2ResourceSlice { + static getAttributeTypeMap() { + return _V1beta2ResourceSlice.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceSlice.discriminator = void 0; +V1beta2ResourceSlice.mapping = void 0; +V1beta2ResourceSlice.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V1beta2ResourceSliceSpec", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceSliceList.js +var V1beta2ResourceSliceList = class _V1beta2ResourceSliceList { + static getAttributeTypeMap() { + return _V1beta2ResourceSliceList.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceSliceList.discriminator = void 0; +V1beta2ResourceSliceList.mapping = void 0; +V1beta2ResourceSliceList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V1beta2ResourceSliceSpec.js +var V1beta2ResourceSliceSpec = class _V1beta2ResourceSliceSpec { + static getAttributeTypeMap() { + return _V1beta2ResourceSliceSpec.attributeTypeMap; + } + constructor() { + } +}; +V1beta2ResourceSliceSpec.discriminator = void 0; +V1beta2ResourceSliceSpec.mapping = void 0; +V1beta2ResourceSliceSpec.attributeTypeMap = [ + { + "name": "allNodes", + "baseName": "allNodes", + "type": "boolean", + "format": "" + }, + { + "name": "devices", + "baseName": "devices", + "type": "Array", + "format": "" + }, + { + "name": "driver", + "baseName": "driver", + "type": "string", + "format": "" + }, + { + "name": "nodeName", + "baseName": "nodeName", + "type": "string", + "format": "" + }, + { + "name": "nodeSelector", + "baseName": "nodeSelector", + "type": "V1NodeSelector", + "format": "" + }, + { + "name": "perDeviceNodeSelection", + "baseName": "perDeviceNodeSelection", + "type": "boolean", + "format": "" + }, + { + "name": "pool", + "baseName": "pool", + "type": "V1beta2ResourcePool", + "format": "" + }, + { + "name": "sharedCounters", + "baseName": "sharedCounters", + "type": "Array", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ContainerResourceMetricSource.js +var V2ContainerResourceMetricSource = class _V2ContainerResourceMetricSource { + static getAttributeTypeMap() { + return _V2ContainerResourceMetricSource.attributeTypeMap; + } + constructor() { + } +}; +V2ContainerResourceMetricSource.discriminator = void 0; +V2ContainerResourceMetricSource.mapping = void 0; +V2ContainerResourceMetricSource.attributeTypeMap = [ + { + "name": "container", + "baseName": "container", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "target", + "baseName": "target", + "type": "V2MetricTarget", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ContainerResourceMetricStatus.js +var V2ContainerResourceMetricStatus = class _V2ContainerResourceMetricStatus { + static getAttributeTypeMap() { + return _V2ContainerResourceMetricStatus.attributeTypeMap; + } + constructor() { + } +}; +V2ContainerResourceMetricStatus.discriminator = void 0; +V2ContainerResourceMetricStatus.mapping = void 0; +V2ContainerResourceMetricStatus.attributeTypeMap = [ + { + "name": "container", + "baseName": "container", + "type": "string", + "format": "" + }, + { + "name": "current", + "baseName": "current", + "type": "V2MetricValueStatus", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2CrossVersionObjectReference.js +var V2CrossVersionObjectReference = class _V2CrossVersionObjectReference { + static getAttributeTypeMap() { + return _V2CrossVersionObjectReference.attributeTypeMap; + } + constructor() { + } +}; +V2CrossVersionObjectReference.discriminator = void 0; +V2CrossVersionObjectReference.mapping = void 0; +V2CrossVersionObjectReference.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ExternalMetricSource.js +var V2ExternalMetricSource = class _V2ExternalMetricSource { + static getAttributeTypeMap() { + return _V2ExternalMetricSource.attributeTypeMap; + } + constructor() { + } +}; +V2ExternalMetricSource.discriminator = void 0; +V2ExternalMetricSource.mapping = void 0; +V2ExternalMetricSource.attributeTypeMap = [ + { + "name": "metric", + "baseName": "metric", + "type": "V2MetricIdentifier", + "format": "" + }, + { + "name": "target", + "baseName": "target", + "type": "V2MetricTarget", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ExternalMetricStatus.js +var V2ExternalMetricStatus = class _V2ExternalMetricStatus { + static getAttributeTypeMap() { + return _V2ExternalMetricStatus.attributeTypeMap; + } + constructor() { + } +}; +V2ExternalMetricStatus.discriminator = void 0; +V2ExternalMetricStatus.mapping = void 0; +V2ExternalMetricStatus.attributeTypeMap = [ + { + "name": "current", + "baseName": "current", + "type": "V2MetricValueStatus", + "format": "" + }, + { + "name": "metric", + "baseName": "metric", + "type": "V2MetricIdentifier", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HPAScalingPolicy.js +var V2HPAScalingPolicy = class _V2HPAScalingPolicy { + static getAttributeTypeMap() { + return _V2HPAScalingPolicy.attributeTypeMap; + } + constructor() { + } +}; +V2HPAScalingPolicy.discriminator = void 0; +V2HPAScalingPolicy.mapping = void 0; +V2HPAScalingPolicy.attributeTypeMap = [ + { + "name": "periodSeconds", + "baseName": "periodSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "number", + "format": "int32" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HPAScalingRules.js +var V2HPAScalingRules = class _V2HPAScalingRules { + static getAttributeTypeMap() { + return _V2HPAScalingRules.attributeTypeMap; + } + constructor() { + } +}; +V2HPAScalingRules.discriminator = void 0; +V2HPAScalingRules.mapping = void 0; +V2HPAScalingRules.attributeTypeMap = [ + { + "name": "policies", + "baseName": "policies", + "type": "Array", + "format": "" + }, + { + "name": "selectPolicy", + "baseName": "selectPolicy", + "type": "string", + "format": "" + }, + { + "name": "stabilizationWindowSeconds", + "baseName": "stabilizationWindowSeconds", + "type": "number", + "format": "int32" + }, + { + "name": "tolerance", + "baseName": "tolerance", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HorizontalPodAutoscaler.js +var V2HorizontalPodAutoscaler = class _V2HorizontalPodAutoscaler { + static getAttributeTypeMap() { + return _V2HorizontalPodAutoscaler.attributeTypeMap; + } + constructor() { + } +}; +V2HorizontalPodAutoscaler.discriminator = void 0; +V2HorizontalPodAutoscaler.mapping = void 0; +V2HorizontalPodAutoscaler.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ObjectMeta", + "format": "" + }, + { + "name": "spec", + "baseName": "spec", + "type": "V2HorizontalPodAutoscalerSpec", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "V2HorizontalPodAutoscalerStatus", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HorizontalPodAutoscalerBehavior.js +var V2HorizontalPodAutoscalerBehavior = class _V2HorizontalPodAutoscalerBehavior { + static getAttributeTypeMap() { + return _V2HorizontalPodAutoscalerBehavior.attributeTypeMap; + } + constructor() { + } +}; +V2HorizontalPodAutoscalerBehavior.discriminator = void 0; +V2HorizontalPodAutoscalerBehavior.mapping = void 0; +V2HorizontalPodAutoscalerBehavior.attributeTypeMap = [ + { + "name": "scaleDown", + "baseName": "scaleDown", + "type": "V2HPAScalingRules", + "format": "" + }, + { + "name": "scaleUp", + "baseName": "scaleUp", + "type": "V2HPAScalingRules", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HorizontalPodAutoscalerCondition.js +var V2HorizontalPodAutoscalerCondition = class _V2HorizontalPodAutoscalerCondition { + static getAttributeTypeMap() { + return _V2HorizontalPodAutoscalerCondition.attributeTypeMap; + } + constructor() { + } +}; +V2HorizontalPodAutoscalerCondition.discriminator = void 0; +V2HorizontalPodAutoscalerCondition.mapping = void 0; +V2HorizontalPodAutoscalerCondition.attributeTypeMap = [ + { + "name": "lastTransitionTime", + "baseName": "lastTransitionTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "message", + "baseName": "message", + "type": "string", + "format": "" + }, + { + "name": "reason", + "baseName": "reason", + "type": "string", + "format": "" + }, + { + "name": "status", + "baseName": "status", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HorizontalPodAutoscalerList.js +var V2HorizontalPodAutoscalerList = class _V2HorizontalPodAutoscalerList { + static getAttributeTypeMap() { + return _V2HorizontalPodAutoscalerList.attributeTypeMap; + } + constructor() { + } +}; +V2HorizontalPodAutoscalerList.discriminator = void 0; +V2HorizontalPodAutoscalerList.mapping = void 0; +V2HorizontalPodAutoscalerList.attributeTypeMap = [ + { + "name": "apiVersion", + "baseName": "apiVersion", + "type": "string", + "format": "" + }, + { + "name": "items", + "baseName": "items", + "type": "Array", + "format": "" + }, + { + "name": "kind", + "baseName": "kind", + "type": "string", + "format": "" + }, + { + "name": "metadata", + "baseName": "metadata", + "type": "V1ListMeta", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HorizontalPodAutoscalerSpec.js +var V2HorizontalPodAutoscalerSpec = class _V2HorizontalPodAutoscalerSpec { + static getAttributeTypeMap() { + return _V2HorizontalPodAutoscalerSpec.attributeTypeMap; + } + constructor() { + } +}; +V2HorizontalPodAutoscalerSpec.discriminator = void 0; +V2HorizontalPodAutoscalerSpec.mapping = void 0; +V2HorizontalPodAutoscalerSpec.attributeTypeMap = [ + { + "name": "behavior", + "baseName": "behavior", + "type": "V2HorizontalPodAutoscalerBehavior", + "format": "" + }, + { + "name": "maxReplicas", + "baseName": "maxReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "metrics", + "baseName": "metrics", + "type": "Array", + "format": "" + }, + { + "name": "minReplicas", + "baseName": "minReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "scaleTargetRef", + "baseName": "scaleTargetRef", + "type": "V2CrossVersionObjectReference", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2HorizontalPodAutoscalerStatus.js +var V2HorizontalPodAutoscalerStatus = class _V2HorizontalPodAutoscalerStatus { + static getAttributeTypeMap() { + return _V2HorizontalPodAutoscalerStatus.attributeTypeMap; + } + constructor() { + } +}; +V2HorizontalPodAutoscalerStatus.discriminator = void 0; +V2HorizontalPodAutoscalerStatus.mapping = void 0; +V2HorizontalPodAutoscalerStatus.attributeTypeMap = [ + { + "name": "conditions", + "baseName": "conditions", + "type": "Array", + "format": "" + }, + { + "name": "currentMetrics", + "baseName": "currentMetrics", + "type": "Array", + "format": "" + }, + { + "name": "currentReplicas", + "baseName": "currentReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "desiredReplicas", + "baseName": "desiredReplicas", + "type": "number", + "format": "int32" + }, + { + "name": "lastScaleTime", + "baseName": "lastScaleTime", + "type": "Date", + "format": "date-time" + }, + { + "name": "observedGeneration", + "baseName": "observedGeneration", + "type": "number", + "format": "int64" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2MetricIdentifier.js +var V2MetricIdentifier = class _V2MetricIdentifier { + static getAttributeTypeMap() { + return _V2MetricIdentifier.attributeTypeMap; + } + constructor() { + } +}; +V2MetricIdentifier.discriminator = void 0; +V2MetricIdentifier.mapping = void 0; +V2MetricIdentifier.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "selector", + "baseName": "selector", + "type": "V1LabelSelector", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2MetricSpec.js +var V2MetricSpec = class _V2MetricSpec { + static getAttributeTypeMap() { + return _V2MetricSpec.attributeTypeMap; + } + constructor() { + } +}; +V2MetricSpec.discriminator = void 0; +V2MetricSpec.mapping = void 0; +V2MetricSpec.attributeTypeMap = [ + { + "name": "containerResource", + "baseName": "containerResource", + "type": "V2ContainerResourceMetricSource", + "format": "" + }, + { + "name": "external", + "baseName": "external", + "type": "V2ExternalMetricSource", + "format": "" + }, + { + "name": "object", + "baseName": "object", + "type": "V2ObjectMetricSource", + "format": "" + }, + { + "name": "pods", + "baseName": "pods", + "type": "V2PodsMetricSource", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "V2ResourceMetricSource", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2MetricStatus.js +var V2MetricStatus = class _V2MetricStatus { + static getAttributeTypeMap() { + return _V2MetricStatus.attributeTypeMap; + } + constructor() { + } +}; +V2MetricStatus.discriminator = void 0; +V2MetricStatus.mapping = void 0; +V2MetricStatus.attributeTypeMap = [ + { + "name": "containerResource", + "baseName": "containerResource", + "type": "V2ContainerResourceMetricStatus", + "format": "" + }, + { + "name": "external", + "baseName": "external", + "type": "V2ExternalMetricStatus", + "format": "" + }, + { + "name": "object", + "baseName": "object", + "type": "V2ObjectMetricStatus", + "format": "" + }, + { + "name": "pods", + "baseName": "pods", + "type": "V2PodsMetricStatus", + "format": "" + }, + { + "name": "resource", + "baseName": "resource", + "type": "V2ResourceMetricStatus", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2MetricTarget.js +var V2MetricTarget = class _V2MetricTarget { + static getAttributeTypeMap() { + return _V2MetricTarget.attributeTypeMap; + } + constructor() { + } +}; +V2MetricTarget.discriminator = void 0; +V2MetricTarget.mapping = void 0; +V2MetricTarget.attributeTypeMap = [ + { + "name": "averageUtilization", + "baseName": "averageUtilization", + "type": "number", + "format": "int32" + }, + { + "name": "averageValue", + "baseName": "averageValue", + "type": "string", + "format": "" + }, + { + "name": "type", + "baseName": "type", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2MetricValueStatus.js +var V2MetricValueStatus = class _V2MetricValueStatus { + static getAttributeTypeMap() { + return _V2MetricValueStatus.attributeTypeMap; + } + constructor() { + } +}; +V2MetricValueStatus.discriminator = void 0; +V2MetricValueStatus.mapping = void 0; +V2MetricValueStatus.attributeTypeMap = [ + { + "name": "averageUtilization", + "baseName": "averageUtilization", + "type": "number", + "format": "int32" + }, + { + "name": "averageValue", + "baseName": "averageValue", + "type": "string", + "format": "" + }, + { + "name": "value", + "baseName": "value", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ObjectMetricSource.js +var V2ObjectMetricSource = class _V2ObjectMetricSource { + static getAttributeTypeMap() { + return _V2ObjectMetricSource.attributeTypeMap; + } + constructor() { + } +}; +V2ObjectMetricSource.discriminator = void 0; +V2ObjectMetricSource.mapping = void 0; +V2ObjectMetricSource.attributeTypeMap = [ + { + "name": "describedObject", + "baseName": "describedObject", + "type": "V2CrossVersionObjectReference", + "format": "" + }, + { + "name": "metric", + "baseName": "metric", + "type": "V2MetricIdentifier", + "format": "" + }, + { + "name": "target", + "baseName": "target", + "type": "V2MetricTarget", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ObjectMetricStatus.js +var V2ObjectMetricStatus = class _V2ObjectMetricStatus { + static getAttributeTypeMap() { + return _V2ObjectMetricStatus.attributeTypeMap; + } + constructor() { + } +}; +V2ObjectMetricStatus.discriminator = void 0; +V2ObjectMetricStatus.mapping = void 0; +V2ObjectMetricStatus.attributeTypeMap = [ + { + "name": "current", + "baseName": "current", + "type": "V2MetricValueStatus", + "format": "" + }, + { + "name": "describedObject", + "baseName": "describedObject", + "type": "V2CrossVersionObjectReference", + "format": "" + }, + { + "name": "metric", + "baseName": "metric", + "type": "V2MetricIdentifier", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2PodsMetricSource.js +var V2PodsMetricSource = class _V2PodsMetricSource { + static getAttributeTypeMap() { + return _V2PodsMetricSource.attributeTypeMap; + } + constructor() { + } +}; +V2PodsMetricSource.discriminator = void 0; +V2PodsMetricSource.mapping = void 0; +V2PodsMetricSource.attributeTypeMap = [ + { + "name": "metric", + "baseName": "metric", + "type": "V2MetricIdentifier", + "format": "" + }, + { + "name": "target", + "baseName": "target", + "type": "V2MetricTarget", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2PodsMetricStatus.js +var V2PodsMetricStatus = class _V2PodsMetricStatus { + static getAttributeTypeMap() { + return _V2PodsMetricStatus.attributeTypeMap; + } + constructor() { + } +}; +V2PodsMetricStatus.discriminator = void 0; +V2PodsMetricStatus.mapping = void 0; +V2PodsMetricStatus.attributeTypeMap = [ + { + "name": "current", + "baseName": "current", + "type": "V2MetricValueStatus", + "format": "" + }, + { + "name": "metric", + "baseName": "metric", + "type": "V2MetricIdentifier", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ResourceMetricSource.js +var V2ResourceMetricSource = class _V2ResourceMetricSource { + static getAttributeTypeMap() { + return _V2ResourceMetricSource.attributeTypeMap; + } + constructor() { + } +}; +V2ResourceMetricSource.discriminator = void 0; +V2ResourceMetricSource.mapping = void 0; +V2ResourceMetricSource.attributeTypeMap = [ + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + }, + { + "name": "target", + "baseName": "target", + "type": "V2MetricTarget", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/V2ResourceMetricStatus.js +var V2ResourceMetricStatus = class _V2ResourceMetricStatus { + static getAttributeTypeMap() { + return _V2ResourceMetricStatus.attributeTypeMap; + } + constructor() { + } +}; +V2ResourceMetricStatus.discriminator = void 0; +V2ResourceMetricStatus.mapping = void 0; +V2ResourceMetricStatus.attributeTypeMap = [ + { + "name": "current", + "baseName": "current", + "type": "V2MetricValueStatus", + "format": "" + }, + { + "name": "name", + "baseName": "name", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/models/VersionInfo.js +var VersionInfo = class _VersionInfo { + static getAttributeTypeMap() { + return _VersionInfo.attributeTypeMap; + } + constructor() { + } +}; +VersionInfo.discriminator = void 0; +VersionInfo.mapping = void 0; +VersionInfo.attributeTypeMap = [ + { + "name": "buildDate", + "baseName": "buildDate", + "type": "string", + "format": "" + }, + { + "name": "compiler", + "baseName": "compiler", + "type": "string", + "format": "" + }, + { + "name": "emulationMajor", + "baseName": "emulationMajor", + "type": "string", + "format": "" + }, + { + "name": "emulationMinor", + "baseName": "emulationMinor", + "type": "string", + "format": "" + }, + { + "name": "gitCommit", + "baseName": "gitCommit", + "type": "string", + "format": "" + }, + { + "name": "gitTreeState", + "baseName": "gitTreeState", + "type": "string", + "format": "" + }, + { + "name": "gitVersion", + "baseName": "gitVersion", + "type": "string", + "format": "" + }, + { + "name": "goVersion", + "baseName": "goVersion", + "type": "string", + "format": "" + }, + { + "name": "major", + "baseName": "major", + "type": "string", + "format": "" + }, + { + "name": "minCompatibilityMajor", + "baseName": "minCompatibilityMajor", + "type": "string", + "format": "" + }, + { + "name": "minCompatibilityMinor", + "baseName": "minCompatibilityMinor", + "type": "string", + "format": "" + }, + { + "name": "minor", + "baseName": "minor", + "type": "string", + "format": "" + }, + { + "name": "platform", + "baseName": "platform", + "type": "string", + "format": "" + } +]; + +// node_modules/@kubernetes/client-node/dist/gen/middleware.js +var PromiseMiddlewareWrapper = class { + constructor(middleware) { + this.middleware = middleware; + } + pre(context) { + return from(this.middleware.pre(context)); + } + post(context) { + return from(this.middleware.post(context)); + } +}; + +// node_modules/@kubernetes/client-node/dist/gen/servers.js +var ServerConfiguration = class { + constructor(url, variableConfiguration) { + this.url = url; + this.variableConfiguration = variableConfiguration; + } + /** + * Sets the value of the variables of this server. Variables are included in + * the `url` of this ServerConfiguration in the form `{variableName}` + * + * @param variableConfiguration a partial variable configuration for the + * variables contained in the url + */ + setVariables(variableConfiguration) { + Object.assign(this.variableConfiguration, variableConfiguration); + } + getConfiguration() { + return this.variableConfiguration; + } + getUrl() { + let replacedUrl = this.url; + for (const [key, value] of Object.entries(this.variableConfiguration)) { + replacedUrl = replacedUrl.replaceAll(`{${key}}`, value); + } + return replacedUrl; + } + /** + * Creates a new request context for this server using the url with variables + * replaced with their respective values and the endpoint of the request appended. + * + * @param endpoint the endpoint to be queried on the server + * @param httpMethod httpMethod to be used + * + */ + makeRequestContext(endpoint, httpMethod) { + return new RequestContext(this.getUrl() + endpoint, httpMethod); + } +}; +var server1 = new ServerConfiguration("", {}); + +// node_modules/@kubernetes/client-node/dist/gen/configuration.js +function createConfiguration(conf = {}) { + const configuration = { + baseServer: conf.baseServer !== void 0 ? conf.baseServer : server1, + httpApi: conf.httpApi || new IsomorphicFetchHttpLibrary(), + middleware: conf.middleware || [], + authMethods: configureAuthMethods(conf.authMethods) + }; + if (conf.promiseMiddleware) { + conf.promiseMiddleware.forEach((m) => configuration.middleware.push(new PromiseMiddlewareWrapper(m))); + } + return configuration; +} + +// node_modules/@kubernetes/client-node/dist/gen/models/ObjectSerializer.js +var primitives = [ + "string", + "boolean", + "double", + "integer", + "long", + "float", + "number", + "any" +]; +var enumsMap = /* @__PURE__ */ new Set([]); +var typeMap = { + "AdmissionregistrationV1ServiceReference": AdmissionregistrationV1ServiceReference, + "AdmissionregistrationV1WebhookClientConfig": AdmissionregistrationV1WebhookClientConfig, + "ApiextensionsV1ServiceReference": ApiextensionsV1ServiceReference, + "ApiextensionsV1WebhookClientConfig": ApiextensionsV1WebhookClientConfig, + "ApiregistrationV1ServiceReference": ApiregistrationV1ServiceReference, + "AuthenticationV1TokenRequest": AuthenticationV1TokenRequest, + "CoreV1EndpointPort": CoreV1EndpointPort, + "CoreV1Event": CoreV1Event, + "CoreV1EventList": CoreV1EventList, + "CoreV1EventSeries": CoreV1EventSeries, + "CoreV1ResourceClaim": CoreV1ResourceClaim, + "DiscoveryV1EndpointPort": DiscoveryV1EndpointPort, + "EventsV1Event": EventsV1Event, + "EventsV1EventList": EventsV1EventList, + "EventsV1EventSeries": EventsV1EventSeries, + "FlowcontrolV1Subject": FlowcontrolV1Subject, + "RbacV1Subject": RbacV1Subject, + "ResourceV1ResourceClaim": ResourceV1ResourceClaim, + "StorageV1TokenRequest": StorageV1TokenRequest, + "V1APIGroup": V1APIGroup, + "V1APIGroupList": V1APIGroupList, + "V1APIResource": V1APIResource, + "V1APIResourceList": V1APIResourceList, + "V1APIService": V1APIService, + "V1APIServiceCondition": V1APIServiceCondition, + "V1APIServiceList": V1APIServiceList, + "V1APIServiceSpec": V1APIServiceSpec, + "V1APIServiceStatus": V1APIServiceStatus, + "V1APIVersions": V1APIVersions, + "V1AWSElasticBlockStoreVolumeSource": V1AWSElasticBlockStoreVolumeSource, + "V1Affinity": V1Affinity, + "V1AggregationRule": V1AggregationRule, + "V1AllocatedDeviceStatus": V1AllocatedDeviceStatus, + "V1AllocationResult": V1AllocationResult, + "V1AppArmorProfile": V1AppArmorProfile, + "V1AttachedVolume": V1AttachedVolume, + "V1AuditAnnotation": V1AuditAnnotation, + "V1AzureDiskVolumeSource": V1AzureDiskVolumeSource, + "V1AzureFilePersistentVolumeSource": V1AzureFilePersistentVolumeSource, + "V1AzureFileVolumeSource": V1AzureFileVolumeSource, + "V1Binding": V1Binding, + "V1BoundObjectReference": V1BoundObjectReference, + "V1CELDeviceSelector": V1CELDeviceSelector, + "V1CSIDriver": V1CSIDriver, + "V1CSIDriverList": V1CSIDriverList, + "V1CSIDriverSpec": V1CSIDriverSpec, + "V1CSINode": V1CSINode, + "V1CSINodeDriver": V1CSINodeDriver, + "V1CSINodeList": V1CSINodeList, + "V1CSINodeSpec": V1CSINodeSpec, + "V1CSIPersistentVolumeSource": V1CSIPersistentVolumeSource, + "V1CSIStorageCapacity": V1CSIStorageCapacity, + "V1CSIStorageCapacityList": V1CSIStorageCapacityList, + "V1CSIVolumeSource": V1CSIVolumeSource, + "V1Capabilities": V1Capabilities, + "V1CapacityRequestPolicy": V1CapacityRequestPolicy, + "V1CapacityRequestPolicyRange": V1CapacityRequestPolicyRange, + "V1CapacityRequirements": V1CapacityRequirements, + "V1CephFSPersistentVolumeSource": V1CephFSPersistentVolumeSource, + "V1CephFSVolumeSource": V1CephFSVolumeSource, + "V1CertificateSigningRequest": V1CertificateSigningRequest, + "V1CertificateSigningRequestCondition": V1CertificateSigningRequestCondition, + "V1CertificateSigningRequestList": V1CertificateSigningRequestList, + "V1CertificateSigningRequestSpec": V1CertificateSigningRequestSpec, + "V1CertificateSigningRequestStatus": V1CertificateSigningRequestStatus, + "V1CinderPersistentVolumeSource": V1CinderPersistentVolumeSource, + "V1CinderVolumeSource": V1CinderVolumeSource, + "V1ClientIPConfig": V1ClientIPConfig, + "V1ClusterRole": V1ClusterRole, + "V1ClusterRoleBinding": V1ClusterRoleBinding, + "V1ClusterRoleBindingList": V1ClusterRoleBindingList, + "V1ClusterRoleList": V1ClusterRoleList, + "V1ClusterTrustBundleProjection": V1ClusterTrustBundleProjection, + "V1ComponentCondition": V1ComponentCondition, + "V1ComponentStatus": V1ComponentStatus, + "V1ComponentStatusList": V1ComponentStatusList, + "V1Condition": V1Condition, + "V1ConfigMap": V1ConfigMap, + "V1ConfigMapEnvSource": V1ConfigMapEnvSource, + "V1ConfigMapKeySelector": V1ConfigMapKeySelector, + "V1ConfigMapList": V1ConfigMapList, + "V1ConfigMapNodeConfigSource": V1ConfigMapNodeConfigSource, + "V1ConfigMapProjection": V1ConfigMapProjection, + "V1ConfigMapVolumeSource": V1ConfigMapVolumeSource, + "V1Container": V1Container, + "V1ContainerExtendedResourceRequest": V1ContainerExtendedResourceRequest, + "V1ContainerImage": V1ContainerImage, + "V1ContainerPort": V1ContainerPort, + "V1ContainerResizePolicy": V1ContainerResizePolicy, + "V1ContainerRestartRule": V1ContainerRestartRule, + "V1ContainerRestartRuleOnExitCodes": V1ContainerRestartRuleOnExitCodes, + "V1ContainerState": V1ContainerState, + "V1ContainerStateRunning": V1ContainerStateRunning, + "V1ContainerStateTerminated": V1ContainerStateTerminated, + "V1ContainerStateWaiting": V1ContainerStateWaiting, + "V1ContainerStatus": V1ContainerStatus, + "V1ContainerUser": V1ContainerUser, + "V1ControllerRevision": V1ControllerRevision, + "V1ControllerRevisionList": V1ControllerRevisionList, + "V1Counter": V1Counter, + "V1CounterSet": V1CounterSet, + "V1CronJob": V1CronJob, + "V1CronJobList": V1CronJobList, + "V1CronJobSpec": V1CronJobSpec, + "V1CronJobStatus": V1CronJobStatus, + "V1CrossVersionObjectReference": V1CrossVersionObjectReference, + "V1CustomResourceColumnDefinition": V1CustomResourceColumnDefinition, + "V1CustomResourceConversion": V1CustomResourceConversion, + "V1CustomResourceDefinition": V1CustomResourceDefinition, + "V1CustomResourceDefinitionCondition": V1CustomResourceDefinitionCondition, + "V1CustomResourceDefinitionList": V1CustomResourceDefinitionList, + "V1CustomResourceDefinitionNames": V1CustomResourceDefinitionNames, + "V1CustomResourceDefinitionSpec": V1CustomResourceDefinitionSpec, + "V1CustomResourceDefinitionStatus": V1CustomResourceDefinitionStatus, + "V1CustomResourceDefinitionVersion": V1CustomResourceDefinitionVersion, + "V1CustomResourceSubresourceScale": V1CustomResourceSubresourceScale, + "V1CustomResourceSubresources": V1CustomResourceSubresources, + "V1CustomResourceValidation": V1CustomResourceValidation, + "V1DaemonEndpoint": V1DaemonEndpoint, + "V1DaemonSet": V1DaemonSet, + "V1DaemonSetCondition": V1DaemonSetCondition, + "V1DaemonSetList": V1DaemonSetList, + "V1DaemonSetSpec": V1DaemonSetSpec, + "V1DaemonSetStatus": V1DaemonSetStatus, + "V1DaemonSetUpdateStrategy": V1DaemonSetUpdateStrategy, + "V1DeleteOptions": V1DeleteOptions, + "V1Deployment": V1Deployment, + "V1DeploymentCondition": V1DeploymentCondition, + "V1DeploymentList": V1DeploymentList, + "V1DeploymentSpec": V1DeploymentSpec, + "V1DeploymentStatus": V1DeploymentStatus, + "V1DeploymentStrategy": V1DeploymentStrategy, + "V1Device": V1Device, + "V1DeviceAllocationConfiguration": V1DeviceAllocationConfiguration, + "V1DeviceAllocationResult": V1DeviceAllocationResult, + "V1DeviceAttribute": V1DeviceAttribute, + "V1DeviceCapacity": V1DeviceCapacity, + "V1DeviceClaim": V1DeviceClaim, + "V1DeviceClaimConfiguration": V1DeviceClaimConfiguration, + "V1DeviceClass": V1DeviceClass, + "V1DeviceClassConfiguration": V1DeviceClassConfiguration, + "V1DeviceClassList": V1DeviceClassList, + "V1DeviceClassSpec": V1DeviceClassSpec, + "V1DeviceConstraint": V1DeviceConstraint, + "V1DeviceCounterConsumption": V1DeviceCounterConsumption, + "V1DeviceRequest": V1DeviceRequest, + "V1DeviceRequestAllocationResult": V1DeviceRequestAllocationResult, + "V1DeviceSelector": V1DeviceSelector, + "V1DeviceSubRequest": V1DeviceSubRequest, + "V1DeviceTaint": V1DeviceTaint, + "V1DeviceToleration": V1DeviceToleration, + "V1DownwardAPIProjection": V1DownwardAPIProjection, + "V1DownwardAPIVolumeFile": V1DownwardAPIVolumeFile, + "V1DownwardAPIVolumeSource": V1DownwardAPIVolumeSource, + "V1EmptyDirVolumeSource": V1EmptyDirVolumeSource, + "V1Endpoint": V1Endpoint, + "V1EndpointAddress": V1EndpointAddress, + "V1EndpointConditions": V1EndpointConditions, + "V1EndpointHints": V1EndpointHints, + "V1EndpointSlice": V1EndpointSlice, + "V1EndpointSliceList": V1EndpointSliceList, + "V1EndpointSubset": V1EndpointSubset, + "V1Endpoints": V1Endpoints, + "V1EndpointsList": V1EndpointsList, + "V1EnvFromSource": V1EnvFromSource, + "V1EnvVar": V1EnvVar, + "V1EnvVarSource": V1EnvVarSource, + "V1EphemeralContainer": V1EphemeralContainer, + "V1EphemeralVolumeSource": V1EphemeralVolumeSource, + "V1EventSource": V1EventSource, + "V1Eviction": V1Eviction, + "V1ExactDeviceRequest": V1ExactDeviceRequest, + "V1ExecAction": V1ExecAction, + "V1ExemptPriorityLevelConfiguration": V1ExemptPriorityLevelConfiguration, + "V1ExpressionWarning": V1ExpressionWarning, + "V1ExternalDocumentation": V1ExternalDocumentation, + "V1FCVolumeSource": V1FCVolumeSource, + "V1FieldSelectorAttributes": V1FieldSelectorAttributes, + "V1FieldSelectorRequirement": V1FieldSelectorRequirement, + "V1FileKeySelector": V1FileKeySelector, + "V1FlexPersistentVolumeSource": V1FlexPersistentVolumeSource, + "V1FlexVolumeSource": V1FlexVolumeSource, + "V1FlockerVolumeSource": V1FlockerVolumeSource, + "V1FlowDistinguisherMethod": V1FlowDistinguisherMethod, + "V1FlowSchema": V1FlowSchema, + "V1FlowSchemaCondition": V1FlowSchemaCondition, + "V1FlowSchemaList": V1FlowSchemaList, + "V1FlowSchemaSpec": V1FlowSchemaSpec, + "V1FlowSchemaStatus": V1FlowSchemaStatus, + "V1ForNode": V1ForNode, + "V1ForZone": V1ForZone, + "V1GCEPersistentDiskVolumeSource": V1GCEPersistentDiskVolumeSource, + "V1GRPCAction": V1GRPCAction, + "V1GitRepoVolumeSource": V1GitRepoVolumeSource, + "V1GlusterfsPersistentVolumeSource": V1GlusterfsPersistentVolumeSource, + "V1GlusterfsVolumeSource": V1GlusterfsVolumeSource, + "V1GroupSubject": V1GroupSubject, + "V1GroupVersionForDiscovery": V1GroupVersionForDiscovery, + "V1HTTPGetAction": V1HTTPGetAction, + "V1HTTPHeader": V1HTTPHeader, + "V1HTTPIngressPath": V1HTTPIngressPath, + "V1HTTPIngressRuleValue": V1HTTPIngressRuleValue, + "V1HorizontalPodAutoscaler": V1HorizontalPodAutoscaler, + "V1HorizontalPodAutoscalerList": V1HorizontalPodAutoscalerList, + "V1HorizontalPodAutoscalerSpec": V1HorizontalPodAutoscalerSpec, + "V1HorizontalPodAutoscalerStatus": V1HorizontalPodAutoscalerStatus, + "V1HostAlias": V1HostAlias, + "V1HostIP": V1HostIP, + "V1HostPathVolumeSource": V1HostPathVolumeSource, + "V1IPAddress": V1IPAddress, + "V1IPAddressList": V1IPAddressList, + "V1IPAddressSpec": V1IPAddressSpec, + "V1IPBlock": V1IPBlock, + "V1ISCSIPersistentVolumeSource": V1ISCSIPersistentVolumeSource, + "V1ISCSIVolumeSource": V1ISCSIVolumeSource, + "V1ImageVolumeSource": V1ImageVolumeSource, + "V1Ingress": V1Ingress, + "V1IngressBackend": V1IngressBackend, + "V1IngressClass": V1IngressClass, + "V1IngressClassList": V1IngressClassList, + "V1IngressClassParametersReference": V1IngressClassParametersReference, + "V1IngressClassSpec": V1IngressClassSpec, + "V1IngressList": V1IngressList, + "V1IngressLoadBalancerIngress": V1IngressLoadBalancerIngress, + "V1IngressLoadBalancerStatus": V1IngressLoadBalancerStatus, + "V1IngressPortStatus": V1IngressPortStatus, + "V1IngressRule": V1IngressRule, + "V1IngressServiceBackend": V1IngressServiceBackend, + "V1IngressSpec": V1IngressSpec, + "V1IngressStatus": V1IngressStatus, + "V1IngressTLS": V1IngressTLS, + "V1JSONSchemaProps": V1JSONSchemaProps, + "V1Job": V1Job, + "V1JobCondition": V1JobCondition, + "V1JobList": V1JobList, + "V1JobSpec": V1JobSpec, + "V1JobStatus": V1JobStatus, + "V1JobTemplateSpec": V1JobTemplateSpec, + "V1KeyToPath": V1KeyToPath, + "V1LabelSelector": V1LabelSelector, + "V1LabelSelectorAttributes": V1LabelSelectorAttributes, + "V1LabelSelectorRequirement": V1LabelSelectorRequirement, + "V1Lease": V1Lease, + "V1LeaseList": V1LeaseList, + "V1LeaseSpec": V1LeaseSpec, + "V1Lifecycle": V1Lifecycle, + "V1LifecycleHandler": V1LifecycleHandler, + "V1LimitRange": V1LimitRange, + "V1LimitRangeItem": V1LimitRangeItem, + "V1LimitRangeList": V1LimitRangeList, + "V1LimitRangeSpec": V1LimitRangeSpec, + "V1LimitResponse": V1LimitResponse, + "V1LimitedPriorityLevelConfiguration": V1LimitedPriorityLevelConfiguration, + "V1LinuxContainerUser": V1LinuxContainerUser, + "V1ListMeta": V1ListMeta, + "V1LoadBalancerIngress": V1LoadBalancerIngress, + "V1LoadBalancerStatus": V1LoadBalancerStatus, + "V1LocalObjectReference": V1LocalObjectReference, + "V1LocalSubjectAccessReview": V1LocalSubjectAccessReview, + "V1LocalVolumeSource": V1LocalVolumeSource, + "V1ManagedFieldsEntry": V1ManagedFieldsEntry, + "V1MatchCondition": V1MatchCondition, + "V1MatchResources": V1MatchResources, + "V1ModifyVolumeStatus": V1ModifyVolumeStatus, + "V1MutatingWebhook": V1MutatingWebhook, + "V1MutatingWebhookConfiguration": V1MutatingWebhookConfiguration, + "V1MutatingWebhookConfigurationList": V1MutatingWebhookConfigurationList, + "V1NFSVolumeSource": V1NFSVolumeSource, + "V1NamedRuleWithOperations": V1NamedRuleWithOperations, + "V1Namespace": V1Namespace, + "V1NamespaceCondition": V1NamespaceCondition, + "V1NamespaceList": V1NamespaceList, + "V1NamespaceSpec": V1NamespaceSpec, + "V1NamespaceStatus": V1NamespaceStatus, + "V1NetworkDeviceData": V1NetworkDeviceData, + "V1NetworkPolicy": V1NetworkPolicy, + "V1NetworkPolicyEgressRule": V1NetworkPolicyEgressRule, + "V1NetworkPolicyIngressRule": V1NetworkPolicyIngressRule, + "V1NetworkPolicyList": V1NetworkPolicyList, + "V1NetworkPolicyPeer": V1NetworkPolicyPeer, + "V1NetworkPolicyPort": V1NetworkPolicyPort, + "V1NetworkPolicySpec": V1NetworkPolicySpec, + "V1Node": V1Node, + "V1NodeAddress": V1NodeAddress, + "V1NodeAffinity": V1NodeAffinity, + "V1NodeCondition": V1NodeCondition, + "V1NodeConfigSource": V1NodeConfigSource, + "V1NodeConfigStatus": V1NodeConfigStatus, + "V1NodeDaemonEndpoints": V1NodeDaemonEndpoints, + "V1NodeFeatures": V1NodeFeatures, + "V1NodeList": V1NodeList, + "V1NodeRuntimeHandler": V1NodeRuntimeHandler, + "V1NodeRuntimeHandlerFeatures": V1NodeRuntimeHandlerFeatures, + "V1NodeSelector": V1NodeSelector, + "V1NodeSelectorRequirement": V1NodeSelectorRequirement, + "V1NodeSelectorTerm": V1NodeSelectorTerm, + "V1NodeSpec": V1NodeSpec, + "V1NodeStatus": V1NodeStatus, + "V1NodeSwapStatus": V1NodeSwapStatus, + "V1NodeSystemInfo": V1NodeSystemInfo, + "V1NonResourceAttributes": V1NonResourceAttributes, + "V1NonResourcePolicyRule": V1NonResourcePolicyRule, + "V1NonResourceRule": V1NonResourceRule, + "V1ObjectFieldSelector": V1ObjectFieldSelector, + "V1ObjectMeta": V1ObjectMeta, + "V1ObjectReference": V1ObjectReference, + "V1OpaqueDeviceConfiguration": V1OpaqueDeviceConfiguration, + "V1Overhead": V1Overhead, + "V1OwnerReference": V1OwnerReference, + "V1ParamKind": V1ParamKind, + "V1ParamRef": V1ParamRef, + "V1ParentReference": V1ParentReference, + "V1PersistentVolume": V1PersistentVolume, + "V1PersistentVolumeClaim": V1PersistentVolumeClaim, + "V1PersistentVolumeClaimCondition": V1PersistentVolumeClaimCondition, + "V1PersistentVolumeClaimList": V1PersistentVolumeClaimList, + "V1PersistentVolumeClaimSpec": V1PersistentVolumeClaimSpec, + "V1PersistentVolumeClaimStatus": V1PersistentVolumeClaimStatus, + "V1PersistentVolumeClaimTemplate": V1PersistentVolumeClaimTemplate, + "V1PersistentVolumeClaimVolumeSource": V1PersistentVolumeClaimVolumeSource, + "V1PersistentVolumeList": V1PersistentVolumeList, + "V1PersistentVolumeSpec": V1PersistentVolumeSpec, + "V1PersistentVolumeStatus": V1PersistentVolumeStatus, + "V1PhotonPersistentDiskVolumeSource": V1PhotonPersistentDiskVolumeSource, + "V1Pod": V1Pod, + "V1PodAffinity": V1PodAffinity, + "V1PodAffinityTerm": V1PodAffinityTerm, + "V1PodAntiAffinity": V1PodAntiAffinity, + "V1PodCertificateProjection": V1PodCertificateProjection, + "V1PodCondition": V1PodCondition, + "V1PodDNSConfig": V1PodDNSConfig, + "V1PodDNSConfigOption": V1PodDNSConfigOption, + "V1PodDisruptionBudget": V1PodDisruptionBudget, + "V1PodDisruptionBudgetList": V1PodDisruptionBudgetList, + "V1PodDisruptionBudgetSpec": V1PodDisruptionBudgetSpec, + "V1PodDisruptionBudgetStatus": V1PodDisruptionBudgetStatus, + "V1PodExtendedResourceClaimStatus": V1PodExtendedResourceClaimStatus, + "V1PodFailurePolicy": V1PodFailurePolicy, + "V1PodFailurePolicyOnExitCodesRequirement": V1PodFailurePolicyOnExitCodesRequirement, + "V1PodFailurePolicyOnPodConditionsPattern": V1PodFailurePolicyOnPodConditionsPattern, + "V1PodFailurePolicyRule": V1PodFailurePolicyRule, + "V1PodIP": V1PodIP, + "V1PodList": V1PodList, + "V1PodOS": V1PodOS, + "V1PodReadinessGate": V1PodReadinessGate, + "V1PodResourceClaim": V1PodResourceClaim, + "V1PodResourceClaimStatus": V1PodResourceClaimStatus, + "V1PodSchedulingGate": V1PodSchedulingGate, + "V1PodSecurityContext": V1PodSecurityContext, + "V1PodSpec": V1PodSpec, + "V1PodStatus": V1PodStatus, + "V1PodTemplate": V1PodTemplate, + "V1PodTemplateList": V1PodTemplateList, + "V1PodTemplateSpec": V1PodTemplateSpec, + "V1PolicyRule": V1PolicyRule, + "V1PolicyRulesWithSubjects": V1PolicyRulesWithSubjects, + "V1PortStatus": V1PortStatus, + "V1PortworxVolumeSource": V1PortworxVolumeSource, + "V1Preconditions": V1Preconditions, + "V1PreferredSchedulingTerm": V1PreferredSchedulingTerm, + "V1PriorityClass": V1PriorityClass, + "V1PriorityClassList": V1PriorityClassList, + "V1PriorityLevelConfiguration": V1PriorityLevelConfiguration, + "V1PriorityLevelConfigurationCondition": V1PriorityLevelConfigurationCondition, + "V1PriorityLevelConfigurationList": V1PriorityLevelConfigurationList, + "V1PriorityLevelConfigurationReference": V1PriorityLevelConfigurationReference, + "V1PriorityLevelConfigurationSpec": V1PriorityLevelConfigurationSpec, + "V1PriorityLevelConfigurationStatus": V1PriorityLevelConfigurationStatus, + "V1Probe": V1Probe, + "V1ProjectedVolumeSource": V1ProjectedVolumeSource, + "V1QueuingConfiguration": V1QueuingConfiguration, + "V1QuobyteVolumeSource": V1QuobyteVolumeSource, + "V1RBDPersistentVolumeSource": V1RBDPersistentVolumeSource, + "V1RBDVolumeSource": V1RBDVolumeSource, + "V1ReplicaSet": V1ReplicaSet, + "V1ReplicaSetCondition": V1ReplicaSetCondition, + "V1ReplicaSetList": V1ReplicaSetList, + "V1ReplicaSetSpec": V1ReplicaSetSpec, + "V1ReplicaSetStatus": V1ReplicaSetStatus, + "V1ReplicationController": V1ReplicationController, + "V1ReplicationControllerCondition": V1ReplicationControllerCondition, + "V1ReplicationControllerList": V1ReplicationControllerList, + "V1ReplicationControllerSpec": V1ReplicationControllerSpec, + "V1ReplicationControllerStatus": V1ReplicationControllerStatus, + "V1ResourceAttributes": V1ResourceAttributes, + "V1ResourceClaimConsumerReference": V1ResourceClaimConsumerReference, + "V1ResourceClaimList": V1ResourceClaimList, + "V1ResourceClaimSpec": V1ResourceClaimSpec, + "V1ResourceClaimStatus": V1ResourceClaimStatus, + "V1ResourceClaimTemplate": V1ResourceClaimTemplate, + "V1ResourceClaimTemplateList": V1ResourceClaimTemplateList, + "V1ResourceClaimTemplateSpec": V1ResourceClaimTemplateSpec, + "V1ResourceFieldSelector": V1ResourceFieldSelector, + "V1ResourceHealth": V1ResourceHealth, + "V1ResourcePolicyRule": V1ResourcePolicyRule, + "V1ResourcePool": V1ResourcePool, + "V1ResourceQuota": V1ResourceQuota, + "V1ResourceQuotaList": V1ResourceQuotaList, + "V1ResourceQuotaSpec": V1ResourceQuotaSpec, + "V1ResourceQuotaStatus": V1ResourceQuotaStatus, + "V1ResourceRequirements": V1ResourceRequirements, + "V1ResourceRule": V1ResourceRule, + "V1ResourceSlice": V1ResourceSlice, + "V1ResourceSliceList": V1ResourceSliceList, + "V1ResourceSliceSpec": V1ResourceSliceSpec, + "V1ResourceStatus": V1ResourceStatus, + "V1Role": V1Role, + "V1RoleBinding": V1RoleBinding, + "V1RoleBindingList": V1RoleBindingList, + "V1RoleList": V1RoleList, + "V1RoleRef": V1RoleRef, + "V1RollingUpdateDaemonSet": V1RollingUpdateDaemonSet, + "V1RollingUpdateDeployment": V1RollingUpdateDeployment, + "V1RollingUpdateStatefulSetStrategy": V1RollingUpdateStatefulSetStrategy, + "V1RuleWithOperations": V1RuleWithOperations, + "V1RuntimeClass": V1RuntimeClass, + "V1RuntimeClassList": V1RuntimeClassList, + "V1SELinuxOptions": V1SELinuxOptions, + "V1Scale": V1Scale, + "V1ScaleIOPersistentVolumeSource": V1ScaleIOPersistentVolumeSource, + "V1ScaleIOVolumeSource": V1ScaleIOVolumeSource, + "V1ScaleSpec": V1ScaleSpec, + "V1ScaleStatus": V1ScaleStatus, + "V1Scheduling": V1Scheduling, + "V1ScopeSelector": V1ScopeSelector, + "V1ScopedResourceSelectorRequirement": V1ScopedResourceSelectorRequirement, + "V1SeccompProfile": V1SeccompProfile, + "V1Secret": V1Secret, + "V1SecretEnvSource": V1SecretEnvSource, + "V1SecretKeySelector": V1SecretKeySelector, + "V1SecretList": V1SecretList, + "V1SecretProjection": V1SecretProjection, + "V1SecretReference": V1SecretReference, + "V1SecretVolumeSource": V1SecretVolumeSource, + "V1SecurityContext": V1SecurityContext, + "V1SelectableField": V1SelectableField, + "V1SelfSubjectAccessReview": V1SelfSubjectAccessReview, + "V1SelfSubjectAccessReviewSpec": V1SelfSubjectAccessReviewSpec, + "V1SelfSubjectReview": V1SelfSubjectReview, + "V1SelfSubjectReviewStatus": V1SelfSubjectReviewStatus, + "V1SelfSubjectRulesReview": V1SelfSubjectRulesReview, + "V1SelfSubjectRulesReviewSpec": V1SelfSubjectRulesReviewSpec, + "V1ServerAddressByClientCIDR": V1ServerAddressByClientCIDR, + "V1Service": V1Service, + "V1ServiceAccount": V1ServiceAccount, + "V1ServiceAccountList": V1ServiceAccountList, + "V1ServiceAccountSubject": V1ServiceAccountSubject, + "V1ServiceAccountTokenProjection": V1ServiceAccountTokenProjection, + "V1ServiceBackendPort": V1ServiceBackendPort, + "V1ServiceCIDR": V1ServiceCIDR, + "V1ServiceCIDRList": V1ServiceCIDRList, + "V1ServiceCIDRSpec": V1ServiceCIDRSpec, + "V1ServiceCIDRStatus": V1ServiceCIDRStatus, + "V1ServiceList": V1ServiceList, + "V1ServicePort": V1ServicePort, + "V1ServiceSpec": V1ServiceSpec, + "V1ServiceStatus": V1ServiceStatus, + "V1SessionAffinityConfig": V1SessionAffinityConfig, + "V1SleepAction": V1SleepAction, + "V1StatefulSet": V1StatefulSet, + "V1StatefulSetCondition": V1StatefulSetCondition, + "V1StatefulSetList": V1StatefulSetList, + "V1StatefulSetOrdinals": V1StatefulSetOrdinals, + "V1StatefulSetPersistentVolumeClaimRetentionPolicy": V1StatefulSetPersistentVolumeClaimRetentionPolicy, + "V1StatefulSetSpec": V1StatefulSetSpec, + "V1StatefulSetStatus": V1StatefulSetStatus, + "V1StatefulSetUpdateStrategy": V1StatefulSetUpdateStrategy, + "V1Status": V1Status, + "V1StatusCause": V1StatusCause, + "V1StatusDetails": V1StatusDetails, + "V1StorageClass": V1StorageClass, + "V1StorageClassList": V1StorageClassList, + "V1StorageOSPersistentVolumeSource": V1StorageOSPersistentVolumeSource, + "V1StorageOSVolumeSource": V1StorageOSVolumeSource, + "V1SubjectAccessReview": V1SubjectAccessReview, + "V1SubjectAccessReviewSpec": V1SubjectAccessReviewSpec, + "V1SubjectAccessReviewStatus": V1SubjectAccessReviewStatus, + "V1SubjectRulesReviewStatus": V1SubjectRulesReviewStatus, + "V1SuccessPolicy": V1SuccessPolicy, + "V1SuccessPolicyRule": V1SuccessPolicyRule, + "V1Sysctl": V1Sysctl, + "V1TCPSocketAction": V1TCPSocketAction, + "V1Taint": V1Taint, + "V1TokenRequestSpec": V1TokenRequestSpec, + "V1TokenRequestStatus": V1TokenRequestStatus, + "V1TokenReview": V1TokenReview, + "V1TokenReviewSpec": V1TokenReviewSpec, + "V1TokenReviewStatus": V1TokenReviewStatus, + "V1Toleration": V1Toleration, + "V1TopologySelectorLabelRequirement": V1TopologySelectorLabelRequirement, + "V1TopologySelectorTerm": V1TopologySelectorTerm, + "V1TopologySpreadConstraint": V1TopologySpreadConstraint, + "V1TypeChecking": V1TypeChecking, + "V1TypedLocalObjectReference": V1TypedLocalObjectReference, + "V1TypedObjectReference": V1TypedObjectReference, + "V1UncountedTerminatedPods": V1UncountedTerminatedPods, + "V1UserInfo": V1UserInfo, + "V1UserSubject": V1UserSubject, + "V1ValidatingAdmissionPolicy": V1ValidatingAdmissionPolicy, + "V1ValidatingAdmissionPolicyBinding": V1ValidatingAdmissionPolicyBinding, + "V1ValidatingAdmissionPolicyBindingList": V1ValidatingAdmissionPolicyBindingList, + "V1ValidatingAdmissionPolicyBindingSpec": V1ValidatingAdmissionPolicyBindingSpec, + "V1ValidatingAdmissionPolicyList": V1ValidatingAdmissionPolicyList, + "V1ValidatingAdmissionPolicySpec": V1ValidatingAdmissionPolicySpec, + "V1ValidatingAdmissionPolicyStatus": V1ValidatingAdmissionPolicyStatus, + "V1ValidatingWebhook": V1ValidatingWebhook, + "V1ValidatingWebhookConfiguration": V1ValidatingWebhookConfiguration, + "V1ValidatingWebhookConfigurationList": V1ValidatingWebhookConfigurationList, + "V1Validation": V1Validation, + "V1ValidationRule": V1ValidationRule, + "V1Variable": V1Variable, + "V1Volume": V1Volume, + "V1VolumeAttachment": V1VolumeAttachment, + "V1VolumeAttachmentList": V1VolumeAttachmentList, + "V1VolumeAttachmentSource": V1VolumeAttachmentSource, + "V1VolumeAttachmentSpec": V1VolumeAttachmentSpec, + "V1VolumeAttachmentStatus": V1VolumeAttachmentStatus, + "V1VolumeAttributesClass": V1VolumeAttributesClass, + "V1VolumeAttributesClassList": V1VolumeAttributesClassList, + "V1VolumeDevice": V1VolumeDevice, + "V1VolumeError": V1VolumeError, + "V1VolumeMount": V1VolumeMount, + "V1VolumeMountStatus": V1VolumeMountStatus, + "V1VolumeNodeAffinity": V1VolumeNodeAffinity, + "V1VolumeNodeResources": V1VolumeNodeResources, + "V1VolumeProjection": V1VolumeProjection, + "V1VolumeResourceRequirements": V1VolumeResourceRequirements, + "V1VsphereVirtualDiskVolumeSource": V1VsphereVirtualDiskVolumeSource, + "V1WatchEvent": V1WatchEvent, + "V1WebhookConversion": V1WebhookConversion, + "V1WeightedPodAffinityTerm": V1WeightedPodAffinityTerm, + "V1WindowsSecurityContextOptions": V1WindowsSecurityContextOptions, + "V1alpha1ApplyConfiguration": V1alpha1ApplyConfiguration, + "V1alpha1ClusterTrustBundle": V1alpha1ClusterTrustBundle, + "V1alpha1ClusterTrustBundleList": V1alpha1ClusterTrustBundleList, + "V1alpha1ClusterTrustBundleSpec": V1alpha1ClusterTrustBundleSpec, + "V1alpha1GroupVersionResource": V1alpha1GroupVersionResource, + "V1alpha1JSONPatch": V1alpha1JSONPatch, + "V1alpha1MatchCondition": V1alpha1MatchCondition, + "V1alpha1MatchResources": V1alpha1MatchResources, + "V1alpha1MigrationCondition": V1alpha1MigrationCondition, + "V1alpha1MutatingAdmissionPolicy": V1alpha1MutatingAdmissionPolicy, + "V1alpha1MutatingAdmissionPolicyBinding": V1alpha1MutatingAdmissionPolicyBinding, + "V1alpha1MutatingAdmissionPolicyBindingList": V1alpha1MutatingAdmissionPolicyBindingList, + "V1alpha1MutatingAdmissionPolicyBindingSpec": V1alpha1MutatingAdmissionPolicyBindingSpec, + "V1alpha1MutatingAdmissionPolicyList": V1alpha1MutatingAdmissionPolicyList, + "V1alpha1MutatingAdmissionPolicySpec": V1alpha1MutatingAdmissionPolicySpec, + "V1alpha1Mutation": V1alpha1Mutation, + "V1alpha1NamedRuleWithOperations": V1alpha1NamedRuleWithOperations, + "V1alpha1ParamKind": V1alpha1ParamKind, + "V1alpha1ParamRef": V1alpha1ParamRef, + "V1alpha1PodCertificateRequest": V1alpha1PodCertificateRequest, + "V1alpha1PodCertificateRequestList": V1alpha1PodCertificateRequestList, + "V1alpha1PodCertificateRequestSpec": V1alpha1PodCertificateRequestSpec, + "V1alpha1PodCertificateRequestStatus": V1alpha1PodCertificateRequestStatus, + "V1alpha1ServerStorageVersion": V1alpha1ServerStorageVersion, + "V1alpha1StorageVersion": V1alpha1StorageVersion, + "V1alpha1StorageVersionCondition": V1alpha1StorageVersionCondition, + "V1alpha1StorageVersionList": V1alpha1StorageVersionList, + "V1alpha1StorageVersionMigration": V1alpha1StorageVersionMigration, + "V1alpha1StorageVersionMigrationList": V1alpha1StorageVersionMigrationList, + "V1alpha1StorageVersionMigrationSpec": V1alpha1StorageVersionMigrationSpec, + "V1alpha1StorageVersionMigrationStatus": V1alpha1StorageVersionMigrationStatus, + "V1alpha1StorageVersionStatus": V1alpha1StorageVersionStatus, + "V1alpha1Variable": V1alpha1Variable, + "V1alpha1VolumeAttributesClass": V1alpha1VolumeAttributesClass, + "V1alpha1VolumeAttributesClassList": V1alpha1VolumeAttributesClassList, + "V1alpha2LeaseCandidate": V1alpha2LeaseCandidate, + "V1alpha2LeaseCandidateList": V1alpha2LeaseCandidateList, + "V1alpha2LeaseCandidateSpec": V1alpha2LeaseCandidateSpec, + "V1alpha3CELDeviceSelector": V1alpha3CELDeviceSelector, + "V1alpha3DeviceSelector": V1alpha3DeviceSelector, + "V1alpha3DeviceTaint": V1alpha3DeviceTaint, + "V1alpha3DeviceTaintRule": V1alpha3DeviceTaintRule, + "V1alpha3DeviceTaintRuleList": V1alpha3DeviceTaintRuleList, + "V1alpha3DeviceTaintRuleSpec": V1alpha3DeviceTaintRuleSpec, + "V1alpha3DeviceTaintSelector": V1alpha3DeviceTaintSelector, + "V1beta1AllocatedDeviceStatus": V1beta1AllocatedDeviceStatus, + "V1beta1AllocationResult": V1beta1AllocationResult, + "V1beta1ApplyConfiguration": V1beta1ApplyConfiguration, + "V1beta1BasicDevice": V1beta1BasicDevice, + "V1beta1CELDeviceSelector": V1beta1CELDeviceSelector, + "V1beta1CapacityRequestPolicy": V1beta1CapacityRequestPolicy, + "V1beta1CapacityRequestPolicyRange": V1beta1CapacityRequestPolicyRange, + "V1beta1CapacityRequirements": V1beta1CapacityRequirements, + "V1beta1ClusterTrustBundle": V1beta1ClusterTrustBundle, + "V1beta1ClusterTrustBundleList": V1beta1ClusterTrustBundleList, + "V1beta1ClusterTrustBundleSpec": V1beta1ClusterTrustBundleSpec, + "V1beta1Counter": V1beta1Counter, + "V1beta1CounterSet": V1beta1CounterSet, + "V1beta1Device": V1beta1Device, + "V1beta1DeviceAllocationConfiguration": V1beta1DeviceAllocationConfiguration, + "V1beta1DeviceAllocationResult": V1beta1DeviceAllocationResult, + "V1beta1DeviceAttribute": V1beta1DeviceAttribute, + "V1beta1DeviceCapacity": V1beta1DeviceCapacity, + "V1beta1DeviceClaim": V1beta1DeviceClaim, + "V1beta1DeviceClaimConfiguration": V1beta1DeviceClaimConfiguration, + "V1beta1DeviceClass": V1beta1DeviceClass, + "V1beta1DeviceClassConfiguration": V1beta1DeviceClassConfiguration, + "V1beta1DeviceClassList": V1beta1DeviceClassList, + "V1beta1DeviceClassSpec": V1beta1DeviceClassSpec, + "V1beta1DeviceConstraint": V1beta1DeviceConstraint, + "V1beta1DeviceCounterConsumption": V1beta1DeviceCounterConsumption, + "V1beta1DeviceRequest": V1beta1DeviceRequest, + "V1beta1DeviceRequestAllocationResult": V1beta1DeviceRequestAllocationResult, + "V1beta1DeviceSelector": V1beta1DeviceSelector, + "V1beta1DeviceSubRequest": V1beta1DeviceSubRequest, + "V1beta1DeviceTaint": V1beta1DeviceTaint, + "V1beta1DeviceToleration": V1beta1DeviceToleration, + "V1beta1IPAddress": V1beta1IPAddress, + "V1beta1IPAddressList": V1beta1IPAddressList, + "V1beta1IPAddressSpec": V1beta1IPAddressSpec, + "V1beta1JSONPatch": V1beta1JSONPatch, + "V1beta1LeaseCandidate": V1beta1LeaseCandidate, + "V1beta1LeaseCandidateList": V1beta1LeaseCandidateList, + "V1beta1LeaseCandidateSpec": V1beta1LeaseCandidateSpec, + "V1beta1MatchCondition": V1beta1MatchCondition, + "V1beta1MatchResources": V1beta1MatchResources, + "V1beta1MutatingAdmissionPolicy": V1beta1MutatingAdmissionPolicy, + "V1beta1MutatingAdmissionPolicyBinding": V1beta1MutatingAdmissionPolicyBinding, + "V1beta1MutatingAdmissionPolicyBindingList": V1beta1MutatingAdmissionPolicyBindingList, + "V1beta1MutatingAdmissionPolicyBindingSpec": V1beta1MutatingAdmissionPolicyBindingSpec, + "V1beta1MutatingAdmissionPolicyList": V1beta1MutatingAdmissionPolicyList, + "V1beta1MutatingAdmissionPolicySpec": V1beta1MutatingAdmissionPolicySpec, + "V1beta1Mutation": V1beta1Mutation, + "V1beta1NamedRuleWithOperations": V1beta1NamedRuleWithOperations, + "V1beta1NetworkDeviceData": V1beta1NetworkDeviceData, + "V1beta1OpaqueDeviceConfiguration": V1beta1OpaqueDeviceConfiguration, + "V1beta1ParamKind": V1beta1ParamKind, + "V1beta1ParamRef": V1beta1ParamRef, + "V1beta1ParentReference": V1beta1ParentReference, + "V1beta1ResourceClaim": V1beta1ResourceClaim, + "V1beta1ResourceClaimConsumerReference": V1beta1ResourceClaimConsumerReference, + "V1beta1ResourceClaimList": V1beta1ResourceClaimList, + "V1beta1ResourceClaimSpec": V1beta1ResourceClaimSpec, + "V1beta1ResourceClaimStatus": V1beta1ResourceClaimStatus, + "V1beta1ResourceClaimTemplate": V1beta1ResourceClaimTemplate, + "V1beta1ResourceClaimTemplateList": V1beta1ResourceClaimTemplateList, + "V1beta1ResourceClaimTemplateSpec": V1beta1ResourceClaimTemplateSpec, + "V1beta1ResourcePool": V1beta1ResourcePool, + "V1beta1ResourceSlice": V1beta1ResourceSlice, + "V1beta1ResourceSliceList": V1beta1ResourceSliceList, + "V1beta1ResourceSliceSpec": V1beta1ResourceSliceSpec, + "V1beta1ServiceCIDR": V1beta1ServiceCIDR, + "V1beta1ServiceCIDRList": V1beta1ServiceCIDRList, + "V1beta1ServiceCIDRSpec": V1beta1ServiceCIDRSpec, + "V1beta1ServiceCIDRStatus": V1beta1ServiceCIDRStatus, + "V1beta1Variable": V1beta1Variable, + "V1beta1VolumeAttributesClass": V1beta1VolumeAttributesClass, + "V1beta1VolumeAttributesClassList": V1beta1VolumeAttributesClassList, + "V1beta2AllocatedDeviceStatus": V1beta2AllocatedDeviceStatus, + "V1beta2AllocationResult": V1beta2AllocationResult, + "V1beta2CELDeviceSelector": V1beta2CELDeviceSelector, + "V1beta2CapacityRequestPolicy": V1beta2CapacityRequestPolicy, + "V1beta2CapacityRequestPolicyRange": V1beta2CapacityRequestPolicyRange, + "V1beta2CapacityRequirements": V1beta2CapacityRequirements, + "V1beta2Counter": V1beta2Counter, + "V1beta2CounterSet": V1beta2CounterSet, + "V1beta2Device": V1beta2Device, + "V1beta2DeviceAllocationConfiguration": V1beta2DeviceAllocationConfiguration, + "V1beta2DeviceAllocationResult": V1beta2DeviceAllocationResult, + "V1beta2DeviceAttribute": V1beta2DeviceAttribute, + "V1beta2DeviceCapacity": V1beta2DeviceCapacity, + "V1beta2DeviceClaim": V1beta2DeviceClaim, + "V1beta2DeviceClaimConfiguration": V1beta2DeviceClaimConfiguration, + "V1beta2DeviceClass": V1beta2DeviceClass, + "V1beta2DeviceClassConfiguration": V1beta2DeviceClassConfiguration, + "V1beta2DeviceClassList": V1beta2DeviceClassList, + "V1beta2DeviceClassSpec": V1beta2DeviceClassSpec, + "V1beta2DeviceConstraint": V1beta2DeviceConstraint, + "V1beta2DeviceCounterConsumption": V1beta2DeviceCounterConsumption, + "V1beta2DeviceRequest": V1beta2DeviceRequest, + "V1beta2DeviceRequestAllocationResult": V1beta2DeviceRequestAllocationResult, + "V1beta2DeviceSelector": V1beta2DeviceSelector, + "V1beta2DeviceSubRequest": V1beta2DeviceSubRequest, + "V1beta2DeviceTaint": V1beta2DeviceTaint, + "V1beta2DeviceToleration": V1beta2DeviceToleration, + "V1beta2ExactDeviceRequest": V1beta2ExactDeviceRequest, + "V1beta2NetworkDeviceData": V1beta2NetworkDeviceData, + "V1beta2OpaqueDeviceConfiguration": V1beta2OpaqueDeviceConfiguration, + "V1beta2ResourceClaim": V1beta2ResourceClaim, + "V1beta2ResourceClaimConsumerReference": V1beta2ResourceClaimConsumerReference, + "V1beta2ResourceClaimList": V1beta2ResourceClaimList, + "V1beta2ResourceClaimSpec": V1beta2ResourceClaimSpec, + "V1beta2ResourceClaimStatus": V1beta2ResourceClaimStatus, + "V1beta2ResourceClaimTemplate": V1beta2ResourceClaimTemplate, + "V1beta2ResourceClaimTemplateList": V1beta2ResourceClaimTemplateList, + "V1beta2ResourceClaimTemplateSpec": V1beta2ResourceClaimTemplateSpec, + "V1beta2ResourcePool": V1beta2ResourcePool, + "V1beta2ResourceSlice": V1beta2ResourceSlice, + "V1beta2ResourceSliceList": V1beta2ResourceSliceList, + "V1beta2ResourceSliceSpec": V1beta2ResourceSliceSpec, + "V2ContainerResourceMetricSource": V2ContainerResourceMetricSource, + "V2ContainerResourceMetricStatus": V2ContainerResourceMetricStatus, + "V2CrossVersionObjectReference": V2CrossVersionObjectReference, + "V2ExternalMetricSource": V2ExternalMetricSource, + "V2ExternalMetricStatus": V2ExternalMetricStatus, + "V2HPAScalingPolicy": V2HPAScalingPolicy, + "V2HPAScalingRules": V2HPAScalingRules, + "V2HorizontalPodAutoscaler": V2HorizontalPodAutoscaler, + "V2HorizontalPodAutoscalerBehavior": V2HorizontalPodAutoscalerBehavior, + "V2HorizontalPodAutoscalerCondition": V2HorizontalPodAutoscalerCondition, + "V2HorizontalPodAutoscalerList": V2HorizontalPodAutoscalerList, + "V2HorizontalPodAutoscalerSpec": V2HorizontalPodAutoscalerSpec, + "V2HorizontalPodAutoscalerStatus": V2HorizontalPodAutoscalerStatus, + "V2MetricIdentifier": V2MetricIdentifier, + "V2MetricSpec": V2MetricSpec, + "V2MetricStatus": V2MetricStatus, + "V2MetricTarget": V2MetricTarget, + "V2MetricValueStatus": V2MetricValueStatus, + "V2ObjectMetricSource": V2ObjectMetricSource, + "V2ObjectMetricStatus": V2ObjectMetricStatus, + "V2PodsMetricSource": V2PodsMetricSource, + "V2PodsMetricStatus": V2PodsMetricStatus, + "V2ResourceMetricSource": V2ResourceMetricSource, + "V2ResourceMetricStatus": V2ResourceMetricStatus, + "VersionInfo": VersionInfo +}; +var parseMimeType = (mimeType) => { + const [type2 = "", subtype = ""] = mimeType.split("/"); + return { + type: type2, + subtype, + subtypeTokens: subtype.split("+") + }; +}; +var mimeTypePredicateFactory = (predicate) => (mimeType) => predicate(parseMimeType(mimeType)); +var mimeTypeSimplePredicateFactory = (type2, subtype) => mimeTypePredicateFactory((descriptor) => { + if (descriptor.type !== type2) + return false; + if (subtype != null && descriptor.subtype !== subtype) + return false; + return true; +}); +var isTextLikeMimeType = mimeTypeSimplePredicateFactory("text"); +var isJsonMimeType = mimeTypeSimplePredicateFactory("application", "json"); +var isJsonLikeMimeType = mimeTypePredicateFactory((descriptor) => descriptor.type === "application" && descriptor.subtypeTokens.some((item) => item === "json")); +var isOctetStreamMimeType = mimeTypeSimplePredicateFactory("application", "octet-stream"); +var isFormUrlencodedMimeType = mimeTypeSimplePredicateFactory("application", "x-www-form-urlencoded"); +var supportedMimeTypePredicatesWithPriority = [ + isJsonMimeType, + isJsonLikeMimeType, + isTextLikeMimeType, + isOctetStreamMimeType, + isFormUrlencodedMimeType +]; +var nullableSuffix = " | null"; +var optionalSuffix = " | undefined"; +var arrayPrefix = "Array<"; +var arraySuffix = ">"; +var mapPrefix = "{ [key: string]: "; +var mapSuffix = "; }"; +var ObjectSerializer = class _ObjectSerializer { + static findCorrectType(data, expectedType) { + if (data == void 0) { + return expectedType; + } else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) { + return expectedType; + } else if (expectedType === "Date") { + return expectedType; + } else { + if (enumsMap.has(expectedType)) { + return expectedType; + } + if (!typeMap[expectedType]) { + return expectedType; + } + let discriminatorProperty = typeMap[expectedType].discriminator; + if (discriminatorProperty == null) { + return expectedType; + } else { + if (data[discriminatorProperty]) { + var discriminatorType = data[discriminatorProperty]; + let mapping = typeMap[expectedType].mapping; + if (mapping != void 0 && mapping[discriminatorType]) { + return mapping[discriminatorType]; + } else if (typeMap[discriminatorType]) { + return discriminatorType; + } else { + return expectedType; + } + } else { + return expectedType; + } + } + } + } + static serialize(data, type2, format2) { + if (data == void 0) { + return data; + } else if (primitives.indexOf(type2.toLowerCase()) !== -1) { + return data; + } else if (type2.endsWith(nullableSuffix)) { + let subType = type2.slice(0, -nullableSuffix.length); + return _ObjectSerializer.serialize(data, subType, format2); + } else if (type2.endsWith(optionalSuffix)) { + let subType = type2.slice(0, -optionalSuffix.length); + return _ObjectSerializer.serialize(data, subType, format2); + } else if (type2.startsWith(arrayPrefix)) { + let subType = type2.slice(arrayPrefix.length, -arraySuffix.length); + let transformedData = []; + for (let date of data) { + transformedData.push(_ObjectSerializer.serialize(date, subType, format2)); + } + return transformedData; + } else if (type2.startsWith(mapPrefix)) { + let subType = type2.slice(mapPrefix.length, -mapSuffix.length); + let transformedData = {}; + for (let key in data) { + transformedData[key] = _ObjectSerializer.serialize(data[key], subType, format2); + } + return transformedData; + } else if (type2 === "Date") { + if (!(data instanceof Date)) { + return data; + } + if (format2 == "date") { + let month = data.getMonth() + 1; + let monthStr = month < 10 ? "0" + month.toString() : month.toString(); + let day = data.getDate(); + let dayStr = day < 10 ? "0" + day.toString() : day.toString(); + return data.getFullYear() + "-" + monthStr + "-" + dayStr; + } else { + return data.toISOString(); + } + } else { + if (enumsMap.has(type2)) { + return data; + } + if (!typeMap[type2]) { + return data; + } + type2 = this.findCorrectType(data, type2); + let attributeTypes = typeMap[type2].getAttributeTypeMap(); + let instance = {}; + for (let attributeType of attributeTypes) { + instance[attributeType.baseName] = _ObjectSerializer.serialize(data[attributeType.name], attributeType.type, attributeType.format); + } + return instance; + } + } + static deserialize(data, type2, format2) { + type2 = _ObjectSerializer.findCorrectType(data, type2); + if (data == void 0) { + return data; + } else if (primitives.indexOf(type2.toLowerCase()) !== -1) { + return data; + } else if (type2.endsWith(nullableSuffix)) { + let subType = type2.slice(0, -nullableSuffix.length); + return _ObjectSerializer.deserialize(data, subType, format2); + } else if (type2.endsWith(optionalSuffix)) { + let subType = type2.slice(0, -optionalSuffix.length); + return _ObjectSerializer.deserialize(data, subType, format2); + } else if (type2.startsWith(arrayPrefix)) { + let subType = type2.slice(arrayPrefix.length, -arraySuffix.length); + let transformedData = []; + for (let date of data) { + transformedData.push(_ObjectSerializer.deserialize(date, subType, format2)); + } + return transformedData; + } else if (type2.startsWith(mapPrefix)) { + let subType = type2.slice(mapPrefix.length, -mapSuffix.length); + let transformedData = {}; + for (let key in data) { + transformedData[key] = _ObjectSerializer.deserialize(data[key], subType, format2); + } + return transformedData; + } else if (type2 === "Date") { + return new Date(data); + } else { + if (enumsMap.has(type2)) { + return data; + } + if (!typeMap[type2]) { + return data; + } + let instance = new typeMap[type2](); + let attributeTypes = typeMap[type2].getAttributeTypeMap(); + for (let attributeType of attributeTypes) { + let value = _ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type, attributeType.format); + if (value !== void 0) { + instance[attributeType.name] = value; + } + } + return instance; + } + } + /** + * Normalize media type + * + * We currently do not handle any media types attributes, i.e. anything + * after a semicolon. All content is assumed to be UTF-8 compatible. + */ + static normalizeMediaType(mediaType) { + var _a; + if (mediaType === void 0) { + return void 0; + } + return ((_a = mediaType.split(";")[0]) !== null && _a !== void 0 ? _a : "").trim().toLowerCase(); + } + /** + * From a list of possible media types, choose the one we can handle best. + * + * The order of the given media types does not have any impact on the choice + * made. + */ + static getPreferredMediaType(mediaTypes) { + if (mediaTypes.length === 0) { + return "application/json"; + } + const normalMediaTypes = mediaTypes.map(_ObjectSerializer.normalizeMediaType); + for (const predicate of supportedMimeTypePredicatesWithPriority) { + for (const mediaType of normalMediaTypes) { + if (mediaType != null && predicate(mediaType)) { + return mediaType; + } + } + } + throw new Error("None of the given media types are supported: " + mediaTypes.join(", ")); + } + /** + * Convert data to a string according the given media type + */ + static stringify(data, mediaType) { + if (isTextLikeMimeType(mediaType)) { + return String(data); + } + if (isJsonLikeMimeType(mediaType)) { + return JSON.stringify(data); + } + throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.stringify."); + } + /** + * Parse data from a string according to the given media type + */ + static parse(rawData, mediaType) { + if (mediaType === void 0) { + throw new Error("Cannot parse content. No Content-Type defined."); + } + if (isTextLikeMimeType(mediaType)) { + return rawData; + } + if (isJsonLikeMimeType(mediaType)) { + return JSON.parse(rawData); + } + throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse."); + } +}; + +// node_modules/oauth4webapi/build/index.js +var USER_AGENT; +if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) { + const NAME = "oauth4webapi"; + const VERSION = "v3.8.5"; + USER_AGENT = `${NAME}/${VERSION}`; +} +function looseInstanceOf(input, expected) { + if (input == null) { + return false; + } + try { + return input instanceof expected || Object.getPrototypeOf(input)[Symbol.toStringTag] === expected.prototype[Symbol.toStringTag]; + } catch { + return false; + } +} +var ERR_INVALID_ARG_VALUE = "ERR_INVALID_ARG_VALUE"; +var ERR_INVALID_ARG_TYPE = "ERR_INVALID_ARG_TYPE"; +function CodedTypeError(message, code, cause) { + const err = new TypeError(message, { cause }); + Object.assign(err, { code }); + return err; +} +var allowInsecureRequests = /* @__PURE__ */ Symbol(); +var clockSkew = /* @__PURE__ */ Symbol(); +var clockTolerance = /* @__PURE__ */ Symbol(); +var customFetch = /* @__PURE__ */ Symbol(); +var jweDecrypt = /* @__PURE__ */ Symbol(); +var encoder = new TextEncoder(); +var decoder = new TextDecoder(); +function buf(input) { + if (typeof input === "string") { + return encoder.encode(input); + } + return decoder.decode(input); +} +var encodeBase64Url; +if (Uint8Array.prototype.toBase64) { + encodeBase64Url = (input) => { + if (input instanceof ArrayBuffer) { + input = new Uint8Array(input); + } + return input.toBase64({ alphabet: "base64url", omitPadding: true }); + }; +} else { + const CHUNK_SIZE = 32768; + encodeBase64Url = (input) => { + if (input instanceof ArrayBuffer) { + input = new Uint8Array(input); + } + const arr = []; + for (let i = 0; i < input.byteLength; i += CHUNK_SIZE) { + arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE))); + } + return btoa(arr.join("")).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_"); + }; +} +var decodeBase64Url; +if (Uint8Array.fromBase64) { + decodeBase64Url = (input) => { + try { + return Uint8Array.fromBase64(input, { alphabet: "base64url" }); + } catch (cause) { + throw CodedTypeError("The input to be decoded is not correctly encoded.", ERR_INVALID_ARG_VALUE, cause); + } + }; +} else { + decodeBase64Url = (input) => { + try { + const binary2 = atob(input.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "")); + const bytes = new Uint8Array(binary2.length); + for (let i = 0; i < binary2.length; i++) { + bytes[i] = binary2.charCodeAt(i); + } + return bytes; + } catch (cause) { + throw CodedTypeError("The input to be decoded is not correctly encoded.", ERR_INVALID_ARG_VALUE, cause); + } + }; +} +function b64u(input) { + if (typeof input === "string") { + return decodeBase64Url(input); + } + return encodeBase64Url(input); +} +var UnsupportedOperationError = class extends Error { + code; + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + this.code = UNSUPPORTED_OPERATION; + Error.captureStackTrace?.(this, this.constructor); + } +}; +var OperationProcessingError = class extends Error { + code; + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + if (options?.code) { + this.code = options?.code; + } + Error.captureStackTrace?.(this, this.constructor); + } +}; +function OPE(message, code, cause) { + return new OperationProcessingError(message, { code, cause }); +} +function isJsonObject(input) { + if (input === null || typeof input !== "object" || Array.isArray(input)) { + return false; + } + return true; +} +function prepareHeaders(input) { + if (looseInstanceOf(input, Headers)) { + input = Object.fromEntries(input.entries()); + } + const headers2 = new Headers(input ?? {}); + if (USER_AGENT && !headers2.has("user-agent")) { + headers2.set("user-agent", USER_AGENT); + } + if (headers2.has("authorization")) { + throw CodedTypeError('"options.headers" must not include the "authorization" header name', ERR_INVALID_ARG_VALUE); + } + return headers2; +} +function signal(url, value) { + if (value !== void 0) { + if (typeof value === "function") { + value = value(url.href); + } + if (!(value instanceof AbortSignal)) { + throw CodedTypeError('"options.signal" must return or be an instance of AbortSignal', ERR_INVALID_ARG_TYPE); + } + return value; + } + return void 0; +} +function replaceDoubleSlash(pathname) { + if (pathname.includes("//")) { + return pathname.replace("//", "/"); + } + return pathname; +} +function prependWellKnown(url, wellKnown, allowTerminatingSlash = false) { + if (url.pathname === "/") { + url.pathname = wellKnown; + } else { + url.pathname = replaceDoubleSlash(`${wellKnown}/${allowTerminatingSlash ? url.pathname : url.pathname.replace(/(\/)$/, "")}`); + } + return url; +} +function appendWellKnown(url, wellKnown) { + url.pathname = replaceDoubleSlash(`${url.pathname}/${wellKnown}`); + return url; +} +async function performDiscovery(input, urlName, transform, options) { + if (!(input instanceof URL)) { + throw CodedTypeError(`"${urlName}" must be an instance of URL`, ERR_INVALID_ARG_TYPE); + } + checkProtocol(input, options?.[allowInsecureRequests] !== true); + const url = transform(new URL(input.href)); + const headers2 = prepareHeaders(options?.headers); + headers2.set("accept", "application/json"); + return (options?.[customFetch] || fetch)(url.href, { + body: void 0, + headers: Object.fromEntries(headers2.entries()), + method: "GET", + redirect: "manual", + signal: signal(url, options?.signal) + }); +} +async function discoveryRequest(issuerIdentifier, options) { + return performDiscovery(issuerIdentifier, "issuerIdentifier", (url) => { + switch (options?.algorithm) { + case void 0: + case "oidc": + appendWellKnown(url, ".well-known/openid-configuration"); + break; + case "oauth2": + prependWellKnown(url, ".well-known/oauth-authorization-server"); + break; + default: + throw CodedTypeError('"options.algorithm" must be "oidc" (default), or "oauth2"', ERR_INVALID_ARG_VALUE); + } + return url; + }, options); +} +function assertNumber(input, allow0, it, code, cause) { + try { + if (typeof input !== "number" || !Number.isFinite(input)) { + throw CodedTypeError(`${it} must be a number`, ERR_INVALID_ARG_TYPE, cause); + } + if (input > 0) + return; + if (allow0) { + if (input !== 0) { + throw CodedTypeError(`${it} must be a non-negative number`, ERR_INVALID_ARG_VALUE, cause); + } + return; + } + throw CodedTypeError(`${it} must be a positive number`, ERR_INVALID_ARG_VALUE, cause); + } catch (err) { + if (code) { + throw OPE(err.message, code, cause); + } + throw err; + } +} +function assertString(input, it, code, cause) { + try { + if (typeof input !== "string") { + throw CodedTypeError(`${it} must be a string`, ERR_INVALID_ARG_TYPE, cause); + } + if (input.length === 0) { + throw CodedTypeError(`${it} must not be empty`, ERR_INVALID_ARG_VALUE, cause); + } + } catch (err) { + if (code) { + throw OPE(err.message, code, cause); + } + throw err; + } +} +async function processDiscoveryResponse(expectedIssuerIdentifier, response) { + const expected = expectedIssuerIdentifier; + if (!(expected instanceof URL) && expected !== _nodiscoverycheck) { + throw CodedTypeError('"expectedIssuerIdentifier" must be an instance of URL', ERR_INVALID_ARG_TYPE); + } + if (!looseInstanceOf(response, Response)) { + throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE); + } + if (response.status !== 200) { + throw OPE('"response" is not a conform Authorization Server Metadata response (unexpected HTTP status code)', RESPONSE_IS_NOT_CONFORM, response); + } + assertReadableResponse(response); + const json2 = await getResponseJsonBody(response); + assertString(json2.issuer, '"response" body "issuer" property', INVALID_RESPONSE, { body: json2 }); + if (expected !== _nodiscoverycheck && new URL(json2.issuer).href !== expected.href) { + throw OPE('"response" body "issuer" property does not match the expected value', JSON_ATTRIBUTE_COMPARISON, { expected: expected.href, body: json2, attribute: "issuer" }); + } + return json2; +} +function assertApplicationJson(response) { + assertContentType(response, "application/json"); +} +function notJson(response, ...types2) { + let msg = '"response" content-type must be '; + if (types2.length > 2) { + const last = types2.pop(); + msg += `${types2.join(", ")}, or ${last}`; + } else if (types2.length === 2) { + msg += `${types2[0]} or ${types2[1]}`; + } else { + msg += types2[0]; + } + return OPE(msg, RESPONSE_IS_NOT_JSON, response); +} +function assertContentType(response, contentType) { + if (getContentType(response) !== contentType) { + throw notJson(response, contentType); + } +} +function getClockSkew(client) { + const skew = client?.[clockSkew]; + return typeof skew === "number" && Number.isFinite(skew) ? skew : 0; +} +function getClockTolerance(client) { + const tolerance = client?.[clockTolerance]; + return typeof tolerance === "number" && Number.isFinite(tolerance) && Math.sign(tolerance) !== -1 ? tolerance : 30; +} +function epochTime() { + return Math.floor(Date.now() / 1e3); +} +function assertAs(as) { + if (typeof as !== "object" || as === null) { + throw CodedTypeError('"as" must be an object', ERR_INVALID_ARG_TYPE); + } + assertString(as.issuer, '"as.issuer"'); +} +function assertClient(client) { + if (typeof client !== "object" || client === null) { + throw CodedTypeError('"client" must be an object', ERR_INVALID_ARG_TYPE); + } + assertString(client.client_id, '"client.client_id"'); +} +function ClientSecretPost(clientSecret) { + assertString(clientSecret, '"clientSecret"'); + return (_as, client, body, _headers) => { + body.set("client_id", client.client_id); + body.set("client_secret", clientSecret); + }; +} +function None() { + return (_as, client, body, _headers) => { + body.set("client_id", client.client_id); + }; +} +var URLParse = URL.parse ? (url, base) => URL.parse(url, base) : (url, base) => { + try { + return new URL(url, base); + } catch { + return null; + } +}; +function checkProtocol(url, enforceHttps) { + if (enforceHttps && url.protocol !== "https:") { + throw OPE("only requests to HTTPS are allowed", HTTP_REQUEST_FORBIDDEN, url); + } + if (url.protocol !== "https:" && url.protocol !== "http:") { + throw OPE("only HTTP and HTTPS requests are allowed", REQUEST_PROTOCOL_FORBIDDEN, url); + } +} +function validateEndpoint(value, endpoint, useMtlsAlias, enforceHttps) { + let url; + if (typeof value !== "string" || !(url = URLParse(value))) { + throw OPE(`authorization server metadata does not contain a valid ${useMtlsAlias ? `"as.mtls_endpoint_aliases.${endpoint}"` : `"as.${endpoint}"`}`, value === void 0 ? MISSING_SERVER_METADATA : INVALID_SERVER_METADATA, { attribute: useMtlsAlias ? `mtls_endpoint_aliases.${endpoint}` : endpoint }); + } + checkProtocol(url, enforceHttps); + return url; +} +function resolveEndpoint(as, endpoint, useMtlsAlias, enforceHttps) { + if (useMtlsAlias && as.mtls_endpoint_aliases && endpoint in as.mtls_endpoint_aliases) { + return validateEndpoint(as.mtls_endpoint_aliases[endpoint], endpoint, useMtlsAlias, enforceHttps); + } + return validateEndpoint(as[endpoint], endpoint, useMtlsAlias, enforceHttps); +} +function isDPoPNonceError(err) { + if (err instanceof WWWAuthenticateChallengeError) { + const { 0: challenge, length } = err.cause; + return length === 1 && challenge.scheme === "dpop" && challenge.parameters.error === "use_dpop_nonce"; + } + if (err instanceof ResponseBodyError) { + return err.error === "use_dpop_nonce"; + } + return false; +} +var ResponseBodyError = class extends Error { + cause; + code; + error; + status; + error_description; + response; + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + this.code = RESPONSE_BODY_ERROR; + this.cause = options.cause; + this.error = options.cause.error; + this.status = options.response.status; + this.error_description = options.cause.error_description; + Object.defineProperty(this, "response", { enumerable: false, value: options.response }); + Error.captureStackTrace?.(this, this.constructor); + } +}; +var AuthorizationResponseError = class extends Error { + cause; + code; + error; + error_description; + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + this.code = AUTHORIZATION_RESPONSE_ERROR; + this.cause = options.cause; + this.error = options.cause.get("error"); + this.error_description = options.cause.get("error_description") ?? void 0; + Error.captureStackTrace?.(this, this.constructor); + } +}; +var WWWAuthenticateChallengeError = class extends Error { + cause; + code; + response; + status; + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + this.code = WWW_AUTHENTICATE_CHALLENGE; + this.cause = options.cause; + this.status = options.response.status; + this.response = options.response; + Object.defineProperty(this, "response", { enumerable: false }); + Error.captureStackTrace?.(this, this.constructor); + } +}; +var tokenMatch = "[a-zA-Z0-9!#$%&\\'\\*\\+\\-\\.\\^_`\\|~]+"; +var token68Match = "[a-zA-Z0-9\\-\\._\\~\\+\\/]+={0,2}"; +var quotedMatch = '"((?:[^"\\\\]|\\\\[\\s\\S])*)"'; +var quotedParamMatcher = "(" + tokenMatch + ")\\s*=\\s*" + quotedMatch; +var paramMatcher = "(" + tokenMatch + ")\\s*=\\s*(" + tokenMatch + ")"; +var schemeRE = new RegExp("^[,\\s]*(" + tokenMatch + ")"); +var quotedParamRE = new RegExp("^[,\\s]*" + quotedParamMatcher + "[,\\s]*(.*)"); +var unquotedParamRE = new RegExp("^[,\\s]*" + paramMatcher + "[,\\s]*(.*)"); +var token68ParamRE = new RegExp("^(" + token68Match + ")(?:$|[,\\s])(.*)"); +function parseWwwAuthenticateChallenges(response) { + if (!looseInstanceOf(response, Response)) { + throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE); + } + const header = response.headers.get("www-authenticate"); + if (header === null) { + return void 0; + } + const challenges = []; + let rest = header; + while (rest) { + let match = rest.match(schemeRE); + const scheme = match?.["1"].toLowerCase(); + if (!scheme) { + return void 0; + } + const afterScheme = rest.substring(match[0].length); + if (afterScheme && !afterScheme.match(/^[\s,]/)) { + return void 0; + } + const spaceMatch = afterScheme.match(/^\s+(.*)$/); + const hasParameters = !!spaceMatch; + rest = spaceMatch ? spaceMatch[1] : void 0; + const parameters = {}; + let token68; + if (hasParameters) { + while (rest) { + let key; + let value; + if (match = rest.match(quotedParamRE)) { + ; + [, key, value, rest] = match; + if (value.includes("\\")) { + try { + value = JSON.parse(`"${value}"`); + } catch { + } + } + parameters[key.toLowerCase()] = value; + continue; + } + if (match = rest.match(unquotedParamRE)) { + ; + [, key, value, rest] = match; + parameters[key.toLowerCase()] = value; + continue; + } + if (match = rest.match(token68ParamRE)) { + if (Object.keys(parameters).length) { + break; + } + ; + [, token68, rest] = match; + break; + } + return void 0; + } + } else { + rest = afterScheme || void 0; + } + const challenge = { scheme, parameters }; + if (token68) { + challenge.token68 = token68; + } + challenges.push(challenge); + } + if (!challenges.length) { + return void 0; + } + return challenges; +} +async function parseOAuthResponseErrorBody(response) { + if (response.status > 399 && response.status < 500) { + assertReadableResponse(response); + assertApplicationJson(response); + try { + const json2 = await response.clone().json(); + if (isJsonObject(json2) && typeof json2.error === "string" && json2.error.length) { + return json2; + } + } catch { + } + } + return void 0; +} +async function checkOAuthBodyError(response, expected, label) { + if (response.status !== expected) { + checkAuthenticationChallenges(response); + let err; + if (err = await parseOAuthResponseErrorBody(response)) { + await response.body?.cancel(); + throw new ResponseBodyError("server responded with an error in the response body", { + cause: err, + response + }); + } + throw OPE(`"response" is not a conform ${label} response (unexpected HTTP status code)`, RESPONSE_IS_NOT_CONFORM, response); + } +} +function assertDPoP(option) { + if (!branded.has(option)) { + throw CodedTypeError('"options.DPoP" is not a valid DPoPHandle', ERR_INVALID_ARG_VALUE); + } +} +function getContentType(input) { + return input.headers.get("content-type")?.split(";")[0]; +} +async function authenticatedRequest(as, client, clientAuthentication, url, body, headers2, options) { + await clientAuthentication(as, client, body, headers2); + headers2.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8"); + return (options?.[customFetch] || fetch)(url.href, { + body, + headers: Object.fromEntries(headers2.entries()), + method: "POST", + redirect: "manual", + signal: signal(url, options?.signal) + }); +} +async function tokenEndpointRequest(as, client, clientAuthentication, grantType, parameters, options) { + const url = resolveEndpoint(as, "token_endpoint", client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true); + parameters.set("grant_type", grantType); + const headers2 = prepareHeaders(options?.headers); + headers2.set("accept", "application/json"); + if (options?.DPoP !== void 0) { + assertDPoP(options.DPoP); + await options.DPoP.addProof(url, headers2, "POST"); + } + const response = await authenticatedRequest(as, client, clientAuthentication, url, parameters, headers2, options); + options?.DPoP?.cacheNonce(response, url); + return response; +} +async function refreshTokenGrantRequest(as, client, clientAuthentication, refreshToken, options) { + assertAs(as); + assertClient(client); + assertString(refreshToken, '"refreshToken"'); + const parameters = new URLSearchParams(options?.additionalParameters); + parameters.set("refresh_token", refreshToken); + return tokenEndpointRequest(as, client, clientAuthentication, "refresh_token", parameters, options); +} +var idTokenClaims = /* @__PURE__ */ new WeakMap(); +var jwtRefs = /* @__PURE__ */ new WeakMap(); +function getValidatedIdTokenClaims(ref) { + if (!ref.id_token) { + return void 0; + } + const claims = idTokenClaims.get(ref); + if (!claims) { + throw CodedTypeError('"ref" was already garbage collected or did not resolve from the proper sources', ERR_INVALID_ARG_VALUE); + } + return claims; +} +async function processGenericAccessTokenResponse(as, client, response, additionalRequiredIdTokenClaims, decryptFn, recognizedTokenTypes) { + assertAs(as); + assertClient(client); + if (!looseInstanceOf(response, Response)) { + throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE); + } + await checkOAuthBodyError(response, 200, "Token Endpoint"); + assertReadableResponse(response); + const json2 = await getResponseJsonBody(response); + assertString(json2.access_token, '"response" body "access_token" property', INVALID_RESPONSE, { + body: json2 + }); + assertString(json2.token_type, '"response" body "token_type" property', INVALID_RESPONSE, { + body: json2 + }); + json2.token_type = json2.token_type.toLowerCase(); + if (json2.expires_in !== void 0) { + let expiresIn = typeof json2.expires_in !== "number" ? parseFloat(json2.expires_in) : json2.expires_in; + assertNumber(expiresIn, true, '"response" body "expires_in" property', INVALID_RESPONSE, { + body: json2 + }); + json2.expires_in = expiresIn; + } + if (json2.refresh_token !== void 0) { + assertString(json2.refresh_token, '"response" body "refresh_token" property', INVALID_RESPONSE, { + body: json2 + }); + } + if (json2.scope !== void 0 && typeof json2.scope !== "string") { + throw OPE('"response" body "scope" property must be a string', INVALID_RESPONSE, { body: json2 }); + } + if (json2.id_token !== void 0) { + assertString(json2.id_token, '"response" body "id_token" property', INVALID_RESPONSE, { + body: json2 + }); + const requiredClaims = ["aud", "exp", "iat", "iss", "sub"]; + if (client.require_auth_time === true) { + requiredClaims.push("auth_time"); + } + if (client.default_max_age !== void 0) { + assertNumber(client.default_max_age, true, '"client.default_max_age"'); + requiredClaims.push("auth_time"); + } + if (additionalRequiredIdTokenClaims?.length) { + requiredClaims.push(...additionalRequiredIdTokenClaims); + } + const { claims, jwt } = await validateJwt(json2.id_token, checkSigningAlgorithm.bind(void 0, client.id_token_signed_response_alg, as.id_token_signing_alg_values_supported, "RS256"), getClockSkew(client), getClockTolerance(client), decryptFn).then(validatePresence.bind(void 0, requiredClaims)).then(validateIssuer.bind(void 0, as)).then(validateAudience.bind(void 0, client.client_id)); + if (Array.isArray(claims.aud) && claims.aud.length !== 1) { + if (claims.azp === void 0) { + throw OPE('ID Token "aud" (audience) claim includes additional untrusted audiences', JWT_CLAIM_COMPARISON, { claims, claim: "aud" }); + } + if (claims.azp !== client.client_id) { + throw OPE('unexpected ID Token "azp" (authorized party) claim value', JWT_CLAIM_COMPARISON, { expected: client.client_id, claims, claim: "azp" }); + } + } + if (claims.auth_time !== void 0) { + assertNumber(claims.auth_time, true, 'ID Token "auth_time" (authentication time)', INVALID_RESPONSE, { claims }); + } + jwtRefs.set(response, jwt); + idTokenClaims.set(json2, claims); + } + if (recognizedTokenTypes?.[json2.token_type] !== void 0) { + recognizedTokenTypes[json2.token_type](response, json2); + } else if (json2.token_type !== "dpop" && json2.token_type !== "bearer") { + throw new UnsupportedOperationError("unsupported `token_type` value", { cause: { body: json2 } }); + } + return json2; +} +function checkAuthenticationChallenges(response) { + let challenges; + if (challenges = parseWwwAuthenticateChallenges(response)) { + throw new WWWAuthenticateChallengeError("server responded with a challenge in the WWW-Authenticate HTTP Header", { cause: challenges, response }); + } +} +async function processRefreshTokenResponse(as, client, response, options) { + return processGenericAccessTokenResponse(as, client, response, void 0, options?.[jweDecrypt], options?.recognizedTokenTypes); +} +function validateAudience(expected, result) { + if (Array.isArray(result.claims.aud)) { + if (!result.claims.aud.includes(expected)) { + throw OPE('unexpected JWT "aud" (audience) claim value', JWT_CLAIM_COMPARISON, { + expected, + claims: result.claims, + claim: "aud" + }); + } + } else if (result.claims.aud !== expected) { + throw OPE('unexpected JWT "aud" (audience) claim value', JWT_CLAIM_COMPARISON, { + expected, + claims: result.claims, + claim: "aud" + }); + } + return result; +} +function validateIssuer(as, result) { + const expected = as[_expectedIssuer]?.(result) ?? as.issuer; + if (result.claims.iss !== expected) { + throw OPE('unexpected JWT "iss" (issuer) claim value', JWT_CLAIM_COMPARISON, { + expected, + claims: result.claims, + claim: "iss" + }); + } + return result; +} +var branded = /* @__PURE__ */ new WeakSet(); +var jwtClaimNames = { + aud: "audience", + c_hash: "code hash", + client_id: "client id", + exp: "expiration time", + iat: "issued at", + iss: "issuer", + jti: "jwt id", + nonce: "nonce", + s_hash: "state hash", + sub: "subject", + ath: "access token hash", + htm: "http method", + htu: "http uri", + cnf: "confirmation", + auth_time: "authentication time" +}; +function validatePresence(required, result) { + for (const claim of required) { + if (result.claims[claim] === void 0) { + throw OPE(`JWT "${claim}" (${jwtClaimNames[claim]}) claim missing`, INVALID_RESPONSE, { + claims: result.claims + }); + } + } + return result; +} +var WWW_AUTHENTICATE_CHALLENGE = "OAUTH_WWW_AUTHENTICATE_CHALLENGE"; +var RESPONSE_BODY_ERROR = "OAUTH_RESPONSE_BODY_ERROR"; +var UNSUPPORTED_OPERATION = "OAUTH_UNSUPPORTED_OPERATION"; +var AUTHORIZATION_RESPONSE_ERROR = "OAUTH_AUTHORIZATION_RESPONSE_ERROR"; +var PARSE_ERROR = "OAUTH_PARSE_ERROR"; +var INVALID_RESPONSE = "OAUTH_INVALID_RESPONSE"; +var RESPONSE_IS_NOT_JSON = "OAUTH_RESPONSE_IS_NOT_JSON"; +var RESPONSE_IS_NOT_CONFORM = "OAUTH_RESPONSE_IS_NOT_CONFORM"; +var HTTP_REQUEST_FORBIDDEN = "OAUTH_HTTP_REQUEST_FORBIDDEN"; +var REQUEST_PROTOCOL_FORBIDDEN = "OAUTH_REQUEST_PROTOCOL_FORBIDDEN"; +var JWT_TIMESTAMP_CHECK = "OAUTH_JWT_TIMESTAMP_CHECK_FAILED"; +var JWT_CLAIM_COMPARISON = "OAUTH_JWT_CLAIM_COMPARISON_FAILED"; +var JSON_ATTRIBUTE_COMPARISON = "OAUTH_JSON_ATTRIBUTE_COMPARISON_FAILED"; +var MISSING_SERVER_METADATA = "OAUTH_MISSING_SERVER_METADATA"; +var INVALID_SERVER_METADATA = "OAUTH_INVALID_SERVER_METADATA"; +function assertReadableResponse(response) { + if (response.bodyUsed) { + throw CodedTypeError('"response" body has been used already', ERR_INVALID_ARG_VALUE); + } +} +async function validateJwt(jws, checkAlg, clockSkew2, clockTolerance2, decryptJwt) { + let { 0: protectedHeader, 1: payload, length } = jws.split("."); + if (length === 5) { + if (decryptJwt !== void 0) { + jws = await decryptJwt(jws); + ({ 0: protectedHeader, 1: payload, length } = jws.split(".")); + } else { + throw new UnsupportedOperationError("JWE decryption is not configured", { cause: jws }); + } + } + if (length !== 3) { + throw OPE("Invalid JWT", INVALID_RESPONSE, jws); + } + let header; + try { + header = JSON.parse(buf(b64u(protectedHeader))); + } catch (cause) { + throw OPE("failed to parse JWT Header body as base64url encoded JSON", PARSE_ERROR, cause); + } + if (!isJsonObject(header)) { + throw OPE("JWT Header must be a top level object", INVALID_RESPONSE, jws); + } + checkAlg(header); + if (header.crit !== void 0) { + throw new UnsupportedOperationError('no JWT "crit" header parameter extensions are supported', { + cause: { header } + }); + } + let claims; + try { + claims = JSON.parse(buf(b64u(payload))); + } catch (cause) { + throw OPE("failed to parse JWT Payload body as base64url encoded JSON", PARSE_ERROR, cause); + } + if (!isJsonObject(claims)) { + throw OPE("JWT Payload must be a top level object", INVALID_RESPONSE, jws); + } + const now = epochTime() + clockSkew2; + if (claims.exp !== void 0) { + if (typeof claims.exp !== "number") { + throw OPE('unexpected JWT "exp" (expiration time) claim type', INVALID_RESPONSE, { claims }); + } + if (claims.exp <= now - clockTolerance2) { + throw OPE('unexpected JWT "exp" (expiration time) claim value, expiration is past current timestamp', JWT_TIMESTAMP_CHECK, { claims, now, tolerance: clockTolerance2, claim: "exp" }); + } + } + if (claims.iat !== void 0) { + if (typeof claims.iat !== "number") { + throw OPE('unexpected JWT "iat" (issued at) claim type', INVALID_RESPONSE, { claims }); + } + } + if (claims.iss !== void 0) { + if (typeof claims.iss !== "string") { + throw OPE('unexpected JWT "iss" (issuer) claim type', INVALID_RESPONSE, { claims }); + } + } + if (claims.nbf !== void 0) { + if (typeof claims.nbf !== "number") { + throw OPE('unexpected JWT "nbf" (not before) claim type', INVALID_RESPONSE, { claims }); + } + if (claims.nbf > now + clockTolerance2) { + throw OPE('unexpected JWT "nbf" (not before) claim value', JWT_TIMESTAMP_CHECK, { + claims, + now, + tolerance: clockTolerance2, + claim: "nbf" + }); + } + } + if (claims.aud !== void 0) { + if (typeof claims.aud !== "string" && !Array.isArray(claims.aud)) { + throw OPE('unexpected JWT "aud" (audience) claim type', INVALID_RESPONSE, { claims }); + } + } + return { header, claims, jwt: jws }; +} +function checkSigningAlgorithm(client, issuer, fallback, header) { + if (client !== void 0) { + if (typeof client === "string" ? header.alg !== client : !client.includes(header.alg)) { + throw OPE('unexpected JWT "alg" header parameter', INVALID_RESPONSE, { + header, + expected: client, + reason: "client configuration" + }); + } + return; + } + if (Array.isArray(issuer)) { + if (!issuer.includes(header.alg)) { + throw OPE('unexpected JWT "alg" header parameter', INVALID_RESPONSE, { + header, + expected: issuer, + reason: "authorization server metadata" + }); + } + return; + } + if (fallback !== void 0) { + if (typeof fallback === "string" ? header.alg !== fallback : typeof fallback === "function" ? !fallback(header.alg) : !fallback.includes(header.alg)) { + throw OPE('unexpected JWT "alg" header parameter', INVALID_RESPONSE, { + header, + expected: fallback, + reason: "default value" + }); + } + return; + } + throw OPE('missing client or server configuration to verify used JWT "alg" header parameter', void 0, { client, issuer, fallback }); +} +async function getResponseJsonBody(response, check = assertApplicationJson) { + let json2; + try { + json2 = await response.json(); + } catch (cause) { + check(response); + throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause); + } + if (!isJsonObject(json2)) { + throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json2 }); + } + return json2; +} +var _nodiscoverycheck = /* @__PURE__ */ Symbol(); +var _expectedIssuer = /* @__PURE__ */ Symbol(); + +// node_modules/openid-client/build/index.js +var headers; +var USER_AGENT2; +if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) { + const NAME = "openid-client"; + const VERSION = "v6.8.2"; + USER_AGENT2 = `${NAME}/${VERSION}`; + headers = { "user-agent": USER_AGENT2 }; +} +var int2 = (config) => { + return props.get(config); +}; +var props; +var tbi; +function ClientSecretPost2(clientSecret) { + if (clientSecret !== void 0) { + return ClientSecretPost(clientSecret); + } + tbi ||= /* @__PURE__ */ new WeakMap(); + return (as, client, body, headers2) => { + let auth; + if (!(auth = tbi.get(client))) { + assertString2(client.client_secret, '"metadata.client_secret"'); + auth = ClientSecretPost(client.client_secret); + tbi.set(client, auth); + } + return auth(as, client, body, headers2); + }; +} +function assertString2(input, it) { + if (typeof input !== "string") { + throw CodedTypeError2(`${it} must be a string`, ERR_INVALID_ARG_TYPE2); + } + if (input.length === 0) { + throw CodedTypeError2(`${it} must not be empty`, ERR_INVALID_ARG_VALUE2); + } +} +function None2() { + return None(); +} +var customFetch2 = customFetch; +var ERR_INVALID_ARG_VALUE2 = "ERR_INVALID_ARG_VALUE"; +var ERR_INVALID_ARG_TYPE2 = "ERR_INVALID_ARG_TYPE"; +function CodedTypeError2(message, code, cause) { + const err = new TypeError(message, { cause }); + Object.assign(err, { code }); + return err; +} +var ClientError = class extends Error { + code; + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + this.code = options?.code; + Error.captureStackTrace?.(this, this.constructor); + } +}; +var decoder2 = new TextDecoder(); +function e(msg, cause, code) { + return new ClientError(msg, { cause, code }); +} +function errorHandler(err) { + if (err instanceof TypeError || err instanceof ClientError || err instanceof ResponseBodyError || err instanceof AuthorizationResponseError || err instanceof WWWAuthenticateChallengeError) { + throw err; + } + if (err instanceof OperationProcessingError) { + switch (err.code) { + case HTTP_REQUEST_FORBIDDEN: + throw e("only requests to HTTPS are allowed", err, err.code); + case REQUEST_PROTOCOL_FORBIDDEN: + throw e("only requests to HTTP or HTTPS are allowed", err, err.code); + case RESPONSE_IS_NOT_CONFORM: + throw e("unexpected HTTP response status code", err.cause, err.code); + case RESPONSE_IS_NOT_JSON: + throw e("unexpected response content-type", err.cause, err.code); + case PARSE_ERROR: + throw e("parsing error occured", err, err.code); + case INVALID_RESPONSE: + throw e("invalid response encountered", err, err.code); + case JWT_CLAIM_COMPARISON: + throw e("unexpected JWT claim value encountered", err, err.code); + case JSON_ATTRIBUTE_COMPARISON: + throw e("unexpected JSON attribute value encountered", err, err.code); + case JWT_TIMESTAMP_CHECK: + throw e("JWT timestamp claim value failed validation", err, err.code); + default: + throw e(err.message, err, err.code); + } + } + if (err instanceof UnsupportedOperationError) { + throw e("unsupported operation", err, err.code); + } + if (err instanceof DOMException) { + switch (err.name) { + case "OperationError": + throw e("runtime operation error", err, UNSUPPORTED_OPERATION); + case "NotSupportedError": + throw e("runtime unsupported operation", err, UNSUPPORTED_OPERATION); + case "TimeoutError": + throw e("operation timed out", err, "OAUTH_TIMEOUT"); + case "AbortError": + throw e("operation aborted", err, "OAUTH_ABORT"); + } + } + throw new ClientError("something went wrong", { cause: err }); +} +function handleEntraId(server, as, options) { + if (server.origin === "https://login.microsoftonline.com" && (!options?.algorithm || options.algorithm === "oidc")) { + as[kEntraId] = true; + return true; + } + return false; +} +function handleB2Clogin(server, options) { + if (server.hostname.endsWith(".b2clogin.com") && (!options?.algorithm || options.algorithm === "oidc")) { + return true; + } + return false; +} +async function discovery(server, clientId, metadata, clientAuthentication, options) { + const as = await performDiscovery2(server, options); + const instance = new Configuration(as, clientId, metadata, clientAuthentication); + let internals = int2(instance); + if (options?.[customFetch2]) { + internals.fetch = options[customFetch2]; + } + if (options?.timeout) { + internals.timeout = options.timeout; + } + if (options?.execute) { + for (const extension of options.execute) { + extension(instance); + } + } + return instance; +} +async function performDiscovery2(server, options) { + if (!(server instanceof URL)) { + throw CodedTypeError2('"server" must be an instance of URL', ERR_INVALID_ARG_TYPE2); + } + const resolve2 = !server.href.includes("/.well-known/"); + const timeout = options?.timeout ?? 30; + const signal3 = AbortSignal.timeout(timeout * 1e3); + const as = await (resolve2 ? discoveryRequest(server, { + algorithm: options?.algorithm, + [customFetch]: options?.[customFetch2], + [allowInsecureRequests]: options?.execute?.includes(allowInsecureRequests2), + signal: signal3, + headers: new Headers(headers) + }) : (options?.[customFetch2] || fetch)((() => { + checkProtocol(server, options?.execute?.includes(allowInsecureRequests2) ? false : true); + return server.href; + })(), { + headers: Object.fromEntries(new Headers({ accept: "application/json", ...headers }).entries()), + body: void 0, + method: "GET", + redirect: "manual", + signal: signal3 + })).then((response) => processDiscoveryResponse(_nodiscoverycheck, response)).catch(errorHandler); + if (resolve2 && new URL(as.issuer).href !== server.href) { + handleEntraId(server, as, options) || handleB2Clogin(server, options) || (() => { + throw new ClientError("discovered metadata issuer does not match the expected issuer", { + code: JSON_ATTRIBUTE_COMPARISON, + cause: { + expected: server.href, + body: as, + attribute: "issuer" + } + }); + })(); + } + return as; +} +function getServerHelpers(metadata) { + return { + supportsPKCE: { + __proto__: null, + value(method = "S256") { + return metadata.code_challenge_methods_supported?.includes(method) === true; + } + } + }; +} +function addServerHelpers(metadata) { + Object.defineProperties(metadata, getServerHelpers(metadata)); +} +var kEntraId = /* @__PURE__ */ Symbol(); +var Configuration = class { + constructor(server, clientId, metadata, clientAuthentication) { + if (typeof clientId !== "string" || !clientId.length) { + throw CodedTypeError2('"clientId" must be a non-empty string', ERR_INVALID_ARG_TYPE2); + } + if (typeof metadata === "string") { + metadata = { client_secret: metadata }; + } + if (metadata?.client_id !== void 0 && clientId !== metadata.client_id) { + throw CodedTypeError2('"clientId" and "metadata.client_id" must be the same', ERR_INVALID_ARG_VALUE2); + } + const client = { + ...structuredClone(metadata), + client_id: clientId + }; + client[clockSkew] = metadata?.[clockSkew] ?? 0; + client[clockTolerance] = metadata?.[clockTolerance] ?? 30; + let auth; + if (clientAuthentication) { + auth = clientAuthentication; + } else { + if (typeof client.client_secret === "string" && client.client_secret.length) { + auth = ClientSecretPost2(client.client_secret); + } else { + auth = None2(); + } + } + let c = Object.freeze(client); + const clone = structuredClone(server); + if (kEntraId in server) { + clone[_expectedIssuer] = ({ claims: { tid } }) => server.issuer.replace("{tenantid}", tid); + } + let as = Object.freeze(clone); + props ||= /* @__PURE__ */ new WeakMap(); + props.set(this, { + __proto__: null, + as, + c, + auth, + tlsOnly: true, + jwksCache: {} + }); + } + serverMetadata() { + const metadata = structuredClone(int2(this).as); + addServerHelpers(metadata); + return metadata; + } + clientMetadata() { + const metadata = structuredClone(int2(this).c); + return metadata; + } + get timeout() { + return int2(this).timeout; + } + set timeout(value) { + int2(this).timeout = value; + } + get [customFetch2]() { + return int2(this).fetch; + } + set [customFetch2](value) { + int2(this).fetch = value; + } +}; +Object.freeze(Configuration.prototype); +function getHelpers(response) { + let exp = void 0; + if (response.expires_in !== void 0) { + const now = /* @__PURE__ */ new Date(); + now.setSeconds(now.getSeconds() + response.expires_in); + exp = now.getTime(); + } + return { + expiresIn: { + __proto__: null, + value() { + if (exp) { + const now = Date.now(); + if (exp > now) { + return Math.floor((exp - now) / 1e3); + } + return 0; + } + return void 0; + } + }, + claims: { + __proto__: null, + value() { + try { + return getValidatedIdTokenClaims(this); + } catch { + return void 0; + } + } + } + }; +} +function addHelpers(response) { + Object.defineProperties(response, getHelpers(response)); +} +function allowInsecureRequests2(config) { + int2(config).tlsOnly = false; +} +async function refreshTokenGrant(config, refreshToken, parameters, options) { + checkConfig(config); + parameters = new URLSearchParams(parameters); + const { as, c, auth, fetch: fetch7, tlsOnly, nonRepudiation, timeout, decrypt } = int2(config); + const response = await refreshTokenGrantRequest(as, c, auth, refreshToken, { + [customFetch]: fetch7, + [allowInsecureRequests]: !tlsOnly, + additionalParameters: parameters, + DPoP: options?.DPoP, + headers: new Headers(headers), + signal: signal2(timeout) + }).catch(errorHandler); + const p = processRefreshTokenResponse(as, c, response, { + [jweDecrypt]: decrypt + }); + let result; + try { + result = await p; + } catch (err) { + if (retryable(err, options)) { + return refreshTokenGrant(config, refreshToken, parameters, { + ...options, + flag: retry + }); + } + errorHandler(err); + } + result.id_token && await nonRepudiation?.(response); + addHelpers(result); + return result; +} +function checkConfig(input) { + if (!(input instanceof Configuration)) { + throw CodedTypeError2('"config" must be an instance of Configuration', ERR_INVALID_ARG_TYPE2); + } + if (Object.getPrototypeOf(input) !== Configuration.prototype) { + throw CodedTypeError2("subclassing Configuration is not allowed", ERR_INVALID_ARG_VALUE2); + } +} +function signal2(timeout) { + return timeout ? AbortSignal.timeout(timeout * 1e3) : void 0; +} +function retryable(err, options) { + if (options?.DPoP && options.flag !== retry) { + return isDPoPNonceError(err); + } + return false; +} +var retry = /* @__PURE__ */ Symbol(); + +// node_modules/rfc4648/lib/rfc4648.js +var base64UrlEncoding = { + chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", + bits: 6 +}; +var base64url = { + parse: function parse(string, opts) { + return _parse(string, base64UrlEncoding, opts); + }, + stringify: function stringify(data, opts) { + return _stringify(data, base64UrlEncoding, opts); + } +}; +function _parse(string, encoding, opts) { + var _opts$out; + if (opts === void 0) { + opts = {}; + } + if (!encoding.codes) { + encoding.codes = {}; + for (var i = 0; i < encoding.chars.length; ++i) { + encoding.codes[encoding.chars[i]] = i; + } + } + if (!opts.loose && string.length * encoding.bits & 7) { + throw new SyntaxError("Invalid padding"); + } + var end = string.length; + while (string[end - 1] === "=") { + --end; + if (!opts.loose && !((string.length - end) * encoding.bits & 7)) { + throw new SyntaxError("Invalid padding"); + } + } + var out = new ((_opts$out = opts.out) != null ? _opts$out : Uint8Array)(end * encoding.bits / 8 | 0); + var bits = 0; + var buffer = 0; + var written = 0; + for (var _i = 0; _i < end; ++_i) { + var value = encoding.codes[string[_i]]; + if (value === void 0) { + throw new SyntaxError("Invalid character " + string[_i]); + } + buffer = buffer << encoding.bits | value; + bits += encoding.bits; + if (bits >= 8) { + bits -= 8; + out[written++] = 255 & buffer >> bits; + } + } + if (bits >= encoding.bits || 255 & buffer << 8 - bits) { + throw new SyntaxError("Unexpected end of data"); + } + return out; +} +function _stringify(data, encoding, opts) { + if (opts === void 0) { + opts = {}; + } + var _opts = opts, _opts$pad = _opts.pad, pad = _opts$pad === void 0 ? true : _opts$pad; + var mask = (1 << encoding.bits) - 1; + var out = ""; + var bits = 0; + var buffer = 0; + for (var i = 0; i < data.length; ++i) { + buffer = buffer << 8 | 255 & data[i]; + bits += 8; + while (bits > encoding.bits) { + bits -= encoding.bits; + out += encoding.chars[mask & buffer >> bits]; + } + } + if (bits) { + out += encoding.chars[mask & buffer << encoding.bits - bits]; + } + if (pad) { + while (out.length * encoding.bits & 7) { + out += "="; + } + } + return out; +} + +// node_modules/@kubernetes/client-node/dist/oidc_auth.js +var OidcClient2 = class { + constructor(c) { + this.config = c; + } + async refresh(token) { + const newToken = await refreshTokenGrant(this.config, token); + return { + id_token: newToken.id_token, + refresh_token: newToken.refresh_token, + expires_at: newToken.expiresIn() + }; + } +}; +var OpenIDConnectAuth = class _OpenIDConnectAuth { + constructor() { + this.currentTokenExpiration = 0; + } + static decodeJWT(token) { + const parts = token.split("."); + if (parts.length !== 3) { + return null; + } + const header = JSON.parse(new TextDecoder().decode(base64url.parse(parts[0], { loose: true }))); + const payload = JSON.parse(new TextDecoder().decode(base64url.parse(parts[1], { loose: true }))); + const signature = parts[2]; + return { + header, + payload, + signature + }; + } + static expirationFromToken(token) { + const jwt = _OpenIDConnectAuth.decodeJWT(token); + if (!jwt) { + return 0; + } + return jwt.payload.exp; + } + isAuthProvider(user) { + if (!user.authProvider) { + return false; + } + return user.authProvider.name === "oidc"; + } + /** + * Setup the authentication header for oidc authed clients + * @param user user info + * @param opts request options + * @param overrideClient for testing, a preconfigured oidc client + */ + async applyAuthentication(user, opts, overrideClient) { + const token = await this.getToken(user, overrideClient); + if (token) { + opts.headers["Authorization"] = `Bearer ${token}`; + } + } + async getToken(user, overrideClient) { + if (!user.authProvider.config) { + return null; + } + if (!user.authProvider.config["client-secret"]) { + user.authProvider.config["client-secret"] = ""; + } + if (!user.authProvider.config || !user.authProvider.config["id-token"]) { + return null; + } + return this.refresh(user, overrideClient); + } + async refresh(user, overrideClient) { + if (this.currentTokenExpiration === 0) { + this.currentTokenExpiration = _OpenIDConnectAuth.expirationFromToken(user.authProvider.config["id-token"]); + } + if (Date.now() / 1e3 > this.currentTokenExpiration) { + if (!user.authProvider.config["client-id"] || !user.authProvider.config["refresh-token"] || !user.authProvider.config["idp-issuer-url"]) { + return null; + } + const client = overrideClient ? overrideClient : await this.getClient(user); + const newToken = await client.refresh(user.authProvider.config["refresh-token"]); + user.authProvider.config["id-token"] = newToken.id_token; + user.authProvider.config["refresh-token"] = newToken.refresh_token; + this.currentTokenExpiration = newToken.expires_at; + } + return user.authProvider.config["id-token"]; + } + async getClient(user) { + const configuration = await discovery(user.authProvider.config["idp-issuer-url"], user.authProvider.config["client-id"]); + return new OidcClient2(configuration); + } +}; + +// node_modules/@kubernetes/client-node/dist/config.js +var import_socks_proxy_agent = __toESM(require_dist2(), 1); +import child_process2 from "node:child_process"; + +// node_modules/hpagent/index.mjs +var import_index = __toESM(require_hpagent(), 1); +var HttpProxyAgent = import_index.default.HttpProxyAgent; +var HttpsProxyAgent = import_index.default.HttpsProxyAgent; + +// node_modules/@kubernetes/client-node/dist/config.js +var SERVICEACCOUNT_ROOT = "/var/run/secrets/kubernetes.io/serviceaccount"; +var SERVICEACCOUNT_CA_PATH = SERVICEACCOUNT_ROOT + "/ca.crt"; +var SERVICEACCOUNT_TOKEN_PATH = SERVICEACCOUNT_ROOT + "/token"; +var SERVICEACCOUNT_NAMESPACE_PATH = SERVICEACCOUNT_ROOT + "/namespace"; +function fileExists(filepath) { + try { + fs5.accessSync(filepath); + return true; + } catch { + return false; + } +} +var KubeConfig = class _KubeConfig { + // Optionally add additional external authenticators, you must do this + // before you load a kubeconfig file that references them. + addAuthenticator(authenticator) { + this.custom_authenticators.push(authenticator); + } + constructor() { + this.authenticators = [ + new AzureAuth(), + new GoogleCloudPlatformAuth(), + new ExecAuth(), + new FileAuth(), + new OpenIDConnectAuth() + ]; + this.custom_authenticators = []; + this.contexts = []; + this.clusters = []; + this.users = []; + } + getContexts() { + return this.contexts; + } + getClusters() { + return this.clusters; + } + getUsers() { + return this.users; + } + getCurrentContext() { + return this.currentContext; + } + setCurrentContext(context) { + this.currentContext = context; + } + getContextObject(name) { + if (!this.contexts) { + return null; + } + return findObject(this.contexts, name, "context"); + } + getCurrentCluster() { + const context = this.getCurrentContextObject(); + if (!context) { + return null; + } + return this.getCluster(context.cluster); + } + getCluster(name) { + return findObject(this.clusters, name, "cluster"); + } + getCurrentUser() { + const ctx = this.getCurrentContextObject(); + if (!ctx) { + return null; + } + return this.getUser(ctx.user); + } + getUser(name) { + return findObject(this.users, name, "user"); + } + loadFromFile(file, opts) { + const rootDirectory = path4.dirname(file); + this.loadFromString(fs5.readFileSync(file).toString("utf-8"), opts); + this.makePathsAbsolute(rootDirectory); + } + async applyToFetchOptions(opts) { + await this.applyToHTTPSOptions(opts); + const headers2 = new import_node_fetch2.Headers(); + for (const [key, val] of Object.entries(opts.headers || {})) { + if (Array.isArray(val)) { + val.forEach((innerVal) => { + headers2.append(key, innerVal); + }); + } else if (typeof val === "number" || typeof val === "string") { + headers2.set(key, val.toString()); + } + } + if (opts.auth) { + headers2.set("Authorization", "Basic " + Buffer.from(opts.auth).toString("base64")); + } + return { + agent: opts.agent, + headers: headers2, + method: opts.method, + timeout: opts.timeout + }; + } + async applyToHTTPSOptions(opts) { + const user = this.getCurrentUser(); + const cluster = this.getCurrentCluster(); + await this.applyOptions(opts); + if (user && user.username) { + opts.auth = `${user.username}:${user.password}`; + } + const agentOptions = {}; + agentOptions.ca = opts.ca; + agentOptions.cert = opts.cert; + agentOptions.key = opts.key; + agentOptions.pfx = opts.pfx; + agentOptions.passphrase = opts.passphrase; + if (opts.rejectUnauthorized !== void 0) { + agentOptions.rejectUnauthorized = opts.rejectUnauthorized; + } + agentOptions.timeout = opts.timeout; + agentOptions.servername = opts.servername; + agentOptions.ciphers = opts.ciphers; + agentOptions.honorCipherOrder = opts.honorCipherOrder; + agentOptions.ecdhCurve = opts.ecdhCurve; + agentOptions.clientCertEngine = opts.clientCertEngine; + agentOptions.crl = opts.crl; + agentOptions.dhparam = opts.dhparam; + agentOptions.secureOptions = opts.secureOptions; + agentOptions.secureProtocol = opts.secureProtocol; + agentOptions.sessionIdContext = opts.sessionIdContext; + opts.agent = this.createAgent(cluster, agentOptions); + } + /** + * Applies SecurityAuthentication to RequestContext of an API Call from API Client + * @param context + */ + async applySecurityAuthentication(context) { + const cluster = this.getCurrentCluster(); + const user = this.getCurrentUser(); + const agentOptions = {}; + const httpsOptions = {}; + await this.applyOptions(httpsOptions); + if (cluster && cluster.skipTLSVerify) { + agentOptions.rejectUnauthorized = false; + } + if (cluster && cluster.tlsServerName) { + agentOptions.servername = cluster.tlsServerName; + } + if (user && user.username) { + const auth = Buffer.from(`${user.username}:${user.password}`).toString("base64"); + context.setHeaderParam("Authorization", `Basic ${auth}`); + } + const headers2 = httpsOptions.headers || {}; + Object.entries(headers2).forEach(([key, value]) => { + context.setHeaderParam(key, `${value}`); + }); + agentOptions.ca = httpsOptions.ca; + agentOptions.cert = httpsOptions.cert; + agentOptions.key = httpsOptions.key; + agentOptions.pfx = httpsOptions.pfx; + agentOptions.passphrase = httpsOptions.passphrase; + if (httpsOptions.rejectUnauthorized !== void 0) { + agentOptions.rejectUnauthorized = httpsOptions.rejectUnauthorized; + } + context.setAgent(this.createAgent(cluster, agentOptions)); + } + /** + * Returns name of this security authentication method + * @returns string + */ + getName() { + return "kubeconfig authentication"; + } + loadFromString(config, opts) { + const obj = jsYaml.load(config); + this.clusters = newClusters(obj.clusters, opts); + this.contexts = newContexts(obj.contexts, opts); + this.users = newUsers(obj.users, opts); + this.currentContext = obj["current-context"]; + } + loadFromOptions(options) { + this.clusters = options.clusters; + this.contexts = options.contexts; + this.users = options.users; + this.currentContext = options.currentContext; + } + loadFromClusterAndUser(cluster, user) { + this.clusters = [cluster]; + this.users = [user]; + this.currentContext = "loaded-context"; + this.contexts = [ + { + cluster: cluster.name, + user: user.name, + name: this.currentContext + } + ]; + } + loadFromCluster(pathPrefix = "") { + const host = process.env.KUBERNETES_SERVICE_HOST; + const port = process.env.KUBERNETES_SERVICE_PORT; + const clusterName = "inCluster"; + const userName = "inClusterUser"; + const contextName = "inClusterContext"; + let scheme = "https"; + if (port === "80" || port === "8080" || port === "8001") { + scheme = "http"; + } + let serverHost = host; + if (host && net.isIPv6(host)) { + serverHost = `[${host}]`; + } + this.clusters = [ + { + name: clusterName, + caFile: `${pathPrefix}${SERVICEACCOUNT_CA_PATH}`, + server: `${scheme}://${serverHost}:${port}`, + skipTLSVerify: false + } + ]; + this.users = [ + { + name: userName, + authProvider: { + name: "tokenFile", + config: { + tokenFile: `${pathPrefix}${SERVICEACCOUNT_TOKEN_PATH}` + } + } + } + ]; + const namespaceFile = `${pathPrefix}${SERVICEACCOUNT_NAMESPACE_PATH}`; + let namespace; + if (fileExists(namespaceFile)) { + namespace = fs5.readFileSync(namespaceFile).toString("utf-8"); + } + this.contexts = [ + { + cluster: clusterName, + name: contextName, + user: userName, + namespace + } + ]; + this.currentContext = contextName; + } + mergeConfig(config, preserveContext = false) { + if (!preserveContext && config.currentContext) { + this.currentContext = config.currentContext; + } + config.clusters.forEach((cluster) => { + this.addCluster(cluster); + }); + config.users.forEach((user) => { + this.addUser(user); + }); + config.contexts.forEach((ctx) => { + this.addContext(ctx); + }); + } + addCluster(cluster) { + if (!this.clusters) { + this.clusters = []; + } + this.clusters.forEach((c, ix) => { + if (c.name === cluster.name) { + throw new Error(`Duplicate cluster: ${c.name}`); + } + }); + this.clusters.push(cluster); + } + addUser(user) { + if (!this.users) { + this.users = []; + } + this.users.forEach((c, ix) => { + if (c.name === user.name) { + throw new Error(`Duplicate user: ${c.name}`); + } + }); + this.users.push(user); + } + addContext(ctx) { + if (!this.contexts) { + this.contexts = []; + } + this.contexts.forEach((c, ix) => { + if (c.name === ctx.name) { + throw new Error(`Duplicate context: ${c.name}`); + } + }); + this.contexts.push(ctx); + } + loadFromDefault(opts, contextFromStartingConfig = false, platform2 = process.platform) { + if (process.env.KUBECONFIG && process.env.KUBECONFIG.length > 0) { + const files = process.env.KUBECONFIG.split(path4.delimiter).filter((filename) => filename); + this.loadFromFile(files[0], opts); + for (let i = 1; i < files.length; i++) { + const kc = new _KubeConfig(); + kc.loadFromFile(files[i], opts); + this.mergeConfig(kc, contextFromStartingConfig); + } + return; + } + const home = findHomeDir(platform2); + if (home) { + const config = path4.join(home, ".kube", "config"); + if (fileExists(config)) { + this.loadFromFile(config, opts); + return; + } + } + if (platform2 === "win32") { + try { + const envKubeconfigPathResult = child_process2.spawnSync("wsl.exe", [ + "bash", + "-c", + "printenv KUBECONFIG" + ]); + if (envKubeconfigPathResult.status === 0 && envKubeconfigPathResult.stdout.length > 0) { + const result = child_process2.spawnSync("wsl.exe", [ + "cat", + envKubeconfigPathResult.stdout.toString("utf8") + ]); + if (result.status === 0) { + this.loadFromString(result.stdout.toString("utf8"), opts); + return; + } + } + } catch { + } + try { + const configResult = child_process2.spawnSync("wsl.exe", ["cat", "~/.kube/config"]); + if (configResult.status === 0) { + this.loadFromString(configResult.stdout.toString("utf8"), opts); + const result = child_process2.spawnSync("wsl.exe", ["wslpath", "-w", "~/.kube"]); + if (result.status === 0) { + this.makePathsAbsolute(result.stdout.toString("utf8")); + } + return; + } + } catch { + } + } + if (fileExists(SERVICEACCOUNT_TOKEN_PATH)) { + this.loadFromCluster(); + return; + } + this.loadFromClusterAndUser({ name: "cluster", server: "http://localhost:8080" }, { name: "user" }); + } + makeApiClient(apiClientType) { + const cluster = this.getCurrentCluster(); + if (!cluster) { + throw new Error("No active cluster!"); + } + const authConfig = { + default: this + }; + const baseServerConfig = new ServerConfiguration(cluster.server, {}); + const config = createConfiguration({ + baseServer: baseServerConfig, + authMethods: authConfig + }); + const apiClient = new apiClientType(config); + return apiClient; + } + makePathsAbsolute(rootDirectory) { + this.clusters.forEach((cluster) => { + if (cluster.caFile) { + cluster.caFile = makeAbsolutePath(rootDirectory, cluster.caFile); + } + }); + this.users.forEach((user) => { + if (user.certFile) { + user.certFile = makeAbsolutePath(rootDirectory, user.certFile); + } + if (user.keyFile) { + user.keyFile = makeAbsolutePath(rootDirectory, user.keyFile); + } + }); + } + exportConfig() { + const configObj = { + apiVersion: "v1", + kind: "Config", + clusters: this.clusters.map(exportCluster), + users: this.users.map(exportUser), + contexts: this.contexts.map(exportContext), + preferences: {}, + "current-context": this.getCurrentContext() + }; + return JSON.stringify(configObj); + } + getCurrentContextObject() { + return this.getContextObject(this.currentContext); + } + createAgent(cluster, agentOptions) { + var _a, _b; + let agent; + if (cluster && cluster.proxyUrl) { + if (cluster.proxyUrl.startsWith("socks")) { + agent = new import_socks_proxy_agent.SocksProxyAgent(cluster.proxyUrl, agentOptions); + } else if (cluster.server.startsWith("https")) { + const httpsProxyAgentOptions = agentOptions; + httpsProxyAgentOptions.proxy = cluster.proxyUrl; + agent = new HttpsProxyAgent(httpsProxyAgentOptions); + } else if (cluster.server.startsWith("http")) { + const httpProxyAgentOptions = agentOptions; + httpProxyAgentOptions.proxy = cluster.proxyUrl; + agent = new HttpProxyAgent(httpProxyAgentOptions); + } else { + throw new Error("Unsupported proxy type"); + } + } else if (((_a = cluster === null || cluster === void 0 ? void 0 : cluster.server) === null || _a === void 0 ? void 0 : _a.startsWith("http:")) && cluster.skipTLSVerify) { + agent = new http.Agent(agentOptions); + } else if (((_b = cluster === null || cluster === void 0 ? void 0 : cluster.server) === null || _b === void 0 ? void 0 : _b.startsWith("http:")) && !cluster.skipTLSVerify) { + throw new Error("HTTP protocol is not allowed when skipTLSVerify is not set or false"); + } else { + agent = new https.Agent(agentOptions); + } + return agent; + } + applyHTTPSOptions(opts) { + var _a; + const cluster = this.getCurrentCluster(); + const user = this.getCurrentUser(); + if (!user) { + return; + } + if (cluster != null && cluster.skipTLSVerify) { + opts.rejectUnauthorized = false; + } + if (cluster != null && cluster.tlsServerName) { + opts.servername = cluster.tlsServerName; + } + const ca = cluster != null ? bufferFromFileOrString(cluster.caFile, cluster.caData) : null; + if (ca) { + opts.ca = ca; + } + const cert = bufferFromFileOrString(user.certFile, user.certData); + if (cert) { + opts.cert = cert; + } + const key = bufferFromFileOrString(user.keyFile, user.keyData); + if (key) { + opts.key = key; + } + if (user.impersonateUser != null) { + (_a = opts.headers) !== null && _a !== void 0 ? _a : opts.headers = {}; + opts.headers["Impersonate-User"] = user.impersonateUser; + } + } + async applyAuthorizationHeader(opts) { + const user = this.getCurrentUser(); + if (!user) { + return; + } + let authenticator = this.authenticators.find((elt) => { + return elt.isAuthProvider(user); + }); + if (!authenticator) { + authenticator = this.custom_authenticators.find((elt) => { + return elt.isAuthProvider(user); + }); + } + if (!opts.headers) { + opts.headers = {}; + } + if (authenticator) { + await authenticator.applyAuthentication(user, opts); + } + if (user.token) { + opts.headers.Authorization = `Bearer ${user.token}`; + } + } + async applyOptions(opts) { + this.applyHTTPSOptions(opts); + await this.applyAuthorizationHeader(opts); + } +}; +function makeAbsolutePath(root, file) { + if (!root || path4.isAbsolute(file)) { + return file; + } + return path4.join(root, file); +} +function bufferFromFileOrString(file, data) { + if (file) { + return fs5.readFileSync(file); + } + if (data) { + return Buffer.from(data, "base64"); + } + return null; +} +function dropDuplicatesAndNils(a) { + return a.reduce((acceptedValues, currentValue) => { + if (currentValue && !acceptedValues.includes(currentValue)) { + return acceptedValues.concat(currentValue); + } else { + return acceptedValues; + } + }, []); +} +function findHomeDir(platform2 = process.platform) { + if (platform2 !== "win32") { + if (process.env.HOME) { + try { + fs5.accessSync(process.env.HOME); + return process.env.HOME; + } catch { + } + } + return null; + } + const homeDrivePath = process.env.HOMEDRIVE && process.env.HOMEPATH ? path4.join(process.env.HOMEDRIVE, process.env.HOMEPATH) : ""; + const homePath = process.env.HOME || ""; + const userProfile = process.env.USERPROFILE || ""; + const favourHomeDrivePathList = dropDuplicatesAndNils([homePath, homeDrivePath, userProfile]); + const favourUserProfileList = dropDuplicatesAndNils([homePath, userProfile, homeDrivePath]); + for (const dir of favourHomeDrivePathList) { + try { + fs5.accessSync(path4.join(dir, ".kube", "config")); + return dir; + } catch { + } + } + for (const dir of favourUserProfileList) { + try { + fs5.accessSync(dir, fs5.constants.W_OK); + return dir; + } catch { + } + } + for (const dir of favourUserProfileList) { + try { + fs5.accessSync(dir); + return dir; + } catch { + } + } + return favourUserProfileList[0] || null; +} +function findObject(list, name, key) { + if (!list) { + return null; + } + for (const obj of list) { + if (obj.name === name) { + if (obj[key]) { + obj[key].name = name; + return obj[key]; + } + return obj; + } + } + return null; +} + +// node_modules/@kubernetes/client-node/dist/watch.js +var import_node_fetch3 = __toESM(require_lib2(), 1); +import { STATUS_CODES } from "node:http"; +import { createInterface } from "node:readline"; +var Watch = class { + constructor(config) { + this.config = config; + } + // Watch the resource and call provided callback with parsed json object + // upon event received over the watcher connection. + // + // "done" callback is called either when connection is closed or when there + // is an error. In either case, watcher takes care of properly closing the + // underlaying connection so that it doesn't leak any resources. + async watch(path7, queryParams, callback, done) { + const cluster = this.config.getCurrentCluster(); + if (!cluster) { + throw new Error("No currently active cluster"); + } + const watchURL = new URL(cluster.server + path7); + watchURL.searchParams.set("watch", "true"); + for (const [key, val] of Object.entries(queryParams || {})) { + if (val !== void 0) { + watchURL.searchParams.set(key, val.toString()); + } + } + const requestInit = await this.config.applyToFetchOptions({}); + const controller = new AbortController(); + const timeoutSignal = AbortSignal.timeout(3e4); + requestInit.signal = AbortSignal.any([controller.signal, timeoutSignal]); + requestInit.signal = controller.signal; + requestInit.method = "GET"; + let doneCalled = false; + const doneCallOnce = (err) => { + if (!doneCalled) { + doneCalled = true; + controller.abort(); + done(err); + } + }; + try { + const response = await (0, import_node_fetch3.default)(watchURL, requestInit); + if (requestInit.agent && typeof requestInit.agent === "object") { + for (const socket of Object.values(requestInit.agent.sockets).flat()) { + socket === null || socket === void 0 ? void 0 : socket.setKeepAlive(true, 3e4); + } + } + if (response.status === 200) { + const body = response.body; + body.on("error", doneCallOnce); + body.on("close", () => doneCallOnce(null)); + body.on("finish", () => doneCallOnce(null)); + const lines = createInterface(body); + lines.on("error", doneCallOnce); + lines.on("close", () => doneCallOnce(null)); + lines.on("finish", () => doneCallOnce(null)); + lines.on("line", (line) => { + try { + const data = JSON.parse(line.toString()); + callback(data.type, data.object, data); + } catch { + } + }); + } else { + const statusText = response.statusText || STATUS_CODES[response.status] || "Internal Server Error"; + const error2 = new Error(statusText); + error2.statusCode = response.status; + throw error2; + } + } catch (err) { + doneCallOnce(err); + } + return controller; + } +}; +Watch.SERVER_SIDE_CLOSE = { error: "Connection closed on server" }; + +// node_modules/@kubernetes/client-node/dist/serializer.js +var isKubernetesObject = (data) => !!data && typeof data === "object" && "apiVersion" in data && "kind" in data; +var KubernetesObject = class _KubernetesObject { + serialize() { + const instance = {}; + for (const attributeType of _KubernetesObject.attributeTypeMap) { + const value = this[attributeType.baseName]; + if (value !== void 0) { + instance[attributeType.name] = ObjectSerializer.serialize(this[attributeType.baseName], attributeType.type, attributeType.format); + } + } + for (const [key, value] of Object.entries(this)) { + if (_KubernetesObject.attributeTypeMap.find((t) => t.name === key)) { + continue; + } + instance[key] = value; + } + return instance; + } + static fromUnknown(data) { + if (!isKubernetesObject(data)) { + throw new Error(`Unable to deseriliaze non-Kubernetes object ${data}.`); + } + const instance = new _KubernetesObject(); + for (const attributeType of _KubernetesObject.attributeTypeMap) { + const value = data[attributeType.baseName]; + if (value !== void 0) { + instance[attributeType.name] = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type, attributeType.format); + } + } + for (const [key, value] of Object.entries(data)) { + if (_KubernetesObject.attributeTypeMap.find((t) => t.name === key)) { + continue; + } + instance[key] = value; + } + return instance; + } +}; +KubernetesObject.attributeTypeMap = [ + { + name: "apiVersion", + baseName: "apiVersion", + type: "string", + format: "" + }, + { + name: "kind", + baseName: "kind", + type: "string", + format: "" + }, + { + name: "metadata", + baseName: "metadata", + type: "V1ObjectMeta", + format: "" + } +]; +var gvString = ({ group, version }) => [group, version].join("/"); +var gvkFromObject = (obj) => { + const [g, v] = obj.apiVersion.split("/"); + return { + kind: obj.kind, + group: v ? g : "", + version: v ? v : g + }; +}; +var ObjectSerializer2 = class _ObjectSerializer extends ObjectSerializer { + /** + * Adds a dedicated seriliazer for a Kubernetes resource. + * Every resource is uniquly identified using its group, version and kind. + * @param gvk + * @param serializer + */ + static registerModel(gvk, serializer) { + var _a; + var _b; + const gv = gvString(gvk); + const kinds = (_a = (_b = this.modelRegistry)[gv]) !== null && _a !== void 0 ? _a : _b[gv] = {}; + if (kinds[gvk.kind]) { + throw new Error(`Kind ${gvk.kind} of ${gv} is already defined`); + } + kinds[gvk.kind] = serializer; + } + /** + * Removes all registered models from the registry. + */ + static clearModelRegistry() { + this.modelRegistry = {}; + } + static getSerializerForObject(obj) { + var _a; + if (!isKubernetesObject(obj)) { + return void 0; + } + const gvk = gvkFromObject(obj); + return (_a = _ObjectSerializer.modelRegistry[gvString(gvk)]) === null || _a === void 0 ? void 0 : _a[gvk.kind]; + } + static serialize(data, type2, format2 = "") { + const serializer = _ObjectSerializer.getSerializerForObject(data); + if (serializer) { + return serializer.serialize(data, type2, format2); + } + if (data instanceof KubernetesObject) { + return data.serialize(); + } + const obj = ObjectSerializer.serialize(data, type2, format2); + if (obj !== data) { + return obj; + } + if (!isKubernetesObject(data)) { + return obj; + } + const instance = {}; + for (const attributeType of KubernetesObject.attributeTypeMap) { + const value = data[attributeType.baseName]; + if (value !== void 0) { + instance[attributeType.name] = ObjectSerializer.serialize(data[attributeType.baseName], attributeType.type, attributeType.format); + } + } + for (const [key, value] of Object.entries(data)) { + if (KubernetesObject.attributeTypeMap.find((t) => t.name === key)) { + continue; + } + instance[key] = value; + } + return instance; + } + static deserialize(data, type2, format2 = "") { + const serializer = _ObjectSerializer.getSerializerForObject(data); + if (serializer) { + return serializer.deserialize(data, type2, format2); + } + const obj = ObjectSerializer.deserialize(data, type2, format2); + if (obj !== data) { + return obj; + } + if (!isKubernetesObject(data)) { + return obj; + } + return KubernetesObject.fromUnknown(data); + } +}; +ObjectSerializer2.modelRegistry = {}; + +// node_modules/@kubernetes/client-node/dist/web-socket-handler.js +var import_isomorphic_ws = __toESM(require_node2(), 1); +var protocols = [ + "v5.channel.k8s.io", + "v4.channel.k8s.io", + "v3.channel.k8s.io", + "v2.channel.k8s.io", + "channel.k8s.io" +]; +var WebSocketHandler = class _WebSocketHandler { + static supportsClose(protocol) { + return protocol === "v5.channel.k8s.io"; + } + static closeStream(streamNum, streams) { + switch (streamNum) { + case _WebSocketHandler.StdinStream: + streams.stdin.pause(); + break; + case _WebSocketHandler.StdoutStream: + streams.stdout.end(); + break; + case _WebSocketHandler.StderrStream: + streams.stderr.end(); + break; + } + } + static handleStandardStreams(streamNum, buff, stdout, stderr) { + if (buff.length < 1) { + return null; + } + if (stdout && streamNum === _WebSocketHandler.StdoutStream) { + stdout.write(buff); + } else if (stderr && streamNum === _WebSocketHandler.StderrStream) { + stderr.write(buff); + } else if (streamNum === _WebSocketHandler.StatusStream) { + if (stdout && stdout !== process.stdout) { + stdout.end(); + } + if (stderr && stderr !== process.stderr) { + stderr.end(); + } + return JSON.parse(buff.toString("utf8")); + } else { + throw new Error("Unknown stream: " + streamNum); + } + return null; + } + static handleStandardInput(ws, stdin, streamNum = 0) { + stdin.on("data", (data) => { + ws.send(copyChunkForWebSocket(streamNum, data, stdin.readableEncoding)); + }); + stdin.on("end", () => { + if (_WebSocketHandler.supportsClose(ws.protocol)) { + const buff = Buffer.alloc(2); + buff.writeUint8(this.CloseStream, 0); + buff.writeUint8(this.StdinStream, 1); + ws.send(buff); + return; + } + ws.close(); + }); + return true; + } + static async processData(data, ws, createWS, streamNum = 0, retryCount = 3, encoding) { + const buff = copyChunkForWebSocket(streamNum, data, encoding); + let i = 0; + for (; i < retryCount; ++i) { + if (ws !== null && ws.readyState === import_isomorphic_ws.default.OPEN) { + ws.send(buff); + break; + } else { + ws = await createWS(); + } + } + if (i >= retryCount) { + throw new Error("can't send data to ws"); + } + return ws; + } + static restartableHandleStandardInput(createWS, stdin, streamNum = 0, retryCount = 3, addFlushForTesting = false) { + if (retryCount < 0) { + throw new Error("retryCount can't be lower than 0."); + } + let queue = Promise.resolve(); + let ws = null; + stdin.on("data", (data) => { + queue = queue.then(async () => { + ws = await _WebSocketHandler.processData(data, ws, createWS, streamNum, retryCount, stdin.readableEncoding); + }); + }); + if (addFlushForTesting) { + stdin.on("flush", async () => { + await queue; + }); + } + stdin.on("end", () => { + if (ws !== null) { + ws.close(); + } + }); + return () => ws; + } + // factory is really just for test injection + constructor(kc, socketFactoryFn, streamsInterface = { + stdin: process.stdin, + stdout: process.stdout, + stderr: process.stderr + }) { + this.config = kc; + this.socketFactory = socketFactoryFn; + this.streams = streamsInterface; + } + /** + * Connect to a web socket endpoint. + * @param path The HTTP Path to connect to on the server. + * @param textHandler Callback for text over the web socket. + * Returns true if the connection should be kept alive, false to disconnect. + * @param binaryHandler Callback for binary data over the web socket. + * Returns true if the connection should be kept alive, false to disconnect. + */ + async connect(path7, textHandler, binaryHandler) { + const cluster = this.config.getCurrentCluster(); + if (!cluster) { + throw new Error("No cluster is defined."); + } + const server = cluster.server; + const ssl = server.startsWith("https://"); + const target = ssl ? server.substr(8) : server.substr(7); + const proto = ssl ? "wss" : "ws"; + const uri = `${proto}://${target}${path7}`; + const opts = {}; + await this.config.applyToHTTPSOptions(opts); + return await new Promise((resolve2, reject) => { + const client = this.socketFactory ? this.socketFactory(uri, protocols, opts) : new import_isomorphic_ws.default(uri, protocols, opts); + let resolved = false; + client.onopen = () => { + resolved = true; + resolve2(client); + }; + client.onerror = (err) => { + if (!resolved) { + reject(err); + } + }; + client.onmessage = ({ data }) => { + if (typeof data === "string") { + if (data.charCodeAt(0) === _WebSocketHandler.CloseStream) { + _WebSocketHandler.closeStream(data.charCodeAt(1), this.streams); + } + if (textHandler && !textHandler(data)) { + client.close(); + } + } else if (data instanceof Buffer) { + const streamNum = data.readUint8(0); + if (streamNum === _WebSocketHandler.CloseStream) { + _WebSocketHandler.closeStream(data.readInt8(1), this.streams); + } + if (binaryHandler && !binaryHandler(streamNum, data.slice(1))) { + client.close(); + } + } + }; + }); + } +}; +WebSocketHandler.StdinStream = 0; +WebSocketHandler.StdoutStream = 1; +WebSocketHandler.StderrStream = 2; +WebSocketHandler.StatusStream = 3; +WebSocketHandler.ResizeStream = 4; +WebSocketHandler.CloseStream = 255; +function copyChunkForWebSocket(streamNum, chunk, encoding) { + let buff; + if (chunk instanceof Buffer) { + buff = Buffer.alloc(chunk.length + 1); + chunk.copy(buff, 1); + } else { + encoding !== null && encoding !== void 0 ? encoding : encoding = "utf-8"; + const size = Buffer.byteLength(chunk, encoding); + buff = Buffer.alloc(size + 1); + buff.write(chunk, 1, size, encoding); + } + buff.writeInt8(streamNum, 0); + return buff; +} + +// node_modules/@kubernetes/client-node/dist/log.js +var import_node_fetch4 = __toESM(require_lib2(), 1); + +// node_modules/@kubernetes/client-node/dist/cp.js +var import_stream_buffers = __toESM(require_streambuffer(), 1); +var import_tar_fs = __toESM(require_tar_fs(), 1); + +// node_modules/@kubernetes/client-node/dist/metrics.js +var import_node_fetch5 = __toESM(require_lib2(), 1); + +// node_modules/@kubernetes/client-node/dist/health.js +var import_node_fetch6 = __toESM(require_lib2(), 1); + +// node_modules/@kubernetes/client-node/dist/index.js +var import_node_fetch7 = __toESM(require_lib2(), 1); + +// src/types/k8sSecret.ts +import * as util from "util"; +function parseK8sSecret(secret) { + if (!secret) throw Error("K8s secret yaml is invalid"); + if (!secret.data) throw k8sSecretMissingFieldError("data"); + if (!secret.data.token) throw k8sSecretMissingFieldError("token"); + if (!secret.data["ca.crt"]) throw k8sSecretMissingFieldError("ca.crt"); + return secret; +} +var k8sSecretMissingFieldError = (field) => Error(util.format("K8s secret yaml does not contain %s field", field)); + +// src/types/method.ts +var Method = /* @__PURE__ */ ((Method2) => { + Method2["KUBECONFIG"] = "kubeconfig"; + Method2["SERVICE_ACCOUNT"] = "service-account"; + Method2["SERVICE_PRINCIPAL"] = "service-principal"; + return Method2; +})(Method || {}); +var parseMethod = (str2) => { + const key = Object.keys(Method).find( + (k) => Method[k].toLowerCase() === str2.toLowerCase() + ); + return key !== void 0 ? Method[key] : void 0; +}; + +// src/kubeconfigs/default.ts +function getDefaultKubeconfig() { + const method = parseMethod( + getInput("method", { required: true }) + ); + switch (method) { + case "service-account" /* SERVICE_ACCOUNT */: { + const clusterUrl = getInput("k8s-url", { required: true }); + debug( + "Found clusterUrl. Creating kubeconfig using certificate and token" + ); + const k8sSecret = getInput("k8s-secret", { + required: true + }); + const parsedK8sSecret = parseK8sSecret( + load(k8sSecret) + ); + const certAuth = parsedK8sSecret.data["ca.crt"]; + const token = Buffer.from( + parsedK8sSecret.data.token, + "base64" + ).toString(); + return createKubeconfig(certAuth, token, clusterUrl); + } + case "service-principal" /* SERVICE_PRINCIPAL */: { + warning( + "Service Principal method not supported for default cluster type" + ); + } + case void 0: { + warning("Defaulting to kubeconfig method"); + } + default: { + debug("Setting context using kubeconfig"); + let Encoding; + ((Encoding2) => { + Encoding2["Base64"] = "base64"; + Encoding2["Plaintext"] = "plaintext"; + })(Encoding || (Encoding = {})); + const rawKubeconfig = getInput("kubeconfig", { required: true }); + const encoding = getInput("kubeconfig-encoding")?.toLowerCase() || "plaintext" /* Plaintext */; + if (encoding !== "base64" /* Base64 */ && encoding !== "plaintext" /* Plaintext */) { + throw new Error( + `Invalid kubeconfig-encoding: '${encoding}'. Must be 'plaintext' or 'base64'.` + ); + } + const kubeconfig = encoding === "base64" /* Base64 */ ? Buffer.from(rawKubeconfig, "base64").toString("utf-8") : rawKubeconfig; + return kubeconfig; + } + } +} +function createKubeconfig(certAuth, token, clusterUrl) { + const kc = new KubeConfig(); + kc.loadFromClusterAndUser( + { + name: "default", + server: clusterUrl, + caData: certAuth, + skipTLSVerify: false + }, + { + name: "default-user", + token + } + ); + return kc.exportConfig(); +} + +// src/kubeconfigs/arc.ts +import * as path5 from "path"; + +// src/kubeconfigs/azCommands.ts +import * as fs6 from "fs"; +import { spawn as spawn2 } from "child_process"; +var AZ_TIMEOUT_SECONDS = 120; +async function runAzCliCommand(azPath, args, options = {}) { + await exec(azPath, args, options); +} +async function runAzKubeconfigCommandBlocking(azPath, args, kubeconfigPath) { + const proc3 = spawn2(azPath, args, { + detached: true, + stdio: "ignore" + }); + proc3.unref(); + await sleep(AZ_TIMEOUT_SECONDS); + return fs6.readFileSync(kubeconfigPath).toString(); +} +var sleep = (seconds) => new Promise((resolve2) => setTimeout(resolve2, seconds * 1e3)); + +// src/kubeconfigs/arc.ts +var RUNNER_TEMP = process.env["RUNNER_TEMP"] || ""; +var KUBECONFIG_LOCATION = path5.join( + RUNNER_TEMP, + `arc_kubeconfig_${Date.now()}` +); +async function getArcKubeconfig() { + const resourceGroupName = getInput("resource-group", { required: true }); + const clusterName = getInput("cluster-name", { required: true }); + const azPath = await which("az", true); + const method = parseMethod( + getInput("method", { required: true }) + ); + await runAzCliCommand(azPath, ["extension", "add", "-n", "connectedk8s"]); + switch (method) { + case "service-account" /* SERVICE_ACCOUNT */: + const saToken = getInput("token", { required: true }); + return await runAzKubeconfigCommandBlocking( + azPath, + [ + "connectedk8s", + "proxy", + "-n", + clusterName, + "-g", + resourceGroupName, + "--token", + saToken, + "-f", + KUBECONFIG_LOCATION + ], + KUBECONFIG_LOCATION + ); + case "service-principal" /* SERVICE_PRINCIPAL */: + return await runAzKubeconfigCommandBlocking( + azPath, + [ + "connectedk8s", + "proxy", + "-n", + clusterName, + "-g", + resourceGroupName, + "-f", + KUBECONFIG_LOCATION + ], + KUBECONFIG_LOCATION + ); + case void 0: + warning("Defaulting to kubeconfig method"); + case "kubeconfig" /* KUBECONFIG */: + default: + throw Error("Kubeconfig method not supported for Arc cluster"); + } +} + +// src/utils.ts +async function getKubeconfig(type2) { + switch (type2) { + case "arc" /* ARC */: { + return await getArcKubeconfig(); + } + case void 0: { + warning("Cluster type not recognized. Defaulting to generic."); + } + default: { + return getDefaultKubeconfig(); + } + } +} +function setContext(kubeconfig) { + const context = getInput("context"); + if (!context) { + debug("Can't set context because context is unspecified."); + return kubeconfig; + } + const kc = new KubeConfig(); + kc.loadFromString(kubeconfig); + kc.setCurrentContext(context); + return kc.exportConfig(); +} + +// src/action.ts +async function run() { + const clusterType = parseCluster( + getInput("cluster-type", { + required: true + }) + ); + const runnerTempDirectory = process.env["RUNNER_TEMP"] ?? ""; + const kubeconfigPath = path6.join( + runnerTempDirectory, + `kubeconfig_${Date.now()}` + ); + const kubeconfig = await getKubeconfig(clusterType); + const kubeconfigWithContext = setContext(kubeconfig); + debug(`Writing kubeconfig contents to ${kubeconfigPath}`); + fs7.writeFileSync(kubeconfigPath, kubeconfigWithContext); + fs7.chmodSync(kubeconfigPath, "600"); + debug("Setting KUBECONFIG environment variable"); + exportVariable("KUBECONFIG", kubeconfigPath); +} + +// src/run.ts +run().catch(setFailed); +/*! Bundled license information: + +undici/lib/web/fetch/body.js: + (*! formdata-polyfill. MIT License. Jimmy Wärting *) + +undici/lib/web/websocket/frame.js: + (*! ws. MIT License. Einar Otto Stangvik *) + +js-yaml/dist/js-yaml.mjs: + (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *) +*/