\\d+)m|\\${ANSI_ESCAPE_LINK}(?.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
+ if (groups.code !== undefined) {
+ const code = Number.parseFloat(groups.code);
+ escapeCode = code === END_CODE ? undefined : code;
+ } else if (groups.uri !== undefined) {
+ escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+ }
+ }
-/***/ 24622:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ const code = ansiStyles.codes.get(Number(escapeCode));
-const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(36443)
-const kPool = Symbol('pool')
+ if (pre[index + 1] === '\n') {
+ if (escapeUrl) {
+ returnValue += wrapAnsiHyperlink('');
+ }
-class PoolStats {
- constructor (pool) {
- this[kPool] = pool
- }
+ if (escapeCode && code) {
+ returnValue += wrapAnsi(code);
+ }
+ } else if (character === '\n') {
+ if (escapeCode && code) {
+ returnValue += wrapAnsi(escapeCode);
+ }
- get connected () {
- return this[kPool][kConnected]
- }
+ if (escapeUrl) {
+ returnValue += wrapAnsiHyperlink(escapeUrl);
+ }
+ }
+ }
- get free () {
- return this[kPool][kFree]
- }
+ return returnValue;
+};
- get pending () {
- return this[kPool][kPending]
- }
+// For each newline, invoke the method separately
+module.exports = (string, columns, options) => {
+ return String(string)
+ .normalize()
+ .replace(/\r\n/g, '\n')
+ .split('\n')
+ .map(line => exec(line, columns, options))
+ .join('\n');
+};
- get queued () {
- return this[kPool][kQueued]
- }
- get running () {
- return this[kPool][kRunning]
- }
+/***/ }),
- get size () {
- return this[kPool][kSize]
+/***/ 58264:
+/***/ ((module) => {
+
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+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 cb = args[args.length-1]
+ if (typeof ret === 'function' && ret !== cb) {
+ Object.keys(cb).forEach(function (k) {
+ ret[k] = cb[k]
+ })
+ }
+ return ret
}
}
-module.exports = PoolStats
-
/***/ }),
-/***/ 35076:
+/***/ 11354:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
"use strict";
-const {
- PoolBase,
- kClients,
- kNeedDrain,
- kAddClient,
- kGetDispatcher
-} = __nccwpck_require__(58640)
-const Client = __nccwpck_require__(86197)
-const {
- InvalidArgumentError
-} = __nccwpck_require__(68707)
-const util = __nccwpck_require__(3440)
-const { kUrl, kInterceptors } = __nccwpck_require__(36443)
-const buildConnector = __nccwpck_require__(59136)
+const WebSocket = __nccwpck_require__(56681);
-const kOptions = Symbol('options')
-const kConnections = Symbol('connections')
-const kFactory = Symbol('factory')
+WebSocket.createWebSocketStream = __nccwpck_require__(86412);
+WebSocket.Server = __nccwpck_require__(70129);
+WebSocket.Receiver = __nccwpck_require__(20893);
+WebSocket.Sender = __nccwpck_require__(7389);
-function defaultFactory (origin, opts) {
- return new Client(origin, opts)
-}
+WebSocket.WebSocket = WebSocket;
+WebSocket.WebSocketServer = WebSocket.Server;
-class Pool extends PoolBase {
- constructor (origin, {
- connections,
- factory = defaultFactory,
- connect,
- connectTimeout,
- tls,
- maxCachedSessions,
- socketPath,
- autoSelectFamily,
- autoSelectFamilyAttemptTimeout,
- allowH2,
- ...options
- } = {}) {
- super()
+module.exports = WebSocket;
- 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')
- }
+/***/ 95803:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- if (typeof connect !== 'function') {
- connect = buildConnector({
- ...tls,
- maxCachedSessions,
- allowH2,
- socketPath,
- timeout: connectTimeout,
- ...(util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
- ...connect
- })
- }
+"use strict";
- this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool)
- ? options.interceptors.Pool
- : []
- this[kConnections] = connections || null
- this[kUrl] = util.parseOrigin(origin)
- this[kOptions] = { ...util.deepClone(options), connect, allowH2 }
- this[kOptions].interceptors = options.interceptors
- ? { ...options.interceptors }
- : undefined
- this[kFactory] = factory
- }
- [kGetDispatcher] () {
- let dispatcher = this[kClients].find(dispatcher => !dispatcher[kNeedDrain])
+const { EMPTY_BUFFER } = __nccwpck_require__(71791);
- if (dispatcher) {
- return dispatcher
- }
+const FastBuffer = Buffer[Symbol.species];
- if (!this[kConnections] || this[kClients].length < this[kConnections]) {
- dispatcher = this[kFactory](this[kUrl], this[kOptions])
- this[kAddClient](dispatcher)
- }
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+ if (list.length === 0) return EMPTY_BUFFER;
+ if (list.length === 1) return list[0];
- return dispatcher
+ const target = Buffer.allocUnsafe(totalLength);
+ let offset = 0;
+
+ for (let i = 0; i < list.length; i++) {
+ const buf = list[i];
+ target.set(buf, offset);
+ offset += buf.length;
+ }
+
+ if (offset < totalLength) {
+ return new FastBuffer(target.buffer, target.byteOffset, offset);
}
+
+ return target;
}
-module.exports = Pool
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+ for (let i = 0; i < length; i++) {
+ output[offset + i] = source[i] ^ mask[i & 3];
+ }
+}
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+ for (let i = 0; i < buffer.length; i++) {
+ buffer[i] ^= mask[i & 3];
+ }
+}
-/***/ }),
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+ if (buf.length === buf.buffer.byteLength) {
+ return buf.buffer;
+ }
-/***/ 22720:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+}
-"use strict";
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+ toBuffer.readOnly = true;
+ if (Buffer.isBuffer(data)) return data;
-const { kProxy, kClose, kDestroy, kInterceptors } = __nccwpck_require__(36443)
-const { URL } = __nccwpck_require__(87016)
-const Agent = __nccwpck_require__(59965)
-const Pool = __nccwpck_require__(35076)
-const DispatcherBase = __nccwpck_require__(50001)
-const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(68707)
-const buildConnector = __nccwpck_require__(59136)
+ let buf;
-const kAgent = Symbol('proxy agent')
-const kClient = Symbol('proxy client')
-const kProxyHeaders = Symbol('proxy headers')
-const kRequestTls = Symbol('request tls settings')
-const kProxyTls = Symbol('proxy tls settings')
-const kConnectEndpoint = Symbol('connect endpoint function')
+ if (data instanceof ArrayBuffer) {
+ buf = new FastBuffer(data);
+ } else if (ArrayBuffer.isView(data)) {
+ buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+ } else {
+ buf = Buffer.from(data);
+ toBuffer.readOnly = false;
+ }
-function defaultProtocolPort (protocol) {
- return protocol === 'https:' ? 443 : 80
+ return buf;
}
-function buildProxyOptions (opts) {
- if (typeof opts === 'string') {
- opts = { uri: opts }
- }
+module.exports = {
+ concat,
+ mask: _mask,
+ toArrayBuffer,
+ toBuffer,
+ unmask: _unmask
+};
- if (!opts || !opts.uri) {
- throw new InvalidArgumentError('Proxy opts.uri is mandatory')
- }
+/* istanbul ignore else */
+if (!process.env.WS_NO_BUFFER_UTIL) {
+ try {
+ const bufferUtil = __nccwpck_require__(18327);
- return {
- uri: opts.uri,
- protocol: opts.protocol || 'https'
+ 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 (e) {
+ // Continue regardless of the error.
}
}
-function defaultFactory (origin, opts) {
- return new Pool(origin, opts)
-}
-class ProxyAgent extends DispatcherBase {
- constructor (opts) {
- super(opts)
- this[kProxy] = buildProxyOptions(opts)
- this[kAgent] = new Agent(opts)
- this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent)
- ? opts.interceptors.ProxyAgent
- : []
+/***/ }),
- if (typeof opts === 'string') {
- opts = { uri: opts }
- }
+/***/ 71791:
+/***/ ((module) => {
- if (!opts || !opts.uri) {
- throw new InvalidArgumentError('Proxy opts.uri is mandatory')
- }
+"use strict";
- const { clientFactory = defaultFactory } = opts
- if (typeof clientFactory !== 'function') {
- throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
- }
+const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob = typeof Blob !== 'undefined';
- this[kRequestTls] = opts.requestTls
- this[kProxyTls] = opts.proxyTls
- this[kProxyHeaders] = opts.headers || {}
+if (hasBlob) BINARY_TYPES.push('blob');
- const resolvedUrl = new URL(opts.uri)
- const { origin, port, host, username, password } = resolvedUrl
+module.exports = {
+ BINARY_TYPES,
+ EMPTY_BUFFER: Buffer.alloc(0),
+ GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+ hasBlob,
+ kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+ kListener: Symbol('kListener'),
+ kStatusCode: Symbol('status-code'),
+ kWebSocket: Symbol('websocket'),
+ NOOP: () => {}
+};
- if (opts.auth && opts.token) {
- throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
- } else if (opts.auth) {
- /* @deprecated in favour of opts.token */
- 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 })
- this[kClient] = clientFactory(resolvedUrl, { connect })
- this[kAgent] = new Agent({
- ...opts,
- connect: async (opts, callback) => {
- let requestedHost = opts.host
- if (!opts.port) {
- requestedHost += `:${defaultProtocolPort(opts.protocol)}`
- }
- try {
- const { socket, statusCode } = await this[kClient].connect({
- origin,
- port,
- path: requestedHost,
- signal: opts.signal,
- headers: {
- ...this[kProxyHeaders],
- host
- }
- })
- if (statusCode !== 200) {
- socket.on('error', () => {}).destroy()
- callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`))
- }
- if (opts.protocol !== 'https:') {
- callback(null, socket)
- return
- }
- let servername
- if (this[kRequestTls]) {
- servername = this[kRequestTls].servername
- } else {
- servername = opts.servername
- }
- this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
- } catch (err) {
- callback(err)
- }
- }
- })
- }
+/***/ }),
- dispatch (opts, handler) {
- const { host } = new URL(opts.origin)
- const headers = buildHeaders(opts.headers)
- throwIfProxyAuthIsSent(headers)
- return this[kAgent].dispatch(
- {
- ...opts,
- headers: {
- ...headers,
- host
- }
- },
- handler
- )
+/***/ 34634:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kForOnEventAttribute, kListener } = __nccwpck_require__(71791);
+
+const kCode = Symbol('kCode');
+const kData = Symbol('kData');
+const kError = Symbol('kError');
+const kMessage = Symbol('kMessage');
+const kReason = Symbol('kReason');
+const kTarget = Symbol('kTarget');
+const kType = Symbol('kType');
+const kWasClean = Symbol('kWasClean');
+
+/**
+ * Class representing an event.
+ */
+class Event {
+ /**
+ * Create a new `Event`.
+ *
+ * @param {String} type The name of the event
+ * @throws {TypeError} If the `type` argument is not specified
+ */
+ constructor(type) {
+ this[kTarget] = null;
+ this[kType] = type;
}
- async [kClose] () {
- await this[kAgent].close()
- await this[kClient].close()
+ /**
+ * @type {*}
+ */
+ get target() {
+ return this[kTarget];
}
- async [kDestroy] () {
- await this[kAgent].destroy()
- await this[kClient].destroy()
+ /**
+ * @type {String}
+ */
+ get type() {
+ return this[kType];
}
}
+Object.defineProperty(Event.prototype, 'target', { enumerable: true });
+Object.defineProperty(Event.prototype, 'type', { enumerable: true });
+
/**
- * @param {string[] | Record} headers
- * @returns {Record}
+ * Class representing a close event.
+ *
+ * @extends Event
*/
-function buildHeaders (headers) {
- // When using undici.fetch, the headers list is stored
- // as an array.
- if (Array.isArray(headers)) {
- /** @type {Record} */
- const headersPair = {}
+class CloseEvent extends Event {
+ /**
+ * 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(type, options = {}) {
+ super(type);
- for (let i = 0; i < headers.length; i += 2) {
- headersPair[headers[i]] = headers[i + 1]
- }
+ this[kCode] = options.code === undefined ? 0 : options.code;
+ this[kReason] = options.reason === undefined ? '' : options.reason;
+ this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+ }
- return headersPair
+ /**
+ * @type {Number}
+ */
+ get code() {
+ return this[kCode];
}
- return headers
+ /**
+ * @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 });
+
/**
- * @param {Record} headers
+ * Class representing an error event.
*
- * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
- * Nevertheless, it was changed and to avoid a security vulnerability by end users
- * this check was created.
- * It should be removed in the next major version for performance reasons
+ * @extends Event
*/
-function throwIfProxyAuthIsSent (headers) {
- const existProxyAuth = headers && Object.keys(headers)
- .find((key) => key.toLowerCase() === 'proxy-authorization')
- if (existProxyAuth) {
- throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
- }
-}
+class ErrorEvent extends Event {
+ /**
+ * 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(type, options = {}) {
+ super(type);
-module.exports = ProxyAgent
+ this[kError] = options.error === undefined ? null : options.error;
+ this[kMessage] = options.message === undefined ? '' : options.message;
+ }
+ /**
+ * @type {*}
+ */
+ get error() {
+ return this[kError];
+ }
-/***/ }),
+ /**
+ * @type {String}
+ */
+ get message() {
+ return this[kMessage];
+ }
+}
-/***/ 28804:
-/***/ ((module) => {
+Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
+Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
-"use strict";
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+class MessageEvent extends Event {
+ /**
+ * 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(type, options = {}) {
+ super(type);
+ this[kData] = options.data === undefined ? null : options.data;
+ }
-let fastNow = Date.now()
-let fastNowTimeout
+ /**
+ * @type {*}
+ */
+ get data() {
+ return this[kData];
+ }
+}
-const fastTimers = []
+Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
-function onTimeout () {
- fastNow = Date.now()
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+ /**
+ * 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(type, handler, options = {}) {
+ for (const listener of this.listeners(type)) {
+ if (
+ !options[kForOnEventAttribute] &&
+ listener[kListener] === handler &&
+ !listener[kForOnEventAttribute]
+ ) {
+ return;
+ }
+ }
- let len = fastTimers.length
- let idx = 0
- while (idx < len) {
- const timer = fastTimers[idx]
+ let wrapper;
- if (timer.state === 0) {
- timer.state = fastNow + timer.delay
- } else if (timer.state > 0 && fastNow >= timer.state) {
- timer.state = -1
- timer.callback(timer.opaque)
- }
+ if (type === 'message') {
+ wrapper = function onMessage(data, isBinary) {
+ const event = new MessageEvent('message', {
+ data: isBinary ? data : data.toString()
+ });
- if (timer.state === -1) {
- timer.state = -2
- if (idx !== len - 1) {
- fastTimers[idx] = fastTimers.pop()
- } else {
- fastTimers.pop()
- }
- len -= 1
- } else {
- idx += 1
- }
- }
+ event[kTarget] = this;
+ callListener(handler, this, event);
+ };
+ } else if (type === 'close') {
+ wrapper = function onClose(code, message) {
+ const event = new CloseEvent('close', {
+ code,
+ reason: message.toString(),
+ wasClean: this._closeFrameReceived && this._closeFrameSent
+ });
- if (fastTimers.length > 0) {
- refreshTimeout()
- }
-}
+ event[kTarget] = this;
+ callListener(handler, this, event);
+ };
+ } else if (type === 'error') {
+ wrapper = function onError(error) {
+ const event = new ErrorEvent('error', {
+ error,
+ message: error.message
+ });
-function refreshTimeout () {
- if (fastNowTimeout && fastNowTimeout.refresh) {
- fastNowTimeout.refresh()
- } else {
- clearTimeout(fastNowTimeout)
- fastNowTimeout = setTimeout(onTimeout, 1e3)
- if (fastNowTimeout.unref) {
- fastNowTimeout.unref()
- }
- }
-}
+ event[kTarget] = this;
+ callListener(handler, this, event);
+ };
+ } else if (type === 'open') {
+ wrapper = function onOpen() {
+ const event = new Event('open');
-class Timeout {
- constructor (callback, delay, opaque) {
- this.callback = callback
- this.delay = delay
- this.opaque = opaque
+ event[kTarget] = this;
+ callListener(handler, this, event);
+ };
+ } else {
+ return;
+ }
- // -2 not in timer list
- // -1 in timer list but inactive
- // 0 in timer list waiting for time
- // > 0 in timer list waiting for time to expire
- this.state = -2
+ wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+ wrapper[kListener] = handler;
- this.refresh()
- }
+ if (options.once) {
+ this.once(type, wrapper);
+ } else {
+ this.on(type, wrapper);
+ }
+ },
- refresh () {
- if (this.state === -2) {
- fastTimers.push(this)
- if (!fastNowTimeout || fastTimers.length === 1) {
- refreshTimeout()
+ /**
+ * 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(type, handler) {
+ for (const listener of this.listeners(type)) {
+ if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+ this.removeListener(type, listener);
+ break;
}
}
-
- this.state = 0
- }
-
- clear () {
- this.state = -1
}
-}
+};
module.exports = {
- setTimeout (callback, delay, opaque) {
- return delay < 1e3
- ? setTimeout(callback, delay, opaque)
- : new Timeout(callback, delay, opaque)
- },
- clearTimeout (timeout) {
- if (timeout instanceof Timeout) {
- timeout.clear()
- } else {
- clearTimeout(timeout)
- }
+ CloseEvent,
+ ErrorEvent,
+ Event,
+ EventTarget,
+ MessageEvent
+};
+
+/**
+ * Call an event listener
+ *
+ * @param {(Function|Object)} listener The listener to call
+ * @param {*} thisArg The value to use as `this`` when calling the listener
+ * @param {Event} event The event to pass to the listener
+ * @private
+ */
+function callListener(listener, thisArg, event) {
+ if (typeof listener === 'object' && listener.handleEvent) {
+ listener.handleEvent.call(listener, event);
+ } else {
+ listener.call(thisArg, event);
}
}
/***/ }),
-/***/ 68550:
+/***/ 61335:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
"use strict";
-const diagnosticsChannel = __nccwpck_require__(31637)
-const { uid, states } = __nccwpck_require__(45913)
-const {
- kReadyState,
- kSentClose,
- kByteParser,
- kReceivedClose
-} = __nccwpck_require__(62933)
-const { fireEvent, failWebsocketConnection } = __nccwpck_require__(3574)
-const { CloseEvent } = __nccwpck_require__(46255)
-const { makeRequest } = __nccwpck_require__(25194)
-const { fetching } = __nccwpck_require__(12315)
-const { Headers } = __nccwpck_require__(26349)
-const { getGlobalDispatcher } = __nccwpck_require__(32581)
-const { kHeadersList } = __nccwpck_require__(36443)
-
-const channels = {}
-channels.open = diagnosticsChannel.channel('undici:websocket:open')
-channels.close = diagnosticsChannel.channel('undici:websocket:close')
-channels.socketError = diagnosticsChannel.channel('undici:websocket:socket_error')
-
-/** @type {import('crypto')} */
-let crypto
-try {
- crypto = __nccwpck_require__(76982)
-} catch {
+const { tokenChars } = __nccwpck_require__(26615);
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ * parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+ if (dest[name] === undefined) dest[name] = [elem];
+ else dest[name].push(elem);
}
/**
- * @see https://websockets.spec.whatwg.org/#concept-websocket-establish
- * @param {URL} url
- * @param {string|string[]} protocols
- * @param {import('./websocket').WebSocket} ws
- * @param {(response: any) => void} onEstablish
- * @param {Partial} options
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
*/
-function establishWebSocketConnection (url, protocols, ws, onEstablish, options) {
- // 1. Let requestURL be a copy of url, with its scheme set to "http", if url’s
- // scheme is "ws", and to "https" otherwise.
- const requestURL = url
+function parse(header) {
+ const offers = Object.create(null);
+ let params = 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;
- requestURL.protocol = url.protocol === 'ws:' ? 'http:' : 'https:'
+ for (; i < header.length; i++) {
+ code = header.charCodeAt(i);
- // 2. Let request be a new request, whose URL is requestURL, client is client,
- // service-workers mode is "none", referrer is "no-referrer", mode is
- // "websocket", credentials mode is "include", cache mode is "no-store" ,
- // and redirect mode is "error".
- const request = makeRequest({
- urlList: [requestURL],
- serviceWorkers: 'none',
- referrer: 'no-referrer',
- mode: 'websocket',
- credentials: 'include',
- cache: 'no-store',
- redirect: 'error'
- })
+ if (extensionName === undefined) {
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1) start = i;
+ } else if (
+ i !== 0 &&
+ (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+ ) {
+ if (end === -1 && start !== -1) end = i;
+ } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
- // Note: undici extension, allow setting custom headers.
- if (options.headers) {
- const headersList = new Headers(options.headers)[kHeadersList]
+ if (end === -1) end = i;
+ const name = header.slice(start, end);
+ if (code === 0x2c) {
+ push(offers, name, params);
+ params = Object.create(null);
+ } else {
+ extensionName = name;
+ }
- request.headersList = headersList
- }
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else if (paramName === undefined) {
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1) start = i;
+ } else if (code === 0x20 || code === 0x09) {
+ if (end === -1 && start !== -1) end = i;
+ } else if (code === 0x3b || code === 0x2c) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
- // 3. Append (`Upgrade`, `websocket`) to request’s header list.
- // 4. Append (`Connection`, `Upgrade`) to request’s header list.
- // Note: both of these are handled by undici currently.
- // https://github.com/nodejs/undici/blob/68c269c4144c446f3f1220951338daef4a6b5ec4/lib/client.js#L1397
+ if (end === -1) end = i;
+ push(params, header.slice(start, end), true);
+ if (code === 0x2c) {
+ push(offers, extensionName, params);
+ params = Object.create(null);
+ extensionName = undefined;
+ }
- // 5. Let keyValue be a nonce consisting of a randomly selected
- // 16-byte value that has been forgiving-base64-encoded and
- // isomorphic encoded.
- const keyValue = crypto.randomBytes(16).toString('base64')
+ start = end = -1;
+ } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+ paramName = header.slice(start, i);
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else {
+ //
+ // The value of a quoted-string after unescaping must conform to the
+ // token ABNF, so only token characters are valid.
+ // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+ //
+ 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 === 0x22 /* '"' */ && start !== -1) {
+ inQuotes = false;
+ end = i;
+ } else if (code === 0x5c /* '\' */) {
+ isEscaping = true;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+ inQuotes = true;
+ } else if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1) start = i;
+ } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+ if (end === -1) end = i;
+ } else if (code === 0x3b || code === 0x2c) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
- // 6. Append (`Sec-WebSocket-Key`, keyValue) to request’s
- // header list.
- request.headersList.append('sec-websocket-key', keyValue)
+ if (end === -1) end = i;
+ let value = header.slice(start, end);
+ if (mustUnescape) {
+ value = value.replace(/\\/g, '');
+ mustUnescape = false;
+ }
+ push(params, paramName, value);
+ if (code === 0x2c) {
+ push(offers, extensionName, params);
+ params = Object.create(null);
+ extensionName = undefined;
+ }
- // 7. Append (`Sec-WebSocket-Version`, `13`) to request’s
- // header list.
- request.headersList.append('sec-websocket-version', '13')
+ paramName = undefined;
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ }
+ }
- // 8. For each protocol in protocols, combine
- // (`Sec-WebSocket-Protocol`, protocol) in request’s header
- // list.
- for (const protocol of protocols) {
- request.headersList.append('sec-websocket-protocol', protocol)
+ if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
+ throw new SyntaxError('Unexpected end of input');
}
- // 9. Let permessageDeflate be a user-agent defined
- // "permessage-deflate" extension header value.
- // https://github.com/mozilla/gecko-dev/blob/ce78234f5e653a5d3916813ff990f053510227bc/netwerk/protocol/websocket/WebSocketChannel.cpp#L2673
- // TODO: enable once permessage-deflate is supported
- const permessageDeflate = '' // 'permessage-deflate; 15'
+ if (end === -1) end = i;
+ const token = header.slice(start, end);
+ if (extensionName === undefined) {
+ push(offers, token, params);
+ } else {
+ if (paramName === undefined) {
+ push(params, token, true);
+ } else if (mustUnescape) {
+ push(params, paramName, token.replace(/\\/g, ''));
+ } else {
+ push(params, paramName, token);
+ }
+ push(offers, extensionName, params);
+ }
- // 10. Append (`Sec-WebSocket-Extensions`, permessageDeflate) to
- // request’s header list.
- // request.headersList.append('sec-websocket-extensions', permessageDeflate)
+ return offers;
+}
- // 11. Fetch request with useParallelQueue set to true, and
- // processResponse given response being these steps:
- const controller = fetching({
- request,
- useParallelQueue: true,
- dispatcher: options.dispatcher ?? getGlobalDispatcher(),
- processResponse (response) {
- // 1. If response is a network error or its status is not 101,
- // fail the WebSocket connection.
- if (response.type === 'error' || response.status !== 101) {
- failWebsocketConnection(ws, 'Received network error or non-101 status code.')
- return
- }
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format(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(', ');
+}
- // 2. If protocols is not the empty list and extracting header
- // list values given `Sec-WebSocket-Protocol` and response’s
- // header list results in null, failure, or the empty byte
- // sequence, then fail the WebSocket connection.
- if (protocols.length !== 0 && !response.headersList.get('Sec-WebSocket-Protocol')) {
- failWebsocketConnection(ws, 'Server did not respond with sent protocols.')
- return
- }
+module.exports = { format, parse };
- // 3. Follow the requirements stated step 2 to step 6, inclusive,
- // of the last set of steps in section 4.1 of The WebSocket
- // Protocol to validate response. This either results in fail
- // the WebSocket connection or the WebSocket connection is
- // established.
- // 2. If the response lacks an |Upgrade| header field or the |Upgrade|
- // header field contains a value that is not an ASCII case-
- // insensitive match for the value "websocket", the client MUST
- // _Fail the WebSocket Connection_.
- if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
- failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".')
- return
- }
+/***/ }),
- // 3. If the response lacks a |Connection| header field or the
- // |Connection| header field doesn't contain a token that is an
- // ASCII case-insensitive match for the value "Upgrade", the client
- // MUST _Fail the WebSocket Connection_.
- if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
- failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".')
- return
- }
+/***/ 10958:
+/***/ ((module) => {
- // 4. If the response lacks a |Sec-WebSocket-Accept| header field or
- // the |Sec-WebSocket-Accept| contains a value other than the
- // base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket-
- // Key| (as a string, not base64-decoded) with the string "258EAFA5-
- // E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and
- // trailing whitespace, the client MUST _Fail the WebSocket
- // Connection_.
- const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
- const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64')
- if (secWSAccept !== digest) {
- failWebsocketConnection(ws, 'Incorrect hash received in Sec-WebSocket-Accept header.')
- return
- }
+"use strict";
- // 5. If the response includes a |Sec-WebSocket-Extensions| header
- // field and this header field indicates the use of an extension
- // that was not present in the client's handshake (the server has
- // indicated an extension not requested by the client), the client
- // MUST _Fail the WebSocket Connection_. (The parsing of this
- // header field to determine which extensions are requested is
- // discussed in Section 9.1.)
- const secExtension = response.headersList.get('Sec-WebSocket-Extensions')
- if (secExtension !== null && secExtension !== permessageDeflate) {
- failWebsocketConnection(ws, 'Received different permessage-deflate than the one set.')
- return
- }
+const kDone = Symbol('kDone');
+const kRun = Symbol('kRun');
- // 6. If the response includes a |Sec-WebSocket-Protocol| header field
- // and this header field indicates the use of a subprotocol that was
- // not present in the client's handshake (the server has indicated a
- // subprotocol not requested by the client), the client MUST _Fail
- // the WebSocket Connection_.
- const secProtocol = response.headersList.get('Sec-WebSocket-Protocol')
+/**
+ * A very simple job queue with adjustable concurrency. Adapted from
+ * https://github.com/STRML/async-limiter
+ */
+class Limiter {
+ /**
+ * 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;
+ }
- if (secProtocol !== null && secProtocol !== request.headersList.get('Sec-WebSocket-Protocol')) {
- failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.')
- return
- }
+ /**
+ * Adds a job to the queue.
+ *
+ * @param {Function} job The job to run
+ * @public
+ */
+ add(job) {
+ this.jobs.push(job);
+ this[kRun]();
+ }
- response.socket.on('data', onSocketData)
- response.socket.on('close', onSocketClose)
- response.socket.on('error', onSocketError)
+ /**
+ * Removes a job from the queue and runs it if possible.
+ *
+ * @private
+ */
+ [kRun]() {
+ if (this.pending === this.concurrency) return;
- if (channels.open.hasSubscribers) {
- channels.open.publish({
- address: response.socket.address(),
- protocol: secProtocol,
- extensions: secExtension
- })
- }
+ if (this.jobs.length) {
+ const job = this.jobs.shift();
- onEstablish(response)
+ this.pending++;
+ job(this[kDone]);
}
- })
-
- return controller
-}
-
-/**
- * @param {Buffer} chunk
- */
-function onSocketData (chunk) {
- if (!this.ws[kByteParser].write(chunk)) {
- this.pause()
}
}
-/**
- * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
- * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
- */
-function onSocketClose () {
- const { ws } = this
+module.exports = Limiter;
- // If the TCP connection was closed after the
- // WebSocket closing handshake was completed, the WebSocket connection
- // is said to have been closed _cleanly_.
- const wasClean = ws[kSentClose] && ws[kReceivedClose]
- let code = 1005
- let reason = ''
+/***/ }),
- const result = ws[kByteParser].closingInfo
+/***/ 4376:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- if (result) {
- code = result.code ?? 1005
- reason = result.reason
- } else if (!ws[kSentClose]) {
- // If _The WebSocket
- // Connection is Closed_ and no Close control frame was received by the
- // endpoint (such as could occur if the underlying transport connection
- // is lost), _The WebSocket Connection Close Code_ is considered to be
- // 1006.
- code = 1006
- }
+"use strict";
- // 1. Change the ready state to CLOSED (3).
- ws[kReadyState] = states.CLOSED
- // 2. If the user agent was required to fail the WebSocket
- // connection, or if the WebSocket connection was closed
- // after being flagged as full, fire an event named error
- // at the WebSocket object.
- // TODO
+const zlib = __nccwpck_require__(43106);
- // 3. Fire an event named close at the WebSocket object,
- // using CloseEvent, with the wasClean attribute
- // initialized to true if the connection closed cleanly
- // and false otherwise, the code attribute initialized to
- // the WebSocket connection close code, and the reason
- // attribute initialized to the result of applying UTF-8
- // decode without BOM to the WebSocket connection close
- // reason.
- fireEvent('close', ws, CloseEvent, {
- wasClean, code, reason
- })
+const bufferUtil = __nccwpck_require__(95803);
+const Limiter = __nccwpck_require__(10958);
+const { kStatusCode } = __nccwpck_require__(71791);
- if (channels.close.hasSubscribers) {
- channels.close.publish({
- websocket: ws,
- code,
- reason
- })
- }
-}
+const FastBuffer = Buffer[Symbol.species];
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const kPerMessageDeflate = Symbol('permessage-deflate');
+const kTotalLength = Symbol('total-length');
+const kCallback = Symbol('callback');
+const kBuffers = Symbol('buffers');
+const kError = Symbol('error');
-function onSocketError (error) {
- const { ws } = this
+//
+// We limit zlib concurrency, which prevents severe memory fragmentation
+// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+// and https://github.com/websockets/ws/issues/1202
+//
+// Intentionally global; it's the global thread pool that's an issue.
+//
+let zlibLimiter;
- ws[kReadyState] = states.CLOSING
+/**
+ * permessage-deflate implementation.
+ */
+class PerMessageDeflate {
+ /**
+ * 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|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
+ * @param {Boolean} [isServer=false] Create the instance in either server or
+ * client mode
+ * @param {Number} [maxPayload=0] The maximum allowed message length
+ */
+ constructor(options, isServer, maxPayload) {
+ this._maxPayload = maxPayload | 0;
+ this._options = options || {};
+ this._threshold =
+ this._options.threshold !== undefined ? this._options.threshold : 1024;
+ this._isServer = !!isServer;
+ this._deflate = null;
+ this._inflate = null;
- if (channels.socketError.hasSubscribers) {
- channels.socketError.publish(error)
+ this.params = null;
+
+ if (!zlibLimiter) {
+ const concurrency =
+ this._options.concurrencyLimit !== undefined
+ ? this._options.concurrencyLimit
+ : 10;
+ zlibLimiter = new Limiter(concurrency);
+ }
}
- this.destroy()
-}
+ /**
+ * @type {String}
+ */
+ static get extensionName() {
+ return 'permessage-deflate';
+ }
-module.exports = {
- establishWebSocketConnection
-}
+ /**
+ * 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;
+ }
-/***/ 45913:
-/***/ ((module) => {
+ /**
+ * 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);
-"use strict";
+ this.params = this._isServer
+ ? this.acceptAsServer(configurations)
+ : this.acceptAsClient(configurations);
+ return this.params;
+ }
-// This is a Globally Unique Identifier unique used
-// to validate that the endpoint accepts websocket
-// connections.
-// See https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3
-const uid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+ /**
+ * Releases all resources used by the extension.
+ *
+ * @public
+ */
+ cleanup() {
+ if (this._inflate) {
+ this._inflate.close();
+ this._inflate = null;
+ }
-/** @type {PropertyDescriptor} */
-const staticPropertyDescriptors = {
- enumerable: true,
- writable: false,
- configurable: false
-}
+ if (this._deflate) {
+ const callback = this._deflate[kCallback];
-const states = {
- CONNECTING: 0,
- OPEN: 1,
- CLOSING: 2,
- CLOSED: 3
-}
+ this._deflate.close();
+ this._deflate = null;
-const opcodes = {
- CONTINUATION: 0x0,
- TEXT: 0x1,
- BINARY: 0x2,
- CLOSE: 0x8,
- PING: 0x9,
- PONG: 0xA
-}
+ if (callback) {
+ callback(
+ new Error(
+ 'The deflate stream was closed while data was being processed'
+ )
+ );
+ }
+ }
+ }
-const maxUnsigned16Bit = 2 ** 16 - 1 // 65535
+ /**
+ * 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;
+ }
-const parserStates = {
- INFO: 0,
- PAYLOADLENGTH_16: 2,
- PAYLOADLENGTH_64: 3,
- READ_DATA: 4
-}
+ return true;
+ });
-const emptyBuffer = Buffer.allocUnsafe(0)
+ if (!accepted) {
+ throw new Error('None of the extension offers can be accepted');
+ }
-module.exports = {
- uid,
- staticPropertyDescriptors,
- states,
- opcodes,
- maxUnsigned16Bit,
- parserStates,
- emptyBuffer
-}
+ 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];
-/***/ 46255:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ if (
+ this._options.clientNoContextTakeover === false &&
+ params.client_no_context_takeover
+ ) {
+ throw new Error('Unexpected parameter "client_no_context_takeover"');
+ }
-"use strict";
+ 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;
+ }
-const { webidl } = __nccwpck_require__(74222)
-const { kEnumerableProperty } = __nccwpck_require__(3440)
-const { MessagePort } = __nccwpck_require__(28167)
+ /**
+ * 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];
-/**
- * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
- */
-class MessageEvent extends Event {
- #eventInit
+ if (value.length > 1) {
+ throw new Error(`Parameter "${key}" must have only a single value`);
+ }
- constructor (type, eventInitDict = {}) {
- webidl.argumentLengthCheck(arguments, 1, { header: 'MessageEvent constructor' })
+ value = value[0];
- type = webidl.converters.DOMString(type)
- eventInitDict = webidl.converters.MessageEventInit(eventInitDict)
+ 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}"`);
+ }
- super(type, eventInitDict)
+ params[key] = value;
+ });
+ });
- this.#eventInit = eventInitDict
+ return configurations;
}
- get data () {
- webidl.brandCheck(this, MessageEvent)
-
- return this.#eventInit.data
+ /**
+ * 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);
+ });
+ });
}
- get origin () {
- webidl.brandCheck(this, MessageEvent)
-
- return this.#eventInit.origin
+ /**
+ * 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);
+ });
+ });
}
- get lastEventId () {
- webidl.brandCheck(this, MessageEvent)
+ /**
+ * 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';
- return this.#eventInit.lastEventId
- }
+ if (!this._inflate) {
+ const key = `${endpoint}_max_window_bits`;
+ const windowBits =
+ typeof this.params[key] !== 'number'
+ ? zlib.Z_DEFAULT_WINDOWBITS
+ : this.params[key];
- get source () {
- webidl.brandCheck(this, MessageEvent)
+ 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);
+ }
- return this.#eventInit.source
- }
+ this._inflate[kCallback] = callback;
- get ports () {
- webidl.brandCheck(this, MessageEvent)
+ this._inflate.write(data);
+ if (fin) this._inflate.write(TRAILER);
- if (!Object.isFrozen(this.#eventInit.ports)) {
- Object.freeze(this.#eventInit.ports)
- }
+ this._inflate.flush(() => {
+ const err = this._inflate[kError];
- return this.#eventInit.ports
- }
+ if (err) {
+ this._inflate.close();
+ this._inflate = null;
+ callback(err);
+ return;
+ }
- initMessageEvent (
- type,
- bubbles = false,
- cancelable = false,
- data = null,
- origin = '',
- lastEventId = '',
- source = null,
- ports = []
- ) {
- webidl.brandCheck(this, MessageEvent)
+ const data = bufferUtil.concat(
+ this._inflate[kBuffers],
+ this._inflate[kTotalLength]
+ );
- webidl.argumentLengthCheck(arguments, 1, { header: 'MessageEvent.initMessageEvent' })
+ if (this._inflate._readableState.endEmitted) {
+ this._inflate.close();
+ this._inflate = null;
+ } else {
+ this._inflate[kTotalLength] = 0;
+ this._inflate[kBuffers] = [];
- return new MessageEvent(type, {
- bubbles, cancelable, data, origin, lastEventId, source, ports
- })
+ if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+ this._inflate.reset();
+ }
+ }
+
+ callback(null, data);
+ });
}
-}
-/**
- * @see https://websockets.spec.whatwg.org/#the-closeevent-interface
- */
-class CloseEvent extends Event {
- #eventInit
+ /**
+ * 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
+ });
- constructor (type, eventInitDict = {}) {
- webidl.argumentLengthCheck(arguments, 1, { header: 'CloseEvent constructor' })
+ this._deflate[kTotalLength] = 0;
+ this._deflate[kBuffers] = [];
- type = webidl.converters.DOMString(type)
- eventInitDict = webidl.converters.CloseEventInit(eventInitDict)
+ this._deflate.on('data', deflateOnData);
+ }
- super(type, eventInitDict)
+ this._deflate[kCallback] = callback;
- this.#eventInit = eventInitDict
- }
+ this._deflate.write(data);
+ this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+ if (!this._deflate) {
+ //
+ // The deflate stream was closed while data was being processed.
+ //
+ return;
+ }
- get wasClean () {
- webidl.brandCheck(this, CloseEvent)
+ let data = bufferUtil.concat(
+ this._deflate[kBuffers],
+ this._deflate[kTotalLength]
+ );
- return this.#eventInit.wasClean
- }
+ if (fin) {
+ data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);
+ }
- get code () {
- webidl.brandCheck(this, CloseEvent)
+ //
+ // Ensure that the callback will not be called again in
+ // `PerMessageDeflate#cleanup()`.
+ //
+ this._deflate[kCallback] = null;
- return this.#eventInit.code
- }
+ this._deflate[kTotalLength] = 0;
+ this._deflate[kBuffers] = [];
- get reason () {
- webidl.brandCheck(this, CloseEvent)
+ if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+ this._deflate.reset();
+ }
- return this.#eventInit.reason
+ callback(null, data);
+ });
}
}
-// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface
-class ErrorEvent extends Event {
- #eventInit
-
- constructor (type, eventInitDict) {
- webidl.argumentLengthCheck(arguments, 1, { header: 'ErrorEvent constructor' })
+module.exports = PerMessageDeflate;
- super(type, eventInitDict)
+/**
+ * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function deflateOnData(chunk) {
+ this[kBuffers].push(chunk);
+ this[kTotalLength] += chunk.length;
+}
- type = webidl.converters.DOMString(type)
- eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {})
+/**
+ * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function inflateOnData(chunk) {
+ this[kTotalLength] += chunk.length;
- this.#eventInit = eventInitDict
+ if (
+ this[kPerMessageDeflate]._maxPayload < 1 ||
+ this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+ ) {
+ this[kBuffers].push(chunk);
+ return;
}
- get message () {
- webidl.brandCheck(this, ErrorEvent)
+ 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();
+}
- return this.#eventInit.message
- }
+/**
+ * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ *
+ * @param {Error} err The emitted error
+ * @private
+ */
+function inflateOnError(err) {
+ //
+ // There is no need to call `Zlib#close()` as the handle is automatically
+ // closed when an error is emitted.
+ //
+ this[kPerMessageDeflate]._inflate = null;
+ err[kStatusCode] = 1007;
+ this[kCallback](err);
+}
- get filename () {
- webidl.brandCheck(this, ErrorEvent)
- return this.#eventInit.filename
- }
+/***/ }),
- get lineno () {
- webidl.brandCheck(this, ErrorEvent)
+/***/ 20893:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- return this.#eventInit.lineno
- }
+"use strict";
- get colno () {
- webidl.brandCheck(this, ErrorEvent)
- return this.#eventInit.colno
- }
+const { Writable } = __nccwpck_require__(2203);
- get error () {
- webidl.brandCheck(this, ErrorEvent)
+const PerMessageDeflate = __nccwpck_require__(4376);
+const {
+ BINARY_TYPES,
+ EMPTY_BUFFER,
+ kStatusCode,
+ kWebSocket
+} = __nccwpck_require__(71791);
+const { concat, toArrayBuffer, unmask } = __nccwpck_require__(95803);
+const { isValidStatusCode, isValidUTF8 } = __nccwpck_require__(26615);
- return this.#eventInit.error
- }
-}
+const FastBuffer = Buffer[Symbol.species];
-Object.defineProperties(MessageEvent.prototype, {
- [Symbol.toStringTag]: {
- value: 'MessageEvent',
- configurable: true
- },
- data: kEnumerableProperty,
- origin: kEnumerableProperty,
- lastEventId: kEnumerableProperty,
- source: kEnumerableProperty,
- ports: kEnumerableProperty,
- initMessageEvent: kEnumerableProperty
-})
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+const DEFER_EVENT = 6;
-Object.defineProperties(CloseEvent.prototype, {
- [Symbol.toStringTag]: {
- value: 'CloseEvent',
- configurable: true
- },
- reason: kEnumerableProperty,
- code: kEnumerableProperty,
- wasClean: kEnumerableProperty
-})
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends Writable
+ */
+class Receiver 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();
-Object.defineProperties(ErrorEvent.prototype, {
- [Symbol.toStringTag]: {
- value: 'ErrorEvent',
- configurable: true
- },
- message: kEnumerableProperty,
- filename: kEnumerableProperty,
- lineno: kEnumerableProperty,
- colno: kEnumerableProperty,
- error: kEnumerableProperty
-})
+ this._allowSynchronousEvents =
+ options.allowSynchronousEvents !== undefined
+ ? 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] = undefined;
-webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort)
+ this._bufferedBytes = 0;
+ this._buffers = [];
-webidl.converters['sequence'] = webidl.sequenceConverter(
- webidl.converters.MessagePort
-)
+ this._compressed = false;
+ this._payloadLength = 0;
+ this._mask = undefined;
+ this._fragmented = 0;
+ this._masked = false;
+ this._fin = false;
+ this._opcode = 0;
-const 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
- }
-]
+ this._totalPayloadLength = 0;
+ this._messageLength = 0;
+ this._fragments = [];
-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'],
- get defaultValue () {
- return []
- }
+ this._errored = false;
+ this._loop = false;
+ this._state = GET_INFO;
}
-])
-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: ''
- }
-])
+ /**
+ * 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 === 0x08 && this._state == GET_INFO) return cb();
-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
+ this._bufferedBytes += chunk.length;
+ this._buffers.push(chunk);
+ this.startLoop(cb);
}
-])
-module.exports = {
- MessageEvent,
- CloseEvent,
- ErrorEvent
-}
+ /**
+ * 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 buf = this._buffers[0];
+ this._buffers[0] = new FastBuffer(
+ buf.buffer,
+ buf.byteOffset + n,
+ buf.length - n
+ );
-/***/ 31237:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ return new FastBuffer(buf.buffer, buf.byteOffset, n);
+ }
-"use strict";
+ const dst = Buffer.allocUnsafe(n);
+ do {
+ const buf = this._buffers[0];
+ const offset = dst.length - n;
-const { maxUnsigned16Bit } = __nccwpck_require__(45913)
+ if (n >= buf.length) {
+ dst.set(this._buffers.shift(), offset);
+ } else {
+ dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+ this._buffers[0] = new FastBuffer(
+ buf.buffer,
+ buf.byteOffset + n,
+ buf.length - n
+ );
+ }
-/** @type {import('crypto')} */
-let crypto
-try {
- crypto = __nccwpck_require__(76982)
-} catch {
+ n -= buf.length;
+ } while (n > 0);
-}
+ return dst;
+ }
-class WebsocketFrameSend {
/**
- * @param {Buffer|undefined} data
+ * Starts the parsing loop.
+ *
+ * @param {Function} cb Callback
+ * @private
*/
- constructor (data) {
- this.frameData = data
- this.maskKey = crypto.randomBytes(4)
- }
+ startLoop(cb) {
+ this._loop = true;
- createFrame (opcode) {
- const bodyLength = this.frameData?.byteLength ?? 0
+ 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);
- /** @type {number} */
- let payloadLength = bodyLength // 0-125
- let offset = 6
+ if (!this._errored) cb();
+ }
- if (bodyLength > maxUnsigned16Bit) {
- offset += 8 // payload length is next 8 bytes
- payloadLength = 127
- } else if (bodyLength > 125) {
- offset += 2 // payload length is next 2 bytes
- payloadLength = 126
+ /**
+ * Reads the first two bytes of a frame.
+ *
+ * @param {Function} cb Callback
+ * @private
+ */
+ getInfo(cb) {
+ if (this._bufferedBytes < 2) {
+ this._loop = false;
+ return;
}
- const buffer = Buffer.allocUnsafe(bodyLength + offset)
+ const buf = this.consume(2);
- // Clear first 2 bytes, everything else is overwritten
- buffer[0] = buffer[1] = 0
- buffer[0] |= 0x80 // FIN
- buffer[0] = (buffer[0] & 0xF0) + opcode // opcode
+ if ((buf[0] & 0x30) !== 0x00) {
+ const error = this.createError(
+ RangeError,
+ 'RSV2 and RSV3 must be clear',
+ true,
+ 1002,
+ 'WS_ERR_UNEXPECTED_RSV_2_3'
+ );
- /*! ws. MIT License. Einar Otto Stangvik */
- buffer[offset - 4] = this.maskKey[0]
- buffer[offset - 3] = this.maskKey[1]
- buffer[offset - 2] = this.maskKey[2]
- buffer[offset - 1] = this.maskKey[3]
+ cb(error);
+ return;
+ }
- buffer[1] = payloadLength
+ const compressed = (buf[0] & 0x40) === 0x40;
- if (payloadLength === 126) {
- buffer.writeUInt16BE(bodyLength, 2)
- } else if (payloadLength === 127) {
- // Clear extended payload length
- buffer[2] = buffer[3] = 0
- buffer.writeUIntBE(bodyLength, 4, 6)
+ if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+ const error = this.createError(
+ RangeError,
+ 'RSV1 must be clear',
+ true,
+ 1002,
+ 'WS_ERR_UNEXPECTED_RSV_1'
+ );
+
+ cb(error);
+ return;
}
- buffer[1] |= 0x80 // MASK
+ this._fin = (buf[0] & 0x80) === 0x80;
+ this._opcode = buf[0] & 0x0f;
+ this._payloadLength = buf[1] & 0x7f;
- // mask body
- for (let i = 0; i < bodyLength; i++) {
- buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4]
- }
+ if (this._opcode === 0x00) {
+ if (compressed) {
+ const error = this.createError(
+ RangeError,
+ 'RSV1 must be clear',
+ true,
+ 1002,
+ 'WS_ERR_UNEXPECTED_RSV_1'
+ );
- return buffer
- }
-}
+ cb(error);
+ return;
+ }
-module.exports = {
- WebsocketFrameSend
-}
+ if (!this._fragmented) {
+ const error = this.createError(
+ RangeError,
+ 'invalid opcode 0',
+ true,
+ 1002,
+ 'WS_ERR_INVALID_OPCODE'
+ );
+ cb(error);
+ return;
+ }
-/***/ }),
+ this._opcode = this._fragmented;
+ } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+ if (this._fragmented) {
+ const error = this.createError(
+ RangeError,
+ `invalid opcode ${this._opcode}`,
+ true,
+ 1002,
+ 'WS_ERR_INVALID_OPCODE'
+ );
-/***/ 43171:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ cb(error);
+ return;
+ }
-"use strict";
+ this._compressed = compressed;
+ } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+ if (!this._fin) {
+ const error = this.createError(
+ RangeError,
+ 'FIN must be set',
+ true,
+ 1002,
+ 'WS_ERR_EXPECTED_FIN'
+ );
+ cb(error);
+ return;
+ }
-const { Writable } = __nccwpck_require__(2203)
-const diagnosticsChannel = __nccwpck_require__(31637)
-const { parserStates, opcodes, states, emptyBuffer } = __nccwpck_require__(45913)
-const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(62933)
-const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = __nccwpck_require__(3574)
-const { WebsocketFrameSend } = __nccwpck_require__(31237)
+ if (compressed) {
+ const error = this.createError(
+ RangeError,
+ 'RSV1 must be clear',
+ true,
+ 1002,
+ 'WS_ERR_UNEXPECTED_RSV_1'
+ );
-// This code was influenced by ws released under the MIT license.
-// Copyright (c) 2011 Einar Otto Stangvik
-// Copyright (c) 2013 Arnout Kazemier and contributors
-// Copyright (c) 2016 Luigi Pinca and contributors
+ cb(error);
+ return;
+ }
-const channels = {}
-channels.ping = diagnosticsChannel.channel('undici:websocket:ping')
-channels.pong = diagnosticsChannel.channel('undici:websocket:pong')
+ if (
+ this._payloadLength > 0x7d ||
+ (this._opcode === 0x08 && this._payloadLength === 1)
+ ) {
+ const error = this.createError(
+ RangeError,
+ `invalid payload length ${this._payloadLength}`,
+ true,
+ 1002,
+ 'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+ );
-class ByteParser extends Writable {
- #buffers = []
- #byteOffset = 0
+ cb(error);
+ return;
+ }
+ } else {
+ const error = this.createError(
+ RangeError,
+ `invalid opcode ${this._opcode}`,
+ true,
+ 1002,
+ 'WS_ERR_INVALID_OPCODE'
+ );
- #state = parserStates.INFO
+ cb(error);
+ return;
+ }
- #info = {}
- #fragments = []
+ if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+ this._masked = (buf[1] & 0x80) === 0x80;
- constructor (ws) {
- super()
+ if (this._isServer) {
+ if (!this._masked) {
+ const error = this.createError(
+ RangeError,
+ 'MASK must be set',
+ true,
+ 1002,
+ 'WS_ERR_EXPECTED_MASK'
+ );
- this.ws = ws
+ cb(error);
+ return;
+ }
+ } else if (this._masked) {
+ const error = this.createError(
+ RangeError,
+ 'MASK must be clear',
+ true,
+ 1002,
+ 'WS_ERR_UNEXPECTED_MASK'
+ );
+
+ cb(error);
+ 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);
}
/**
- * @param {Buffer} chunk
- * @param {() => void} callback
+ * Gets extended payload length (7+16).
+ *
+ * @param {Function} cb Callback
+ * @private
*/
- _write (chunk, _, callback) {
- this.#buffers.push(chunk)
- this.#byteOffset += chunk.length
+ getPayloadLength16(cb) {
+ if (this._bufferedBytes < 2) {
+ this._loop = false;
+ return;
+ }
- this.run(callback)
+ this._payloadLength = this.consume(2).readUInt16BE(0);
+ this.haveLength(cb);
}
/**
- * 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.
+ * Gets extended payload length (7+64).
+ *
+ * @param {Function} cb Callback
+ * @private
*/
- run (callback) {
- while (true) {
- if (this.#state === parserStates.INFO) {
- // If there aren't enough bytes to parse the payload length, etc.
- if (this.#byteOffset < 2) {
- return callback()
- }
-
- const buffer = this.consume(2)
-
- this.#info.fin = (buffer[0] & 0x80) !== 0
- this.#info.opcode = buffer[0] & 0x0F
-
- // If we receive a fragmented message, we use the type of the first
- // frame to parse the full message as binary/text, when it's terminated
- this.#info.originalOpcode ??= this.#info.opcode
-
- this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION
-
- if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
- // Only text and binary frames can be fragmented
- failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
- return
- }
+ getPayloadLength64(cb) {
+ if (this._bufferedBytes < 8) {
+ this._loop = false;
+ return;
+ }
- const payloadLength = buffer[1] & 0x7F
+ const buf = this.consume(8);
+ const num = buf.readUInt32BE(0);
- 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
- }
+ //
+ // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+ // if payload length is greater than this number.
+ //
+ if (num > Math.pow(2, 53 - 32) - 1) {
+ const error = this.createError(
+ RangeError,
+ 'Unsupported WebSocket frame: payload length > 2^53 - 1',
+ false,
+ 1009,
+ 'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+ );
- if (this.#info.fragmented && payloadLength > 125) {
- // A fragmented frame can't be fragmented itself
- failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
- return
- } else if (
- (this.#info.opcode === opcodes.PING ||
- this.#info.opcode === opcodes.PONG ||
- this.#info.opcode === opcodes.CLOSE) &&
- payloadLength > 125
- ) {
- // Control frames can have a payload length of 125 bytes MAX
- failWebsocketConnection(this.ws, 'Payload length for control frame exceeded 125 bytes.')
- return
- } else if (this.#info.opcode === opcodes.CLOSE) {
- if (payloadLength === 1) {
- failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
- return
- }
+ cb(error);
+ return;
+ }
- const body = this.consume(payloadLength)
+ this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+ this.haveLength(cb);
+ }
- this.#info.closeInfo = this.parseCloseBody(false, body)
+ /**
+ * Payload length has been read.
+ *
+ * @param {Function} cb Callback
+ * @private
+ */
+ haveLength(cb) {
+ if (this._payloadLength && this._opcode < 0x08) {
+ this._totalPayloadLength += this._payloadLength;
+ if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+ const error = this.createError(
+ RangeError,
+ 'Max payload size exceeded',
+ false,
+ 1009,
+ 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+ );
- if (!this.ws[kSentClose]) {
- // If an endpoint receives a Close frame and did not previously send a
- // Close frame, the endpoint MUST send a Close frame in response. (When
- // sending a Close frame in response, the endpoint typically echos the
- // status code it received.)
- const body = Buffer.allocUnsafe(2)
- body.writeUInt16BE(this.#info.closeInfo.code, 0)
- const closeFrame = new WebsocketFrameSend(body)
+ cb(error);
+ return;
+ }
+ }
- this.ws[kResponse].socket.write(
- closeFrame.createFrame(opcodes.CLOSE),
- (err) => {
- if (!err) {
- this.ws[kSentClose] = true
- }
- }
- )
- }
+ if (this._masked) this._state = GET_MASK;
+ else this._state = GET_DATA;
+ }
- // Upon either sending or receiving a Close control frame, it is said
- // that _The WebSocket Closing Handshake is Started_ and that the
- // WebSocket connection is in the CLOSING state.
- this.ws[kReadyState] = states.CLOSING
- this.ws[kReceivedClose] = true
+ /**
+ * Reads mask bytes.
+ *
+ * @private
+ */
+ getMask() {
+ if (this._bufferedBytes < 4) {
+ this._loop = false;
+ return;
+ }
- this.end()
+ this._mask = this.consume(4);
+ this._state = GET_DATA;
+ }
- return
- } else if (this.#info.opcode === opcodes.PING) {
- // Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in
- // response, unless it already received a Close frame.
- // A Pong frame sent in response to a Ping frame must have identical
- // "Application data"
+ /**
+ * Reads data bytes.
+ *
+ * @param {Function} cb Callback
+ * @private
+ */
+ getData(cb) {
+ let data = EMPTY_BUFFER;
- const body = this.consume(payloadLength)
+ if (this._payloadLength) {
+ if (this._bufferedBytes < this._payloadLength) {
+ this._loop = false;
+ return;
+ }
- if (!this.ws[kReceivedClose]) {
- const frame = new WebsocketFrameSend(body)
+ data = this.consume(this._payloadLength);
- this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG))
+ if (
+ this._masked &&
+ (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0
+ ) {
+ unmask(data, this._mask);
+ }
+ }
- if (channels.ping.hasSubscribers) {
- channels.ping.publish({
- payload: body
- })
- }
- }
+ if (this._opcode > 0x07) {
+ this.controlMessage(data, cb);
+ return;
+ }
- this.#state = parserStates.INFO
+ if (this._compressed) {
+ this._state = INFLATING;
+ this.decompress(data, cb);
+ return;
+ }
- if (this.#byteOffset > 0) {
- continue
- } else {
- callback()
- return
- }
- } else if (this.#info.opcode === opcodes.PONG) {
- // A Pong frame MAY be sent unsolicited. This serves as a
- // unidirectional heartbeat. A response to an unsolicited Pong frame is
- // not expected.
+ if (data.length) {
+ //
+ // This message is not compressed so its length is the sum of the payload
+ // length of all fragments.
+ //
+ this._messageLength = this._totalPayloadLength;
+ this._fragments.push(data);
+ }
- const body = this.consume(payloadLength)
+ this.dataMessage(cb);
+ }
- if (channels.pong.hasSubscribers) {
- channels.pong.publish({
- payload: body
- })
- }
+ /**
+ * Decompresses data.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Function} cb Callback
+ * @private
+ */
+ decompress(data, cb) {
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
- if (this.#byteOffset > 0) {
- continue
- } else {
- callback()
- return
- }
- }
- } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
- if (this.#byteOffset < 2) {
- return callback()
- }
+ perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+ if (err) return cb(err);
- const buffer = this.consume(2)
+ if (buf.length) {
+ this._messageLength += buf.length;
+ if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+ const error = this.createError(
+ RangeError,
+ 'Max payload size exceeded',
+ false,
+ 1009,
+ 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+ );
- this.#info.payloadLength = buffer.readUInt16BE(0)
- this.#state = parserStates.READ_DATA
- } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
- if (this.#byteOffset < 8) {
- return callback()
+ cb(error);
+ return;
}
- const buffer = this.consume(8)
- const upper = buffer.readUInt32BE(0)
+ this._fragments.push(buf);
+ }
- // 2^31 is the maxinimum bytes an arraybuffer can contain
- // on 32-bit systems. Although, on 64-bit systems, this is
- // 2^53-1 bytes.
- // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length
- // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
- // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
- if (upper > 2 ** 31 - 1) {
- failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
- return
- }
+ this.dataMessage(cb);
+ if (this._state === GET_INFO) this.startLoop(cb);
+ });
+ }
- const lower = buffer.readUInt32BE(4)
+ /**
+ * Handles a data message.
+ *
+ * @param {Function} cb Callback
+ * @private
+ */
+ dataMessage(cb) {
+ if (!this._fin) {
+ this._state = GET_INFO;
+ return;
+ }
- this.#info.payloadLength = (upper << 8) + lower
- this.#state = parserStates.READ_DATA
- } else if (this.#state === parserStates.READ_DATA) {
- if (this.#byteOffset < this.#info.payloadLength) {
- // If there is still more data in this chunk that needs to be read
- return callback()
- } else if (this.#byteOffset >= this.#info.payloadLength) {
- // If the server sent multiple frames in a single chunk
+ const messageLength = this._messageLength;
+ const fragments = this._fragments;
- const body = this.consume(this.#info.payloadLength)
+ this._totalPayloadLength = 0;
+ this._messageLength = 0;
+ this._fragmented = 0;
+ this._fragments = [];
- this.#fragments.push(body)
+ if (this._opcode === 2) {
+ let data;
- // If the frame is unfragmented, or a fragmented frame was terminated,
- // a message was received
- if (!this.#info.fragmented || (this.#info.fin && this.#info.opcode === opcodes.CONTINUATION)) {
- const fullMessage = Buffer.concat(this.#fragments)
+ 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;
+ }
- websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage)
+ 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 buf = concat(fragments, messageLength);
- this.#info = {}
- this.#fragments.length = 0
- }
+ if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+ const error = this.createError(
+ Error,
+ 'invalid UTF-8 sequence',
+ true,
+ 1007,
+ 'WS_ERR_INVALID_UTF8'
+ );
- this.#state = parserStates.INFO
- }
+ cb(error);
+ return;
}
- if (this.#byteOffset > 0) {
- continue
+ if (this._state === INFLATING || this._allowSynchronousEvents) {
+ this.emit('message', buf, false);
+ this._state = GET_INFO;
} else {
- callback()
- break
+ this._state = DEFER_EVENT;
+ setImmediate(() => {
+ this.emit('message', buf, false);
+ this._state = GET_INFO;
+ this.startLoop(cb);
+ });
}
}
}
/**
- * Take n bytes from the buffered Buffers
- * @param {number} n
- * @returns {Buffer|null}
+ * Handles a control message.
+ *
+ * @param {Buffer} data Data to handle
+ * @return {(Error|RangeError|undefined)} A possible error
+ * @private
*/
- consume (n) {
- if (n > this.#byteOffset) {
- return null
- } 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
+ controlMessage(data, cb) {
+ if (this._opcode === 0x08) {
+ if (data.length === 0) {
+ this._loop = false;
+ this.emit('conclude', 1005, EMPTY_BUFFER);
+ this.end();
} else {
- buffer.set(this.#buffers.shift(), offset)
- offset += next.length
- }
- }
-
- this.#byteOffset -= n
+ const code = data.readUInt16BE(0);
- return buffer
- }
+ if (!isValidStatusCode(code)) {
+ const error = this.createError(
+ RangeError,
+ `invalid status code ${code}`,
+ true,
+ 1002,
+ 'WS_ERR_INVALID_CLOSE_CODE'
+ );
- parseCloseBody (onlyCode, data) {
- // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5
- /** @type {number|undefined} */
- let code
+ cb(error);
+ return;
+ }
- if (data.length >= 2) {
- // _The WebSocket Connection Close Code_ is
- // defined as the status code (Section 7.4) contained in the first Close
- // control frame received by the application
- code = data.readUInt16BE(0)
- }
+ const buf = new FastBuffer(
+ data.buffer,
+ data.byteOffset + 2,
+ data.length - 2
+ );
- if (onlyCode) {
- if (!isValidStatusCode(code)) {
- return null
- }
+ if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+ const error = this.createError(
+ Error,
+ 'invalid UTF-8 sequence',
+ true,
+ 1007,
+ 'WS_ERR_INVALID_UTF8'
+ );
- return { code }
- }
+ cb(error);
+ return;
+ }
- // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6
- /** @type {Buffer} */
- let reason = data.subarray(2)
+ this._loop = false;
+ this.emit('conclude', code, buf);
+ this.end();
+ }
- // Remove BOM
- if (reason[0] === 0xEF && reason[1] === 0xBB && reason[2] === 0xBF) {
- reason = reason.subarray(3)
+ this._state = GET_INFO;
+ return;
}
- if (code !== undefined && !isValidStatusCode(code)) {
- return null
+ if (this._allowSynchronousEvents) {
+ this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+ this._state = GET_INFO;
+ } else {
+ this._state = DEFER_EVENT;
+ setImmediate(() => {
+ this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+ this._state = GET_INFO;
+ this.startLoop(cb);
+ });
}
+ }
- try {
- // TODO: optimize this
- reason = new TextDecoder('utf-8', { fatal: true }).decode(reason)
- } catch {
- return null
- }
+ /**
+ * 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;
- return { code, reason }
- }
+ const err = new ErrorCtor(
+ prefix ? `Invalid WebSocket frame: ${message}` : message
+ );
- get closingInfo () {
- return this.#info.closeInfo
+ Error.captureStackTrace(err, this.createError);
+ err.code = errorCode;
+ err[kStatusCode] = statusCode;
+ return err;
}
}
-module.exports = {
- ByteParser
-}
-
-
-/***/ }),
-
-/***/ 62933:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = {
- kWebSocketURL: Symbol('url'),
- kReadyState: Symbol('ready state'),
- kController: Symbol('controller'),
- kResponse: Symbol('response'),
- kBinaryType: Symbol('binary type'),
- kSentClose: Symbol('sent close'),
- kReceivedClose: Symbol('received close'),
- kByteParser: Symbol('byte parser')
-}
+module.exports = Receiver;
/***/ }),
-/***/ 3574:
+/***/ 7389:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
"use strict";
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
-const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(62933)
-const { states, opcodes } = __nccwpck_require__(45913)
-const { MessageEvent, ErrorEvent } = __nccwpck_require__(46255)
-/* globals Blob */
+const { Duplex } = __nccwpck_require__(2203);
+const { randomFillSync } = __nccwpck_require__(76982);
-/**
- * @param {import('./websocket').WebSocket} ws
- */
-function isEstablished (ws) {
- // If the server's response is validated as provided for above, it is
- // said that _The WebSocket Connection is Established_ and that the
- // WebSocket Connection is in the OPEN state.
- return ws[kReadyState] === states.OPEN
-}
+const PerMessageDeflate = __nccwpck_require__(4376);
+const { EMPTY_BUFFER, kWebSocket, NOOP } = __nccwpck_require__(71791);
+const { isBlob, isValidStatusCode } = __nccwpck_require__(26615);
+const { mask: applyMask, toBuffer } = __nccwpck_require__(95803);
-/**
- * @param {import('./websocket').WebSocket} ws
- */
-function isClosing (ws) {
- // Upon either sending or receiving a Close control frame, it is said
- // that _The WebSocket Closing Handshake is Started_ and that the
- // WebSocket connection is in the CLOSING state.
- return ws[kReadyState] === states.CLOSING
-}
+const kByteLength = Symbol('kByteLength');
+const maskBuffer = Buffer.alloc(4);
+const RANDOM_POOL_SIZE = 8 * 1024;
+let randomPool;
+let randomPoolPointer = RANDOM_POOL_SIZE;
-/**
- * @param {import('./websocket').WebSocket} ws
- */
-function isClosed (ws) {
- return ws[kReadyState] === states.CLOSED
-}
+const DEFAULT = 0;
+const DEFLATING = 1;
+const GET_BLOB_DATA = 2;
/**
- * @see https://dom.spec.whatwg.org/#concept-event-fire
- * @param {string} e
- * @param {EventTarget} target
- * @param {EventInit | undefined} eventInitDict
+ * HyBi Sender implementation.
*/
-function fireEvent (e, target, eventConstructor = Event, eventInitDict) {
- // 1. If eventConstructor is not given, then let eventConstructor be Event.
+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 || {};
- // 2. Let event be the result of creating an event given eventConstructor,
- // in the relevant realm of target.
- // 3. Initialize event’s type attribute to e.
- const event = new eventConstructor(e, eventInitDict) // eslint-disable-line new-cap
+ if (generateMask) {
+ this._generateMask = generateMask;
+ this._maskBuffer = Buffer.alloc(4);
+ }
- // 4. Initialize any other IDL attributes of event as described in the
- // invocation of this algorithm.
+ this._socket = socket;
- // 5. Return the result of dispatching event at target, with legacy target
- // override flag set if set.
- target.dispatchEvent(event)
-}
+ this._firstFragment = true;
+ this._compress = false;
-/**
- * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
- * @param {import('./websocket').WebSocket} ws
- * @param {number} type Opcode
- * @param {Buffer} data application data
- */
-function websocketMessageReceived (ws, type, data) {
- // 1. If ready state is not OPEN (1), then return.
- if (ws[kReadyState] !== states.OPEN) {
- return
+ this._bufferedBytes = 0;
+ this._queue = [];
+ this._state = DEFAULT;
+ this.onerror = NOOP;
+ this[kWebSocket] = undefined;
}
- // 2. Let dataForEvent be determined by switching on type and binary type:
- let dataForEvent
+ /**
+ * 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 merge = false;
+ let offset = 2;
+ let skipMasking = false;
- if (type === opcodes.TEXT) {
- // -> type indicates that the data is Text
- // a new DOMString containing data
- try {
- dataForEvent = new TextDecoder('utf-8', { fatal: true }).decode(data)
- } catch {
- failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
- return
- }
- } else if (type === opcodes.BINARY) {
- if (ws[kBinaryType] === 'blob') {
- // -> type indicates that the data is Binary and binary type is "blob"
- // a new Blob object, created in the relevant Realm of the WebSocket
- // object, that represents data as its raw data
- dataForEvent = new Blob([data])
- } else {
- // -> type indicates that the data is Binary and binary type is "arraybuffer"
- // a new ArrayBuffer object, created in the relevant Realm of the
- // WebSocket object, whose contents are data
- dataForEvent = new Uint8Array(data).buffer
- }
- }
+ if (options.mask) {
+ mask = options.maskBuffer || maskBuffer;
- // 3. Fire an event named message at the WebSocket object, using MessageEvent,
- // with the origin attribute initialized to the serialization of the WebSocket
- // object’s url's origin, and the data attribute initialized to dataForEvent.
- fireEvent('message', ws, MessageEvent, {
- origin: ws[kWebSocketURL].origin,
- data: dataForEvent
- })
-}
+ if (options.generateMask) {
+ options.generateMask(mask);
+ } else {
+ if (randomPoolPointer === RANDOM_POOL_SIZE) {
+ /* istanbul ignore else */
+ if (randomPool === undefined) {
+ //
+ // This is lazily initialized because server-sent frames must not
+ // be masked so it may never be used.
+ //
+ randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+ }
-/**
- * @see https://datatracker.ietf.org/doc/html/rfc6455
- * @see https://datatracker.ietf.org/doc/html/rfc2616
- * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
- * @param {string} protocol
- */
-function isValidSubprotocol (protocol) {
- // If present, this value indicates one
- // or more comma-separated subprotocol the client wishes to speak,
- // ordered by preference. The elements that comprise this value
- // MUST be non-empty strings with characters in the range U+0021 to
- // U+007E not including separator characters as defined in
- // [RFC2616] and MUST all be unique strings.
- if (protocol.length === 0) {
- return false
- }
+ randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+ randomPoolPointer = 0;
+ }
- for (const char of protocol) {
- const code = char.charCodeAt(0)
+ mask[0] = randomPool[randomPoolPointer++];
+ mask[1] = randomPool[randomPoolPointer++];
+ mask[2] = randomPool[randomPoolPointer++];
+ mask[3] = randomPool[randomPoolPointer++];
+ }
- if (
- code < 0x21 ||
- code > 0x7E ||
- char === '(' ||
- char === ')' ||
- char === '<' ||
- char === '>' ||
- char === '@' ||
- char === ',' ||
- char === ';' ||
- char === ':' ||
- char === '\\' ||
- char === '"' ||
- char === '/' ||
- char === '[' ||
- char === ']' ||
- char === '?' ||
- char === '=' ||
- char === '{' ||
- char === '}' ||
- code === 32 || // SP
- code === 9 // HT
- ) {
- return false
+ skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+ offset = 6;
}
- }
-
- return true
-}
-
-/**
- * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
- * @param {number} code
- */
-function isValidStatusCode (code) {
- if (code >= 1000 && code < 1015) {
- return (
- code !== 1004 && // reserved
- code !== 1005 && // "MUST NOT be set as a status code"
- code !== 1006 // "MUST NOT be set as a status code"
- )
- }
-
- return code >= 3000 && code <= 4999
-}
-/**
- * @param {import('./websocket').WebSocket} ws
- * @param {string|undefined} reason
- */
-function failWebsocketConnection (ws, reason) {
- const { [kController]: controller, [kResponse]: response } = ws
+ let dataLength;
- controller.abort()
+ if (typeof data === 'string') {
+ if (
+ (!options.mask || skipMasking) &&
+ options[kByteLength] !== undefined
+ ) {
+ dataLength = options[kByteLength];
+ } else {
+ data = Buffer.from(data);
+ dataLength = data.length;
+ }
+ } else {
+ dataLength = data.length;
+ merge = options.mask && options.readOnly && !skipMasking;
+ }
- if (response?.socket && !response.socket.destroyed) {
- response.socket.destroy()
- }
+ let payloadLength = dataLength;
- if (reason) {
- fireEvent('error', ws, ErrorEvent, {
- error: new Error(reason)
- })
- }
-}
+ if (dataLength >= 65536) {
+ offset += 8;
+ payloadLength = 127;
+ } else if (dataLength > 125) {
+ offset += 2;
+ payloadLength = 126;
+ }
-module.exports = {
- isEstablished,
- isClosing,
- isClosed,
- fireEvent,
- isValidSubprotocol,
- isValidStatusCode,
- failWebsocketConnection,
- websocketMessageReceived
-}
+ const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
+ target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+ if (options.rsv1) target[0] |= 0x40;
-/***/ }),
+ target[1] = payloadLength;
-/***/ 55171:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ if (payloadLength === 126) {
+ target.writeUInt16BE(dataLength, 2);
+ } else if (payloadLength === 127) {
+ target[2] = target[3] = 0;
+ target.writeUIntBE(dataLength, 4, 6);
+ }
-"use strict";
+ if (!options.mask) return [target, data];
+ target[1] |= 0x80;
+ target[offset - 4] = mask[0];
+ target[offset - 3] = mask[1];
+ target[offset - 2] = mask[2];
+ target[offset - 1] = mask[3];
-const { webidl } = __nccwpck_require__(74222)
-const { DOMException } = __nccwpck_require__(87326)
-const { URLSerializer } = __nccwpck_require__(94322)
-const { getGlobalOrigin } = __nccwpck_require__(75628)
-const { staticPropertyDescriptors, states, opcodes, emptyBuffer } = __nccwpck_require__(45913)
-const {
- kWebSocketURL,
- kReadyState,
- kController,
- kBinaryType,
- kResponse,
- kSentClose,
- kByteParser
-} = __nccwpck_require__(62933)
-const { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = __nccwpck_require__(3574)
-const { establishWebSocketConnection } = __nccwpck_require__(68550)
-const { WebsocketFrameSend } = __nccwpck_require__(31237)
-const { ByteParser } = __nccwpck_require__(43171)
-const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(3440)
-const { getGlobalDispatcher } = __nccwpck_require__(32581)
-const { types } = __nccwpck_require__(39023)
+ if (skipMasking) return [target, data];
-let experimentalWarned = false
+ if (merge) {
+ applyMask(data, mask, target, offset, dataLength);
+ return [target];
+ }
-// https://websockets.spec.whatwg.org/#interface-definition
-class WebSocket extends EventTarget {
- #events = {
- open: null,
- error: null,
- close: null,
- message: null
+ applyMask(data, mask, data, 0, dataLength);
+ return [target, data];
}
- #bufferedAmount = 0
- #protocol = ''
- #extensions = ''
-
/**
- * @param {string} url
- * @param {string|string[]} protocols
+ * 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
*/
- constructor (url, protocols = []) {
- super()
-
- webidl.argumentLengthCheck(arguments, 1, { header: 'WebSocket constructor' })
-
- if (!experimentalWarned) {
- experimentalWarned = true
- process.emitWarning('WebSockets are experimental, expect them to change at any time.', {
- code: 'UNDICI-WS'
- })
- }
-
- const options = webidl.converters['DOMString or sequence or WebSocketInit'](protocols)
-
- url = webidl.converters.USVString(url)
- protocols = options.protocols
+ close(code, data, mask, cb) {
+ let buf;
- // 1. Let baseURL be this's relevant settings object's API base URL.
- const baseURL = getGlobalOrigin()
+ if (code === undefined) {
+ buf = EMPTY_BUFFER;
+ } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+ throw new TypeError('First argument must be a valid error code number');
+ } else if (data === undefined || !data.length) {
+ buf = Buffer.allocUnsafe(2);
+ buf.writeUInt16BE(code, 0);
+ } else {
+ const length = Buffer.byteLength(data);
- // 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
- let urlRecord
+ if (length > 123) {
+ throw new RangeError('The message must not be greater than 123 bytes');
+ }
- try {
- urlRecord = new URL(url, baseURL)
- } catch (e) {
- // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
- throw new DOMException(e, 'SyntaxError')
- }
+ buf = Buffer.allocUnsafe(2 + length);
+ buf.writeUInt16BE(code, 0);
- // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
- if (urlRecord.protocol === 'http:') {
- urlRecord.protocol = 'ws:'
- } else if (urlRecord.protocol === 'https:') {
- // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
- urlRecord.protocol = 'wss:'
+ if (typeof data === 'string') {
+ buf.write(data, 2);
+ } else {
+ buf.set(data, 2);
+ }
}
- // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
- if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
- throw new DOMException(
- `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
- 'SyntaxError'
- )
- }
+ const options = {
+ [kByteLength]: buf.length,
+ fin: true,
+ generateMask: this._generateMask,
+ mask,
+ maskBuffer: this._maskBuffer,
+ opcode: 0x08,
+ readOnly: false,
+ rsv1: false
+ };
- // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
- // DOMException.
- if (urlRecord.hash || urlRecord.href.endsWith('#')) {
- throw new DOMException('Got fragment', 'SyntaxError')
+ if (this._state !== DEFAULT) {
+ this.enqueue([this.dispatch, buf, false, options, cb]);
+ } else {
+ this.sendFrame(Sender.frame(buf, options), cb);
}
+ }
- // 8. If protocols is a string, set protocols to a sequence consisting
- // of just that string.
- if (typeof protocols === 'string') {
- protocols = [protocols]
- }
+ /**
+ * 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;
- // 9. If any of the values in protocols occur more than once or otherwise
- // fail to match the requirements for elements that comprise the value
- // of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
- // protocol, then throw a "SyntaxError" DOMException.
- if (protocols.length !== new Set(protocols.map(p => p.toLowerCase())).size) {
- throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
+ 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 (protocols.length > 0 && !protocols.every(p => isValidSubprotocol(p))) {
- throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
+ if (byteLength > 125) {
+ throw new RangeError('The data size must not be greater than 125 bytes');
}
- // 10. Set this's url to urlRecord.
- this[kWebSocketURL] = new URL(urlRecord.href)
-
- // 11. Let client be this's relevant settings object.
+ const options = {
+ [kByteLength]: byteLength,
+ fin: true,
+ generateMask: this._generateMask,
+ mask,
+ maskBuffer: this._maskBuffer,
+ opcode: 0x09,
+ readOnly,
+ rsv1: false
+ };
- // 12. Run this step in parallel:
+ 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);
+ }
+ }
- // 1. Establish a WebSocket connection given urlRecord, protocols,
- // and client.
- this[kController] = establishWebSocketConnection(
- urlRecord,
- protocols,
- this,
- (response) => this.#onConnectionEstablished(response),
- options
- )
+ /**
+ * 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;
- // Each WebSocket object has an associated ready state, which is a
- // number representing the state of the connection. Initially it must
- // be CONNECTING (0).
- this[kReadyState] = WebSocket.CONNECTING
+ 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;
+ }
- // The extensions attribute must initially return the empty string.
+ if (byteLength > 125) {
+ throw new RangeError('The data size must not be greater than 125 bytes');
+ }
- // The protocol attribute must initially return the empty string.
+ const options = {
+ [kByteLength]: byteLength,
+ fin: true,
+ generateMask: this._generateMask,
+ mask,
+ maskBuffer: this._maskBuffer,
+ opcode: 0x0a,
+ readOnly,
+ rsv1: false
+ };
- // Each WebSocket object has an associated binary type, which is a
- // BinaryType. Initially it must be "blob".
- this[kBinaryType] = 'blob'
+ 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);
+ }
}
/**
- * @see https://websockets.spec.whatwg.org/#dom-websocket-close
- * @param {number|undefined} code
- * @param {string|undefined} reason
+ * 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
*/
- close (code = undefined, reason = undefined) {
- webidl.brandCheck(this, WebSocket)
+ send(data, options, cb) {
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ let opcode = options.binary ? 2 : 1;
+ let rsv1 = options.compress;
- if (code !== undefined) {
- code = webidl.converters['unsigned short'](code, { clamp: true })
- }
+ let byteLength;
+ let readOnly;
- if (reason !== undefined) {
- reason = webidl.converters.USVString(reason)
+ 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;
}
- // 1. If code is present, but is neither an integer equal to 1000 nor an
- // integer in the range 3000 to 4999, inclusive, throw an
- // "InvalidAccessError" DOMException.
- if (code !== undefined) {
- if (code !== 1000 && (code < 3000 || code > 4999)) {
- throw new DOMException('invalid code', 'InvalidAccessError')
+ 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;
}
- let reasonByteLength = 0
+ if (options.fin) this._firstFragment = true;
- // 2. If reason is present, then run these substeps:
- if (reason !== undefined) {
- // 1. Let reasonBytes be the result of encoding reason.
- // 2. If reasonBytes is longer than 123 bytes, then throw a
- // "SyntaxError" DOMException.
- reasonByteLength = Buffer.byteLength(reason)
+ const opts = {
+ [kByteLength]: byteLength,
+ fin: options.fin,
+ generateMask: this._generateMask,
+ mask: options.mask,
+ maskBuffer: this._maskBuffer,
+ opcode,
+ readOnly,
+ rsv1
+ };
- if (reasonByteLength > 123) {
- throw new DOMException(
- `Reason must be less than 123 bytes; received ${reasonByteLength}`,
- 'SyntaxError'
- )
+ 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);
}
+ }
- // 3. Run the first matching steps from the following list:
- if (this[kReadyState] === WebSocket.CLOSING || this[kReadyState] === WebSocket.CLOSED) {
- // If this's ready state is CLOSING (2) or CLOSED (3)
- // Do nothing.
- } else if (!isEstablished(this)) {
- // If the WebSocket connection is not yet established
- // Fail the WebSocket connection and set this's ready state
- // to CLOSING (2).
- failWebsocketConnection(this, 'Connection was closed before it was established.')
- this[kReadyState] = WebSocket.CLOSING
- } else if (!isClosing(this)) {
- // If the WebSocket closing handshake has not yet been started
- // Start the WebSocket closing handshake and set this's ready
- // state to CLOSING (2).
- // - If neither code nor reason is present, the WebSocket Close
- // message must not have a body.
- // - If code is present, then the status code to use in the
- // WebSocket Close message must be the integer given by code.
- // - If reason is also present, then reasonBytes must be
- // provided in the Close message after the status code.
-
- const frame = new WebsocketFrameSend()
+ /**
+ * 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;
- // If neither code nor reason is present, the WebSocket Close
- // message must not have a body.
+ blob
+ .arrayBuffer()
+ .then((arrayBuffer) => {
+ if (this._socket.destroyed) {
+ const err = new Error(
+ 'The socket was closed while the blob was being read'
+ );
- // If code is present, then the status code to use in the
- // WebSocket Close message must be the integer given by code.
- if (code !== undefined && reason === undefined) {
- frame.frameData = Buffer.allocUnsafe(2)
- frame.frameData.writeUInt16BE(code, 0)
- } else if (code !== undefined && reason !== undefined) {
- // If reason is also present, then reasonBytes must be
- // provided in the Close message after the status code.
- frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
- frame.frameData.writeUInt16BE(code, 0)
- // the body MAY contain UTF-8-encoded data with value /reason/
- frame.frameData.write(reason, 2, 'utf-8')
- } else {
- frame.frameData = emptyBuffer
- }
+ //
+ // `callCallbacks` is called in the next tick to ensure that errors
+ // that might be thrown in the callbacks behave like errors thrown
+ // outside the promise chain.
+ //
+ process.nextTick(callCallbacks, this, err, cb);
+ return;
+ }
- /** @type {import('stream').Duplex} */
- const socket = this[kResponse].socket
+ this._bufferedBytes -= options[kByteLength];
+ const data = toBuffer(arrayBuffer);
- socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
- if (!err) {
- this[kSentClose] = true
+ if (!compress) {
+ this._state = DEFAULT;
+ this.sendFrame(Sender.frame(data, options), cb);
+ this.dequeue();
+ } else {
+ this.dispatch(data, compress, options, cb);
}
})
+ .catch((err) => {
+ //
+ // `onError` is called in the next tick for the same reason that
+ // `callCallbacks` above is.
+ //
+ process.nextTick(onError, this, err, cb);
+ });
+ }
- // Upon either sending or receiving a Close control frame, it is said
- // that _The WebSocket Closing Handshake is Started_ and that the
- // WebSocket connection is in the CLOSING state.
- this[kReadyState] = states.CLOSING
- } else {
- // Otherwise
- // Set this's ready state to CLOSING (2).
- this[kReadyState] = WebSocket.CLOSING
+ /**
+ * 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, (_, buf) => {
+ 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(buf, 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));
}
}
/**
- * @see https://websockets.spec.whatwg.org/#dom-websocket-send
- * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
+ * 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[]} list The frame to send
+ * @param {Function} [cb] Callback
+ * @private
*/
- send (data) {
- webidl.brandCheck(this, WebSocket)
-
- webidl.argumentLengthCheck(arguments, 1, { header: 'WebSocket.send' })
-
- data = webidl.converters.WebSocketSendData(data)
-
- // 1. If this's ready state is CONNECTING, then throw an
- // "InvalidStateError" DOMException.
- if (this[kReadyState] === WebSocket.CONNECTING) {
- throw new DOMException('Sent before connected.', 'InvalidStateError')
+ 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);
}
+ }
+}
- // 2. Run the appropriate set of steps from the following list:
- // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
- // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
+module.exports = Sender;
- if (!isEstablished(this) || isClosing(this)) {
- return
- }
+/**
+ * Calls queued callbacks with an error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error to call the callbacks with
+ * @param {Function} [cb] The first callback
+ * @private
+ */
+function callCallbacks(sender, err, cb) {
+ if (typeof cb === 'function') cb(err);
- /** @type {import('stream').Duplex} */
- const socket = this[kResponse].socket
+ for (let i = 0; i < sender._queue.length; i++) {
+ const params = sender._queue[i];
+ const callback = params[params.length - 1];
- // If data is a string
- if (typeof data === 'string') {
- // If the WebSocket connection is established and the WebSocket
- // closing handshake has not yet started, then the user agent
- // must send a WebSocket Message comprised of the data argument
- // using a text frame opcode; if the data cannot be sent, e.g.
- // because it would need to be buffered but the buffer is full,
- // the user agent must flag the WebSocket as full and then close
- // the WebSocket connection. Any invocation of this method with a
- // string argument that does not throw an exception must increase
- // the bufferedAmount attribute by the number of bytes needed to
- // express the argument as UTF-8.
+ if (typeof callback === 'function') callback(err);
+ }
+}
- const value = Buffer.from(data)
- const frame = new WebsocketFrameSend(value)
- const buffer = frame.createFrame(opcodes.TEXT)
+/**
+ * Handles a `Sender` error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error
+ * @param {Function} [cb] The first pending callback
+ * @private
+ */
+function onError(sender, err, cb) {
+ callCallbacks(sender, err, cb);
+ sender.onerror(err);
+}
- this.#bufferedAmount += value.byteLength
- socket.write(buffer, () => {
- this.#bufferedAmount -= value.byteLength
- })
- } else if (types.isArrayBuffer(data)) {
- // If the WebSocket connection is established, and the WebSocket
- // closing handshake has not yet started, then the user agent must
- // send a WebSocket Message comprised of data using a binary frame
- // opcode; if the data cannot be sent, e.g. because it would need
- // to be buffered but the buffer is full, the user agent must flag
- // the WebSocket as full and then close the WebSocket connection.
- // The data to be sent is the data stored in the buffer described
- // by the ArrayBuffer object. Any invocation of this method with an
- // ArrayBuffer argument that does not throw an exception must
- // increase the bufferedAmount attribute by the length of the
- // ArrayBuffer in bytes.
- const value = Buffer.from(data)
- const frame = new WebsocketFrameSend(value)
- const buffer = frame.createFrame(opcodes.BINARY)
+/***/ }),
- this.#bufferedAmount += value.byteLength
- socket.write(buffer, () => {
- this.#bufferedAmount -= value.byteLength
- })
- } else if (ArrayBuffer.isView(data)) {
- // If the WebSocket connection is established, and the WebSocket
- // closing handshake has not yet started, then the user agent must
- // send a WebSocket Message comprised of data using a binary frame
- // opcode; if the data cannot be sent, e.g. because it would need to
- // be buffered but the buffer is full, the user agent must flag the
- // WebSocket as full and then close the WebSocket connection. The
- // data to be sent is the data stored in the section of the buffer
- // described by the ArrayBuffer object that data references. Any
- // invocation of this method with this kind of argument that does
- // not throw an exception must increase the bufferedAmount attribute
- // by the length of data’s buffer in bytes.
+/***/ 86412:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- const ab = Buffer.from(data, data.byteOffset, data.byteLength)
+"use strict";
- const frame = new WebsocketFrameSend(ab)
- const buffer = frame.createFrame(opcodes.BINARY)
- this.#bufferedAmount += ab.byteLength
- socket.write(buffer, () => {
- this.#bufferedAmount -= ab.byteLength
- })
- } else if (isBlobLike(data)) {
- // If the WebSocket connection is established, and the WebSocket
- // closing handshake has not yet started, then the user agent must
- // send a WebSocket Message comprised of data using a binary frame
- // opcode; if the data cannot be sent, e.g. because it would need to
- // be buffered but the buffer is full, the user agent must flag the
- // WebSocket as full and then close the WebSocket connection. The data
- // to be sent is the raw data represented by the Blob object. Any
- // invocation of this method with a Blob argument that does not throw
- // an exception must increase the bufferedAmount attribute by the size
- // of the Blob object’s raw data, in bytes.
+const { Duplex } = __nccwpck_require__(2203);
- const frame = new WebsocketFrameSend()
+/**
+ * Emits the `'close'` event on a stream.
+ *
+ * @param {Duplex} stream The stream.
+ * @private
+ */
+function emitClose(stream) {
+ stream.emit('close');
+}
- data.arrayBuffer().then((ab) => {
- const value = Buffer.from(ab)
- frame.frameData = value
- const buffer = frame.createFrame(opcodes.BINARY)
+/**
+ * The listener of the `'end'` event.
+ *
+ * @private
+ */
+function duplexOnEnd() {
+ if (!this.destroyed && this._writableState.finished) {
+ this.destroy();
+ }
+}
- this.#bufferedAmount += value.byteLength
- socket.write(buffer, () => {
- this.#bufferedAmount -= value.byteLength
- })
- })
- }
+/**
+ * The listener of the `'error'` event.
+ *
+ * @param {Error} err The error
+ * @private
+ */
+function duplexOnError(err) {
+ this.removeListener('error', duplexOnError);
+ this.destroy();
+ if (this.listenerCount('error') === 0) {
+ // Do not suppress the throwing behavior.
+ this.emit('error', err);
}
+}
- get readyState () {
- webidl.brandCheck(this, WebSocket)
+/**
+ * Wraps a `WebSocket` in a duplex stream.
+ *
+ * @param {WebSocket} ws The `WebSocket` to wrap
+ * @param {Object} [options] The options for the `Duplex` constructor
+ * @return {Duplex} The duplex stream
+ * @public
+ */
+function createWebSocketStream(ws, options) {
+ let terminateOnDestroy = true;
- // The readyState getter steps are to return this's ready state.
- return this[kReadyState]
- }
+ const duplex = new Duplex({
+ ...options,
+ autoDestroy: false,
+ emitClose: false,
+ objectMode: false,
+ writableObjectMode: false
+ });
- get bufferedAmount () {
- webidl.brandCheck(this, WebSocket)
+ ws.on('message', function message(msg, isBinary) {
+ const data =
+ !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
- return this.#bufferedAmount
- }
+ if (!duplex.push(data)) ws.pause();
+ });
- get url () {
- webidl.brandCheck(this, WebSocket)
+ ws.once('error', function error(err) {
+ if (duplex.destroyed) return;
- // The url getter steps are to return this's url, serialized.
- return URLSerializer(this[kWebSocketURL])
- }
+ // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+ //
+ // - If the `'error'` event is emitted before the `'open'` event, then
+ // `ws.terminate()` is a noop as no socket is assigned.
+ // - Otherwise, the error is re-emitted by the listener of the `'error'`
+ // event of the `Receiver` object. The listener already closes the
+ // connection by calling `ws.close()`. This allows a close frame to be
+ // sent to the other peer. If `ws.terminate()` is called right after this,
+ // then the close frame might not be sent.
+ terminateOnDestroy = false;
+ duplex.destroy(err);
+ });
- get extensions () {
- webidl.brandCheck(this, WebSocket)
+ ws.once('close', function close() {
+ if (duplex.destroyed) return;
- return this.#extensions
- }
+ duplex.push(null);
+ });
- get protocol () {
- webidl.brandCheck(this, WebSocket)
+ duplex._destroy = function (err, callback) {
+ if (ws.readyState === ws.CLOSED) {
+ callback(err);
+ process.nextTick(emitClose, duplex);
+ return;
+ }
- return this.#protocol
- }
+ let called = false;
- get onopen () {
- webidl.brandCheck(this, WebSocket)
+ ws.once('error', function error(err) {
+ called = true;
+ callback(err);
+ });
- return this.#events.open
- }
+ ws.once('close', function close() {
+ if (!called) callback(err);
+ process.nextTick(emitClose, duplex);
+ });
- set onopen (fn) {
- webidl.brandCheck(this, WebSocket)
+ if (terminateOnDestroy) ws.terminate();
+ };
- if (this.#events.open) {
- this.removeEventListener('open', this.#events.open)
+ duplex._final = function (callback) {
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once('open', function open() {
+ duplex._final(callback);
+ });
+ return;
}
- if (typeof fn === 'function') {
- this.#events.open = fn
- this.addEventListener('open', fn)
+ // If the value of the `_socket` property is `null` it means that `ws` is a
+ // client websocket and the handshake failed. In fact, when this happens, a
+ // socket is never assigned to the websocket. Wait for the `'error'` event
+ // that will be emitted by the websocket.
+ if (ws._socket === null) return;
+
+ if (ws._socket._writableState.finished) {
+ callback();
+ if (duplex._readableState.endEmitted) duplex.destroy();
} else {
- this.#events.open = null
+ ws._socket.once('finish', function finish() {
+ // `duplex` is not destroyed here because the `'end'` event will be
+ // emitted on `duplex` after this `'finish'` event. The EOF signaling
+ // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+ callback();
+ });
+ ws.close();
}
- }
-
- get onerror () {
- webidl.brandCheck(this, WebSocket)
-
- return this.#events.error
- }
+ };
- set onerror (fn) {
- webidl.brandCheck(this, WebSocket)
+ duplex._read = function () {
+ if (ws.isPaused) ws.resume();
+ };
- if (this.#events.error) {
- this.removeEventListener('error', this.#events.error)
+ duplex._write = function (chunk, encoding, callback) {
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once('open', function open() {
+ duplex._write(chunk, encoding, callback);
+ });
+ return;
}
- if (typeof fn === 'function') {
- this.#events.error = fn
- this.addEventListener('error', fn)
- } else {
- this.#events.error = null
- }
- }
+ ws.send(chunk, callback);
+ };
- get onclose () {
- webidl.brandCheck(this, WebSocket)
+ duplex.on('end', duplexOnEnd);
+ duplex.on('error', duplexOnError);
+ return duplex;
+}
- return this.#events.close
- }
+module.exports = createWebSocketStream;
- 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
- }
- }
+/***/ 43332:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- get onmessage () {
- webidl.brandCheck(this, WebSocket)
+"use strict";
- return this.#events.message
- }
- set onmessage (fn) {
- webidl.brandCheck(this, WebSocket)
+const { tokenChars } = __nccwpck_require__(26615);
- if (this.#events.message) {
- this.removeEventListener('message', this.#events.message)
- }
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+ *
+ * @param {String} header The field value of the header
+ * @return {Set} The subprotocol names
+ * @public
+ */
+function parse(header) {
+ const protocols = new Set();
+ let start = -1;
+ let end = -1;
+ let i = 0;
- if (typeof fn === 'function') {
- this.#events.message = fn
- this.addEventListener('message', fn)
- } else {
- this.#events.message = null
- }
- }
+ for (i; i < header.length; i++) {
+ const code = header.charCodeAt(i);
- get binaryType () {
- webidl.brandCheck(this, WebSocket)
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1) start = i;
+ } else if (
+ i !== 0 &&
+ (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+ ) {
+ if (end === -1 && start !== -1) end = i;
+ } else if (code === 0x2c /* ',' */) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
- return this[kBinaryType]
- }
+ if (end === -1) end = i;
- set binaryType (type) {
- webidl.brandCheck(this, WebSocket)
+ const protocol = header.slice(start, end);
- if (type !== 'blob' && type !== 'arraybuffer') {
- this[kBinaryType] = 'blob'
+ if (protocols.has(protocol)) {
+ throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+ }
+
+ protocols.add(protocol);
+ start = end = -1;
} else {
- this[kBinaryType] = type
+ throw new SyntaxError(`Unexpected character at index ${i}`);
}
}
- /**
- * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
- */
- #onConnectionEstablished (response) {
- // processResponse is called when the "response’s header list has been received and initialized."
- // once this happens, the connection is open
- this[kResponse] = response
-
- const parser = new ByteParser(this)
- parser.on('drain', function onParserDrain () {
- this.ws[kResponse].socket.resume()
- })
+ if (start === -1 || end !== -1) {
+ throw new SyntaxError('Unexpected end of input');
+ }
- response.socket.ws = this
- this[kByteParser] = parser
+ const protocol = header.slice(start, i);
- // 1. Change the ready state to OPEN (1).
- this[kReadyState] = states.OPEN
+ if (protocols.has(protocol)) {
+ throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+ }
- // 2. Change the extensions attribute’s value to the extensions in use, if
- // it is not the null value.
- // https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
- const extensions = response.headersList.get('sec-websocket-extensions')
+ protocols.add(protocol);
+ return protocols;
+}
- if (extensions !== null) {
- this.#extensions = extensions
- }
+module.exports = { parse };
- // 3. Change the protocol attribute’s value to the subprotocol in use, if
- // it is not the null value.
- // https://datatracker.ietf.org/doc/html/rfc6455#section-1.9
- const protocol = response.headersList.get('sec-websocket-protocol')
- if (protocol !== null) {
- this.#protocol = protocol
- }
+/***/ }),
- // 4. Fire an event named open at the WebSocket object.
- fireEvent('open', this)
- }
-}
+/***/ 26615:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-// https://websockets.spec.whatwg.org/#dom-websocket-connecting
-WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING
-// https://websockets.spec.whatwg.org/#dom-websocket-open
-WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN
-// https://websockets.spec.whatwg.org/#dom-websocket-closing
-WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING
-// https://websockets.spec.whatwg.org/#dom-websocket-closed
-WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED
+"use strict";
-Object.defineProperties(WebSocket.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(WebSocket, {
- CONNECTING: staticPropertyDescriptors,
- OPEN: staticPropertyDescriptors,
- CLOSING: staticPropertyDescriptors,
- CLOSED: staticPropertyDescriptors
-})
+const { isUtf8 } = __nccwpck_require__(20181);
-webidl.converters['sequence'] = webidl.sequenceConverter(
- webidl.converters.DOMString
-)
+const { hasBlob } = __nccwpck_require__(71791);
-webidl.converters['DOMString or sequence'] = function (V) {
- if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) {
- return webidl.converters['sequence'](V)
- }
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const 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
+];
- return webidl.converters.DOMString(V)
+/**
+ * Checks if a status code is allowed in a close frame.
+ *
+ * @param {Number} code The status code
+ * @return {Boolean} `true` if the status code is valid, else `false`
+ * @public
+ */
+function isValidStatusCode(code) {
+ return (
+ (code >= 1000 &&
+ code <= 1014 &&
+ code !== 1004 &&
+ code !== 1005 &&
+ code !== 1006) ||
+ (code >= 3000 && code <= 4999)
+ );
}
-// This implements the propsal made in https://github.com/whatwg/websockets/issues/42
-webidl.converters.WebSocketInit = webidl.dictionaryConverter([
- {
- key: 'protocols',
- converter: webidl.converters['DOMString or sequence'],
- get defaultValue () {
- return []
- }
- },
- {
- key: 'dispatcher',
- converter: (V) => V,
- get defaultValue () {
- return getGlobalDispatcher()
- }
- },
- {
- key: 'headers',
- converter: webidl.nullableConverter(webidl.converters.HeadersInit)
- }
-])
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function _isValidUTF8(buf) {
+ const len = buf.length;
+ let i = 0;
-webidl.converters['DOMString or sequence or WebSocketInit'] = function (V) {
- if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) {
- return webidl.converters.WebSocketInit(V)
- }
+ while (i < len) {
+ if ((buf[i] & 0x80) === 0) {
+ // 0xxxxxxx
+ i++;
+ } else if ((buf[i] & 0xe0) === 0xc0) {
+ // 110xxxxx 10xxxxxx
+ if (
+ i + 1 === len ||
+ (buf[i + 1] & 0xc0) !== 0x80 ||
+ (buf[i] & 0xfe) === 0xc0 // Overlong
+ ) {
+ return false;
+ }
- return { protocols: webidl.converters['DOMString or sequence'](V) }
-}
+ i += 2;
+ } else if ((buf[i] & 0xf0) === 0xe0) {
+ // 1110xxxx 10xxxxxx 10xxxxxx
+ if (
+ i + 2 >= len ||
+ (buf[i + 1] & 0xc0) !== 0x80 ||
+ (buf[i + 2] & 0xc0) !== 0x80 ||
+ (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
+ (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
+ ) {
+ return false;
+ }
-webidl.converters.WebSocketSendData = function (V) {
- if (webidl.util.Type(V) === 'Object') {
- if (isBlobLike(V)) {
- return webidl.converters.Blob(V, { strict: false })
- }
+ i += 3;
+ } else if ((buf[i] & 0xf8) === 0xf0) {
+ // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ if (
+ i + 3 >= len ||
+ (buf[i + 1] & 0xc0) !== 0x80 ||
+ (buf[i + 2] & 0xc0) !== 0x80 ||
+ (buf[i + 3] & 0xc0) !== 0x80 ||
+ (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
+ (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
+ buf[i] > 0xf4 // > U+10FFFF
+ ) {
+ return false;
+ }
- if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
- return webidl.converters.BufferSource(V)
+ i += 4;
+ } else {
+ return false;
}
}
- return webidl.converters.USVString(V)
+ return true;
+}
+
+/**
+ * Determines whether a value is a `Blob`.
+ *
+ * @param {*} value The value to be tested
+ * @return {Boolean} `true` if `value` is a `Blob`, else `false`
+ * @private
+ */
+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 = {
- WebSocket
+ isBlob,
+ isValidStatusCode,
+ isValidUTF8: _isValidUTF8,
+ tokenChars
+};
+
+if (isUtf8) {
+ module.exports.isValidUTF8 = function (buf) {
+ return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+ };
+} /* istanbul ignore else */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+ try {
+ const isValidUTF8 = __nccwpck_require__(62414);
+
+ module.exports.isValidUTF8 = function (buf) {
+ return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+ };
+ } catch (e) {
+ // Continue regardless of the error.
+ }
}
/***/ }),
-/***/ 43236:
+/***/ 70129:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
"use strict";
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
-const stringWidth = __nccwpck_require__(60060);
-const stripAnsi = __nccwpck_require__(13958);
-const ansiStyles = __nccwpck_require__(54412);
-
-const ESCAPES = new Set([
- '\u001B',
- '\u009B'
-]);
-
-const END_CODE = 39;
-
-const ANSI_ESCAPE_BELL = '\u0007';
-const ANSI_CSI = '[';
-const ANSI_OSC = ']';
-const ANSI_SGR_TERMINATOR = 'm';
-const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
-
-const wrapAnsi = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
-
-// Calculate the length of words split on ' ', ignoring
-// the extra characters added by ansi escape codes
-const wordLengths = string => string.split(' ').map(character => stringWidth(character));
-
-// Wrap a long word across multiple rows
-// Ansi escape codes do not count towards length
-const wrapWord = (rows, word, columns) => {
- const characters = [...word];
-
- let isInsideEscape = false;
- let isInsideLinkEscape = false;
- let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
- for (const [index, character] of characters.entries()) {
- const characterLength = stringWidth(character);
- if (visible + characterLength <= columns) {
- rows[rows.length - 1] += character;
- } else {
- rows.push(character);
- visible = 0;
- }
+const EventEmitter = __nccwpck_require__(24434);
+const http = __nccwpck_require__(58611);
+const { Duplex } = __nccwpck_require__(2203);
+const { createHash } = __nccwpck_require__(76982);
- if (ESCAPES.has(character)) {
- isInsideEscape = true;
- isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
- }
+const extension = __nccwpck_require__(61335);
+const PerMessageDeflate = __nccwpck_require__(4376);
+const subprotocol = __nccwpck_require__(43332);
+const WebSocket = __nccwpck_require__(56681);
+const { GUID, kWebSocket } = __nccwpck_require__(71791);
- if (isInsideEscape) {
- if (isInsideLinkEscape) {
- if (character === ANSI_ESCAPE_BELL) {
- isInsideEscape = false;
- isInsideLinkEscape = false;
- }
- } else if (character === ANSI_SGR_TERMINATOR) {
- isInsideEscape = false;
- }
+const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
- continue;
- }
+const RUNNING = 0;
+const CLOSING = 1;
+const CLOSED = 2;
- visible += characterLength;
+/**
+ * Class representing a WebSocket server.
+ *
+ * @extends EventEmitter
+ */
+class WebSocketServer extends EventEmitter {
+ /**
+ * 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 {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();
- if (visible === columns && index < characters.length - 1) {
- rows.push('');
- visible = 0;
- }
- }
+ options = {
+ allowSynchronousEvents: true,
+ autoPong: true,
+ maxPayload: 100 * 1024 * 1024,
+ skipUTF8Validation: false,
+ perMessageDeflate: false,
+ handleProtocols: null,
+ clientTracking: true,
+ verifyClient: null,
+ noServer: false,
+ backlog: null, // use default (511 as implemented in net.js)
+ server: null,
+ host: null,
+ path: null,
+ port: null,
+ WebSocket,
+ ...options
+ };
- // It's possible that the last row we copy over is only
- // ansi escape characters, handle this edge-case
- if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
- rows[rows.length - 2] += rows.pop();
- }
-};
+ 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'
+ );
+ }
-// Trims spaces from a string ignoring invisible sequences
-const stringVisibleTrimSpacesRight = string => {
- const words = string.split(' ');
- let last = words.length;
+ if (options.port != null) {
+ this._server = http.createServer((req, res) => {
+ const body = http.STATUS_CODES[426];
- while (last > 0) {
- if (stringWidth(words[last - 1]) > 0) {
- break;
- }
+ 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;
+ }
- last--;
- }
+ if (this._server) {
+ const emitConnection = this.emit.bind(this, 'connection');
- if (last === words.length) {
- return string;
- }
+ 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);
+ }
+ });
+ }
- return words.slice(0, last).join(' ') + words.slice(last).join('');
-};
+ if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+ if (options.clientTracking) {
+ this.clients = new Set();
+ this._shouldEmitClose = false;
+ }
-// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
-//
-// 'hard' will never allow a string to take up more than columns characters
-//
-// 'soft' allows long words to expand past the column length
-const exec = (string, columns, options = {}) => {
- if (options.trim !== false && string.trim() === '') {
- return '';
- }
+ this.options = options;
+ this._state = RUNNING;
+ }
- let returnValue = '';
- let escapeCode;
- let escapeUrl;
+ /**
+ * 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');
+ }
- const lengths = wordLengths(string);
- let rows = [''];
+ if (!this._server) return null;
+ return this._server.address();
+ }
- for (const [index, word] of string.split(' ').entries()) {
- if (options.trim !== false) {
- rows[rows.length - 1] = rows[rows.length - 1].trimStart();
- }
+ /**
+ * 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'));
+ });
+ }
- let rowLength = stringWidth(rows[rows.length - 1]);
+ process.nextTick(emitClose, this);
+ return;
+ }
- if (index !== 0) {
- if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
- // If we start with a new word but the current row length equals the length of the columns, add a new row
- rows.push('');
- rowLength = 0;
- }
+ if (cb) this.once('close', cb);
- if (rowLength > 0 || options.trim === false) {
- rows[rows.length - 1] += ' ';
- rowLength++;
- }
- }
+ if (this._state === CLOSING) return;
+ this._state = CLOSING;
- // In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
- if (options.hard && lengths[index] > columns) {
- const remainingColumns = (columns - rowLength);
- const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
- const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
- if (breaksStartingNextLine < breaksStartingThisLine) {
- rows.push('');
- }
+ if (this.options.noServer || this.options.server) {
+ if (this._server) {
+ this._removeListeners();
+ this._removeListeners = this._server = null;
+ }
- wrapWord(rows, word, columns);
- continue;
- }
+ 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;
- if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
- if (options.wordWrap === false && rowLength < columns) {
- wrapWord(rows, word, columns);
- continue;
- }
+ this._removeListeners();
+ this._removeListeners = this._server = null;
- rows.push('');
- }
+ //
+ // The HTTP/S server was created internally. Close it, and rely on its
+ // `'close'` event.
+ //
+ server.close(() => {
+ emitClose(this);
+ });
+ }
+ }
- if (rowLength + lengths[index] > columns && options.wordWrap === false) {
- wrapWord(rows, word, columns);
- continue;
- }
+ /**
+ * 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 index = req.url.indexOf('?');
+ const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
- rows[rows.length - 1] += word;
- }
+ if (pathname !== this.options.path) return false;
+ }
- if (options.trim !== false) {
- rows = rows.map(stringVisibleTrimSpacesRight);
- }
+ return true;
+ }
- const pre = [...rows.join('\n')];
+ /**
+ * 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);
- for (const [index, character] of pre.entries()) {
- returnValue += character;
+ const key = req.headers['sec-websocket-key'];
+ const upgrade = req.headers.upgrade;
+ const version = +req.headers['sec-websocket-version'];
- if (ESCAPES.has(character)) {
- const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?\\d+)m|\\${ANSI_ESCAPE_LINK}(?.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
- if (groups.code !== undefined) {
- const code = Number.parseFloat(groups.code);
- escapeCode = code === END_CODE ? undefined : code;
- } else if (groups.uri !== undefined) {
- escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
- }
- }
+ if (req.method !== 'GET') {
+ const message = 'Invalid HTTP method';
+ abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+ return;
+ }
- const code = ansiStyles.codes.get(Number(escapeCode));
+ if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+ const message = 'Invalid Upgrade header';
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
- if (pre[index + 1] === '\n') {
- if (escapeUrl) {
- returnValue += wrapAnsiHyperlink('');
- }
+ if (key === undefined || !keyRegex.test(key)) {
+ const message = 'Missing or invalid Sec-WebSocket-Key header';
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
- if (escapeCode && code) {
- returnValue += wrapAnsi(code);
- }
- } else if (character === '\n') {
- if (escapeCode && code) {
- returnValue += wrapAnsi(escapeCode);
- }
+ if (version !== 8 && version !== 13) {
+ const message = 'Missing or invalid Sec-WebSocket-Version header';
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
- if (escapeUrl) {
- returnValue += wrapAnsiHyperlink(escapeUrl);
- }
- }
- }
+ if (!this.shouldHandle(req)) {
+ abortHandshake(socket, 400);
+ return;
+ }
- return returnValue;
-};
+ const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
+ let protocols = new Set();
-// For each newline, invoke the method separately
-module.exports = (string, columns, options) => {
- return String(string)
- .normalize()
- .replace(/\r\n/g, '\n')
- .split('\n')
- .map(line => exec(line, columns, options))
- .join('\n');
-};
+ if (secWebSocketProtocol !== undefined) {
+ try {
+ protocols = 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 !== undefined
+ ) {
+ const perMessageDeflate = new PerMessageDeflate(
+ this.options.perMessageDeflate,
+ true,
+ this.options.maxPayload
+ );
-/***/ 58264:
-/***/ ((module) => {
+ try {
+ const offers = extension.parse(secWebSocketExtensions);
-// Returns a wrapper function that returns a wrapped callback
-// The wrapper function should do some stuff, and return a
-// presumably different callback function.
-// This makes sure that own properties are retained, so that
-// decorations and such are not lost along the way.
-module.exports = wrappy
-function wrappy (fn, cb) {
- if (fn && cb) return wrappy(fn)(cb)
+ 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 (typeof fn !== 'function')
- throw new TypeError('need wrapper function')
+ //
+ // Optionally call external client verification handler.
+ //
+ if (this.options.verifyClient) {
+ const info = {
+ origin:
+ req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+ secure: !!(req.socket.authorized || req.socket.encrypted),
+ req
+ };
- Object.keys(fn).forEach(function (k) {
- wrapper[k] = fn[k]
- })
+ if (this.options.verifyClient.length === 2) {
+ this.options.verifyClient(info, (verified, code, message, headers) => {
+ if (!verified) {
+ return abortHandshake(socket, code || 401, message, headers);
+ }
- return wrapper
+ this.completeUpgrade(
+ extensions,
+ key,
+ protocols,
+ req,
+ socket,
+ head,
+ cb
+ );
+ });
+ return;
+ }
- 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 cb = args[args.length-1]
- if (typeof ret === 'function' && ret !== cb) {
- Object.keys(cb).forEach(function (k) {
- ret[k] = cb[k]
- })
+ if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
}
- return ret
+
+ this.completeUpgrade(extensions, key, protocols, 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, protocols, req, socket, head, cb) {
+ //
+ // Destroy the socket if the client has already sent a FIN packet.
+ //
+ 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'
+ );
+ }
-/***/ 11354:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ if (this._state > RUNNING) return abortHandshake(socket, 503);
-"use strict";
+ const digest = createHash('sha1')
+ .update(key + GUID)
+ .digest('base64');
+ const headers = [
+ 'HTTP/1.1 101 Switching Protocols',
+ 'Upgrade: websocket',
+ 'Connection: Upgrade',
+ `Sec-WebSocket-Accept: ${digest}`
+ ];
-const WebSocket = __nccwpck_require__(56681);
+ const ws = new this.options.WebSocket(null, undefined, this.options);
-WebSocket.createWebSocketStream = __nccwpck_require__(86412);
-WebSocket.Server = __nccwpck_require__(70129);
-WebSocket.Receiver = __nccwpck_require__(20893);
-WebSocket.Sender = __nccwpck_require__(7389);
+ if (protocols.size) {
+ //
+ // Optionally call external protocol selection handler.
+ //
+ const protocol = this.options.handleProtocols
+ ? this.options.handleProtocols(protocols, req)
+ : protocols.values().next().value;
-WebSocket.WebSocket = WebSocket;
-WebSocket.WebSocketServer = WebSocket.Server;
+ if (protocol) {
+ headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+ ws._protocol = protocol;
+ }
+ }
-module.exports = WebSocket;
+ if (extensions[PerMessageDeflate.extensionName]) {
+ const params = extensions[PerMessageDeflate.extensionName].params;
+ const value = extension.format({
+ [PerMessageDeflate.extensionName]: [params]
+ });
+ headers.push(`Sec-WebSocket-Extensions: ${value}`);
+ ws._extensions = extensions;
+ }
+ //
+ // Allow external modification/inspection of handshake headers.
+ //
+ this.emit('headers', headers, req);
-/***/ }),
+ socket.write(headers.concat('\r\n').join('\r\n'));
+ socket.removeListener('error', socketOnError);
-/***/ 95803:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ ws.setSocket(socket, head, {
+ allowSynchronousEvents: this.options.allowSynchronousEvents,
+ maxPayload: this.options.maxPayload,
+ skipUTF8Validation: this.options.skipUTF8Validation
+ });
-"use strict";
+ if (this.clients) {
+ this.clients.add(ws);
+ ws.on('close', () => {
+ this.clients.delete(ws);
+ if (this._shouldEmitClose && !this.clients.size) {
+ process.nextTick(emitClose, this);
+ }
+ });
+ }
-const { EMPTY_BUFFER } = __nccwpck_require__(71791);
+ cb(ws, req);
+ }
+}
-const FastBuffer = Buffer[Symbol.species];
+module.exports = WebSocketServer;
/**
- * Merges an array of buffers into a new buffer.
+ * Add event listeners on an `EventEmitter` using a map of
+ * pairs.
*
- * @param {Buffer[]} list The array of buffers to concat
- * @param {Number} totalLength The total length of buffers in the list
- * @return {Buffer} The resulting buffer
- * @public
+ * @param {EventEmitter} server The event emitter
+ * @param {Object.} map The listeners to add
+ * @return {Function} A function that will remove the added listeners when
+ * called
+ * @private
*/
-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 buf = list[i];
- target.set(buf, offset);
- offset += buf.length;
- }
-
- if (offset < totalLength) {
- return new FastBuffer(target.buffer, target.byteOffset, offset);
- }
+function addListeners(server, map) {
+ for (const event of Object.keys(map)) server.on(event, map[event]);
- return target;
+ return function removeListeners() {
+ for (const event of Object.keys(map)) {
+ server.removeListener(event, map[event]);
+ }
+ };
}
/**
- * Masks a buffer using the given mask.
+ * Emit a `'close'` event on an `EventEmitter`.
*
- * @param {Buffer} source The buffer to mask
- * @param {Buffer} mask The mask to use
- * @param {Buffer} output The buffer where to store the result
- * @param {Number} offset The offset at which to start writing
- * @param {Number} length The number of bytes to mask.
- * @public
+ * @param {EventEmitter} server The event emitter
+ * @private
*/
-function _mask(source, mask, output, offset, length) {
- for (let i = 0; i < length; i++) {
- output[offset + i] = source[i] ^ mask[i & 3];
- }
+function emitClose(server) {
+ server._state = CLOSED;
+ server.emit('close');
}
/**
- * Unmasks a buffer using the given mask.
+ * Handle socket errors.
*
- * @param {Buffer} buffer The buffer to unmask
- * @param {Buffer} mask The mask to use
- * @public
+ * @private
*/
-function _unmask(buffer, mask) {
- for (let i = 0; i < buffer.length; i++) {
- buffer[i] ^= mask[i & 3];
- }
+function socketOnError() {
+ this.destroy();
}
/**
- * Converts a buffer to an `ArrayBuffer`.
+ * Close the connection when preconditions are not fulfilled.
*
- * @param {Buffer} buf The buffer to convert
- * @return {ArrayBuffer} Converted buffer
- * @public
+ * @param {Duplex} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} [message] The HTTP response body
+ * @param {Object} [headers] Additional HTTP response headers
+ * @private
*/
-function toArrayBuffer(buf) {
- if (buf.length === buf.buffer.byteLength) {
- return buf.buffer;
- }
+function abortHandshake(socket, code, message, headers) {
+ //
+ // The socket is writable unless the user destroyed or ended it before calling
+ // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+ // error. Handling this does not make much sense as the worst that can happen
+ // is that some of the data written by the user might be discarded due to the
+ // call to `socket.end()` below, which triggers an `'error'` event that in
+ // turn causes the socket to be destroyed.
+ //
+ message = message || http.STATUS_CODES[code];
+ headers = {
+ Connection: 'close',
+ 'Content-Type': 'text/html',
+ 'Content-Length': Buffer.byteLength(message),
+ ...headers
+ };
- return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+ socket.once('finish', socket.destroy);
+
+ socket.end(
+ `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+ Object.keys(headers)
+ .map((h) => `${h}: ${headers[h]}`)
+ .join('\r\n') +
+ '\r\n\r\n' +
+ message
+ );
}
/**
- * Converts `data` to a `Buffer`.
+ * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+ * one listener for it, otherwise call `abortHandshake()`.
*
- * @param {*} data The data to convert
- * @return {Buffer} The buffer
- * @throws {TypeError}
- * @public
+ * @param {WebSocketServer} server The WebSocket server
+ * @param {http.IncomingMessage} req The request object
+ * @param {Duplex} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} message The HTTP response body
+ * @private
*/
-function toBuffer(data) {
- toBuffer.readOnly = true;
-
- if (Buffer.isBuffer(data)) return data;
-
- let buf;
+function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+ if (server.listenerCount('wsClientError')) {
+ const err = new Error(message);
+ Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
- if (data instanceof ArrayBuffer) {
- buf = new FastBuffer(data);
- } else if (ArrayBuffer.isView(data)) {
- buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+ server.emit('wsClientError', err, socket, req);
} else {
- buf = Buffer.from(data);
- toBuffer.readOnly = false;
- }
-
- return buf;
-}
-
-module.exports = {
- concat,
- mask: _mask,
- toArrayBuffer,
- toBuffer,
- unmask: _unmask
-};
-
-/* istanbul ignore else */
-if (!process.env.WS_NO_BUFFER_UTIL) {
- try {
- const bufferUtil = __nccwpck_require__(18327);
-
- 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 (e) {
- // Continue regardless of the error.
+ abortHandshake(socket, code, message);
}
}
/***/ }),
-/***/ 71791:
-/***/ ((module) => {
+/***/ 56681:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
"use strict";
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$", "caughtErrors": "none" }] */
-const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
-const hasBlob = typeof Blob !== 'undefined';
-if (hasBlob) BINARY_TYPES.push('blob');
+const EventEmitter = __nccwpck_require__(24434);
+const https = __nccwpck_require__(65692);
+const http = __nccwpck_require__(58611);
+const net = __nccwpck_require__(69278);
+const tls = __nccwpck_require__(64756);
+const { randomBytes, createHash } = __nccwpck_require__(76982);
+const { Duplex, Readable } = __nccwpck_require__(2203);
+const { URL } = __nccwpck_require__(87016);
-module.exports = {
- BINARY_TYPES,
- EMPTY_BUFFER: Buffer.alloc(0),
- GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
- hasBlob,
- kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
- kListener: Symbol('kListener'),
- kStatusCode: Symbol('status-code'),
- kWebSocket: Symbol('websocket'),
- NOOP: () => {}
-};
+const PerMessageDeflate = __nccwpck_require__(4376);
+const Receiver = __nccwpck_require__(20893);
+const Sender = __nccwpck_require__(7389);
+const { isBlob } = __nccwpck_require__(26615);
+const {
+ BINARY_TYPES,
+ EMPTY_BUFFER,
+ GUID,
+ kForOnEventAttribute,
+ kListener,
+ kStatusCode,
+ kWebSocket,
+ NOOP
+} = __nccwpck_require__(71791);
+const {
+ EventTarget: { addEventListener, removeEventListener }
+} = __nccwpck_require__(34634);
+const { format, parse } = __nccwpck_require__(61335);
+const { toBuffer } = __nccwpck_require__(95803);
-/***/ }),
+const closeTimeout = 30 * 1000;
+const kAborted = Symbol('kAborted');
+const protocolVersions = [8, 13];
+const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-/***/ 34634:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/**
+ * Class representing a WebSocket.
+ *
+ * @extends EventEmitter
+ */
+class WebSocket extends EventEmitter {
+ /**
+ * 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, protocols, options) {
+ super();
-"use strict";
+ 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;
-const { kForOnEventAttribute, kListener } = __nccwpck_require__(71791);
+ if (protocols === undefined) {
+ protocols = [];
+ } else if (!Array.isArray(protocols)) {
+ if (typeof protocols === 'object' && protocols !== null) {
+ options = protocols;
+ protocols = [];
+ } else {
+ protocols = [protocols];
+ }
+ }
-const kCode = Symbol('kCode');
-const kData = Symbol('kData');
-const kError = Symbol('kError');
-const kMessage = Symbol('kMessage');
-const kReason = Symbol('kReason');
-const kTarget = Symbol('kTarget');
-const kType = Symbol('kType');
-const kWasClean = Symbol('kWasClean');
+ initAsClient(this, address, protocols, options);
+ } else {
+ this._autoPong = options.autoPong;
+ this._isServer = true;
+ }
+ }
-/**
- * Class representing an event.
- */
-class Event {
/**
- * Create a new `Event`.
+ * For historical reasons, the custom "nodebuffer" type is used by the default
+ * instead of "blob".
*
- * @param {String} type The name of the event
- * @throws {TypeError} If the `type` argument is not specified
+ * @type {String}
*/
- constructor(type) {
- this[kTarget] = null;
- this[kType] = type;
+ get binaryType() {
+ return this._binaryType;
+ }
+
+ set binaryType(type) {
+ if (!BINARY_TYPES.includes(type)) return;
+
+ this._binaryType = type;
+
+ //
+ // Allow to change `binaryType` on the fly.
+ //
+ if (this._receiver) this._receiver._binaryType = type;
}
/**
- * @type {*}
+ * @type {Number}
*/
- get target() {
- return this[kTarget];
+ get bufferedAmount() {
+ if (!this._socket) return this._bufferedAmount;
+
+ return this._socket._writableState.length + this._sender._bufferedBytes;
}
/**
* @type {String}
*/
- get type() {
- return this[kType];
+ get extensions() {
+ return Object.keys(this._extensions).join();
}
-}
-Object.defineProperty(Event.prototype, 'target', { enumerable: true });
-Object.defineProperty(Event.prototype, 'type', { enumerable: true });
+ /**
+ * @type {Boolean}
+ */
+ get isPaused() {
+ return this._paused;
+ }
-/**
- * Class representing a close event.
- *
- * @extends Event
- */
-class CloseEvent extends Event {
/**
- * 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
+ * @type {Function}
*/
- constructor(type, options = {}) {
- super(type);
+ /* istanbul ignore next */
+ get onclose() {
+ return null;
+ }
- this[kCode] = options.code === undefined ? 0 : options.code;
- this[kReason] = options.reason === undefined ? '' : options.reason;
- this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onerror() {
+ return null;
}
/**
- * @type {Number}
+ * @type {Function}
*/
- get code() {
- return this[kCode];
+ /* istanbul ignore next */
+ get onopen() {
+ return null;
+ }
+
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onmessage() {
+ return null;
}
/**
* @type {String}
*/
- get reason() {
- return this[kReason];
+ get protocol() {
+ return this._protocol;
}
/**
- * @type {Boolean}
+ * @type {Number}
*/
- get wasClean() {
- return this[kWasClean];
+ get readyState() {
+ return this._readyState;
}
-}
-Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
-Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
-Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
+ /**
+ * @type {String}
+ */
+ get url() {
+ return this._url;
+ }
-/**
- * Class representing an error event.
- *
- * @extends Event
- */
-class ErrorEvent extends Event {
/**
- * Create a new `ErrorEvent`.
+ * Set up the socket and the internal resources.
*
- * @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
+ * @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
*/
- constructor(type, options = {}) {
- super(type);
+ 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
+ });
- this[kError] = options.error === undefined ? null : options.error;
- this[kMessage] = options.message === undefined ? '' : options.message;
+ 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;
+
+ //
+ // These methods may not be available if `socket` is just a `Duplex`.
+ //
+ 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');
}
/**
- * @type {*}
+ * Emit the `'close'` event.
+ *
+ * @private
*/
- get error() {
- return this[kError];
+ 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);
}
/**
- * @type {String}
+ * 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
*/
- get message() {
- return this[kMessage];
- }
-}
+ 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;
+ }
-Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
-Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
+ 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) => {
+ //
+ // This error is handled by the `'error'` listener on the socket. We only
+ // want to know if the close frame has been sent here.
+ //
+ if (err) return;
+
+ this._closeFrameSent = true;
+
+ if (
+ this._closeFrameReceived ||
+ this._receiver._writableState.errorEmitted
+ ) {
+ this._socket.end();
+ }
+ });
+
+ setCloseTimer(this);
+ }
-/**
- * Class representing a message event.
- *
- * @extends Event
- */
-class MessageEvent extends Event {
/**
- * Create a new `MessageEvent`.
+ * Pause the socket.
*
- * @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
+ * @public
*/
- constructor(type, options = {}) {
- super(type);
+ pause() {
+ if (
+ this.readyState === WebSocket.CONNECTING ||
+ this.readyState === WebSocket.CLOSED
+ ) {
+ return;
+ }
- this[kData] = options.data === undefined ? null : options.data;
+ this._paused = true;
+ this._socket.pause();
}
/**
- * @type {*}
+ * 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
*/
- get data() {
- return this[kData];
- }
-}
+ ping(data, mask, cb) {
+ if (this.readyState === WebSocket.CONNECTING) {
+ throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+ }
-Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
+ if (typeof data === 'function') {
+ cb = data;
+ data = mask = undefined;
+ } else if (typeof mask === 'function') {
+ cb = mask;
+ mask = undefined;
+ }
+
+ if (typeof data === 'number') data = data.toString();
+
+ if (this.readyState !== WebSocket.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+
+ if (mask === undefined) mask = !this._isServer;
+ this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+ }
-/**
- * This provides methods for emulating the `EventTarget` interface. It's not
- * meant to be used directly.
- *
- * @mixin
- */
-const EventTarget = {
/**
- * Register an event listener.
+ * Send a pong.
*
- * @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.
+ * @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
*/
- addEventListener(type, handler, options = {}) {
- for (const listener of this.listeners(type)) {
- if (
- !options[kForOnEventAttribute] &&
- listener[kListener] === handler &&
- !listener[kForOnEventAttribute]
- ) {
- return;
- }
+ pong(data, mask, cb) {
+ if (this.readyState === WebSocket.CONNECTING) {
+ throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
}
- let wrapper;
+ if (typeof data === 'function') {
+ cb = data;
+ data = mask = undefined;
+ } else if (typeof mask === 'function') {
+ cb = mask;
+ mask = undefined;
+ }
- if (type === 'message') {
- wrapper = function onMessage(data, isBinary) {
- const event = new MessageEvent('message', {
- data: isBinary ? data : data.toString()
- });
+ if (typeof data === 'number') data = data.toString();
- event[kTarget] = this;
- callListener(handler, this, event);
- };
- } else if (type === 'close') {
- wrapper = function onClose(code, message) {
- const event = new CloseEvent('close', {
- code,
- reason: message.toString(),
- wasClean: this._closeFrameReceived && this._closeFrameSent
- });
+ if (this.readyState !== WebSocket.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
- event[kTarget] = this;
- callListener(handler, this, event);
- };
- } else if (type === 'error') {
- wrapper = function onError(error) {
- const event = new ErrorEvent('error', {
- error,
- message: error.message
- });
+ if (mask === undefined) mask = !this._isServer;
+ this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+ }
- event[kTarget] = this;
- callListener(handler, this, event);
- };
- } else if (type === 'open') {
- wrapper = function onOpen() {
- const event = new Event('open');
+ /**
+ * Resume the socket.
+ *
+ * @public
+ */
+ resume() {
+ if (
+ this.readyState === WebSocket.CONNECTING ||
+ this.readyState === WebSocket.CLOSED
+ ) {
+ return;
+ }
- event[kTarget] = this;
- callListener(handler, this, event);
- };
- } else {
+ 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;
}
- wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
- wrapper[kListener] = handler;
+ const opts = {
+ binary: typeof data !== 'string',
+ mask: !this._isServer,
+ compress: true,
+ fin: true,
+ ...options
+ };
- if (options.once) {
- this.once(type, wrapper);
- } else {
- this.on(type, wrapper);
+ if (!this._extensions[PerMessageDeflate.extensionName]) {
+ opts.compress = false;
}
- },
+
+ this._sender.send(data || EMPTY_BUFFER, opts, cb);
+ }
/**
- * Remove an event listener.
+ * Forcibly close the connection.
*
- * @param {String} type A string representing the event type to remove
- * @param {(Function|Object)} handler The listener to remove
* @public
*/
- removeEventListener(type, handler) {
- for (const listener of this.listeners(type)) {
- if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
- this.removeListener(type, listener);
- break;
- }
+ 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;
}
- }
-};
-
-module.exports = {
- CloseEvent,
- ErrorEvent,
- Event,
- EventTarget,
- MessageEvent
-};
-/**
- * Call an event listener
- *
- * @param {(Function|Object)} listener The listener to call
- * @param {*} thisArg The value to use as `this`` when calling the listener
- * @param {Event} event The event to pass to the listener
- * @private
- */
-function callListener(listener, thisArg, event) {
- if (typeof listener === 'object' && listener.handleEvent) {
- listener.handleEvent.call(listener, event);
- } else {
- listener.call(thisArg, event);
+ if (this._socket) {
+ this._readyState = WebSocket.CLOSING;
+ this._socket.destroy();
+ }
}
}
+/**
+ * @constant {Number} CONNECTING
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'CONNECTING', {
+ enumerable: true,
+ value: readyStates.indexOf('CONNECTING')
+});
-/***/ }),
-
-/***/ 61335:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
+/**
+ * @constant {Number} CONNECTING
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'CONNECTING', {
+ enumerable: true,
+ value: readyStates.indexOf('CONNECTING')
+});
+/**
+ * @constant {Number} OPEN
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'OPEN', {
+ enumerable: true,
+ value: readyStates.indexOf('OPEN')
+});
-const { tokenChars } = __nccwpck_require__(26615);
+/**
+ * @constant {Number} OPEN
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'OPEN', {
+ enumerable: true,
+ value: readyStates.indexOf('OPEN')
+});
/**
- * Adds an offer to the map of extension offers or a parameter to the map of
- * parameters.
- *
- * @param {Object} dest The map of extension offers or parameters
- * @param {String} name The extension or parameter name
- * @param {(Object|Boolean|String)} elem The extension parameters or the
- * parameter value
- * @private
+ * @constant {Number} CLOSING
+ * @memberof WebSocket
*/
-function push(dest, name, elem) {
- if (dest[name] === undefined) dest[name] = [elem];
- else dest[name].push(elem);
-}
+Object.defineProperty(WebSocket, 'CLOSING', {
+ enumerable: true,
+ value: readyStates.indexOf('CLOSING')
+});
/**
- * Parses the `Sec-WebSocket-Extensions` header into an object.
- *
- * @param {String} header The field value of the header
- * @return {Object} The parsed object
- * @public
+ * @constant {Number} CLOSING
+ * @memberof WebSocket.prototype
*/
-function parse(header) {
- const offers = Object.create(null);
- let params = 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;
+Object.defineProperty(WebSocket.prototype, 'CLOSING', {
+ enumerable: true,
+ value: readyStates.indexOf('CLOSING')
+});
- for (; i < header.length; i++) {
- code = header.charCodeAt(i);
+/**
+ * @constant {Number} CLOSED
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'CLOSED', {
+ enumerable: true,
+ value: readyStates.indexOf('CLOSED')
+});
- if (extensionName === undefined) {
- if (end === -1 && tokenChars[code] === 1) {
- if (start === -1) start = i;
- } else if (
- i !== 0 &&
- (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
- ) {
- if (end === -1 && start !== -1) end = i;
- } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
- if (start === -1) {
- throw new SyntaxError(`Unexpected character at index ${i}`);
- }
+/**
+ * @constant {Number} CLOSED
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'CLOSED', {
+ enumerable: true,
+ value: readyStates.indexOf('CLOSED')
+});
- if (end === -1) end = i;
- const name = header.slice(start, end);
- if (code === 0x2c) {
- push(offers, name, params);
- params = Object.create(null);
- } else {
- extensionName = name;
- }
+[
+ 'binaryType',
+ 'bufferedAmount',
+ 'extensions',
+ 'isPaused',
+ 'protocol',
+ 'readyState',
+ 'url'
+].forEach((property) => {
+ Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+});
- start = end = -1;
- } else {
- throw new SyntaxError(`Unexpected character at index ${i}`);
+//
+// Add the `onopen`, `onerror`, `onclose`, and `onmessage` attributes.
+// See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface
+//
+['open', 'error', 'close', 'message'].forEach((method) => {
+ Object.defineProperty(WebSocket.prototype, `on${method}`, {
+ enumerable: true,
+ get() {
+ for (const listener of this.listeners(method)) {
+ if (listener[kForOnEventAttribute]) return listener[kListener];
}
- } else if (paramName === undefined) {
- if (end === -1 && tokenChars[code] === 1) {
- if (start === -1) start = i;
- } else if (code === 0x20 || code === 0x09) {
- if (end === -1 && start !== -1) end = i;
- } else if (code === 0x3b || code === 0x2c) {
- if (start === -1) {
- throw new SyntaxError(`Unexpected character at index ${i}`);
- }
- if (end === -1) end = i;
- push(params, header.slice(start, end), true);
- if (code === 0x2c) {
- push(offers, extensionName, params);
- params = Object.create(null);
- extensionName = undefined;
+ return null;
+ },
+ set(handler) {
+ for (const listener of this.listeners(method)) {
+ if (listener[kForOnEventAttribute]) {
+ this.removeListener(method, listener);
+ break;
}
-
- start = end = -1;
- } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
- paramName = header.slice(start, i);
- start = end = -1;
- } else {
- throw new SyntaxError(`Unexpected character at index ${i}`);
}
- } else {
- //
- // The value of a quoted-string after unescaping must conform to the
- // token ABNF, so only token characters are valid.
- // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
- //
- 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 === 0x22 /* '"' */ && start !== -1) {
- inQuotes = false;
- end = i;
- } else if (code === 0x5c /* '\' */) {
- isEscaping = true;
- } else {
- throw new SyntaxError(`Unexpected character at index ${i}`);
- }
- } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
- inQuotes = true;
- } else if (end === -1 && tokenChars[code] === 1) {
- if (start === -1) start = i;
- } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
- if (end === -1) end = i;
- } else if (code === 0x3b || code === 0x2c) {
- 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;
- }
- push(params, paramName, value);
- if (code === 0x2c) {
- push(offers, extensionName, params);
- params = Object.create(null);
- extensionName = undefined;
- }
+ if (typeof handler !== 'function') return;
- paramName = undefined;
- start = end = -1;
- } else {
- throw new SyntaxError(`Unexpected character at index ${i}`);
- }
+ this.addEventListener(method, handler, {
+ [kForOnEventAttribute]: true
+ });
}
- }
-
- if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
- throw new SyntaxError('Unexpected end of input');
- }
+ });
+});
- if (end === -1) end = i;
- const token = header.slice(start, end);
- if (extensionName === undefined) {
- push(offers, token, params);
- } else {
- if (paramName === undefined) {
- push(params, token, true);
- } else if (mustUnescape) {
- push(params, paramName, token.replace(/\\/g, ''));
- } else {
- push(params, paramName, token);
- }
- push(offers, extensionName, params);
- }
+WebSocket.prototype.addEventListener = addEventListener;
+WebSocket.prototype.removeEventListener = removeEventListener;
- return offers;
-}
+module.exports = WebSocket;
/**
- * Builds the `Sec-WebSocket-Extensions` header field value.
+ * Initialize a WebSocket client.
*
- * @param {Object} extensions The map of extensions and parameters to format
- * @return {String} A string representing the given object
- * @public
+ * @param {WebSocket} websocket The client to initialize
+ * @param {(String|URL)} address The URL to which to connect
+ * @param {Array} protocols The subprotocols
+ * @param {Object} [options] Connection 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 {Function} [options.finishRequest] A function which can be used to
+ * customize the headers of each http request before it is sent
+ * @param {Boolean} [options.followRedirects=false] Whether or not to follow
+ * redirects
+ * @param {Function} [options.generateMask] The function used to generate the
+ * masking key
+ * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
+ * handshake request
+ * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+ * size
+ * @param {Number} [options.maxRedirects=10] The maximum number of redirects
+ * allowed
+ * @param {String} [options.origin] Value of the `Origin` or
+ * `Sec-WebSocket-Origin` header
+ * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
+ * permessage-deflate
+ * @param {Number} [options.protocolVersion=13] Value of the
+ * `Sec-WebSocket-Version` header
+ * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+ * not to skip UTF-8 validation for text and close messages
+ * @private
*/
-function format(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(', ');
-}
+function initAsClient(websocket, address, protocols, options) {
+ const opts = {
+ allowSynchronousEvents: true,
+ autoPong: true,
+ protocolVersion: protocolVersions[1],
+ maxPayload: 100 * 1024 * 1024,
+ skipUTF8Validation: false,
+ perMessageDeflate: true,
+ followRedirects: false,
+ maxRedirects: 10,
+ ...options,
+ socketPath: undefined,
+ hostname: undefined,
+ protocol: undefined,
+ timeout: undefined,
+ method: 'GET',
+ host: undefined,
+ path: undefined,
+ port: undefined
+ };
-module.exports = { format, parse };
+ websocket._autoPong = opts.autoPong;
+ if (!protocolVersions.includes(opts.protocolVersion)) {
+ throw new RangeError(
+ `Unsupported protocol version: ${opts.protocolVersion} ` +
+ `(supported versions: ${protocolVersions.join(', ')})`
+ );
+ }
-/***/ }),
+ let parsedUrl;
-/***/ 10958:
-/***/ ((module) => {
+ if (address instanceof URL) {
+ parsedUrl = address;
+ } else {
+ try {
+ parsedUrl = new URL(address);
+ } catch (e) {
+ throw new SyntaxError(`Invalid URL: ${address}`);
+ }
+ }
-"use strict";
+ if (parsedUrl.protocol === 'http:') {
+ parsedUrl.protocol = 'ws:';
+ } else if (parsedUrl.protocol === 'https:') {
+ parsedUrl.protocol = 'wss:';
+ }
+ websocket._url = parsedUrl.href;
-const kDone = Symbol('kDone');
-const kRun = Symbol('kRun');
+ const isSecure = parsedUrl.protocol === 'wss:';
+ const isIpcUrl = parsedUrl.protocol === 'ws+unix:';
+ let invalidUrlMessage;
-/**
- * A very simple job queue with adjustable concurrency. Adapted from
- * https://github.com/STRML/async-limiter
- */
-class Limiter {
- /**
- * 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;
+ 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';
}
- /**
- * Adds a job to the queue.
- *
- * @param {Function} job The job to run
- * @public
- */
- add(job) {
- this.jobs.push(job);
- this[kRun]();
+ if (invalidUrlMessage) {
+ const err = new SyntaxError(invalidUrlMessage);
+
+ if (websocket._redirects === 0) {
+ throw err;
+ } else {
+ emitErrorAndClose(websocket, err);
+ return;
+ }
}
- /**
- * Removes a job from the queue and runs it if possible.
- *
- * @private
- */
- [kRun]() {
- if (this.pending === this.concurrency) return;
+ const defaultPort = isSecure ? 443 : 80;
+ const key = randomBytes(16).toString('base64');
+ const request = isSecure ? https.request : http.request;
+ const protocolSet = new Set();
+ let perMessageDeflate;
- if (this.jobs.length) {
- const job = this.jobs.shift();
+ 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;
- this.pending++;
- job(this[kDone]);
+ if (opts.perMessageDeflate) {
+ perMessageDeflate = new PerMessageDeflate(
+ opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
+ false,
+ opts.maxPayload
+ );
+ opts.headers['Sec-WebSocket-Extensions'] = format({
+ [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+ });
+ }
+ if (protocols.length) {
+ for (const protocol of protocols) {
+ 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'] = protocols.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}`;
}
-}
-module.exports = Limiter;
+ if (isIpcUrl) {
+ const parts = opts.path.split(':');
+ opts.socketPath = parts[0];
+ opts.path = parts[1];
+ }
-/***/ }),
+ let req;
-/***/ 4376:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+ if (opts.followRedirects) {
+ if (websocket._redirects === 0) {
+ websocket._originalIpc = isIpcUrl;
+ websocket._originalSecure = isSecure;
+ websocket._originalHostOrSocketPath = isIpcUrl
+ ? opts.socketPath
+ : parsedUrl.host;
-"use strict";
+ const headers = options && options.headers;
+ //
+ // Shallow copy the user provided options so that headers can be changed
+ // without mutating the original object.
+ //
+ options = { ...options, headers: {} };
-const zlib = __nccwpck_require__(43106);
+ if (headers) {
+ for (const [key, value] of Object.entries(headers)) {
+ options.headers[key.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;
-const bufferUtil = __nccwpck_require__(95803);
-const Limiter = __nccwpck_require__(10958);
-const { kStatusCode } = __nccwpck_require__(71791);
+ if (!isSameHost || (websocket._originalSecure && !isSecure)) {
+ //
+ // Match curl 7.77.0 behavior and drop the following headers. These
+ // headers are also dropped when following a redirect to a subdomain.
+ //
+ delete opts.headers.authorization;
+ delete opts.headers.cookie;
-const FastBuffer = Buffer[Symbol.species];
-const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
-const kPerMessageDeflate = Symbol('permessage-deflate');
-const kTotalLength = Symbol('total-length');
-const kCallback = Symbol('callback');
-const kBuffers = Symbol('buffers');
-const kError = Symbol('error');
+ if (!isSameHost) delete opts.headers.host;
-//
-// We limit zlib concurrency, which prevents severe memory fragmentation
-// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
-// and https://github.com/websockets/ws/issues/1202
-//
-// Intentionally global; it's the global thread pool that's an issue.
-//
-let zlibLimiter;
+ opts.auth = undefined;
+ }
+ }
-/**
- * permessage-deflate implementation.
- */
-class PerMessageDeflate {
- /**
- * 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|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
- * @param {Boolean} [isServer=false] Create the instance in either server or
- * client mode
- * @param {Number} [maxPayload=0] The maximum allowed message length
- */
- constructor(options, isServer, maxPayload) {
- this._maxPayload = maxPayload | 0;
- this._options = options || {};
- this._threshold =
- this._options.threshold !== undefined ? this._options.threshold : 1024;
- this._isServer = !!isServer;
- this._deflate = null;
- this._inflate = null;
+ //
+ // Match curl 7.77.0 behavior and make the first `Authorization` header win.
+ // If the `Authorization` header is set, then there is nothing to do as it
+ // will take precedence.
+ //
+ if (opts.auth && !options.headers.authorization) {
+ options.headers.authorization =
+ 'Basic ' + Buffer.from(opts.auth).toString('base64');
+ }
- this.params = null;
+ req = websocket._req = request(opts);
- if (!zlibLimiter) {
- const concurrency =
- this._options.concurrencyLimit !== undefined
- ? this._options.concurrencyLimit
- : 10;
- zlibLimiter = new Limiter(concurrency);
+ if (websocket._redirects) {
+ //
+ // Unlike what is done for the `'upgrade'` event, no early exit is
+ // triggered here if the user calls `websocket.close()` or
+ // `websocket.terminate()` from a listener of the `'redirect'` event. This
+ // is because the user can also call `request.destroy()` with an error
+ // before calling `websocket.close()` or `websocket.terminate()` and this
+ // would result in an error being emitted on the `request` object with no
+ // `'error'` event listeners attached.
+ //
+ websocket.emit('redirect', websocket.url, req);
}
+ } else {
+ req = websocket._req = request(opts);
}
- /**
- * @type {String}
- */
- static get extensionName() {
- return 'permessage-deflate';
+ if (opts.timeout) {
+ req.on('timeout', () => {
+ abortHandshake(websocket, req, 'Opening handshake has timed out');
+ });
}
- /**
- * Create an extension negotiation offer.
- *
- * @return {Object} Extension parameters
- * @public
- */
- offer() {
- const params = {};
+ req.on('error', (err) => {
+ if (req === null || req[kAborted]) return;
- 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;
+ 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 URL(location, address);
+ } catch (e) {
+ const err = new SyntaxError(`Invalid URL: ${location}`);
+ emitErrorAndClose(websocket, err);
+ return;
+ }
+
+ initAsClient(websocket, addr, protocols, options);
+ } else if (!websocket.emit('unexpected-response', req, res)) {
+ abortHandshake(
+ websocket,
+ req,
+ `Unexpected server response: ${res.statusCode}`
+ );
}
+ });
- return params;
- }
+ req.on('upgrade', (res, socket, head) => {
+ websocket.emit('upgrade', res);
- /**
- * 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);
+ //
+ // The user may have closed the connection from a listener of the
+ // `'upgrade'` event.
+ //
+ if (websocket.readyState !== WebSocket.CONNECTING) return;
- this.params = this._isServer
- ? this.acceptAsServer(configurations)
- : this.acceptAsClient(configurations);
+ req = websocket._req = null;
- return this.params;
- }
+ const upgrade = res.headers.upgrade;
- /**
- * Releases all resources used by the extension.
- *
- * @public
- */
- cleanup() {
- if (this._inflate) {
- this._inflate.close();
- this._inflate = null;
+ if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+ abortHandshake(websocket, socket, 'Invalid Upgrade header');
+ return;
}
- if (this._deflate) {
- const callback = this._deflate[kCallback];
+ const digest = createHash('sha1')
+ .update(key + GUID)
+ .digest('base64');
- this._deflate.close();
- this._deflate = null;
+ if (res.headers['sec-websocket-accept'] !== digest) {
+ abortHandshake(websocket, socket, 'Invalid Sec-WebSocket-Accept header');
+ return;
+ }
- if (callback) {
- callback(
- new Error(
- 'The deflate stream was closed while data was being processed'
- )
- );
+ const serverProt = res.headers['sec-websocket-protocol'];
+ let protError;
+
+ if (serverProt !== undefined) {
+ 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';
}
- }
- /**
- * 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 (protError) {
+ abortHandshake(websocket, socket, protError);
+ return;
+ }
+
+ if (serverProt) websocket._protocol = serverProt;
+
+ const secWebSocketExtensions = res.headers['sec-websocket-extensions'];
+
+ if (secWebSocketExtensions !== undefined) {
+ 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 = parse(secWebSocketExtensions);
+ } catch (err) {
+ const message = 'Invalid Sec-WebSocket-Extensions header';
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+
+ const extensionNames = Object.keys(extensions);
+
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)
+ extensionNames.length !== 1 ||
+ extensionNames[0] !== PerMessageDeflate.extensionName
) {
- return false;
+ const message = 'Server indicated an extension that was not requested';
+ abortHandshake(websocket, socket, message);
+ return;
}
- return true;
- });
+ try {
+ perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+ } catch (err) {
+ const message = 'Invalid Sec-WebSocket-Extensions header';
+ abortHandshake(websocket, socket, message);
+ return;
+ }
- if (!accepted) {
- throw new Error('None of the extension offers can be accepted');
+ websocket._extensions[PerMessageDeflate.extensionName] =
+ perMessageDeflate;
}
- 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;
- }
+ websocket.setSocket(socket, head, {
+ allowSynchronousEvents: opts.allowSynchronousEvents,
+ generateMask: opts.generateMask,
+ maxPayload: opts.maxPayload,
+ skipUTF8Validation: opts.skipUTF8Validation
+ });
+ });
- return accepted;
+ if (opts.finishRequest) {
+ opts.finishRequest(req, websocket);
+ } else {
+ req.end();
}
+}
- /**
- * Accept the extension negotiation response.
- *
- * @param {Array} response The extension negotiation response
- * @return {Object} Accepted configuration
- * @private
- */
- acceptAsClient(response) {
- const params = response[0];
+/**
+ * Emit the `'error'` and `'close'` events.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {Error} The error to emit
+ * @private
+ */
+function emitErrorAndClose(websocket, err) {
+ websocket._readyState = WebSocket.CLOSING;
+ //
+ // The following assignment is practically useless and is done only for
+ // consistency.
+ //
+ websocket._errorEmitted = true;
+ websocket.emit('error', err);
+ websocket.emitClose();
+}
- if (
- this._options.clientNoContextTakeover === false &&
- params.client_no_context_takeover
- ) {
- throw new Error('Unexpected parameter "client_no_context_takeover"');
- }
+/**
+ * Create a `net.Socket` and initiate a connection.
+ *
+ * @param {Object} options Connection options
+ * @return {net.Socket} The newly created socket used to start the connection
+ * @private
+ */
+function netConnect(options) {
+ options.path = options.socketPath;
+ return net.connect(options);
+}
- 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"'
- );
- }
+/**
+ * Create a `tls.TLSSocket` and initiate a connection.
+ *
+ * @param {Object} options Connection options
+ * @return {tls.TLSSocket} The newly created socket used to start the connection
+ * @private
+ */
+function tlsConnect(options) {
+ options.path = undefined;
- return params;
+ if (!options.servername && options.servername !== '') {
+ options.servername = net.isIP(options.host) ? '' : options.host;
}
- /**
- * 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];
+ return tls.connect(options);
+}
- if (value.length > 1) {
- throw new Error(`Parameter "${key}" must have only a single value`);
- }
+/**
+ * Abort the handshake and emit an error.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
+ * abort or the socket to destroy
+ * @param {String} message The error message
+ * @private
+ */
+function abortHandshake(websocket, stream, message) {
+ websocket._readyState = WebSocket.CLOSING;
- value = value[0];
+ const err = new Error(message);
+ Error.captureStackTrace(err, abortHandshake);
- 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}"`);
- }
+ if (stream.setHeader) {
+ stream[kAborted] = true;
+ stream.abort();
- params[key] = value;
- });
- });
+ if (stream.socket && !stream.socket.destroyed) {
+ //
+ // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if
+ // called after the request completed. See
+ // https://github.com/websockets/ws/issues/1869.
+ //
+ stream.socket.destroy();
+ }
- return configurations;
+ process.nextTick(emitErrorAndClose, websocket, err);
+ } else {
+ stream.destroy(err);
+ stream.once('error', websocket.emit.bind(websocket, 'error'));
+ stream.once('close', websocket.emitClose.bind(websocket));
}
+}
- /**
- * 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);
- });
- });
+/**
+ * Handle cases where the `ping()`, `pong()`, or `send()` methods are called
+ * when the `readyState` attribute is `CLOSING` or `CLOSED`.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {*} [data] The data to send
+ * @param {Function} [cb] Callback
+ * @private
+ */
+function sendAfterClose(websocket, data, cb) {
+ if (data) {
+ const length = isBlob(data) ? data.size : toBuffer(data).length;
+
+ //
+ // The `_bufferedAmount` property is used only when the peer is a client and
+ // the opening handshake fails. Under these circumstances, in fact, the
+ // `setSocket()` method is not called, so the `_socket` and `_sender`
+ // properties are set to `null`.
+ //
+ if (websocket._socket) websocket._sender._bufferedBytes += length;
+ else websocket._bufferedAmount += length;
}
- /**
- * 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);
- });
- });
+ if (cb) {
+ const err = new Error(
+ `WebSocket is not open: readyState ${websocket.readyState} ` +
+ `(${readyStates[websocket.readyState]})`
+ );
+ process.nextTick(cb, err);
}
+}
- /**
- * 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';
+/**
+ * The listener of the `Receiver` `'conclude'` event.
+ *
+ * @param {Number} code The status code
+ * @param {Buffer} reason The reason for closing
+ * @private
+ */
+function receiverOnConclude(code, reason) {
+ const websocket = this[kWebSocket];
- if (!this._inflate) {
- const key = `${endpoint}_max_window_bits`;
- const windowBits =
- typeof this.params[key] !== 'number'
- ? zlib.Z_DEFAULT_WINDOWBITS
- : this.params[key];
+ websocket._closeFrameReceived = true;
+ websocket._closeMessage = reason;
+ websocket._closeCode = code;
- 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);
- }
+ if (websocket._socket[kWebSocket] === undefined) return;
- this._inflate[kCallback] = callback;
+ websocket._socket.removeListener('data', socketOnData);
+ process.nextTick(resume, websocket._socket);
- this._inflate.write(data);
- if (fin) this._inflate.write(TRAILER);
+ if (code === 1005) websocket.close();
+ else websocket.close(code, reason);
+}
- this._inflate.flush(() => {
- const err = this._inflate[kError];
+/**
+ * The listener of the `Receiver` `'drain'` event.
+ *
+ * @private
+ */
+function receiverOnDrain() {
+ const websocket = this[kWebSocket];
- if (err) {
- this._inflate.close();
- this._inflate = null;
- callback(err);
- return;
- }
+ if (!websocket.isPaused) websocket._socket.resume();
+}
- const data = bufferUtil.concat(
- this._inflate[kBuffers],
- this._inflate[kTotalLength]
- );
+/**
+ * The listener of the `Receiver` `'error'` event.
+ *
+ * @param {(RangeError|Error)} err The emitted error
+ * @private
+ */
+function receiverOnError(err) {
+ const websocket = this[kWebSocket];
- if (this._inflate._readableState.endEmitted) {
- this._inflate.close();
- this._inflate = null;
- } else {
- this._inflate[kTotalLength] = 0;
- this._inflate[kBuffers] = [];
+ if (websocket._socket[kWebSocket] !== undefined) {
+ websocket._socket.removeListener('data', socketOnData);
- if (fin && this.params[`${endpoint}_no_context_takeover`]) {
- this._inflate.reset();
- }
- }
+ //
+ // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
+ // https://github.com/websockets/ws/issues/1940.
+ //
+ process.nextTick(resume, websocket._socket);
- callback(null, data);
- });
+ websocket.close(err[kStatusCode]);
}
- /**
- * 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
- });
+ if (!websocket._errorEmitted) {
+ websocket._errorEmitted = true;
+ websocket.emit('error', err);
+ }
+}
- this._deflate[kTotalLength] = 0;
- this._deflate[kBuffers] = [];
+/**
+ * The listener of the `Receiver` `'finish'` event.
+ *
+ * @private
+ */
+function receiverOnFinish() {
+ this[kWebSocket].emitClose();
+}
- this._deflate.on('data', deflateOnData);
- }
+/**
+ * The listener of the `Receiver` `'message'` event.
+ *
+ * @param {Buffer|ArrayBuffer|Buffer[])} data The message
+ * @param {Boolean} isBinary Specifies whether the message is binary or not
+ * @private
+ */
+function receiverOnMessage(data, isBinary) {
+ this[kWebSocket].emit('message', data, isBinary);
+}
- this._deflate[kCallback] = callback;
+/**
+ * The listener of the `Receiver` `'ping'` event.
+ *
+ * @param {Buffer} data The data included in the ping frame
+ * @private
+ */
+function receiverOnPing(data) {
+ const websocket = this[kWebSocket];
- this._deflate.write(data);
- this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
- if (!this._deflate) {
- //
- // The deflate stream was closed while data was being processed.
- //
- return;
- }
+ if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
+ websocket.emit('ping', data);
+}
- let data = bufferUtil.concat(
- this._deflate[kBuffers],
- this._deflate[kTotalLength]
- );
+/**
+ * The listener of the `Receiver` `'pong'` event.
+ *
+ * @param {Buffer} data The data included in the pong frame
+ * @private
+ */
+function receiverOnPong(data) {
+ this[kWebSocket].emit('pong', data);
+}
- if (fin) {
- data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);
- }
+/**
+ * Resume a readable stream
+ *
+ * @param {Readable} stream The readable stream
+ * @private
+ */
+function resume(stream) {
+ stream.resume();
+}
- //
- // Ensure that the callback will not be called again in
- // `PerMessageDeflate#cleanup()`.
- //
- this._deflate[kCallback] = null;
+/**
+ * The `Sender` error event handler.
+ *
+ * @param {Error} The error
+ * @private
+ */
+function senderOnError(err) {
+ const websocket = this[kWebSocket];
- this._deflate[kTotalLength] = 0;
- this._deflate[kBuffers] = [];
+ if (websocket.readyState === WebSocket.CLOSED) return;
+ if (websocket.readyState === WebSocket.OPEN) {
+ websocket._readyState = WebSocket.CLOSING;
+ setCloseTimer(websocket);
+ }
- if (fin && this.params[`${endpoint}_no_context_takeover`]) {
- this._deflate.reset();
- }
+ //
+ // `socket.end()` is used instead of `socket.destroy()` to allow the other
+ // peer to finish sending queued data. There is no need to set a timer here
+ // because `CLOSING` means that it is already set or not needed.
+ //
+ this._socket.end();
- callback(null, data);
- });
+ if (!websocket._errorEmitted) {
+ websocket._errorEmitted = true;
+ websocket.emit('error', err);
}
}
-module.exports = PerMessageDeflate;
-
/**
- * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ * Set a timer to destroy the underlying raw socket of a WebSocket.
*
- * @param {Buffer} chunk A chunk of data
+ * @param {WebSocket} websocket The WebSocket instance
* @private
*/
-function deflateOnData(chunk) {
- this[kBuffers].push(chunk);
- this[kTotalLength] += chunk.length;
+function setCloseTimer(websocket) {
+ websocket._closeTimer = setTimeout(
+ websocket._socket.destroy.bind(websocket._socket),
+ closeTimeout
+ );
}
/**
- * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ * The listener of the socket `'close'` event.
*
- * @param {Buffer} chunk A chunk of data
* @private
*/
-function inflateOnData(chunk) {
- this[kTotalLength] += chunk.length;
+function socketOnClose() {
+ const websocket = this[kWebSocket];
+
+ this.removeListener('close', socketOnClose);
+ this.removeListener('data', socketOnData);
+ this.removeListener('end', socketOnEnd);
+
+ websocket._readyState = WebSocket.CLOSING;
+
+ let chunk;
+
+ //
+ // The close frame might not have been received or the `'end'` event emitted,
+ // for example, if the socket was destroyed due to an error. Ensure that the
+ // `receiver` stream is closed after writing any remaining buffered data to
+ // it. If the readable side of the socket is in flowing mode then there is no
+ // buffered data as everything has been already written and `readable.read()`
+ // will return `null`. If instead, the socket is paused, any possible buffered
+ // data will be read as a single chunk.
+ //
+ if (
+ !this._readableState.endEmitted &&
+ !websocket._closeFrameReceived &&
+ !websocket._receiver._writableState.errorEmitted &&
+ (chunk = websocket._socket.read()) !== null
+ ) {
+ websocket._receiver.write(chunk);
+ }
+
+ websocket._receiver.end();
+
+ this[kWebSocket] = undefined;
+
+ clearTimeout(websocket._closeTimer);
if (
- this[kPerMessageDeflate]._maxPayload < 1 ||
- this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+ websocket._receiver._writableState.finished ||
+ websocket._receiver._writableState.errorEmitted
) {
- this[kBuffers].push(chunk);
- return;
+ websocket.emitClose();
+ } else {
+ websocket._receiver.on('error', receiverOnFinish);
+ websocket._receiver.on('finish', receiverOnFinish);
}
+}
- 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();
+/**
+ * The listener of the socket `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function socketOnData(chunk) {
+ if (!this[kWebSocket]._receiver.write(chunk)) {
+ this.pause();
+ }
}
/**
- * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ * The listener of the socket `'end'` event.
*
- * @param {Error} err The emitted error
* @private
*/
-function inflateOnError(err) {
- //
- // There is no need to call `Zlib#close()` as the handle is automatically
- // closed when an error is emitted.
- //
- this[kPerMessageDeflate]._inflate = null;
- err[kStatusCode] = 1007;
- this[kCallback](err);
+function socketOnEnd() {
+ const websocket = this[kWebSocket];
+
+ websocket._readyState = WebSocket.CLOSING;
+ websocket._receiver.end();
+ this.end();
+}
+
+/**
+ * The listener of the socket `'error'` event.
+ *
+ * @private
+ */
+function socketOnError() {
+ const websocket = this[kWebSocket];
+
+ this.removeListener('error', socketOnError);
+ this.on('error', NOOP);
+
+ if (websocket) {
+ websocket._readyState = WebSocket.CLOSING;
+ this.destroy();
+ }
}
/***/ }),
-/***/ 20893:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 20663:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-"use strict";
+var fs = __nccwpck_require__(79896);
+var zlib = __nccwpck_require__(43106);
+var fd_slicer = __nccwpck_require__(23045);
+var crc32 = __nccwpck_require__(19776);
+var util = __nccwpck_require__(39023);
+var EventEmitter = (__nccwpck_require__(24434).EventEmitter);
+var Transform = (__nccwpck_require__(2203).Transform);
+var PassThrough = (__nccwpck_require__(2203).PassThrough);
+var Writable = (__nccwpck_require__(2203).Writable);
+exports.open = open;
+exports.fromFd = fromFd;
+exports.fromBuffer = fromBuffer;
+exports.fromRandomAccessReader = fromRandomAccessReader;
+exports.dosDateTimeToDate = dosDateTimeToDate;
+exports.validateFileName = validateFileName;
+exports.ZipFile = ZipFile;
+exports.Entry = Entry;
+exports.RandomAccessReader = RandomAccessReader;
-const { Writable } = __nccwpck_require__(2203);
+function open(path, options, callback) {
+ if (typeof options === "function") {
+ callback = options;
+ options = null;
+ }
+ if (options == null) options = {};
+ if (options.autoClose == null) options.autoClose = true;
+ if (options.lazyEntries == null) options.lazyEntries = false;
+ if (options.decodeStrings == null) options.decodeStrings = true;
+ if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+ if (options.strictFileNames == null) options.strictFileNames = false;
+ if (callback == null) callback = defaultCallback;
+ fs.open(path, "r", function(err, fd) {
+ if (err) return callback(err);
+ fromFd(fd, options, function(err, zipfile) {
+ if (err) fs.close(fd, defaultCallback);
+ callback(err, zipfile);
+ });
+ });
+}
-const PerMessageDeflate = __nccwpck_require__(4376);
-const {
- BINARY_TYPES,
- EMPTY_BUFFER,
- kStatusCode,
- kWebSocket
-} = __nccwpck_require__(71791);
-const { concat, toArrayBuffer, unmask } = __nccwpck_require__(95803);
-const { isValidStatusCode, isValidUTF8 } = __nccwpck_require__(26615);
+function fromFd(fd, options, callback) {
+ if (typeof options === "function") {
+ callback = options;
+ options = null;
+ }
+ if (options == null) options = {};
+ if (options.autoClose == null) options.autoClose = false;
+ if (options.lazyEntries == null) options.lazyEntries = false;
+ if (options.decodeStrings == null) options.decodeStrings = true;
+ if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+ if (options.strictFileNames == null) options.strictFileNames = false;
+ if (callback == null) callback = defaultCallback;
+ fs.fstat(fd, function(err, stats) {
+ if (err) return callback(err);
+ var reader = fd_slicer.createFromFd(fd, {autoClose: true});
+ fromRandomAccessReader(reader, stats.size, options, callback);
+ });
+}
-const FastBuffer = Buffer[Symbol.species];
+function fromBuffer(buffer, options, callback) {
+ if (typeof options === "function") {
+ callback = options;
+ options = null;
+ }
+ if (options == null) options = {};
+ options.autoClose = false;
+ if (options.lazyEntries == null) options.lazyEntries = false;
+ if (options.decodeStrings == null) options.decodeStrings = true;
+ if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+ if (options.strictFileNames == null) options.strictFileNames = false;
+ // limit the max chunk size. see https://github.com/thejoshwolfe/yauzl/issues/87
+ var reader = fd_slicer.createFromBuffer(buffer, {maxChunkSize: 0x10000});
+ fromRandomAccessReader(reader, buffer.length, options, callback);
+}
-const GET_INFO = 0;
-const GET_PAYLOAD_LENGTH_16 = 1;
-const GET_PAYLOAD_LENGTH_64 = 2;
-const GET_MASK = 3;
-const GET_DATA = 4;
-const INFLATING = 5;
-const DEFER_EVENT = 6;
+function fromRandomAccessReader(reader, totalSize, options, callback) {
+ if (typeof options === "function") {
+ callback = options;
+ options = null;
+ }
+ if (options == null) options = {};
+ if (options.autoClose == null) options.autoClose = true;
+ if (options.lazyEntries == null) options.lazyEntries = false;
+ if (options.decodeStrings == null) options.decodeStrings = true;
+ var decodeStrings = !!options.decodeStrings;
+ if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+ if (options.strictFileNames == null) options.strictFileNames = false;
+ if (callback == null) callback = defaultCallback;
+ if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
+ if (totalSize > Number.MAX_SAFE_INTEGER) {
+ throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+ }
-/**
- * HyBi Receiver implementation.
- *
- * @extends Writable
- */
-class Receiver 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();
+ // the matching unref() call is in zipfile.close()
+ reader.ref();
- this._allowSynchronousEvents =
- options.allowSynchronousEvents !== undefined
- ? 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] = undefined;
+ // eocdr means End of Central Directory Record.
+ // search backwards for the eocdr signature.
+ // the last field of the eocdr is a variable-length comment.
+ // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it.
+ // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if a coherent eocdr was in the comment.
+ // we search backwards for a eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment.
+ var eocdrWithoutCommentSize = 22;
+ var maxCommentSize = 0xffff; // 2-byte size
+ var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
+ var buffer = newBuffer(bufferSize);
+ var bufferReadStart = totalSize - buffer.length;
+ readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+ if (err) return callback(err);
+ for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
+ if (buffer.readUInt32LE(i) !== 0x06054b50) continue;
+ // found eocdr
+ var eocdrBuffer = buffer.slice(i);
- this._bufferedBytes = 0;
- this._buffers = [];
+ // 0 - End of central directory signature = 0x06054b50
+ // 4 - Number of this disk
+ var diskNumber = eocdrBuffer.readUInt16LE(4);
+ if (diskNumber !== 0) {
+ return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+ }
+ // 6 - Disk where central directory starts
+ // 8 - Number of central directory records on this disk
+ // 10 - Total number of central directory records
+ var entryCount = eocdrBuffer.readUInt16LE(10);
+ // 12 - Size of central directory (bytes)
+ // 16 - Offset of start of central directory, relative to start of archive
+ var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+ // 20 - Comment length
+ var commentLength = eocdrBuffer.readUInt16LE(20);
+ var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+ if (commentLength !== expectedCommentLength) {
+ return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
+ }
+ // 22 - Comment
+ // the encoding is always cp437.
+ var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false)
+ : eocdrBuffer.slice(22);
- this._compressed = false;
- this._payloadLength = 0;
- this._mask = undefined;
- this._fragmented = 0;
- this._masked = false;
- this._fin = false;
- this._opcode = 0;
+ if (!(entryCount === 0xffff || centralDirectoryOffset === 0xffffffff)) {
+ return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+ }
- this._totalPayloadLength = 0;
- this._messageLength = 0;
- this._fragments = [];
+ // ZIP64 format
- this._errored = false;
- this._loop = false;
- this._state = GET_INFO;
- }
+ // ZIP64 Zip64 end of central directory locator
+ var zip64EocdlBuffer = newBuffer(20);
+ var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
+ readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err) {
+ if (err) return callback(err);
- /**
- * 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 === 0x08 && this._state == GET_INFO) return cb();
+ // 0 - zip64 end of central dir locator signature = 0x07064b50
+ if (zip64EocdlBuffer.readUInt32LE(0) !== 0x07064b50) {
+ return callback(new Error("invalid zip64 end of central directory locator signature"));
+ }
+ // 4 - number of the disk with the start of the zip64 end of central directory
+ // 8 - relative offset of the zip64 end of central directory record
+ var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+ // 16 - total number of disks
- this._bufferedBytes += chunk.length;
- this._buffers.push(chunk);
- this.startLoop(cb);
+ // ZIP64 end of central directory record
+ var zip64EocdrBuffer = newBuffer(56);
+ readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err) {
+ if (err) return callback(err);
+
+ // 0 - zip64 end of central dir signature 4 bytes (0x06064b50)
+ if (zip64EocdrBuffer.readUInt32LE(0) !== 0x06064b50) {
+ return callback(new Error("invalid zip64 end of central directory record signature"));
+ }
+ // 4 - size of zip64 end of central directory record 8 bytes
+ // 12 - version made by 2 bytes
+ // 14 - version needed to extract 2 bytes
+ // 16 - number of this disk 4 bytes
+ // 20 - number of the disk with the start of the central directory 4 bytes
+ // 24 - total number of entries in the central directory on this disk 8 bytes
+ // 32 - total number of entries in the central directory 8 bytes
+ entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+ // 40 - size of the central directory 8 bytes
+ // 48 - offset of start of central directory with respect to the starting disk number 8 bytes
+ centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+ // 56 - zip64 extensible data sector (variable size)
+ return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+ });
+ });
+ return;
+ }
+ callback(new Error("end of central directory record signature not found"));
+ });
+}
+
+util.inherits(ZipFile, EventEmitter);
+function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+ var self = this;
+ EventEmitter.call(self);
+ self.reader = reader;
+ // forward close events
+ self.reader.on("error", function(err) {
+ // error closing the fd
+ emitError(self, err);
+ });
+ self.reader.once("close", function() {
+ self.emit("close");
+ });
+ self.readEntryCursor = centralDirectoryOffset;
+ self.fileSize = fileSize;
+ self.entryCount = entryCount;
+ self.comment = comment;
+ self.entriesRead = 0;
+ self.autoClose = !!autoClose;
+ self.lazyEntries = !!lazyEntries;
+ self.decodeStrings = !!decodeStrings;
+ self.validateEntrySizes = !!validateEntrySizes;
+ self.strictFileNames = !!strictFileNames;
+ self.isOpen = true;
+ self.emittedError = false;
+
+ if (!self.lazyEntries) self._readEntry();
+}
+ZipFile.prototype.close = function() {
+ if (!this.isOpen) return;
+ this.isOpen = false;
+ this.reader.unref();
+};
+
+function emitErrorAndAutoClose(self, err) {
+ if (self.autoClose) self.close();
+ emitError(self, err);
+}
+function emitError(self, err) {
+ if (self.emittedError) return;
+ self.emittedError = true;
+ self.emit("error", err);
+}
+
+ZipFile.prototype.readEntry = function() {
+ if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
+ this._readEntry();
+};
+ZipFile.prototype._readEntry = function() {
+ var self = this;
+ if (self.entryCount === self.entriesRead) {
+ // done with metadata
+ setImmediate(function() {
+ if (self.autoClose) self.close();
+ if (self.emittedError) return;
+ self.emit("end");
+ });
+ return;
}
+ if (self.emittedError) return;
+ var buffer = newBuffer(46);
+ readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+ if (err) return emitErrorAndAutoClose(self, err);
+ if (self.emittedError) return;
+ var entry = new Entry();
+ // 0 - Central directory file header signature
+ var signature = buffer.readUInt32LE(0);
+ if (signature !== 0x02014b50) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+ // 4 - Version made by
+ entry.versionMadeBy = buffer.readUInt16LE(4);
+ // 6 - Version needed to extract (minimum)
+ entry.versionNeededToExtract = buffer.readUInt16LE(6);
+ // 8 - General purpose bit flag
+ entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+ // 10 - Compression method
+ entry.compressionMethod = buffer.readUInt16LE(10);
+ // 12 - File last modification time
+ entry.lastModFileTime = buffer.readUInt16LE(12);
+ // 14 - File last modification date
+ entry.lastModFileDate = buffer.readUInt16LE(14);
+ // 16 - CRC-32
+ entry.crc32 = buffer.readUInt32LE(16);
+ // 20 - Compressed size
+ entry.compressedSize = buffer.readUInt32LE(20);
+ // 24 - Uncompressed size
+ entry.uncompressedSize = buffer.readUInt32LE(24);
+ // 28 - File name length (n)
+ entry.fileNameLength = buffer.readUInt16LE(28);
+ // 30 - Extra field length (m)
+ entry.extraFieldLength = buffer.readUInt16LE(30);
+ // 32 - File comment length (k)
+ entry.fileCommentLength = buffer.readUInt16LE(32);
+ // 34 - Disk number where file starts
+ // 36 - Internal file attributes
+ entry.internalFileAttributes = buffer.readUInt16LE(36);
+ // 38 - External file attributes
+ entry.externalFileAttributes = buffer.readUInt32LE(38);
+ // 42 - Relative offset of local file header
+ entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
- /**
- * 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 (entry.generalPurposeBitFlag & 0x40) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
- if (n === this._buffers[0].length) return this._buffers.shift();
+ self.readEntryCursor += 46;
- if (n < this._buffers[0].length) {
- const buf = this._buffers[0];
- this._buffers[0] = new FastBuffer(
- buf.buffer,
- buf.byteOffset + n,
- buf.length - n
- );
+ buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+ readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+ if (err) return emitErrorAndAutoClose(self, err);
+ if (self.emittedError) return;
+ // 46 - File name
+ var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0;
+ entry.fileName = self.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8)
+ : buffer.slice(0, entry.fileNameLength);
+
+ // 46+n - Extra field
+ var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+ var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
+ entry.extraFields = [];
+ var i = 0;
+ while (i < extraFieldBuffer.length - 3) {
+ var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+ var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+ var dataStart = i + 4;
+ var dataEnd = dataStart + dataSize;
+ if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self, new Error("extra field length exceeds extra field buffer size"));
+ var dataBuffer = newBuffer(dataSize);
+ extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
+ entry.extraFields.push({
+ id: headerId,
+ data: dataBuffer,
+ });
+ i = dataEnd;
+ }
+
+ // 46+n+m - File comment
+ entry.fileComment = self.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8)
+ : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+ // compatibility hack for https://github.com/thejoshwolfe/yauzl/issues/47
+ entry.comment = entry.fileComment;
+
+ self.readEntryCursor += buffer.length;
+ self.entriesRead += 1;
+
+ if (entry.uncompressedSize === 0xffffffff ||
+ entry.compressedSize === 0xffffffff ||
+ entry.relativeOffsetOfLocalHeader === 0xffffffff) {
+ // ZIP64 format
+ // find the Zip64 Extended Information Extra Field
+ var zip64EiefBuffer = null;
+ for (var i = 0; i < entry.extraFields.length; i++) {
+ var extraField = entry.extraFields[i];
+ if (extraField.id === 0x0001) {
+ zip64EiefBuffer = extraField.data;
+ break;
+ }
+ }
+ if (zip64EiefBuffer == null) {
+ return emitErrorAndAutoClose(self, new Error("expected zip64 extended information extra field"));
+ }
+ var index = 0;
+ // 0 - Original Size 8 bytes
+ if (entry.uncompressedSize === 0xffffffff) {
+ if (index + 8 > zip64EiefBuffer.length) {
+ return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
+ }
+ entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+ index += 8;
+ }
+ // 8 - Compressed Size 8 bytes
+ if (entry.compressedSize === 0xffffffff) {
+ if (index + 8 > zip64EiefBuffer.length) {
+ return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
+ }
+ entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+ index += 8;
+ }
+ // 16 - Relative Header Offset 8 bytes
+ if (entry.relativeOffsetOfLocalHeader === 0xffffffff) {
+ if (index + 8 > zip64EiefBuffer.length) {
+ return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
+ }
+ entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+ index += 8;
+ }
+ // 24 - Disk Start Number 4 bytes
+ }
+
+ // check for Info-ZIP Unicode Path Extra Field (0x7075)
+ // see https://github.com/thejoshwolfe/yauzl/issues/33
+ if (self.decodeStrings) {
+ for (var i = 0; i < entry.extraFields.length; i++) {
+ var extraField = entry.extraFields[i];
+ if (extraField.id === 0x7075) {
+ if (extraField.data.length < 6) {
+ // too short to be meaningful
+ continue;
+ }
+ // Version 1 byte version of this extra field, currently 1
+ if (extraField.data.readUInt8(0) !== 1) {
+ // > Changes may not be backward compatible so this extra
+ // > field should not be used if the version is not recognized.
+ continue;
+ }
+ // NameCRC32 4 bytes File Name Field CRC32 Checksum
+ var oldNameCrc32 = extraField.data.readUInt32LE(1);
+ if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
+ // > If the CRC check fails, this UTF-8 Path Extra Field should be
+ // > ignored and the File Name field in the header should be used instead.
+ continue;
+ }
+ // UnicodeName Variable UTF-8 version of the entry File Name
+ entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
+ break;
+ }
+ }
+ }
+
+ // validate file size
+ if (self.validateEntrySizes && entry.compressionMethod === 0) {
+ var expectedCompressedSize = entry.uncompressedSize;
+ if (entry.isEncrypted()) {
+ // traditional encryption prefixes the file data with a header
+ expectedCompressedSize += 12;
+ }
+ if (entry.compressedSize !== expectedCompressedSize) {
+ var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+ return emitErrorAndAutoClose(self, new Error(msg));
+ }
+ }
+
+ if (self.decodeStrings) {
+ if (!self.strictFileNames) {
+ // allow backslash
+ entry.fileName = entry.fileName.replace(/\\/g, "/");
+ }
+ var errorMessage = validateFileName(entry.fileName, self.validateFileNameOptions);
+ if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
+ }
+ self.emit("entry", entry);
+
+ if (!self.lazyEntries) self._readEntry();
+ });
+ });
+};
+
+ZipFile.prototype.openReadStream = function(entry, options, callback) {
+ var self = this;
+ // parameter validation
+ var relativeStart = 0;
+ var relativeEnd = entry.compressedSize;
+ if (callback == null) {
+ callback = options;
+ options = {};
+ } else {
+ // validate options that the caller has no excuse to get wrong
+ if (options.decrypt != null) {
+ if (!entry.isEncrypted()) {
+ throw new Error("options.decrypt can only be specified for encrypted entries");
+ }
+ if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
+ if (entry.isCompressed()) {
+ if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
+ }
+ }
+ if (options.decompress != null) {
+ if (!entry.isCompressed()) {
+ throw new Error("options.decompress can only be specified for compressed entries");
+ }
+ if (!(options.decompress === false || options.decompress === true)) {
+ throw new Error("invalid options.decompress value: " + options.decompress);
+ }
+ }
+ if (options.start != null || options.end != null) {
+ if (entry.isCompressed() && options.decompress !== false) {
+ throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
+ }
+ if (entry.isEncrypted() && options.decrypt !== false) {
+ throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
+ }
+ }
+ if (options.start != null) {
+ relativeStart = options.start;
+ if (relativeStart < 0) throw new Error("options.start < 0");
+ if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
+ }
+ if (options.end != null) {
+ relativeEnd = options.end;
+ if (relativeEnd < 0) throw new Error("options.end < 0");
+ if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
+ if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
+ }
+ }
+ // any further errors can either be caused by the zipfile,
+ // or were introduced in a minor version of yauzl,
+ // so should be passed to the client rather than thrown.
+ if (!self.isOpen) return callback(new Error("closed"));
+ if (entry.isEncrypted()) {
+ if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+ }
+ // make sure we don't lose the fd before we open the actual read stream
+ self.reader.ref();
+ var buffer = newBuffer(30);
+ readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+ try {
+ if (err) return callback(err);
+ // 0 - Local file header signature = 0x04034b50
+ var signature = buffer.readUInt32LE(0);
+ if (signature !== 0x04034b50) {
+ return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+ }
+ // all this should be redundant
+ // 4 - Version needed to extract (minimum)
+ // 6 - General purpose bit flag
+ // 8 - Compression method
+ // 10 - File last modification time
+ // 12 - File last modification date
+ // 14 - CRC-32
+ // 18 - Compressed size
+ // 22 - Uncompressed size
+ // 26 - File name length (n)
+ var fileNameLength = buffer.readUInt16LE(26);
+ // 28 - Extra field length (m)
+ var extraFieldLength = buffer.readUInt16LE(28);
+ // 30 - File name
+ // 30+n - Extra field
+ var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+ var decompress;
+ if (entry.compressionMethod === 0) {
+ // 0 - The file is stored (no compression)
+ decompress = false;
+ } else if (entry.compressionMethod === 8) {
+ // 8 - The file is Deflated
+ decompress = options.decompress != null ? options.decompress : true;
+ } else {
+ return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+ }
+ var fileDataStart = localFileHeaderEnd;
+ var fileDataEnd = fileDataStart + entry.compressedSize;
+ if (entry.compressedSize !== 0) {
+ // bounds check now, because the read streams will probably not complain loud enough.
+ // since we're dealing with an unsigned offset plus an unsigned size,
+ // we only have 1 thing to check for.
+ if (fileDataEnd > self.fileSize) {
+ return callback(new Error("file data overflows file bounds: " +
+ fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+ }
+ }
+ var readStream = self.reader.createReadStream({
+ start: fileDataStart + relativeStart,
+ end: fileDataStart + relativeEnd,
+ });
+ var endpointStream = readStream;
+ if (decompress) {
+ var destroyed = false;
+ var inflateFilter = zlib.createInflateRaw();
+ readStream.on("error", function(err) {
+ // setImmediate here because errors can be emitted during the first call to pipe()
+ setImmediate(function() {
+ if (!destroyed) inflateFilter.emit("error", err);
+ });
+ });
+ readStream.pipe(inflateFilter);
- return new FastBuffer(buf.buffer, buf.byteOffset, n);
+ if (self.validateEntrySizes) {
+ endpointStream = new AssertByteCountStream(entry.uncompressedSize);
+ inflateFilter.on("error", function(err) {
+ // forward zlib errors to the client-visible stream
+ setImmediate(function() {
+ if (!destroyed) endpointStream.emit("error", err);
+ });
+ });
+ inflateFilter.pipe(endpointStream);
+ } else {
+ // the zlib filter is the client-visible stream
+ endpointStream = inflateFilter;
+ }
+ // this is part of yauzl's API, so implement this function on the client-visible stream
+ endpointStream.destroy = function() {
+ destroyed = true;
+ if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
+ readStream.unpipe(inflateFilter);
+ // TODO: the inflateFilter may cause a memory leak. see Issue #27.
+ readStream.destroy();
+ };
+ }
+ callback(null, endpointStream);
+ } finally {
+ self.reader.unref();
}
+ });
+};
- const dst = Buffer.allocUnsafe(n);
+function Entry() {
+}
+Entry.prototype.getLastModDate = function() {
+ return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
+};
+Entry.prototype.isEncrypted = function() {
+ return (this.generalPurposeBitFlag & 0x1) !== 0;
+};
+Entry.prototype.isCompressed = function() {
+ return this.compressionMethod === 8;
+};
- do {
- const buf = this._buffers[0];
- const offset = dst.length - n;
+function dosDateTimeToDate(date, time) {
+ var day = date & 0x1f; // 1-31
+ var month = (date >> 5 & 0xf) - 1; // 1-12, 0-11
+ var year = (date >> 9 & 0x7f) + 1980; // 0-128, 1980-2108
- if (n >= buf.length) {
- dst.set(this._buffers.shift(), offset);
- } else {
- dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
- this._buffers[0] = new FastBuffer(
- buf.buffer,
- buf.byteOffset + n,
- buf.length - n
- );
- }
+ var millisecond = 0;
+ var second = (time & 0x1f) * 2; // 0-29, 0-58 (even numbers)
+ var minute = time >> 5 & 0x3f; // 0-59
+ var hour = time >> 11 & 0x1f; // 0-23
- n -= buf.length;
- } while (n > 0);
+ return new Date(year, month, day, hour, minute, second, millisecond);
+}
- return dst;
+function validateFileName(fileName) {
+ if (fileName.indexOf("\\") !== -1) {
+ return "invalid characters in fileName: " + fileName;
}
-
- /**
- * 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();
+ if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+ return "absolute path: " + fileName;
+ }
+ if (fileName.split("/").indexOf("..") !== -1) {
+ return "invalid relative path: " + fileName;
}
+ // all good
+ return null;
+}
- /**
- * Reads the first two bytes of a frame.
- *
- * @param {Function} cb Callback
- * @private
- */
- getInfo(cb) {
- if (this._bufferedBytes < 2) {
- this._loop = false;
- return;
+function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+ if (length === 0) {
+ // fs.read will throw an out-of-bounds error if you try to read 0 bytes from a 0 byte file
+ return setImmediate(function() { callback(null, newBuffer(0)); });
+ }
+ reader.read(buffer, offset, length, position, function(err, bytesRead) {
+ if (err) return callback(err);
+ if (bytesRead < length) {
+ return callback(new Error("unexpected EOF"));
}
+ callback();
+ });
+}
- const buf = this.consume(2);
-
- if ((buf[0] & 0x30) !== 0x00) {
- const error = this.createError(
- RangeError,
- 'RSV2 and RSV3 must be clear',
- true,
- 1002,
- 'WS_ERR_UNEXPECTED_RSV_2_3'
- );
+util.inherits(AssertByteCountStream, Transform);
+function AssertByteCountStream(byteCount) {
+ Transform.call(this);
+ this.actualByteCount = 0;
+ this.expectedByteCount = byteCount;
+}
+AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+ this.actualByteCount += chunk.length;
+ if (this.actualByteCount > this.expectedByteCount) {
+ var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+ return cb(new Error(msg));
+ }
+ cb(null, chunk);
+};
+AssertByteCountStream.prototype._flush = function(cb) {
+ if (this.actualByteCount < this.expectedByteCount) {
+ var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+ return cb(new Error(msg));
+ }
+ cb();
+};
- cb(error);
- return;
- }
+util.inherits(RandomAccessReader, EventEmitter);
+function RandomAccessReader() {
+ EventEmitter.call(this);
+ this.refCount = 0;
+}
+RandomAccessReader.prototype.ref = function() {
+ this.refCount += 1;
+};
+RandomAccessReader.prototype.unref = function() {
+ var self = this;
+ self.refCount -= 1;
- const compressed = (buf[0] & 0x40) === 0x40;
+ if (self.refCount > 0) return;
+ if (self.refCount < 0) throw new Error("invalid unref");
- if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
- const error = this.createError(
- RangeError,
- 'RSV1 must be clear',
- true,
- 1002,
- 'WS_ERR_UNEXPECTED_RSV_1'
- );
+ self.close(onCloseDone);
- cb(error);
- return;
- }
+ function onCloseDone(err) {
+ if (err) return self.emit('error', err);
+ self.emit('close');
+ }
+};
+RandomAccessReader.prototype.createReadStream = function(options) {
+ var start = options.start;
+ var end = options.end;
+ if (start === end) {
+ var emptyStream = new PassThrough();
+ setImmediate(function() {
+ emptyStream.end();
+ });
+ return emptyStream;
+ }
+ var stream = this._readStreamForRange(start, end);
- this._fin = (buf[0] & 0x80) === 0x80;
- this._opcode = buf[0] & 0x0f;
- this._payloadLength = buf[1] & 0x7f;
+ var destroyed = false;
+ var refUnrefFilter = new RefUnrefFilter(this);
+ stream.on("error", function(err) {
+ setImmediate(function() {
+ if (!destroyed) refUnrefFilter.emit("error", err);
+ });
+ });
+ refUnrefFilter.destroy = function() {
+ stream.unpipe(refUnrefFilter);
+ refUnrefFilter.unref();
+ stream.destroy();
+ };
- if (this._opcode === 0x00) {
- if (compressed) {
- const error = this.createError(
- RangeError,
- 'RSV1 must be clear',
- true,
- 1002,
- 'WS_ERR_UNEXPECTED_RSV_1'
- );
+ var byteCounter = new AssertByteCountStream(end - start);
+ refUnrefFilter.on("error", function(err) {
+ setImmediate(function() {
+ if (!destroyed) byteCounter.emit("error", err);
+ });
+ });
+ byteCounter.destroy = function() {
+ destroyed = true;
+ refUnrefFilter.unpipe(byteCounter);
+ refUnrefFilter.destroy();
+ };
- cb(error);
- return;
- }
+ return stream.pipe(refUnrefFilter).pipe(byteCounter);
+};
+RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+ throw new Error("not implemented");
+};
+RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+ var readStream = this.createReadStream({start: position, end: position + length});
+ var writeStream = new Writable();
+ var written = 0;
+ writeStream._write = function(chunk, encoding, cb) {
+ chunk.copy(buffer, offset + written, 0, chunk.length);
+ written += chunk.length;
+ cb();
+ };
+ writeStream.on("finish", callback);
+ readStream.on("error", function(error) {
+ callback(error);
+ });
+ readStream.pipe(writeStream);
+};
+RandomAccessReader.prototype.close = function(callback) {
+ setImmediate(callback);
+};
- if (!this._fragmented) {
- const error = this.createError(
- RangeError,
- 'invalid opcode 0',
- true,
- 1002,
- 'WS_ERR_INVALID_OPCODE'
- );
+util.inherits(RefUnrefFilter, PassThrough);
+function RefUnrefFilter(context) {
+ PassThrough.call(this);
+ this.context = context;
+ this.context.ref();
+ this.unreffedYet = false;
+}
+RefUnrefFilter.prototype._flush = function(cb) {
+ this.unref();
+ cb();
+};
+RefUnrefFilter.prototype.unref = function(cb) {
+ if (this.unreffedYet) return;
+ this.unreffedYet = true;
+ this.context.unref();
+};
- cb(error);
- return;
- }
+var cp437 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
+function decodeBuffer(buffer, start, end, isUtf8) {
+ if (isUtf8) {
+ return buffer.toString("utf8", start, end);
+ } else {
+ var result = "";
+ for (var i = start; i < end; i++) {
+ result += cp437[buffer[i]];
+ }
+ return result;
+ }
+}
- this._opcode = this._fragmented;
- } else if (this._opcode === 0x01 || this._opcode === 0x02) {
- if (this._fragmented) {
- const error = this.createError(
- RangeError,
- `invalid opcode ${this._opcode}`,
- true,
- 1002,
- 'WS_ERR_INVALID_OPCODE'
- );
+function readUInt64LE(buffer, offset) {
+ // there is no native function for this, because we can't actually store 64-bit integers precisely.
+ // after 53 bits, JavaScript's Number type (IEEE 754 double) can't store individual integers anymore.
+ // but since 53 bits is a whole lot more than 32 bits, we do our best anyway.
+ var lower32 = buffer.readUInt32LE(offset);
+ var upper32 = buffer.readUInt32LE(offset + 4);
+ // we can't use bitshifting here, because JavaScript bitshifting only works on 32-bit integers.
+ return upper32 * 0x100000000 + lower32;
+ // as long as we're bounds checking the result of this function against the total file size,
+ // we'll catch any overflow errors, because we already made sure the total file size was within reason.
+}
- cb(error);
- return;
- }
+// Node 10 deprecated new Buffer().
+var newBuffer;
+if (typeof Buffer.allocUnsafe === "function") {
+ newBuffer = function(len) {
+ return Buffer.allocUnsafe(len);
+ };
+} else {
+ newBuffer = function(len) {
+ return new Buffer(len);
+ };
+}
- this._compressed = compressed;
- } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
- if (!this._fin) {
- const error = this.createError(
- RangeError,
- 'FIN must be set',
- true,
- 1002,
- 'WS_ERR_EXPECTED_FIN'
- );
+function defaultCallback(err) {
+ if (err) throw err;
+}
- cb(error);
- return;
- }
- if (compressed) {
- const error = this.createError(
- RangeError,
- 'RSV1 must be clear',
- true,
- 1002,
- 'WS_ERR_UNEXPECTED_RSV_1'
- );
+/***/ }),
- cb(error);
- return;
- }
+/***/ 41622:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- if (
- this._payloadLength > 0x7d ||
- (this._opcode === 0x08 && this._payloadLength === 1)
- ) {
- const error = this.createError(
- RangeError,
- `invalid payload length ${this._payloadLength}`,
- true,
- 1002,
- 'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
- );
+/**
+ * ZipStream
+ *
+ * @ignore
+ * @license [MIT]{@link https://github.com/archiverjs/node-zip-stream/blob/master/LICENSE}
+ * @copyright (c) 2014 Chris Talkington, contributors.
+ */
+var inherits = (__nccwpck_require__(39023).inherits);
- cb(error);
- return;
- }
- } else {
- const error = this.createError(
- RangeError,
- `invalid opcode ${this._opcode}`,
- true,
- 1002,
- 'WS_ERR_INVALID_OPCODE'
- );
+var ZipArchiveOutputStream = (__nccwpck_require__(47544).ZipArchiveOutputStream);
+var ZipArchiveEntry = (__nccwpck_require__(47544).ZipArchiveEntry);
- cb(error);
- return;
- }
+var util = __nccwpck_require__(53296);
- if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
- this._masked = (buf[1] & 0x80) === 0x80;
+/**
+ * @constructor
+ * @extends external:ZipArchiveOutputStream
+ * @param {Object} [options]
+ * @param {String} [options.comment] Sets the zip archive comment.
+ * @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
+ * @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
+ * @param {Boolean} [options.store=false] Sets the compression method to STORE.
+ * @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
+ * to control compression.
+ */
+var ZipStream = module.exports = function(options) {
+ if (!(this instanceof ZipStream)) {
+ return new ZipStream(options);
+ }
- if (this._isServer) {
- if (!this._masked) {
- const error = this.createError(
- RangeError,
- 'MASK must be set',
- true,
- 1002,
- 'WS_ERR_EXPECTED_MASK'
- );
+ options = this.options = options || {};
+ options.zlib = options.zlib || {};
- cb(error);
- return;
- }
- } else if (this._masked) {
- const error = this.createError(
- RangeError,
- 'MASK must be clear',
- true,
- 1002,
- 'WS_ERR_UNEXPECTED_MASK'
- );
+ ZipArchiveOutputStream.call(this, options);
- cb(error);
- return;
- }
+ if (typeof options.level === 'number' && options.level >= 0) {
+ options.zlib.level = options.level;
+ delete options.level;
+ }
- 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);
+ if (!options.forceZip64 && typeof options.zlib.level === 'number' && options.zlib.level === 0) {
+ options.store = true;
}
- /**
- * Gets extended payload length (7+16).
- *
- * @param {Function} cb Callback
- * @private
- */
- getPayloadLength16(cb) {
- if (this._bufferedBytes < 2) {
- this._loop = false;
- return;
- }
+ options.namePrependSlash = options.namePrependSlash || false;
- this._payloadLength = this.consume(2).readUInt16BE(0);
- this.haveLength(cb);
+ if (options.comment && options.comment.length > 0) {
+ this.setComment(options.comment);
}
+};
- /**
- * Gets extended payload length (7+64).
- *
- * @param {Function} cb Callback
- * @private
- */
- getPayloadLength64(cb) {
- if (this._bufferedBytes < 8) {
- this._loop = false;
- return;
- }
+inherits(ZipStream, ZipArchiveOutputStream);
- const buf = this.consume(8);
- const num = buf.readUInt32BE(0);
+/**
+ * Normalizes entry data with fallbacks for key properties.
+ *
+ * @private
+ * @param {Object} data
+ * @return {Object}
+ */
+ZipStream.prototype._normalizeFileData = function(data) {
+ data = util.defaults(data, {
+ type: 'file',
+ name: null,
+ namePrependSlash: this.options.namePrependSlash,
+ linkname: null,
+ date: null,
+ mode: null,
+ store: this.options.store,
+ comment: ''
+ });
- //
- // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
- // if payload length is greater than this number.
- //
- if (num > Math.pow(2, 53 - 32) - 1) {
- const error = this.createError(
- RangeError,
- 'Unsupported WebSocket frame: payload length > 2^53 - 1',
- false,
- 1009,
- 'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
- );
+ var isDir = data.type === 'directory';
+ var isSymlink = data.type === 'symlink';
- cb(error);
- return;
+ if (data.name) {
+ data.name = util.sanitizePath(data.name);
+
+ if (!isSymlink && data.name.slice(-1) === '/') {
+ isDir = true;
+ data.type = 'directory';
+ } else if (isDir) {
+ data.name += '/';
}
+ }
- this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
- this.haveLength(cb);
+ if (isDir || isSymlink) {
+ data.store = true;
}
- /**
- * Payload length has been read.
- *
- * @param {Function} cb Callback
- * @private
- */
- haveLength(cb) {
- if (this._payloadLength && this._opcode < 0x08) {
- this._totalPayloadLength += this._payloadLength;
- if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
- const error = this.createError(
- RangeError,
- 'Max payload size exceeded',
- false,
- 1009,
- 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
- );
+ data.date = util.dateify(data.date);
- cb(error);
- return;
- }
- }
+ return data;
+};
- if (this._masked) this._state = GET_MASK;
- else this._state = GET_DATA;
+/**
+ * Appends an entry given an input source (text string, buffer, or stream).
+ *
+ * @param {(Buffer|Stream|String)} source The input source.
+ * @param {Object} data
+ * @param {String} data.name Sets the entry name including internal path.
+ * @param {String} [data.comment] Sets the entry comment.
+ * @param {(String|Date)} [data.date=NOW()] Sets the entry date.
+ * @param {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
+ * @param {Boolean} [data.store=options.store] Sets the compression method to STORE.
+ * @param {String} [data.type=file] Sets the entry type. Defaults to `directory`
+ * if name ends with trailing slash.
+ * @param {Function} callback
+ * @return this
+ */
+ZipStream.prototype.entry = function(source, data, callback) {
+ if (typeof callback !== 'function') {
+ callback = this._emitErrorCallback.bind(this);
+ }
+
+ data = this._normalizeFileData(data);
+
+ if (data.type !== 'file' && data.type !== 'directory' && data.type !== 'symlink') {
+ callback(new Error(data.type + ' entries not currently supported'));
+ return;
}
- /**
- * Reads mask bytes.
- *
- * @private
- */
- getMask() {
- if (this._bufferedBytes < 4) {
- this._loop = false;
- return;
- }
-
- this._mask = this.consume(4);
- this._state = GET_DATA;
+ if (typeof data.name !== 'string' || data.name.length === 0) {
+ callback(new Error('entry name must be a non-empty string value'));
+ return;
}
- /**
- * Reads data bytes.
- *
- * @param {Function} cb Callback
- * @private
- */
- getData(cb) {
- let data = EMPTY_BUFFER;
+ if (data.type === 'symlink' && typeof data.linkname !== 'string') {
+ callback(new Error('entry linkname must be a non-empty string value when type equals symlink'));
+ return;
+ }
- if (this._payloadLength) {
- if (this._bufferedBytes < this._payloadLength) {
- this._loop = false;
- return;
- }
+ var entry = new ZipArchiveEntry(data.name);
+ entry.setTime(data.date, this.options.forceLocalTime);
- data = this.consume(this._payloadLength);
+ if (data.namePrependSlash) {
+ entry.setName(data.name, true);
+ }
- if (
- this._masked &&
- (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0
- ) {
- unmask(data, this._mask);
- }
- }
+ if (data.store) {
+ entry.setMethod(0);
+ }
- if (this._opcode > 0x07) {
- this.controlMessage(data, cb);
- return;
- }
+ if (data.comment.length > 0) {
+ entry.setComment(data.comment);
+ }
- if (this._compressed) {
- this._state = INFLATING;
- this.decompress(data, cb);
- return;
- }
+ if (data.type === 'symlink' && typeof data.mode !== 'number') {
+ data.mode = 40960; // 0120000
+ }
- if (data.length) {
- //
- // This message is not compressed so its length is the sum of the payload
- // length of all fragments.
- //
- this._messageLength = this._totalPayloadLength;
- this._fragments.push(data);
+ if (typeof data.mode === 'number') {
+ if (data.type === 'symlink') {
+ data.mode |= 40960;
}
- this.dataMessage(cb);
+ entry.setUnixMode(data.mode);
}
- /**
- * Decompresses data.
- *
- * @param {Buffer} data Compressed data
- * @param {Function} cb Callback
- * @private
- */
- decompress(data, cb) {
- const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ if (data.type === 'symlink' && typeof data.linkname === 'string') {
+ source = Buffer.from(data.linkname);
+ }
- perMessageDeflate.decompress(data, this._fin, (err, buf) => {
- if (err) return cb(err);
+ return ZipArchiveOutputStream.prototype.entry.call(this, entry, source, callback);
+};
- if (buf.length) {
- this._messageLength += buf.length;
- if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
- const error = this.createError(
- RangeError,
- 'Max payload size exceeded',
- false,
- 1009,
- 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
- );
+/**
+ * Finalizes the instance and prevents further appending to the archive
+ * structure (queue will continue til drained).
+ *
+ * @return void
+ */
+ZipStream.prototype.finalize = function() {
+ this.finish();
+};
- cb(error);
- return;
- }
+/**
+ * Returns the current number of bytes written to this stream.
+ * @function ZipStream#getBytesWritten
+ * @returns {Number}
+ */
- this._fragments.push(buf);
- }
+/**
+ * Compress Commons ZipArchiveOutputStream
+ * @external ZipArchiveOutputStream
+ * @see {@link https://github.com/archiverjs/node-compress-commons}
+ */
- 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;
+/***/ 79407:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
- this._totalPayloadLength = 0;
- this._messageLength = 0;
- this._fragmented = 0;
- this._fragments = [];
+"use strict";
- if (this._opcode === 2) {
- let data;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/**
+ * The entrypoint for the action.
+ */
+const main_1 = __nccwpck_require__(41730);
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+(0, main_1.run)();
- 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 buf = concat(fragments, messageLength);
+/***/ }),
- if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
- const error = this.createError(
- Error,
- 'invalid UTF-8 sequence',
- true,
- 1007,
- 'WS_ERR_INVALID_UTF8'
- );
+/***/ 41730:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
- cb(error);
- return;
- }
+"use strict";
- if (this._state === INFLATING || this._allowSynchronousEvents) {
- this.emit('message', buf, false);
- this._state = GET_INFO;
- } else {
- this._state = DEFER_EVENT;
- setImmediate(() => {
- this.emit('message', buf, false);
- this._state = GET_INFO;
- this.startLoop(cb);
- });
- }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) 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]; } };
}
- }
-
- /**
- * Handles a control message.
- *
- * @param {Buffer} data Data to handle
- * @return {(Error|RangeError|undefined)} A possible error
- * @private
- */
- controlMessage(data, cb) {
- if (this._opcode === 0x08) {
- 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 error = this.createError(
- RangeError,
- `invalid status code ${code}`,
- true,
- 1002,
- 'WS_ERR_INVALID_CLOSE_CODE'
- );
-
- cb(error);
- return;
+ Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+ var ownKeys = function(o) {
+ ownKeys = Object.getOwnPropertyNames || function (o) {
+ var ar = [];
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o);
+ };
+ return function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+ __setModuleDefault(result, mod);
+ return result;
+ };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.run = run;
+const core = __importStar(__nccwpck_require__(37484));
+const puppeteer_1 = __importDefault(__nccwpck_require__(57699));
+const form_data_1 = __importDefault(__nccwpck_require__(96454));
+const axios_1 = __importDefault(__nccwpck_require__(87269));
+const fs_1 = __nccwpck_require__(79896);
+const path_1 = __nccwpck_require__(16928);
+const utils_1 = __nccwpck_require__(71798);
+/**
+ * The main function for the action.
+ * @returns {Promise} Resolves when the action is complete.
+ */
+async function run() {
+ await (0, utils_1.preparePuppeteer)();
+ const browser = await puppeteer_1.default.launch({
+ headless: true,
+ args: ['--no-sandbox', '--disable-setuid-sandbox']
+ });
+ const page = await browser.newPage();
+ try {
+ let assetId = core.getInput('assetId');
+ let assetName = core.getInput('assetName');
+ let zipPath = core.getInput('zipPath');
+ const makeZip = core.getInput('makeZip').toLowerCase() === 'true';
+ const chunkSize = parseInt(core.getInput('chunkSize'));
+ const maxRetries = parseInt(core.getInput('maxRetries'));
+ if (isNaN(chunkSize)) {
+ throw new Error('Invalid chunk size. Must be a number.');
}
-
- const buf = new FastBuffer(
- data.buffer,
- data.byteOffset + 2,
- data.length - 2
- );
-
- if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
- const error = this.createError(
- Error,
- 'invalid UTF-8 sequence',
- true,
- 1007,
- 'WS_ERR_INVALID_UTF8'
- );
-
- cb(error);
- return;
+ if (isNaN(maxRetries)) {
+ throw new Error('Invalid max retries. Must be a number.');
+ }
+ // No asset id or name provided, using the repository name
+ if (!assetId && !assetName) {
+ core.debug('No asset id or name provided, using repository name...');
+ assetName = (0, path_1.basename)((0, utils_1.getEnv)('GITHUB_WORKSPACE'));
+ }
+ const redirectUrl = await getRedirectUrl(page, maxRetries);
+ await setForumCookie(browser, page);
+ await page.goto(redirectUrl, {
+ waitUntil: 'networkidle0'
+ });
+ if (page.url().includes('portal.cfx.re')) {
+ core.info('Redirected to CFX Portal. Uploading file ...');
+ const cookies = await getCookies(browser);
+ if (assetName) {
+ assetId = await (0, utils_1.resolveAssetId)(assetName, cookies);
+ }
+ zipPath = await getZipPath(zipPath, makeZip);
+ await uploadZip(zipPath, assetId, chunkSize, cookies);
+ }
+ else {
+ throw new Error('Redirect failed. Make sure the provided Cookie is valid.');
}
-
- this._loop = false;
- this.emit('conclude', code, buf);
- this.end();
- }
-
- this._state = GET_INFO;
- return;
}
-
- if (this._allowSynchronousEvents) {
- this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
- this._state = GET_INFO;
- } else {
- this._state = DEFER_EVENT;
- setImmediate(() => {
- this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
- this._state = GET_INFO;
- this.startLoop(cb);
- });
+ catch (error) {
+ if (error instanceof Error) {
+ core.setFailed(error.message);
+ }
+ }
+ finally {
+ await browser.close();
}
- }
-
- /**
- * 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;
+/**
+ * Navigates to the SSO URL and waits for the page to load.
+ * If the navigation fails, it will retry up to `maxRetries` times.
+ * @param page
+ * @param maxRetries
+ * @returns {Promise} The redirect URL.
+ * @throws If the navigation fails after `maxRetries` attempts.
+ */
+async function getRedirectUrl(page, maxRetries) {
+ let loaded = false;
+ let attempt = 0;
+ let redirectUrl = null;
+ while (!loaded && attempt < maxRetries) {
+ try {
+ core.info('Navigating to SSO URL ...');
+ await page.goto((0, utils_1.getUrl)('SSO'), {
+ waitUntil: 'networkidle0'
+ });
+ core.info('Navigated to SSO URL. Parsing response body ...');
+ const responseBody = await page.evaluate(() => JSON.parse(document.body.innerText));
+ core.debug('Parsed response body.');
+ redirectUrl = responseBody.url;
+ core.info('Redirected to Forum Origin ...');
+ const forumUrl = new URL(redirectUrl).origin;
+ await page.goto(forumUrl);
+ loaded = true;
+ }
+ catch {
+ core.info(`Failed to navigate to SSO URL. Retrying in 1 seconds...`);
+ await new Promise(resolve => setTimeout(resolve, 1000));
+ attempt++;
+ }
+ }
+ if (!loaded || redirectUrl == null) {
+ throw new Error(`Failed to navigate to SSO URL after ${maxRetries} attempts.`);
+ }
+ return redirectUrl;
+}
+/**
+ * Sets the cookie for the cfx.re login.
+ * @param browser
+ * @param page
+ * @returns {Promise} Resolves when the cookie has been set.
+ */
+async function setForumCookie(browser, page) {
+ core.info('Setting cookies ...');
+ await browser.setCookie({
+ name: '_t',
+ value: core.getInput('cookie'),
+ domain: 'forum.cfx.re',
+ path: '/',
+ expires: -1,
+ size: 1,
+ httpOnly: true,
+ secure: true,
+ session: false
+ });
+ await page.evaluate(() => document.write('Cookie' + document.cookie));
+ core.info('Cookies set. Following redirect...');
+}
+/**
+ * Gets the cookies from the browser.
+ * @param browser
+ * @returns {Promise} Resolves with the cookies as a string.
+ */
+async function getCookies(browser) {
+ return await browser
+ .cookies()
+ .then(cookies => cookies.map(cookie => `${cookie.name}=${cookie.value}`).join('; '));
+}
+/**
+ * Retrieves the zipPath or creates a zip based on the provided parameters.
+ * @param zipPath - The path to the zip file.
+ * @param makeZip - Flag indicating whether to create a zip file.
+ * @returns {Promise} Resolves with the path to the zip file.
+ * @throws If neither zipPath nor makeZip is provided, or if the pre-zip command fails.
+ */
+async function getZipPath(zipPath, makeZip) {
+ core.debug('Zip path: ' + JSON.stringify(zipPath));
+ if (zipPath.length > 0) {
+ core.debug('Using provided zip path.');
+ return zipPath;
+ }
+ if (!makeZip && zipPath.length == 0) {
+ throw new Error('Either zipPath or makeZip must be provided to upload a file.');
+ }
+ core.info('Creating zip file ...');
+ // Clean up github things before zipping
+ (0, utils_1.deleteIfExists)('.git/');
+ (0, utils_1.deleteIfExists)('.github/');
+ (0, utils_1.deleteIfExists)('.vscode/');
+ return (0, utils_1.zipAsset)();
+}
+/**
+ * Starts the re-upload process by uploading the asset in chunks.
+ * @param zipPath
+ * @param assetId
+ * @param chunkSize
+ * @param cookies
+ * @returns {Promise} Resolves when the re-upload process is initiated successfully.
+ * @throws If the re-upload fails due to errors in the response.
+ */
+async function startReupload(zipPath, assetId, chunkSize, cookies) {
+ const stats = (0, fs_1.statSync)(zipPath);
+ const totalSize = stats.size;
+ const originalFileName = (0, path_1.basename)(zipPath);
+ const chunkCount = Math.ceil(totalSize / chunkSize);
+ core.info('Starting upload ...');
+ core.debug(`Total size: ${totalSize}`);
+ core.debug(`Original file name: ${originalFileName}`);
+ core.debug(`Chunk size: ${chunkSize}`);
+ core.debug(`Chunk count: ${chunkCount}`);
+ const reUploadReponse = await axios_1.default.post((0, utils_1.getUrl)('REUPLOAD', assetId), {
+ chunk_count: chunkCount,
+ chunk_size: chunkSize,
+ name: originalFileName,
+ original_file_name: originalFileName,
+ total_size: totalSize
+ }, {
+ headers: {
+ Cookie: cookies
+ }
+ });
+ if (reUploadReponse.data.errors !== null) {
+ core.debug(JSON.stringify(reUploadReponse.data.errors));
+ throw new Error('Failed to re-upload file. See debug logs for more information.');
+ }
+}
+/**
+ * Uploads a zip file in chunks to the specified asset.
+ * @param zipPath
+ * @param assetId
+ * @param chunkSize.
+ * @param cookies
+ * @returns {Promise} Resolves when the upload is complete.
+ * @throws If the upload fails at any stage.
+ */
+async function uploadZip(zipPath, assetId, chunkSize, cookies) {
+ await startReupload(zipPath, assetId, chunkSize, cookies);
+ let chunkIndex = 0;
+ const stats = (0, fs_1.statSync)(zipPath);
+ const totalSize = stats.size;
+ const chunkCount = Math.ceil(totalSize / chunkSize);
+ const stream = (0, fs_1.createReadStream)(zipPath, { highWaterMark: chunkSize });
+ for await (const chunk of stream) {
+ const form = new form_data_1.default();
+ form.append('chunk_id', chunkIndex);
+ form.append('chunk', chunk, {
+ filename: 'blob',
+ contentType: 'application/octet-stream'
+ });
+ await axios_1.default.post((0, utils_1.getUrl)('UPLOAD_CHUNK', assetId), form, {
+ headers: {
+ ...form.getHeaders(),
+ Cookie: cookies
+ }
+ });
+ core.info(`Uploaded chunk ${chunkIndex + 1}/${chunkCount}`);
+ chunkIndex++;
+ }
+ await completeUpload(assetId, cookies);
+}
+/**
+ * Completes the upload process.
+ * @param assetId
+ * @param cookies
+ * @returns {Promise} Resolves when the upload is complete.
+ */
+async function completeUpload(assetId, cookies) {
+ await axios_1.default.post((0, utils_1.getUrl)('COMPLETE_UPLOAD', assetId), {}, {
+ headers: {
+ Cookie: cookies
+ }
+ });
+ core.info('Upload completed.');
+}
/***/ }),
-/***/ 7389:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 38522:
+/***/ ((__unused_webpack_module, exports) => {
"use strict";
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Urls = void 0;
+var Urls;
+(function (Urls) {
+ Urls["API"] = "https://portal-api.cfx.re/v1/";
+ Urls["SSO"] = "auth/discourse?return=";
+ Urls["REUPLOAD"] = "assets/{id}/re-upload";
+ Urls["UPLOAD_CHUNK"] = "assets/{id}/upload-chunk";
+ Urls["COMPLETE_UPLOAD"] = "assets/{id}/complete-upload";
+})(Urls || (exports.Urls = Urls = {}));
-const { Duplex } = __nccwpck_require__(2203);
-const { randomFillSync } = __nccwpck_require__(76982);
-
-const PerMessageDeflate = __nccwpck_require__(4376);
-const { EMPTY_BUFFER, kWebSocket, NOOP } = __nccwpck_require__(71791);
-const { isBlob, isValidStatusCode } = __nccwpck_require__(26615);
-const { mask: applyMask, toBuffer } = __nccwpck_require__(95803);
-
-const kByteLength = Symbol('kByteLength');
-const maskBuffer = Buffer.alloc(4);
-const RANDOM_POOL_SIZE = 8 * 1024;
-let randomPool;
-let randomPoolPointer = RANDOM_POOL_SIZE;
+/***/ }),
-const DEFAULT = 0;
-const DEFLATING = 1;
-const GET_BLOB_DATA = 2;
+/***/ 71798:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
-/**
- * HyBi Sender implementation.
- */
-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 || {};
+"use strict";
- if (generateMask) {
- this._generateMask = generateMask;
- this._maskBuffer = Buffer.alloc(4);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) 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]; } };
}
-
- this._socket = socket;
-
- this._firstFragment = true;
- this._compress = false;
-
- this._bufferedBytes = 0;
- this._queue = [];
- this._state = DEFAULT;
- this.onerror = NOOP;
- this[kWebSocket] = undefined;
- }
-
- /**
- * 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 merge = 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) {
- /* istanbul ignore else */
- if (randomPool === undefined) {
- //
- // This is lazily initialized because server-sent frames must not
- // be masked so it may never be used.
- //
- randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
- }
-
- randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
- randomPoolPointer = 0;
+ Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+ var ownKeys = function(o) {
+ ownKeys = Object.getOwnPropertyNames || function (o) {
+ var ar = [];
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o);
+ };
+ return function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+ __setModuleDefault(result, mod);
+ return result;
+ };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.preparePuppeteer = preparePuppeteer;
+exports.resolveAssetId = resolveAssetId;
+exports.getUrl = getUrl;
+exports.getEnv = getEnv;
+exports.zipAsset = zipAsset;
+exports.deleteIfExists = deleteIfExists;
+const core = __importStar(__nccwpck_require__(37484));
+const axios_1 = __importDefault(__nccwpck_require__(87269));
+const types_1 = __nccwpck_require__(38522);
+const fs_1 = __importDefault(__nccwpck_require__(79896));
+const archiver_1 = __importDefault(__nccwpck_require__(99392));
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const browsers_1 = __nccwpck_require__(73403);
+const CACHE_DIR = '/home/runner/.cache/puppeteer';
+/**
+ * Prepare the Puppeteer environment by installing the necessary browser.
+ * @returns {Promise} Resolves when the environment is prepared.
+ */
+async function preparePuppeteer() {
+ if (process.env.RUNNER_TEMP === undefined) {
+ core.info('Running locally, skipping Puppeteer setup ...');
+ return;
+ }
+ const installed = await (0, browsers_1.getInstalledBrowsers)({
+ cacheDir: CACHE_DIR
+ });
+ if (!installed.some(browser => browser.browser === browsers_1.Browser.CHROME)) {
+ core.info('Installing Chrome ...');
+ await (0, browsers_1.install)({
+ cacheDir: CACHE_DIR,
+ browser: browsers_1.Browser.CHROME,
+ buildId: '131.0.6778.108'
+ });
+ }
+}
+async function resolveAssetId(name, cookies) {
+ core.debug(`Searching asset id for ${name}...`);
+ const search = await axios_1.default.get(`https://portal-api.cfx.re/v1/me/assets?search=${name}&sort=asset.name&direction=asc`, {
+ headers: {
+ Cookie: cookies
}
-
- 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;
+ });
+ if (search.data.items.length == 0) {
+ core.debug(JSON.stringify(search.data));
+ throw new Error(`Failed to find asset id for "${name}". See debug logs for more information.`);
}
-
- let dataLength;
-
- if (typeof data === 'string') {
- if (
- (!options.mask || skipMasking) &&
- options[kByteLength] !== undefined
- ) {
- dataLength = options[kByteLength];
- } else {
- data = Buffer.from(data);
- dataLength = data.length;
- }
- } else {
- dataLength = data.length;
- merge = options.mask && options.readOnly && !skipMasking;
+ // Match the exact name
+ for (const asset of search.data.items) {
+ if (asset.name == name) {
+ core.debug('Found asset id: ' + asset.id);
+ return asset.id.toString();
+ }
}
-
- let payloadLength = dataLength;
-
- if (dataLength >= 65536) {
- offset += 8;
- payloadLength = 127;
- } else if (dataLength > 125) {
- offset += 2;
- payloadLength = 126;
+ core.debug(JSON.stringify(search.data));
+ throw new Error(`Failed to find asset id for "${name}" exact match. See debug logs for more information.`);
+}
+function getUrl(type, id) {
+ const url = types_1.Urls.API + types_1.Urls[type];
+ return id ? url.replace('{id}', id) : url;
+}
+function buildTree(currentPath) {
+ const stats = fs_1.default.statSync(currentPath);
+ if (stats.isFile()) {
+ return path_1.default.basename(currentPath); // Return file name
}
-
- const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
-
- target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
- if (options.rsv1) target[0] |= 0x40;
-
- 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 (stats.isDirectory()) {
+ const children = fs_1.default.readdirSync(currentPath);
+ return {
+ [path_1.default.basename(currentPath)]: children.map(child => buildTree(path_1.default.join(currentPath, child)))
+ };
}
+ return null;
+}
+function getEnv(name) {
+ if (process.env[name] === undefined) {
+ throw new Error(`Environment variable ${name} is not set.`);
+ }
+ return process.env[name];
+}
+async function zipAsset() {
+ core.debug('Zipping asset...');
+ const _path = getEnv('GITHUB_WORKSPACE');
+ const output = fs_1.default.createWriteStream('cfx-portal-upload.zip');
+ const archive = (0, archiver_1.default)('zip', {
+ zlib: { level: 9 }
+ });
+ archive.pipe(output);
+ core.debug('Adding files to zip...');
+ archive.directory(_path, false);
+ core.debug('Zip content: ' + JSON.stringify(buildTree(_path), null, 2));
+ await archive.finalize();
+ return path_1.default.resolve('cfx-portal-upload.zip');
+}
+function deleteIfExists(_path) {
+ _path = path_1.default.join(getEnv('GITHUB_WORKSPACE'), _path);
+ try {
+ if (fs_1.default.existsSync(_path)) {
+ core.debug(`Deleting ${_path}...`);
+ const stats = fs_1.default.lstatSync(_path);
+ if (stats.isDirectory()) {
+ fs_1.default.rmSync(_path, { recursive: true, force: true });
+ }
+ else if (stats.isFile()) {
+ fs_1.default.unlinkSync(_path);
+ }
+ }
+ else {
+ core.debug(`${_path} does not exist, skipping`);
+ }
+ }
+ catch (error) {
+ core.debug(`Skipping ${_path} deletion due to error: ${error}`);
+ }
+}
- if (!options.mask) return [target, data];
-
- target[1] |= 0x80;
- 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 (merge) {
- applyMask(data, mask, target, offset, dataLength);
- return [target];
- }
+/***/ 18327:
+/***/ ((module) => {
- applyMask(data, mask, data, 0, dataLength);
- return [target, data];
- }
+module.exports = eval("require")("bufferutil");
- /**
- * 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 buf;
- if (code === undefined) {
- buf = EMPTY_BUFFER;
- } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
- throw new TypeError('First argument must be a valid error code number');
- } else if (data === undefined || !data.length) {
- buf = Buffer.allocUnsafe(2);
- buf.writeUInt16BE(code, 0);
- } else {
- const length = Buffer.byteLength(data);
+/***/ }),
- if (length > 123) {
- throw new RangeError('The message must not be greater than 123 bytes');
- }
+/***/ 62414:
+/***/ ((module) => {
- buf = Buffer.allocUnsafe(2 + length);
- buf.writeUInt16BE(code, 0);
+module.exports = eval("require")("utf-8-validate");
- if (typeof data === 'string') {
- buf.write(data, 2);
- } else {
- buf.set(data, 2);
- }
- }
- const options = {
- [kByteLength]: buf.length,
- fin: true,
- generateMask: this._generateMask,
- mask,
- maskBuffer: this._maskBuffer,
- opcode: 0x08,
- readOnly: false,
- rsv1: false
- };
+/***/ }),
- if (this._state !== DEFAULT) {
- this.enqueue([this.dispatch, buf, false, options, cb]);
- } else {
- this.sendFrame(Sender.frame(buf, options), cb);
- }
- }
+/***/ 51456:
+/***/ ((module) => {
- /**
- * 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;
+function webpackEmptyAsyncContext(req) {
+ // Here Promise.resolve().then() is used instead of new Promise() to prevent
+ // uncaught exception popping up in devtools
+ return Promise.resolve().then(() => {
+ var e = new Error("Cannot find module '" + req + "'");
+ e.code = 'MODULE_NOT_FOUND';
+ throw e;
+ });
+}
+webpackEmptyAsyncContext.keys = () => ([]);
+webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
+webpackEmptyAsyncContext.id = 51456;
+module.exports = webpackEmptyAsyncContext;
- 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');
- }
+/***/ 31421:
+/***/ ((module) => {
- const options = {
- [kByteLength]: byteLength,
- fin: true,
- generateMask: this._generateMask,
- mask,
- maskBuffer: this._maskBuffer,
- opcode: 0x09,
- readOnly,
- rsv1: false
- };
+function webpackEmptyContext(req) {
+ var e = new Error("Cannot find module '" + req + "'");
+ e.code = 'MODULE_NOT_FOUND';
+ throw e;
+}
+webpackEmptyContext.keys = () => ([]);
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = 31421;
+module.exports = webpackEmptyContext;
- 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;
+/***/ 84655:
+/***/ ((module) => {
- 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;
- }
+function webpackEmptyContext(req) {
+ var e = new Error("Cannot find module '" + req + "'");
+ e.code = 'MODULE_NOT_FOUND';
+ throw e;
+}
+webpackEmptyContext.keys = () => ([]);
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = 84655;
+module.exports = webpackEmptyContext;
- 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: 0x0a,
- readOnly,
- rsv1: false
- };
+/***/ 91500:
+/***/ ((module) => {
- 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);
- }
- }
+function webpackEmptyContext(req) {
+ var e = new Error("Cannot find module '" + req + "'");
+ e.code = 'MODULE_NOT_FOUND';
+ throw e;
+}
+webpackEmptyContext.keys = () => ([]);
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = 91500;
+module.exports = webpackEmptyContext;
- /**
- * 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;
+/***/ 42613:
+/***/ ((module) => {
- 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;
- }
+"use strict";
+module.exports = require("assert");
- 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;
+/***/ 90290:
+/***/ ((module) => {
- const opts = {
- [kByteLength]: byteLength,
- fin: options.fin,
- generateMask: this._generateMask,
- mask: options.mask,
- maskBuffer: this._maskBuffer,
- opcode,
- readOnly,
- rsv1
- };
+"use strict";
+module.exports = require("async_hooks");
- 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;
+/***/ 20181:
+/***/ ((module) => {
- blob
- .arrayBuffer()
- .then((arrayBuffer) => {
- if (this._socket.destroyed) {
- const err = new Error(
- 'The socket was closed while the blob was being read'
- );
+"use strict";
+module.exports = require("buffer");
- //
- // `callCallbacks` is called in the next tick to ensure that errors
- // that might be thrown in the callbacks behave like errors thrown
- // outside the promise chain.
- //
- process.nextTick(callCallbacks, this, err, cb);
- return;
- }
+/***/ }),
- this._bufferedBytes -= options[kByteLength];
- const data = toBuffer(arrayBuffer);
+/***/ 35317:
+/***/ ((module) => {
- if (!compress) {
- this._state = DEFAULT;
- this.sendFrame(Sender.frame(data, options), cb);
- this.dequeue();
- } else {
- this.dispatch(data, compress, options, cb);
- }
- })
- .catch((err) => {
- //
- // `onError` is called in the next tick for the same reason that
- // `callCallbacks` above is.
- //
- process.nextTick(onError, this, err, cb);
- });
- }
+"use strict";
+module.exports = require("child_process");
- /**
- * 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];
+/***/ 64236:
+/***/ ((module) => {
- this._bufferedBytes += options[kByteLength];
- this._state = DEFLATING;
- perMessageDeflate.compress(data, options.fin, (_, buf) => {
- if (this._socket.destroyed) {
- const err = new Error(
- 'The socket was closed while data was being compressed'
- );
+"use strict";
+module.exports = require("console");
- callCallbacks(this, err, cb);
- return;
- }
+/***/ }),
- this._bufferedBytes -= options[kByteLength];
- this._state = DEFAULT;
- options.readOnly = false;
- this.sendFrame(Sender.frame(buf, options), cb);
- this.dequeue();
- });
- }
+/***/ 49140:
+/***/ ((module) => {
- /**
- * Executes queued send operations.
- *
- * @private
- */
- dequeue() {
- while (this._state === DEFAULT && this._queue.length) {
- const params = this._queue.shift();
+"use strict";
+module.exports = require("constants");
- 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);
- }
+/***/ 76982:
+/***/ ((module) => {
- /**
- * Sends a frame.
- *
- * @param {Buffer[]} 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);
- }
- }
-}
+"use strict";
+module.exports = require("crypto");
-module.exports = Sender;
+/***/ }),
-/**
- * Calls queued callbacks with an error.
- *
- * @param {Sender} sender The `Sender` instance
- * @param {Error} err The error to call the callbacks with
- * @param {Function} [cb] The first callback
- * @private
- */
-function callCallbacks(sender, err, cb) {
- if (typeof cb === 'function') cb(err);
+/***/ 31637:
+/***/ ((module) => {
- for (let i = 0; i < sender._queue.length; i++) {
- const params = sender._queue[i];
- const callback = params[params.length - 1];
+"use strict";
+module.exports = require("diagnostics_channel");
- if (typeof callback === 'function') callback(err);
- }
-}
+/***/ }),
-/**
- * Handles a `Sender` error.
- *
- * @param {Sender} sender The `Sender` instance
- * @param {Error} err The error
- * @param {Function} [cb] The first pending callback
- * @private
- */
-function onError(sender, err, cb) {
- callCallbacks(sender, err, cb);
- sender.onerror(err);
-}
+/***/ 72250:
+/***/ ((module) => {
+"use strict";
+module.exports = require("dns");
/***/ }),
-/***/ 86412:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 24434:
+/***/ ((module) => {
"use strict";
+module.exports = require("events");
+/***/ }),
-const { Duplex } = __nccwpck_require__(2203);
+/***/ 79896:
+/***/ ((module) => {
-/**
- * Emits the `'close'` event on a stream.
- *
- * @param {Duplex} stream The stream.
- * @private
- */
-function emitClose(stream) {
- stream.emit('close');
-}
+"use strict";
+module.exports = require("fs");
-/**
- * The listener of the `'end'` event.
- *
- * @private
- */
-function duplexOnEnd() {
- if (!this.destroyed && this._writableState.finished) {
- this.destroy();
- }
-}
+/***/ }),
-/**
- * The listener of the `'error'` event.
- *
- * @param {Error} err The error
- * @private
- */
-function duplexOnError(err) {
- this.removeListener('error', duplexOnError);
- this.destroy();
- if (this.listenerCount('error') === 0) {
- // Do not suppress the throwing behavior.
- this.emit('error', err);
- }
-}
+/***/ 91943:
+/***/ ((module) => {
-/**
- * Wraps a `WebSocket` in a duplex stream.
- *
- * @param {WebSocket} ws The `WebSocket` to wrap
- * @param {Object} [options] The options for the `Duplex` constructor
- * @return {Duplex} The duplex stream
- * @public
- */
-function createWebSocketStream(ws, options) {
- let terminateOnDestroy = true;
+"use strict";
+module.exports = require("fs/promises");
- const duplex = new Duplex({
- ...options,
- autoDestroy: false,
- emitClose: false,
- objectMode: false,
- writableObjectMode: false
- });
+/***/ }),
- ws.on('message', function message(msg, isBinary) {
- const data =
- !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+/***/ 58611:
+/***/ ((module) => {
- if (!duplex.push(data)) ws.pause();
- });
+"use strict";
+module.exports = require("http");
- ws.once('error', function error(err) {
- if (duplex.destroyed) return;
+/***/ }),
- // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
- //
- // - If the `'error'` event is emitted before the `'open'` event, then
- // `ws.terminate()` is a noop as no socket is assigned.
- // - Otherwise, the error is re-emitted by the listener of the `'error'`
- // event of the `Receiver` object. The listener already closes the
- // connection by calling `ws.close()`. This allows a close frame to be
- // sent to the other peer. If `ws.terminate()` is called right after this,
- // then the close frame might not be sent.
- terminateOnDestroy = false;
- duplex.destroy(err);
- });
+/***/ 85675:
+/***/ ((module) => {
- ws.once('close', function close() {
- if (duplex.destroyed) return;
+"use strict";
+module.exports = require("http2");
- duplex.push(null);
- });
+/***/ }),
- duplex._destroy = function (err, callback) {
- if (ws.readyState === ws.CLOSED) {
- callback(err);
- process.nextTick(emitClose, duplex);
- return;
- }
+/***/ 65692:
+/***/ ((module) => {
- let called = false;
+"use strict";
+module.exports = require("https");
- ws.once('error', function error(err) {
- called = true;
- callback(err);
- });
+/***/ }),
- ws.once('close', function close() {
- if (!called) callback(err);
- process.nextTick(emitClose, duplex);
- });
+/***/ 50264:
+/***/ ((module) => {
- if (terminateOnDestroy) ws.terminate();
- };
+"use strict";
+module.exports = require("inspector");
- duplex._final = function (callback) {
- if (ws.readyState === ws.CONNECTING) {
- ws.once('open', function open() {
- duplex._final(callback);
- });
- return;
- }
+/***/ }),
- // If the value of the `_socket` property is `null` it means that `ws` is a
- // client websocket and the handshake failed. In fact, when this happens, a
- // socket is never assigned to the websocket. Wait for the `'error'` event
- // that will be emitted by the websocket.
- if (ws._socket === null) return;
+/***/ 73339:
+/***/ ((module) => {
- if (ws._socket._writableState.finished) {
- callback();
- if (duplex._readableState.endEmitted) duplex.destroy();
- } else {
- ws._socket.once('finish', function finish() {
- // `duplex` is not destroyed here because the `'end'` event will be
- // emitted on `duplex` after this `'finish'` event. The EOF signaling
- // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
- callback();
- });
- ws.close();
- }
- };
+"use strict";
+module.exports = require("module");
- duplex._read = function () {
- if (ws.isPaused) ws.resume();
- };
+/***/ }),
- duplex._write = function (chunk, encoding, callback) {
- if (ws.readyState === ws.CONNECTING) {
- ws.once('open', function open() {
- duplex._write(chunk, encoding, callback);
- });
- return;
- }
+/***/ 69278:
+/***/ ((module) => {
- ws.send(chunk, callback);
- };
+"use strict";
+module.exports = require("net");
- duplex.on('end', duplexOnEnd);
- duplex.on('error', duplexOnError);
- return duplex;
-}
+/***/ }),
-module.exports = createWebSocketStream;
+/***/ 78474:
+/***/ ((module) => {
+"use strict";
+module.exports = require("node:events");
/***/ }),
-/***/ 43332:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 73024:
+/***/ ((module) => {
"use strict";
+module.exports = require("node:fs");
+/***/ }),
-const { tokenChars } = __nccwpck_require__(26615);
+/***/ 51455:
+/***/ ((module) => {
-/**
- * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
- *
- * @param {String} header The field value of the header
- * @return {Set} The subprotocol names
- * @public
- */
-function parse(header) {
- const protocols = new Set();
- let start = -1;
- let end = -1;
- let i = 0;
+"use strict";
+module.exports = require("node:fs/promises");
- 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 === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
- ) {
- if (end === -1 && start !== -1) end = i;
- } else if (code === 0x2c /* ',' */) {
- if (start === -1) {
- throw new SyntaxError(`Unexpected character at index ${i}`);
- }
+/***/ 76760:
+/***/ ((module) => {
- if (end === -1) end = i;
+"use strict";
+module.exports = require("node:path");
- const protocol = header.slice(start, end);
+/***/ }),
- if (protocols.has(protocol)) {
- throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
- }
+/***/ 57075:
+/***/ ((module) => {
- protocols.add(protocol);
- start = end = -1;
- } else {
- throw new SyntaxError(`Unexpected character at index ${i}`);
- }
- }
+"use strict";
+module.exports = require("node:stream");
- if (start === -1 || end !== -1) {
- throw new SyntaxError('Unexpected end of input');
- }
+/***/ }),
- const protocol = header.slice(start, i);
+/***/ 46193:
+/***/ ((module) => {
- if (protocols.has(protocol)) {
- throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
- }
+"use strict";
+module.exports = require("node:string_decoder");
- protocols.add(protocol);
- return protocols;
-}
+/***/ }),
-module.exports = { parse };
+/***/ 73136:
+/***/ ((module) => {
+"use strict";
+module.exports = require("node:url");
/***/ }),
-/***/ 26615:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 57975:
+/***/ ((module) => {
"use strict";
+module.exports = require("node:util");
+/***/ }),
-const { isUtf8 } = __nccwpck_require__(20181);
-
-const { hasBlob } = __nccwpck_require__(71791);
+/***/ 70857:
+/***/ ((module) => {
-//
-// Allowed token characters:
-//
-// '!', '#', '$', '%', '&', ''', '*', '+', '-',
-// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
-//
-// tokenChars[32] === 0 // ' '
-// tokenChars[33] === 1 // '!'
-// tokenChars[34] === 0 // '"'
-// ...
-//
-// prettier-ignore
-const 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
-];
+"use strict";
+module.exports = require("os");
-/**
- * Checks if a status code is allowed in a close frame.
- *
- * @param {Number} code The status code
- * @return {Boolean} `true` if the status code is valid, else `false`
- * @public
- */
-function isValidStatusCode(code) {
- return (
- (code >= 1000 &&
- code <= 1014 &&
- code !== 1004 &&
- code !== 1005 &&
- code !== 1006) ||
- (code >= 3000 && code <= 4999)
- );
-}
+/***/ }),
-/**
- * Checks if a given buffer contains only correct UTF-8.
- * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
- * Markus Kuhn.
- *
- * @param {Buffer} buf The buffer to check
- * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
- * @public
- */
-function _isValidUTF8(buf) {
- const len = buf.length;
- let i = 0;
+/***/ 16928:
+/***/ ((module) => {
- while (i < len) {
- if ((buf[i] & 0x80) === 0) {
- // 0xxxxxxx
- i++;
- } else if ((buf[i] & 0xe0) === 0xc0) {
- // 110xxxxx 10xxxxxx
- if (
- i + 1 === len ||
- (buf[i + 1] & 0xc0) !== 0x80 ||
- (buf[i] & 0xfe) === 0xc0 // Overlong
- ) {
- return false;
- }
+"use strict";
+module.exports = require("path");
- i += 2;
- } else if ((buf[i] & 0xf0) === 0xe0) {
- // 1110xxxx 10xxxxxx 10xxxxxx
- if (
- i + 2 >= len ||
- (buf[i + 1] & 0xc0) !== 0x80 ||
- (buf[i + 2] & 0xc0) !== 0x80 ||
- (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
- (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
- ) {
- return false;
- }
+/***/ }),
- i += 3;
- } else if ((buf[i] & 0xf8) === 0xf0) {
- // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- if (
- i + 3 >= len ||
- (buf[i + 1] & 0xc0) !== 0x80 ||
- (buf[i + 2] & 0xc0) !== 0x80 ||
- (buf[i + 3] & 0xc0) !== 0x80 ||
- (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
- (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
- buf[i] > 0xf4 // > U+10FFFF
- ) {
- return false;
- }
+/***/ 82987:
+/***/ ((module) => {
- i += 4;
- } else {
- return false;
- }
- }
+"use strict";
+module.exports = require("perf_hooks");
- return true;
-}
+/***/ }),
-/**
- * Determines whether a value is a `Blob`.
- *
- * @param {*} value The value to be tested
- * @return {Boolean} `true` if `value` is a `Blob`, else `false`
- * @private
- */
-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')
- );
-}
+/***/ 932:
+/***/ ((module) => {
-module.exports = {
- isBlob,
- isValidStatusCode,
- isValidUTF8: _isValidUTF8,
- tokenChars
-};
+"use strict";
+module.exports = require("process");
-if (isUtf8) {
- module.exports.isValidUTF8 = function (buf) {
- return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
- };
-} /* istanbul ignore else */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
- try {
- const isValidUTF8 = __nccwpck_require__(62414);
+/***/ }),
- module.exports.isValidUTF8 = function (buf) {
- return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
- };
- } catch (e) {
- // Continue regardless of the error.
- }
-}
+/***/ 83480:
+/***/ ((module) => {
+"use strict";
+module.exports = require("querystring");
/***/ }),
-/***/ 70129:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 23785:
+/***/ ((module) => {
"use strict";
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
+module.exports = require("readline");
+/***/ }),
+/***/ 2203:
+/***/ ((module) => {
-const EventEmitter = __nccwpck_require__(24434);
-const http = __nccwpck_require__(58611);
-const { Duplex } = __nccwpck_require__(2203);
-const { createHash } = __nccwpck_require__(76982);
+"use strict";
+module.exports = require("stream");
-const extension = __nccwpck_require__(61335);
-const PerMessageDeflate = __nccwpck_require__(4376);
-const subprotocol = __nccwpck_require__(43332);
-const WebSocket = __nccwpck_require__(56681);
-const { GUID, kWebSocket } = __nccwpck_require__(71791);
+/***/ }),
-const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+/***/ 63774:
+/***/ ((module) => {
-const RUNNING = 0;
-const CLOSING = 1;
-const CLOSED = 2;
+"use strict";
+module.exports = require("stream/web");
-/**
- * Class representing a WebSocket server.
- *
- * @extends EventEmitter
- */
-class WebSocketServer extends EventEmitter {
- /**
- * 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 {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,
- verifyClient: null,
- noServer: false,
- backlog: null, // use default (511 as implemented in net.js)
- server: null,
- host: null,
- path: null,
- port: null,
- WebSocket,
- ...options
- };
+/***/ 13193:
+/***/ ((module) => {
- 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'
- );
- }
+"use strict";
+module.exports = require("string_decoder");
- if (options.port != null) {
- this._server = http.createServer((req, res) => {
- const body = http.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;
- }
+/***/ 53557:
+/***/ ((module) => {
- if (this._server) {
- const emitConnection = this.emit.bind(this, 'connection');
+"use strict";
+module.exports = require("timers");
- 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 = new Set();
- this._shouldEmitClose = false;
- }
+/***/ 64756:
+/***/ ((module) => {
- this.options = options;
- this._state = RUNNING;
- }
+"use strict";
+module.exports = require("tls");
- /**
- * 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();
- }
+/***/ 52018:
+/***/ ((module) => {
- /**
- * 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'));
- });
- }
+"use strict";
+module.exports = require("tty");
- process.nextTick(emitClose, this);
- return;
- }
+/***/ }),
- if (cb) this.once('close', cb);
+/***/ 87016:
+/***/ ((module) => {
- if (this._state === CLOSING) return;
- this._state = CLOSING;
+"use strict";
+module.exports = require("url");
- 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;
+/***/ 39023:
+/***/ ((module) => {
- this._removeListeners();
- this._removeListeners = this._server = null;
+"use strict";
+module.exports = require("util");
- //
- // The HTTP/S server was created internally. Close it, and rely on its
- // `'close'` event.
- //
- 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 index = req.url.indexOf('?');
- const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+/***/ 98253:
+/***/ ((module) => {
- if (pathname !== this.options.path) return false;
- }
+"use strict";
+module.exports = require("util/types");
- 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);
+/***/ 28167:
+/***/ ((module) => {
- const key = req.headers['sec-websocket-key'];
- const upgrade = req.headers.upgrade;
- const version = +req.headers['sec-websocket-version'];
+"use strict";
+module.exports = require("worker_threads");
- if (req.method !== 'GET') {
- const message = 'Invalid HTTP method';
- abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
- return;
- }
+/***/ }),
- if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
- const message = 'Invalid Upgrade header';
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
- return;
- }
+/***/ 43106:
+/***/ ((module) => {
- if (key === undefined || !keyRegex.test(key)) {
- const message = 'Missing or invalid Sec-WebSocket-Key header';
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
- return;
- }
+"use strict";
+module.exports = require("zlib");
- if (version !== 8 && version !== 13) {
- const message = 'Missing or invalid Sec-WebSocket-Version header';
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
- return;
- }
+/***/ }),
- if (!this.shouldHandle(req)) {
- abortHandshake(socket, 400);
- return;
- }
+/***/ 90147:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
- const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
- let protocols = new Set();
+"use strict";
- if (secWebSocketProtocol !== undefined) {
- try {
- protocols = subprotocol.parse(secWebSocketProtocol);
- } catch (err) {
- const message = 'Invalid Sec-WebSocket-Protocol header';
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
- return;
+
+Object.defineProperty(exports, "__esModule", ({
+ value: true
+}));
+exports.codeFrameColumns = codeFrameColumns;
+exports["default"] = _default;
+var _highlight = __nccwpck_require__(26270);
+var _chalk = _interopRequireWildcard(__nccwpck_require__(43351), true);
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+let chalkWithForcedColor = undefined;
+function getChalk(forceColor) {
+ if (forceColor) {
+ var _chalkWithForcedColor;
+ (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new _chalk.default.constructor({
+ enabled: true,
+ level: 1
+ });
+ return chalkWithForcedColor;
+ }
+ return _chalk.default;
+}
+let deprecationWarningShown = false;
+function getDefs(chalk) {
+ return {
+ gutter: chalk.grey,
+ marker: chalk.red.bold,
+ message: chalk.red.bold
+ };
+}
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+function getMarkerLines(loc, source, opts) {
+ const startLoc = Object.assign({
+ column: 0,
+ line: -1
+ }, loc.start);
+ const endLoc = Object.assign({}, startLoc, loc.end);
+ const {
+ linesAbove = 2,
+ linesBelow = 3
+ } = opts || {};
+ const startLine = startLoc.line;
+ const startColumn = startLoc.column;
+ const endLine = endLoc.line;
+ const endColumn = endLoc.column;
+ let start = Math.max(startLine - (linesAbove + 1), 0);
+ let end = Math.min(source.length, endLine + linesBelow);
+ if (startLine === -1) {
+ start = 0;
+ }
+ if (endLine === -1) {
+ end = source.length;
+ }
+ const lineDiff = endLine - startLine;
+ const markerLines = {};
+ if (lineDiff) {
+ for (let i = 0; i <= lineDiff; i++) {
+ const lineNumber = i + startLine;
+ if (!startColumn) {
+ markerLines[lineNumber] = true;
+ } else if (i === 0) {
+ const sourceLength = source[lineNumber - 1].length;
+ markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+ } else if (i === lineDiff) {
+ markerLines[lineNumber] = [0, endColumn];
+ } else {
+ const sourceLength = source[lineNumber - i].length;
+ markerLines[lineNumber] = [0, sourceLength];
}
}
-
- const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
- const extensions = {};
-
- if (
- this.options.perMessageDeflate &&
- secWebSocketExtensions !== undefined
- ) {
- const perMessageDeflate = new PerMessageDeflate(
- this.options.perMessageDeflate,
- true,
- this.options.maxPayload
- );
-
- try {
- const offers = extension.parse(secWebSocketExtensions);
-
- if (offers[PerMessageDeflate.extensionName]) {
- perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
- extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+ } else {
+ if (startColumn === endColumn) {
+ if (startColumn) {
+ markerLines[startLine] = [startColumn, 0];
+ } else {
+ markerLines[startLine] = true;
+ }
+ } else {
+ markerLines[startLine] = [startColumn, endColumn - startColumn];
+ }
+ }
+ return {
+ start,
+ end,
+ markerLines
+ };
+}
+function codeFrameColumns(rawLines, loc, opts = {}) {
+ const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+ const chalk = getChalk(opts.forceColor);
+ const defs = getDefs(chalk);
+ const maybeHighlight = (chalkFn, string) => {
+ return highlighted ? chalkFn(string) : string;
+ };
+ const lines = rawLines.split(NEWLINE);
+ const {
+ start,
+ end,
+ markerLines
+ } = getMarkerLines(loc, lines, opts);
+ const hasColumns = loc.start && typeof loc.start.column === "number";
+ const numberMaxWidth = String(end).length;
+ const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+ let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+ const number = start + 1 + index;
+ const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+ const gutter = ` ${paddedNumber} |`;
+ const hasMarker = markerLines[number];
+ const lastMarkerLine = !markerLines[number + 1];
+ if (hasMarker) {
+ let markerLine = "";
+ if (Array.isArray(hasMarker)) {
+ const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+ const numberOfMarkers = hasMarker[1] || 1;
+ markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+ if (lastMarkerLine && opts.message) {
+ markerLine += " " + maybeHighlight(defs.message, opts.message);
}
- } catch (err) {
- const message =
- 'Invalid or unacceptable Sec-WebSocket-Extensions header';
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
- return;
}
+ return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+ } else {
+ return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+ }
+ }).join("\n");
+ if (opts.message && !hasColumns) {
+ frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+ }
+ if (highlighted) {
+ return chalk.reset(frame);
+ } else {
+ return frame;
+ }
+}
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+ if (!deprecationWarningShown) {
+ deprecationWarningShown = true;
+ const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+ if (process.emitWarning) {
+ process.emitWarning(message, "DeprecationWarning");
+ } else {
+ const deprecationError = new Error(message);
+ deprecationError.name = "DeprecationWarning";
+ console.warn(new Error(message));
+ }
+ }
+ colNumber = Math.max(colNumber, 0);
+ const location = {
+ start: {
+ column: colNumber,
+ line: lineNumber
}
+ };
+ return codeFrameColumns(rawLines, location, opts);
+}
- //
- // Optionally call external client verification handler.
- //
- if (this.options.verifyClient) {
- const info = {
- origin:
- req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
- secure: !!(req.socket.authorized || req.socket.encrypted),
- req
- };
+//# sourceMappingURL=index.js.map
- if (this.options.verifyClient.length === 2) {
- this.options.verifyClient(info, (verified, code, message, headers) => {
- if (!verified) {
- return abortHandshake(socket, code || 401, message, headers);
- }
- this.completeUpgrade(
- extensions,
- key,
- protocols,
- req,
- socket,
- head,
- cb
- );
- });
- return;
- }
+/***/ }),
- if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
- }
+/***/ 92924:
+/***/ ((__unused_webpack_module, exports) => {
- this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
- }
+"use strict";
- /**
- * 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, protocols, req, socket, head, cb) {
- //
- // Destroy the socket if the client has already sent a FIN packet.
- //
- 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'
- );
+Object.defineProperty(exports, "__esModule", ({
+ value: true
+}));
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierName = isIdentifierName;
+exports.isIdentifierStart = isIdentifierStart;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+function isInAstralSet(code, set) {
+ let pos = 0x10000;
+ for (let i = 0, length = set.length; i < length; i += 2) {
+ pos += set[i];
+ if (pos > code) return false;
+ pos += set[i + 1];
+ if (pos >= code) return true;
+ }
+ return false;
+}
+function isIdentifierStart(code) {
+ if (code < 65) return code === 36;
+ if (code <= 90) return true;
+ if (code < 97) return code === 95;
+ if (code <= 122) return true;
+ if (code <= 0xffff) {
+ return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+ }
+ return isInAstralSet(code, astralIdentifierStartCodes);
+}
+function isIdentifierChar(code) {
+ if (code < 48) return code === 36;
+ if (code < 58) return true;
+ if (code < 65) return false;
+ if (code <= 90) return true;
+ if (code < 97) return code === 95;
+ if (code <= 122) return true;
+ if (code <= 0xffff) {
+ return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+ }
+ return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+function isIdentifierName(name) {
+ let isFirst = true;
+ for (let i = 0; i < name.length; i++) {
+ let cp = name.charCodeAt(i);
+ if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+ const trail = name.charCodeAt(++i);
+ if ((trail & 0xfc00) === 0xdc00) {
+ cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+ }
+ }
+ if (isFirst) {
+ isFirst = false;
+ if (!isIdentifierStart(cp)) {
+ return false;
+ }
+ } else if (!isIdentifierChar(cp)) {
+ return false;
}
+ }
+ return !isFirst;
+}
- if (this._state > RUNNING) return abortHandshake(socket, 503);
+//# sourceMappingURL=identifier.js.map
- const digest = createHash('sha1')
- .update(key + GUID)
- .digest('base64');
- const headers = [
- 'HTTP/1.1 101 Switching Protocols',
- 'Upgrade: websocket',
- 'Connection: Upgrade',
- `Sec-WebSocket-Accept: ${digest}`
- ];
+/***/ }),
- const ws = new this.options.WebSocket(null, undefined, this.options);
+/***/ 76599:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
- if (protocols.size) {
- //
- // Optionally call external protocol selection handler.
- //
- const protocol = this.options.handleProtocols
- ? this.options.handleProtocols(protocols, req)
- : protocols.values().next().value;
+"use strict";
- if (protocol) {
- headers.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]
- });
- headers.push(`Sec-WebSocket-Extensions: ${value}`);
- ws._extensions = extensions;
- }
+Object.defineProperty(exports, "__esModule", ({
+ value: true
+}));
+Object.defineProperty(exports, "isIdentifierChar", ({
+ enumerable: true,
+ get: function () {
+ return _identifier.isIdentifierChar;
+ }
+}));
+Object.defineProperty(exports, "isIdentifierName", ({
+ enumerable: true,
+ get: function () {
+ return _identifier.isIdentifierName;
+ }
+}));
+Object.defineProperty(exports, "isIdentifierStart", ({
+ enumerable: true,
+ get: function () {
+ return _identifier.isIdentifierStart;
+ }
+}));
+Object.defineProperty(exports, "isKeyword", ({
+ enumerable: true,
+ get: function () {
+ return _keyword.isKeyword;
+ }
+}));
+Object.defineProperty(exports, "isReservedWord", ({
+ enumerable: true,
+ get: function () {
+ return _keyword.isReservedWord;
+ }
+}));
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", ({
+ enumerable: true,
+ get: function () {
+ return _keyword.isStrictBindOnlyReservedWord;
+ }
+}));
+Object.defineProperty(exports, "isStrictBindReservedWord", ({
+ enumerable: true,
+ get: function () {
+ return _keyword.isStrictBindReservedWord;
+ }
+}));
+Object.defineProperty(exports, "isStrictReservedWord", ({
+ enumerable: true,
+ get: function () {
+ return _keyword.isStrictReservedWord;
+ }
+}));
+var _identifier = __nccwpck_require__(92924);
+var _keyword = __nccwpck_require__(49884);
- //
- // Allow external modification/inspection of handshake headers.
- //
- this.emit('headers', headers, req);
+//# sourceMappingURL=index.js.map
- socket.write(headers.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);
+/***/ 49884:
+/***/ ((__unused_webpack_module, exports) => {
- if (this._shouldEmitClose && !this.clients.size) {
- process.nextTick(emitClose, this);
- }
- });
- }
+"use strict";
- cb(ws, req);
- }
+
+Object.defineProperty(exports, "__esModule", ({
+ value: true
+}));
+exports.isKeyword = isKeyword;
+exports.isReservedWord = isReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isStrictReservedWord = isStrictReservedWord;
+const reservedWords = {
+ keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+ strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+ strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+function isReservedWord(word, inModule) {
+ return inModule && word === "await" || word === "enum";
+}
+function isStrictReservedWord(word, inModule) {
+ return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+function isStrictBindOnlyReservedWord(word) {
+ return reservedWordsStrictBindSet.has(word);
+}
+function isStrictBindReservedWord(word, inModule) {
+ return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+function isKeyword(word) {
+ return keywords.has(word);
}
-module.exports = WebSocketServer;
+//# sourceMappingURL=keyword.js.map
-/**
- * Add event listeners on an `EventEmitter` using a map of
- * pairs.
- *
- * @param {EventEmitter} server The event emitter
- * @param {Object.} map The listeners to add
- * @return {Function} A function that will remove the added listeners when
- * called
- * @private
- */
-function addListeners(server, map) {
- for (const event of Object.keys(map)) server.on(event, map[event]);
- return function removeListeners() {
- for (const event of Object.keys(map)) {
- server.removeListener(event, map[event]);
+/***/ }),
+
+/***/ 26270:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+ value: true
+}));
+exports["default"] = highlight;
+exports.shouldHighlight = shouldHighlight;
+var _jsTokens = __nccwpck_require__(85756);
+var _helperValidatorIdentifier = __nccwpck_require__(76599);
+var _chalk = _interopRequireWildcard(__nccwpck_require__(71318), true);
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
+function getDefs(chalk) {
+ return {
+ keyword: chalk.cyan,
+ capitalized: chalk.yellow,
+ jsxIdentifier: chalk.yellow,
+ punctuator: chalk.yellow,
+ number: chalk.magenta,
+ string: chalk.green,
+ regex: chalk.magenta,
+ comment: chalk.grey,
+ invalid: chalk.white.bgRed.bold
+ };
+}
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+const BRACKET = /^[()[\]{}]$/;
+let tokenize;
+{
+ const JSX_TAG = /^[a-z][\w-]*$/i;
+ const getTokenType = function (token, offset, text) {
+ if (token.type === "name") {
+ if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) {
+ return "keyword";
+ }
+ if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == " colorize(str)).join("\n");
+ } else {
+ highlighted += value;
+ }
+ }
+ return highlighted;
}
-
-/**
- * Handle socket errors.
- *
- * @private
- */
-function socketOnError() {
- this.destroy();
+function shouldHighlight(options) {
+ return _chalk.default.level > 0 || options.forceColor;
}
-
-/**
- * Close the connection when preconditions are not fulfilled.
- *
- * @param {Duplex} socket The socket of the upgrade request
- * @param {Number} code The HTTP response status code
- * @param {String} [message] The HTTP response body
- * @param {Object} [headers] Additional HTTP response headers
- * @private
- */
-function abortHandshake(socket, code, message, headers) {
- //
- // The socket is writable unless the user destroyed or ended it before calling
- // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
- // error. Handling this does not make much sense as the worst that can happen
- // is that some of the data written by the user might be discarded due to the
- // call to `socket.end()` below, which triggers an `'error'` event that in
- // turn causes the socket to be destroyed.
- //
- message = message || http.STATUS_CODES[code];
- headers = {
- Connection: 'close',
- 'Content-Type': 'text/html',
- 'Content-Length': Buffer.byteLength(message),
- ...headers
- };
-
- socket.once('finish', socket.destroy);
-
- socket.end(
- `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
- Object.keys(headers)
- .map((h) => `${h}: ${headers[h]}`)
- .join('\r\n') +
- '\r\n\r\n' +
- message
- );
+let chalkWithForcedColor = undefined;
+function getChalk(forceColor) {
+ if (forceColor) {
+ var _chalkWithForcedColor;
+ (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new _chalk.default.constructor({
+ enabled: true,
+ level: 1
+ });
+ return chalkWithForcedColor;
+ }
+ return _chalk.default;
}
-
-/**
- * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
- * one listener for it, otherwise call `abortHandshake()`.
- *
- * @param {WebSocketServer} server The WebSocket server
- * @param {http.IncomingMessage} req The request object
- * @param {Duplex} socket The socket of the upgrade request
- * @param {Number} code The HTTP response status code
- * @param {String} message The HTTP response body
- * @private
- */
-function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
- if (server.listenerCount('wsClientError')) {
- const err = new Error(message);
- Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
-
- server.emit('wsClientError', err, socket, req);
+{
+ exports.getChalk = options => getChalk(options.forceColor);
+}
+function highlight(code, options = {}) {
+ if (code !== "" && shouldHighlight(options)) {
+ const defs = getDefs(getChalk(options.forceColor));
+ return highlightTokens(defs, code);
} else {
- abortHandshake(socket, code, message);
+ return code;
}
}
+//# sourceMappingURL=index.js.map
+
/***/ }),
-/***/ 56681:
+/***/ 27182:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
"use strict";
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$", "caughtErrors": "none" }] */
+const WritableStream = (__nccwpck_require__(57075).Writable)
+const inherits = (__nccwpck_require__(57975).inherits)
-const EventEmitter = __nccwpck_require__(24434);
-const https = __nccwpck_require__(65692);
-const http = __nccwpck_require__(58611);
-const net = __nccwpck_require__(69278);
-const tls = __nccwpck_require__(64756);
-const { randomBytes, createHash } = __nccwpck_require__(76982);
-const { Duplex, Readable } = __nccwpck_require__(2203);
-const { URL } = __nccwpck_require__(87016);
+const StreamSearch = __nccwpck_require__(84136)
-const PerMessageDeflate = __nccwpck_require__(4376);
-const Receiver = __nccwpck_require__(20893);
-const Sender = __nccwpck_require__(7389);
-const { isBlob } = __nccwpck_require__(26615);
+const PartStream = __nccwpck_require__(50612)
+const HeaderParser = __nccwpck_require__(62271)
-const {
- BINARY_TYPES,
- EMPTY_BUFFER,
- GUID,
- kForOnEventAttribute,
- kListener,
- kStatusCode,
- kWebSocket,
- NOOP
-} = __nccwpck_require__(71791);
-const {
- EventTarget: { addEventListener, removeEventListener }
-} = __nccwpck_require__(34634);
-const { format, parse } = __nccwpck_require__(61335);
-const { toBuffer } = __nccwpck_require__(95803);
+const DASH = 45
+const B_ONEDASH = Buffer.from('-')
+const B_CRLF = Buffer.from('\r\n')
+const EMPTY_FN = function () {}
-const closeTimeout = 30 * 1000;
-const kAborted = Symbol('kAborted');
-const protocolVersions = [8, 13];
-const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
-const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+function Dicer (cfg) {
+ if (!(this instanceof Dicer)) { return new Dicer(cfg) }
+ WritableStream.call(this, cfg)
-/**
- * Class representing a WebSocket.
- *
- * @extends EventEmitter
- */
-class WebSocket extends EventEmitter {
- /**
- * 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, protocols, options) {
- super();
+ if (!cfg || (!cfg.headerFirst && typeof cfg.boundary !== 'string')) { throw new TypeError('Boundary required') }
- 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 (typeof cfg.boundary === 'string') { this.setBoundary(cfg.boundary) } else { this._bparser = undefined }
- if (address !== null) {
- this._bufferedAmount = 0;
- this._isServer = false;
- this._redirects = 0;
+ this._headerFirst = cfg.headerFirst
- if (protocols === undefined) {
- protocols = [];
- } else if (!Array.isArray(protocols)) {
- if (typeof protocols === 'object' && protocols !== null) {
- options = protocols;
- protocols = [];
- } else {
- protocols = [protocols];
+ this._dashes = 0
+ this._parts = 0
+ this._finished = false
+ this._realFinish = false
+ this._isPreamble = true
+ this._justMatched = false
+ this._firstWrite = true
+ this._inHeader = true
+ this._part = undefined
+ this._cb = undefined
+ this._ignoreData = false
+ this._partOpts = { highWaterMark: cfg.partHwm }
+ this._pause = false
+
+ const self = this
+ this._hparser = new HeaderParser(cfg)
+ this._hparser.on('header', function (header) {
+ self._inHeader = false
+ self._part.emit('header', header)
+ })
+}
+inherits(Dicer, WritableStream)
+
+Dicer.prototype.emit = function (ev) {
+ if (ev === 'finish' && !this._realFinish) {
+ if (!this._finished) {
+ const self = this
+ process.nextTick(function () {
+ self.emit('error', new Error('Unexpected end of multipart data'))
+ if (self._part && !self._ignoreData) {
+ const type = (self._isPreamble ? 'Preamble' : 'Part')
+ self._part.emit('error', new Error(type + ' terminated early due to unexpected end of multipart data'))
+ self._part.push(null)
+ process.nextTick(function () {
+ self._realFinish = true
+ self.emit('finish')
+ self._realFinish = false
+ })
+ return
}
- }
+ self._realFinish = true
+ self.emit('finish')
+ self._realFinish = false
+ })
+ }
+ } else { WritableStream.prototype.emit.apply(this, arguments) }
+}
- initAsClient(this, address, protocols, options);
- } else {
- this._autoPong = options.autoPong;
- this._isServer = true;
+Dicer.prototype._write = function (data, encoding, cb) {
+ // ignore unexpected data (e.g. extra trailer data after finished)
+ if (!this._hparser && !this._bparser) { return cb() }
+
+ if (this._headerFirst && this._isPreamble) {
+ if (!this._part) {
+ this._part = new PartStream(this._partOpts)
+ if (this.listenerCount('preamble') !== 0) { this.emit('preamble', this._part) } else { this._ignore() }
}
+ const r = this._hparser.push(data)
+ if (!this._inHeader && r !== undefined && r < data.length) { data = data.slice(r) } else { return cb() }
}
- /**
- * For historical reasons, the custom "nodebuffer" type is used by the default
- * instead of "blob".
- *
- * @type {String}
- */
- get binaryType() {
- return this._binaryType;
+ // allows for "easier" testing
+ if (this._firstWrite) {
+ this._bparser.push(B_CRLF)
+ this._firstWrite = false
}
- set binaryType(type) {
- if (!BINARY_TYPES.includes(type)) return;
-
- this._binaryType = type;
-
- //
- // Allow to change `binaryType` on the fly.
- //
- if (this._receiver) this._receiver._binaryType = type;
- }
+ this._bparser.push(data)
- /**
- * @type {Number}
- */
- get bufferedAmount() {
- if (!this._socket) return this._bufferedAmount;
+ if (this._pause) { this._cb = cb } else { cb() }
+}
- return this._socket._writableState.length + this._sender._bufferedBytes;
- }
+Dicer.prototype.reset = function () {
+ this._part = undefined
+ this._bparser = undefined
+ this._hparser = undefined
+}
- /**
- * @type {String}
- */
- get extensions() {
- return Object.keys(this._extensions).join();
- }
+Dicer.prototype.setBoundary = function (boundary) {
+ const self = this
+ this._bparser = new StreamSearch('\r\n--' + boundary)
+ this._bparser.on('info', function (isMatch, data, start, end) {
+ self._oninfo(isMatch, data, start, end)
+ })
+}
- /**
- * @type {Boolean}
- */
- get isPaused() {
- return this._paused;
+Dicer.prototype._ignore = function () {
+ if (this._part && !this._ignoreData) {
+ this._ignoreData = true
+ this._part.on('error', EMPTY_FN)
+ // we must perform some kind of read on the stream even though we are
+ // ignoring the data, otherwise node's Readable stream will not emit 'end'
+ // after pushing null to the stream
+ this._part.resume()
}
+}
- /**
- * @type {Function}
- */
- /* istanbul ignore next */
- get onclose() {
- return null;
- }
+Dicer.prototype._oninfo = function (isMatch, data, start, end) {
+ let buf; const self = this; let i = 0; let r; let shouldWriteMore = true
- /**
- * @type {Function}
- */
- /* istanbul ignore next */
- get onerror() {
- return null;
+ if (!this._part && this._justMatched && data) {
+ while (this._dashes < 2 && (start + i) < end) {
+ if (data[start + i] === DASH) {
+ ++i
+ ++this._dashes
+ } else {
+ if (this._dashes) { buf = B_ONEDASH }
+ this._dashes = 0
+ break
+ }
+ }
+ if (this._dashes === 2) {
+ if ((start + i) < end && this.listenerCount('trailer') !== 0) { this.emit('trailer', data.slice(start + i, end)) }
+ this.reset()
+ this._finished = true
+ // no more parts will be added
+ if (self._parts === 0) {
+ self._realFinish = true
+ self.emit('finish')
+ self._realFinish = false
+ }
+ }
+ if (this._dashes) { return }
}
-
- /**
- * @type {Function}
- */
- /* istanbul ignore next */
- get onopen() {
- return null;
+ if (this._justMatched) { this._justMatched = false }
+ if (!this._part) {
+ this._part = new PartStream(this._partOpts)
+ this._part._read = function (n) {
+ self._unpause()
+ }
+ if (this._isPreamble && this.listenerCount('preamble') !== 0) {
+ this.emit('preamble', this._part)
+ } else if (this._isPreamble !== true && this.listenerCount('part') !== 0) {
+ this.emit('part', this._part)
+ } else {
+ this._ignore()
+ }
+ if (!this._isPreamble) { this._inHeader = true }
}
-
- /**
- * @type {Function}
- */
- /* istanbul ignore next */
- get onmessage() {
- return null;
+ if (data && start < end && !this._ignoreData) {
+ if (this._isPreamble || !this._inHeader) {
+ if (buf) { shouldWriteMore = this._part.push(buf) }
+ shouldWriteMore = this._part.push(data.slice(start, end))
+ if (!shouldWriteMore) { this._pause = true }
+ } else if (!this._isPreamble && this._inHeader) {
+ if (buf) { this._hparser.push(buf) }
+ r = this._hparser.push(data.slice(start, end))
+ if (!this._inHeader && r !== undefined && r < end) { this._oninfo(false, data, start + r, end) }
+ }
}
-
- /**
- * @type {String}
- */
- get protocol() {
- return this._protocol;
+ if (isMatch) {
+ this._hparser.reset()
+ if (this._isPreamble) { this._isPreamble = false } else {
+ if (start !== end) {
+ ++this._parts
+ this._part.on('end', function () {
+ if (--self._parts === 0) {
+ if (self._finished) {
+ self._realFinish = true
+ self.emit('finish')
+ self._realFinish = false
+ } else {
+ self._unpause()
+ }
+ }
+ })
+ }
+ }
+ this._part.push(null)
+ this._part = undefined
+ this._ignoreData = false
+ this._justMatched = true
+ this._dashes = 0
}
+}
- /**
- * @type {Number}
- */
- get readyState() {
- return this._readyState;
- }
+Dicer.prototype._unpause = function () {
+ if (!this._pause) { return }
- /**
- * @type {String}
- */
- get url() {
- return this._url;
+ this._pause = false
+ if (this._cb) {
+ const cb = this._cb
+ this._cb = undefined
+ cb()
}
+}
- /**
- * 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
- });
+module.exports = Dicer
- 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;
+/***/ 62271:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- receiver.on('conclude', receiverOnConclude);
- receiver.on('drain', receiverOnDrain);
- receiver.on('error', receiverOnError);
- receiver.on('message', receiverOnMessage);
- receiver.on('ping', receiverOnPing);
- receiver.on('pong', receiverOnPong);
+"use strict";
- sender.onerror = senderOnError;
- //
- // These methods may not be available if `socket` is just a `Duplex`.
- //
- if (socket.setTimeout) socket.setTimeout(0);
- if (socket.setNoDelay) socket.setNoDelay();
+const EventEmitter = (__nccwpck_require__(78474).EventEmitter)
+const inherits = (__nccwpck_require__(57975).inherits)
+const getLimit = __nccwpck_require__(22393)
- if (head.length > 0) socket.unshift(head);
+const StreamSearch = __nccwpck_require__(84136)
- socket.on('close', socketOnClose);
- socket.on('data', socketOnData);
- socket.on('end', socketOnEnd);
- socket.on('error', socketOnError);
+const B_DCRLF = Buffer.from('\r\n\r\n')
+const RE_CRLF = /\r\n/g
+const RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/ // eslint-disable-line no-control-regex
- this._readyState = WebSocket.OPEN;
- this.emit('open');
- }
+function HeaderParser (cfg) {
+ EventEmitter.call(this)
- /**
- * Emit the `'close'` event.
- *
- * @private
- */
- emitClose() {
- if (!this._socket) {
- this._readyState = WebSocket.CLOSED;
- this.emit('close', this._closeCode, this._closeMessage);
- return;
- }
+ cfg = cfg || {}
+ const self = this
+ this.nread = 0
+ this.maxed = false
+ this.npairs = 0
+ this.maxHeaderPairs = getLimit(cfg, 'maxHeaderPairs', 2000)
+ this.maxHeaderSize = getLimit(cfg, 'maxHeaderSize', 80 * 1024)
+ this.buffer = ''
+ this.header = {}
+ this.finished = false
+ this.ss = new StreamSearch(B_DCRLF)
+ this.ss.on('info', function (isMatch, data, start, end) {
+ if (data && !self.maxed) {
+ if (self.nread + end - start >= self.maxHeaderSize) {
+ end = self.maxHeaderSize - self.nread + start
+ self.nread = self.maxHeaderSize
+ self.maxed = true
+ } else { self.nread += (end - start) }
- if (this._extensions[PerMessageDeflate.extensionName]) {
- this._extensions[PerMessageDeflate.extensionName].cleanup();
+ self.buffer += data.toString('binary', start, end)
}
+ if (isMatch) { self._finish() }
+ })
+}
+inherits(HeaderParser, EventEmitter)
- 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;
- }
+HeaderParser.prototype.push = function (data) {
+ const r = this.ss.push(data)
+ if (this.finished) { return r }
+}
- if (this.readyState === WebSocket.CLOSING) {
- if (
- this._closeFrameSent &&
- (this._closeFrameReceived || this._receiver._writableState.errorEmitted)
- ) {
- this._socket.end();
- }
+HeaderParser.prototype.reset = function () {
+ this.finished = false
+ this.buffer = ''
+ this.header = {}
+ this.ss.reset()
+}
- return;
- }
+HeaderParser.prototype._finish = function () {
+ if (this.buffer) { this._parseHeader() }
+ this.ss.matches = this.ss.maxMatches
+ const header = this.header
+ this.header = {}
+ this.buffer = ''
+ this.finished = true
+ this.nread = this.npairs = 0
+ this.maxed = false
+ this.emit('header', header)
+}
- this._readyState = WebSocket.CLOSING;
- this._sender.close(code, data, !this._isServer, (err) => {
- //
- // This error is handled by the `'error'` listener on the socket. We only
- // want to know if the close frame has been sent here.
- //
- if (err) return;
+HeaderParser.prototype._parseHeader = function () {
+ if (this.npairs === this.maxHeaderPairs) { return }
- this._closeFrameSent = true;
+ const lines = this.buffer.split(RE_CRLF)
+ const len = lines.length
+ let m, h
- if (
- this._closeFrameReceived ||
- this._receiver._writableState.errorEmitted
- ) {
- this._socket.end();
+ for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
+ if (lines[i].length === 0) { continue }
+ if (lines[i][0] === '\t' || lines[i][0] === ' ') {
+ // folded header content
+ // RFC2822 says to just remove the CRLF and not the whitespace following
+ // it, so we follow the RFC and include the leading whitespace ...
+ if (h) {
+ this.header[h][this.header[h].length - 1] += lines[i]
+ continue
}
- });
-
- setCloseTimer(this);
- }
+ }
- /**
- * Pause the socket.
- *
- * @public
- */
- pause() {
+ const posColon = lines[i].indexOf(':')
if (
- this.readyState === WebSocket.CONNECTING ||
- this.readyState === WebSocket.CLOSED
+ posColon === -1 ||
+ posColon === 0
) {
- return;
+ return
}
-
- this._paused = true;
- this._socket.pause();
+ m = RE_HDR.exec(lines[i])
+ h = m[1].toLowerCase()
+ this.header[h] = this.header[h] || []
+ this.header[h].push((m[2] || ''))
+ if (++this.npairs === this.maxHeaderPairs) { break }
}
+}
- /**
- * 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 = undefined;
- } else if (typeof mask === 'function') {
- cb = mask;
- mask = undefined;
- }
+module.exports = HeaderParser
- if (typeof data === 'number') data = data.toString();
- if (this.readyState !== WebSocket.OPEN) {
- sendAfterClose(this, data, cb);
- return;
- }
+/***/ }),
- if (mask === undefined) mask = !this._isServer;
- this._sender.ping(data || EMPTY_BUFFER, mask, cb);
- }
+/***/ 50612:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- /**
- * 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)');
- }
+"use strict";
- if (typeof data === 'function') {
- cb = data;
- data = mask = undefined;
- } else if (typeof mask === 'function') {
- cb = mask;
- mask = undefined;
- }
- if (typeof data === 'number') data = data.toString();
+const inherits = (__nccwpck_require__(57975).inherits)
+const ReadableStream = (__nccwpck_require__(57075).Readable)
- if (this.readyState !== WebSocket.OPEN) {
- sendAfterClose(this, data, cb);
- return;
- }
+function PartStream (opts) {
+ ReadableStream.call(this, opts)
+}
+inherits(PartStream, ReadableStream)
- if (mask === undefined) mask = !this._isServer;
- this._sender.pong(data || EMPTY_BUFFER, mask, cb);
- }
+PartStream.prototype._read = function (n) {}
- /**
- * Resume the socket.
- *
- * @public
- */
- resume() {
- if (
- this.readyState === WebSocket.CONNECTING ||
- this.readyState === WebSocket.CLOSED
- ) {
- return;
- }
+module.exports = PartStream
- 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 = {};
- }
+/***/ 84136:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- if (typeof data === 'number') data = data.toString();
+"use strict";
- if (this.readyState !== WebSocket.OPEN) {
- sendAfterClose(this, data, cb);
- return;
- }
- const opts = {
- binary: typeof data !== 'string',
- mask: !this._isServer,
- compress: true,
- fin: true,
- ...options
- };
+/**
+ * Copyright Brian White. All rights reserved.
+ *
+ * @see https://github.com/mscdex/streamsearch
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Based heavily on the Streaming Boyer-Moore-Horspool C++ implementation
+ * by Hongli Lai at: https://github.com/FooBarWidget/boyer-moore-horspool
+ */
+const EventEmitter = (__nccwpck_require__(78474).EventEmitter)
+const inherits = (__nccwpck_require__(57975).inherits)
- if (!this._extensions[PerMessageDeflate.extensionName]) {
- opts.compress = false;
- }
+function SBMH (needle) {
+ if (typeof needle === 'string') {
+ needle = Buffer.from(needle)
+ }
- this._sender.send(data || EMPTY_BUFFER, opts, cb);
+ if (!Buffer.isBuffer(needle)) {
+ throw new TypeError('The needle has to be a String or a Buffer.')
}
- /**
- * 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;
- }
+ const needleLength = needle.length
- if (this._socket) {
- this._readyState = WebSocket.CLOSING;
- this._socket.destroy();
- }
+ if (needleLength === 0) {
+ throw new Error('The needle cannot be an empty String/Buffer.')
}
-}
-/**
- * @constant {Number} CONNECTING
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket, 'CONNECTING', {
- enumerable: true,
- value: readyStates.indexOf('CONNECTING')
-});
+ if (needleLength > 256) {
+ throw new Error('The needle cannot have a length bigger than 256.')
+ }
-/**
- * @constant {Number} CONNECTING
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket.prototype, 'CONNECTING', {
- enumerable: true,
- value: readyStates.indexOf('CONNECTING')
-});
+ this.maxMatches = Infinity
+ this.matches = 0
-/**
- * @constant {Number} OPEN
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket, 'OPEN', {
- enumerable: true,
- value: readyStates.indexOf('OPEN')
-});
+ this._occ = new Array(256)
+ .fill(needleLength) // Initialize occurrence table.
+ this._lookbehind_size = 0
+ this._needle = needle
+ this._bufpos = 0
-/**
- * @constant {Number} OPEN
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket.prototype, 'OPEN', {
- enumerable: true,
- value: readyStates.indexOf('OPEN')
-});
+ this._lookbehind = Buffer.alloc(needleLength)
-/**
- * @constant {Number} CLOSING
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket, 'CLOSING', {
- enumerable: true,
- value: readyStates.indexOf('CLOSING')
-});
+ // Populate occurrence table with analysis of the needle,
+ // ignoring last letter.
+ for (var i = 0; i < needleLength - 1; ++i) { // eslint-disable-line no-var
+ this._occ[needle[i]] = needleLength - 1 - i
+ }
+}
+inherits(SBMH, EventEmitter)
-/**
- * @constant {Number} CLOSING
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket.prototype, 'CLOSING', {
- enumerable: true,
- value: readyStates.indexOf('CLOSING')
-});
+SBMH.prototype.reset = function () {
+ this._lookbehind_size = 0
+ this.matches = 0
+ this._bufpos = 0
+}
-/**
- * @constant {Number} CLOSED
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket, 'CLOSED', {
- enumerable: true,
- value: readyStates.indexOf('CLOSED')
-});
+SBMH.prototype.push = function (chunk, pos) {
+ if (!Buffer.isBuffer(chunk)) {
+ chunk = Buffer.from(chunk, 'binary')
+ }
+ const chlen = chunk.length
+ this._bufpos = pos || 0
+ let r
+ while (r !== chlen && this.matches < this.maxMatches) { r = this._sbmh_feed(chunk) }
+ return r
+}
-/**
- * @constant {Number} CLOSED
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket.prototype, 'CLOSED', {
- enumerable: true,
- value: readyStates.indexOf('CLOSED')
-});
+SBMH.prototype._sbmh_feed = function (data) {
+ const len = data.length
+ const needle = this._needle
+ const needleLength = needle.length
+ const lastNeedleChar = needle[needleLength - 1]
-[
- 'binaryType',
- 'bufferedAmount',
- 'extensions',
- 'isPaused',
- 'protocol',
- 'readyState',
- 'url'
-].forEach((property) => {
- Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
-});
+ // Positive: points to a position in `data`
+ // pos == 3 points to data[3]
+ // Negative: points to a position in the lookbehind buffer
+ // pos == -2 points to lookbehind[lookbehind_size - 2]
+ let pos = -this._lookbehind_size
+ let ch
-//
-// Add the `onopen`, `onerror`, `onclose`, and `onmessage` attributes.
-// See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface
-//
-['open', 'error', 'close', 'message'].forEach((method) => {
- Object.defineProperty(WebSocket.prototype, `on${method}`, {
- enumerable: true,
- get() {
- for (const listener of this.listeners(method)) {
- if (listener[kForOnEventAttribute]) return listener[kListener];
- }
+ if (pos < 0) {
+ // Lookbehind buffer is not empty. Perform Boyer-Moore-Horspool
+ // search with character lookup code that considers both the
+ // lookbehind buffer and the current round's haystack data.
+ //
+ // Loop until
+ // there is a match.
+ // or until
+ // we've moved past the position that requires the
+ // lookbehind buffer. In this case we switch to the
+ // optimized loop.
+ // or until
+ // the character to look at lies outside the haystack.
+ while (pos < 0 && pos <= len - needleLength) {
+ ch = this._sbmh_lookup_char(data, pos + needleLength - 1)
- return null;
- },
- set(handler) {
- for (const listener of this.listeners(method)) {
- if (listener[kForOnEventAttribute]) {
- this.removeListener(method, listener);
- break;
- }
+ if (
+ ch === lastNeedleChar &&
+ this._sbmh_memcmp(data, pos, needleLength - 1)
+ ) {
+ this._lookbehind_size = 0
+ ++this.matches
+ this.emit('info', true)
+
+ return (this._bufpos = pos + needleLength)
}
+ pos += this._occ[ch]
+ }
- if (typeof handler !== 'function') return;
+ // No match.
- this.addEventListener(method, handler, {
- [kForOnEventAttribute]: true
- });
+ if (pos < 0) {
+ // There's too few data for Boyer-Moore-Horspool to run,
+ // so let's use a different algorithm to skip as much as
+ // we can.
+ // Forward pos until
+ // the trailing part of lookbehind + data
+ // looks like the beginning of the needle
+ // or until
+ // pos == 0
+ while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { ++pos }
}
- });
-});
-
-WebSocket.prototype.addEventListener = addEventListener;
-WebSocket.prototype.removeEventListener = removeEventListener;
-module.exports = WebSocket;
+ if (pos >= 0) {
+ // Discard lookbehind buffer.
+ this.emit('info', false, this._lookbehind, 0, this._lookbehind_size)
+ this._lookbehind_size = 0
+ } else {
+ // Cut off part of the lookbehind buffer that has
+ // been processed and append the entire haystack
+ // into it.
+ const bytesToCutOff = this._lookbehind_size + pos
+ if (bytesToCutOff > 0) {
+ // The cut off data is guaranteed not to contain the needle.
+ this.emit('info', false, this._lookbehind, 0, bytesToCutOff)
+ }
-/**
- * Initialize a WebSocket client.
- *
- * @param {WebSocket} websocket The client to initialize
- * @param {(String|URL)} address The URL to which to connect
- * @param {Array} protocols The subprotocols
- * @param {Object} [options] Connection 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 {Function} [options.finishRequest] A function which can be used to
- * customize the headers of each http request before it is sent
- * @param {Boolean} [options.followRedirects=false] Whether or not to follow
- * redirects
- * @param {Function} [options.generateMask] The function used to generate the
- * masking key
- * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
- * handshake request
- * @param {Number} [options.maxPayload=104857600] The maximum allowed message
- * size
- * @param {Number} [options.maxRedirects=10] The maximum number of redirects
- * allowed
- * @param {String} [options.origin] Value of the `Origin` or
- * `Sec-WebSocket-Origin` header
- * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
- * permessage-deflate
- * @param {Number} [options.protocolVersion=13] Value of the
- * `Sec-WebSocket-Version` header
- * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
- * not to skip UTF-8 validation for text and close messages
- * @private
- */
-function initAsClient(websocket, address, protocols, options) {
- const opts = {
- allowSynchronousEvents: true,
- autoPong: true,
- protocolVersion: protocolVersions[1],
- maxPayload: 100 * 1024 * 1024,
- skipUTF8Validation: false,
- perMessageDeflate: true,
- followRedirects: false,
- maxRedirects: 10,
- ...options,
- socketPath: undefined,
- hostname: undefined,
- protocol: undefined,
- timeout: undefined,
- method: 'GET',
- host: undefined,
- path: undefined,
- port: undefined
- };
+ this._lookbehind.copy(this._lookbehind, 0, bytesToCutOff,
+ this._lookbehind_size - bytesToCutOff)
+ this._lookbehind_size -= bytesToCutOff
- websocket._autoPong = opts.autoPong;
+ data.copy(this._lookbehind, this._lookbehind_size)
+ this._lookbehind_size += len
- if (!protocolVersions.includes(opts.protocolVersion)) {
- throw new RangeError(
- `Unsupported protocol version: ${opts.protocolVersion} ` +
- `(supported versions: ${protocolVersions.join(', ')})`
- );
+ this._bufpos = len
+ return len
+ }
}
- let parsedUrl;
+ pos += (pos >= 0) * this._bufpos
- if (address instanceof URL) {
- parsedUrl = address;
+ // Lookbehind buffer is now empty. We only need to check if the
+ // needle is in the haystack.
+ if (data.indexOf(needle, pos) !== -1) {
+ pos = data.indexOf(needle, pos)
+ ++this.matches
+ if (pos > 0) { this.emit('info', true, data, this._bufpos, pos) } else { this.emit('info', true) }
+
+ return (this._bufpos = pos + needleLength)
} else {
- try {
- parsedUrl = new URL(address);
- } catch (e) {
- throw new SyntaxError(`Invalid URL: ${address}`);
- }
+ pos = len - needleLength
}
- if (parsedUrl.protocol === 'http:') {
- parsedUrl.protocol = 'ws:';
- } else if (parsedUrl.protocol === 'https:') {
- parsedUrl.protocol = 'wss:';
+ // There was no match. If there's trailing haystack data that we cannot
+ // match yet using the Boyer-Moore-Horspool algorithm (because the trailing
+ // data is less than the needle size) then match using a modified
+ // algorithm that starts matching from the beginning instead of the end.
+ // Whatever trailing data is left after running this algorithm is added to
+ // the lookbehind buffer.
+ while (
+ pos < len &&
+ (
+ data[pos] !== needle[0] ||
+ (
+ (Buffer.compare(
+ data.subarray(pos, pos + len - pos),
+ needle.subarray(0, len - pos)
+ ) !== 0)
+ )
+ )
+ ) {
+ ++pos
+ }
+ if (pos < len) {
+ data.copy(this._lookbehind, 0, pos, pos + (len - pos))
+ this._lookbehind_size = len - pos
}
- websocket._url = parsedUrl.href;
+ // Everything until pos is guaranteed not to contain needle data.
+ if (pos > 0) { this.emit('info', false, data, this._bufpos, pos < len ? pos : len) }
+
+ this._bufpos = len
+ return len
+}
+
+SBMH.prototype._sbmh_lookup_char = function (data, pos) {
+ return (pos < 0)
+ ? this._lookbehind[this._lookbehind_size + pos]
+ : data[pos]
+}
+
+SBMH.prototype._sbmh_memcmp = function (data, pos, len) {
+ for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
+ if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { return false }
+ }
+ return true
+}
+
+module.exports = SBMH
+
+
+/***/ }),
+
+/***/ 89581:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const WritableStream = (__nccwpck_require__(57075).Writable)
+const { inherits } = __nccwpck_require__(57975)
+const Dicer = __nccwpck_require__(27182)
+
+const MultipartParser = __nccwpck_require__(41192)
+const UrlencodedParser = __nccwpck_require__(80855)
+const parseParams = __nccwpck_require__(8929)
+
+function Busboy (opts) {
+ if (!(this instanceof Busboy)) { return new Busboy(opts) }
+
+ if (typeof opts !== 'object') {
+ throw new TypeError('Busboy expected an options-Object.')
+ }
+ if (typeof opts.headers !== 'object') {
+ throw new TypeError('Busboy expected an options-Object with headers-attribute.')
+ }
+ if (typeof opts.headers['content-type'] !== 'string') {
+ throw new TypeError('Missing Content-Type-header.')
+ }
- const isSecure = parsedUrl.protocol === 'wss:';
- const isIpcUrl = parsedUrl.protocol === 'ws+unix:';
- let invalidUrlMessage;
+ const {
+ headers,
+ ...streamOptions
+ } = opts
- 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';
+ this.opts = {
+ autoDestroy: false,
+ ...streamOptions
}
+ WritableStream.call(this, this.opts)
- if (invalidUrlMessage) {
- const err = new SyntaxError(invalidUrlMessage);
+ this._done = false
+ this._parser = this.getParserByHeaders(headers)
+ this._finished = false
+}
+inherits(Busboy, WritableStream)
- if (websocket._redirects === 0) {
- throw err;
- } else {
- emitErrorAndClose(websocket, err);
- return;
+Busboy.prototype.emit = function (ev) {
+ if (ev === 'finish') {
+ if (!this._done) {
+ this._parser?.end()
+ return
+ } else if (this._finished) {
+ return
}
+ this._finished = true
}
+ WritableStream.prototype.emit.apply(this, arguments)
+}
- const defaultPort = isSecure ? 443 : 80;
- const key = randomBytes(16).toString('base64');
- const request = isSecure ? https.request : http.request;
- const protocolSet = 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;
+Busboy.prototype.getParserByHeaders = function (headers) {
+ const parsed = parseParams(headers['content-type'])
- if (opts.perMessageDeflate) {
- perMessageDeflate = new PerMessageDeflate(
- opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
- false,
- opts.maxPayload
- );
- opts.headers['Sec-WebSocket-Extensions'] = format({
- [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
- });
+ const cfg = {
+ defCharset: this.opts.defCharset,
+ fileHwm: this.opts.fileHwm,
+ headers,
+ highWaterMark: this.opts.highWaterMark,
+ isPartAFile: this.opts.isPartAFile,
+ limits: this.opts.limits,
+ parsedConType: parsed,
+ preservePath: this.opts.preservePath
}
- if (protocols.length) {
- for (const protocol of protocols) {
- 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'] = protocols.join(',');
- }
- if (opts.origin) {
- if (opts.protocolVersion < 13) {
- opts.headers['Sec-WebSocket-Origin'] = opts.origin;
- } else {
- opts.headers.Origin = opts.origin;
- }
+ if (MultipartParser.detect.test(parsed[0])) {
+ return new MultipartParser(this, cfg)
}
- if (parsedUrl.username || parsedUrl.password) {
- opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+ if (UrlencodedParser.detect.test(parsed[0])) {
+ return new UrlencodedParser(this, cfg)
}
+ throw new Error('Unsupported Content-Type.')
+}
- if (isIpcUrl) {
- const parts = opts.path.split(':');
+Busboy.prototype._write = function (chunk, encoding, cb) {
+ this._parser.write(chunk, cb)
+}
- opts.socketPath = parts[0];
- opts.path = parts[1];
- }
+module.exports = Busboy
+module.exports["default"] = Busboy
+module.exports.Busboy = Busboy
- let req;
+module.exports.Dicer = Dicer
- if (opts.followRedirects) {
- if (websocket._redirects === 0) {
- websocket._originalIpc = isIpcUrl;
- websocket._originalSecure = isSecure;
- websocket._originalHostOrSocketPath = isIpcUrl
- ? opts.socketPath
- : parsedUrl.host;
- const headers = options && options.headers;
+/***/ }),
- //
- // Shallow copy the user provided options so that headers can be changed
- // without mutating the original object.
- //
- options = { ...options, headers: {} };
+/***/ 41192:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- if (headers) {
- for (const [key, value] of Object.entries(headers)) {
- options.headers[key.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;
+"use strict";
- if (!isSameHost || (websocket._originalSecure && !isSecure)) {
- //
- // Match curl 7.77.0 behavior and drop the following headers. These
- // headers are also dropped when following a redirect to a subdomain.
- //
- delete opts.headers.authorization;
- delete opts.headers.cookie;
- if (!isSameHost) delete opts.headers.host;
+// TODO:
+// * support 1 nested multipart level
+// (see second multipart example here:
+// http://www.w3.org/TR/html401/interact/forms.html#didx-multipartform-data)
+// * support limits.fieldNameSize
+// -- this will require modifications to utils.parseParams
- opts.auth = undefined;
- }
- }
+const { Readable } = __nccwpck_require__(57075)
+const { inherits } = __nccwpck_require__(57975)
- //
- // Match curl 7.77.0 behavior and make the first `Authorization` header win.
- // If the `Authorization` header is set, then there is nothing to do as it
- // will take precedence.
- //
- if (opts.auth && !options.headers.authorization) {
- options.headers.authorization =
- 'Basic ' + Buffer.from(opts.auth).toString('base64');
- }
+const Dicer = __nccwpck_require__(27182)
- req = websocket._req = request(opts);
+const parseParams = __nccwpck_require__(8929)
+const decodeText = __nccwpck_require__(72747)
+const basename = __nccwpck_require__(20692)
+const getLimit = __nccwpck_require__(22393)
- if (websocket._redirects) {
- //
- // Unlike what is done for the `'upgrade'` event, no early exit is
- // triggered here if the user calls `websocket.close()` or
- // `websocket.terminate()` from a listener of the `'redirect'` event. This
- // is because the user can also call `request.destroy()` with an error
- // before calling `websocket.close()` or `websocket.terminate()` and this
- // would result in an error being emitted on the `request` object with no
- // `'error'` event listeners attached.
- //
- websocket.emit('redirect', websocket.url, req);
+const RE_BOUNDARY = /^boundary$/i
+const RE_FIELD = /^form-data$/i
+const RE_CHARSET = /^charset$/i
+const RE_FILENAME = /^filename$/i
+const RE_NAME = /^name$/i
+
+Multipart.detect = /^multipart\/form-data/i
+function Multipart (boy, cfg) {
+ let i
+ let len
+ const self = this
+ let boundary
+ const limits = cfg.limits
+ const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => (contentType === 'application/octet-stream' || fileName !== undefined))
+ const parsedConType = cfg.parsedConType || []
+ const defCharset = cfg.defCharset || 'utf8'
+ const preservePath = cfg.preservePath
+ const fileOpts = { highWaterMark: cfg.fileHwm }
+
+ for (i = 0, len = parsedConType.length; i < len; ++i) {
+ if (Array.isArray(parsedConType[i]) &&
+ RE_BOUNDARY.test(parsedConType[i][0])) {
+ boundary = parsedConType[i][1]
+ break
}
- } else {
- req = websocket._req = request(opts);
}
- if (opts.timeout) {
- req.on('timeout', () => {
- abortHandshake(websocket, req, 'Opening handshake has timed out');
- });
+ function checkFinished () {
+ if (nends === 0 && finished && !boy._done) {
+ finished = false
+ self.end()
+ }
}
- 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 (typeof boundary !== 'string') { throw new Error('Multipart: Boundary not found') }
- if (
- location &&
- opts.followRedirects &&
- statusCode >= 300 &&
- statusCode < 400
- ) {
- if (++websocket._redirects > opts.maxRedirects) {
- abortHandshake(websocket, req, 'Maximum redirects exceeded');
- return;
- }
+ const fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024)
+ const fileSizeLimit = getLimit(limits, 'fileSize', Infinity)
+ const filesLimit = getLimit(limits, 'files', Infinity)
+ const fieldsLimit = getLimit(limits, 'fields', Infinity)
+ const partsLimit = getLimit(limits, 'parts', Infinity)
+ const headerPairsLimit = getLimit(limits, 'headerPairs', 2000)
+ const headerSizeLimit = getLimit(limits, 'headerSize', 80 * 1024)
- req.abort();
+ let nfiles = 0
+ let nfields = 0
+ let nends = 0
+ let curFile
+ let curField
+ let finished = false
- let addr;
+ this._needDrain = false
+ this._pause = false
+ this._cb = undefined
+ this._nparts = 0
+ this._boy = boy
- try {
- addr = new URL(location, address);
- } catch (e) {
- const err = new SyntaxError(`Invalid URL: ${location}`);
- emitErrorAndClose(websocket, err);
- return;
- }
+ const parserCfg = {
+ boundary,
+ maxHeaderPairs: headerPairsLimit,
+ maxHeaderSize: headerSizeLimit,
+ partHwm: fileOpts.highWaterMark,
+ highWaterMark: cfg.highWaterMark
+ }
- initAsClient(websocket, addr, protocols, options);
- } else if (!websocket.emit('unexpected-response', req, res)) {
- abortHandshake(
- websocket,
- req,
- `Unexpected server response: ${res.statusCode}`
- );
+ this.parser = new Dicer(parserCfg)
+ this.parser.on('drain', function () {
+ self._needDrain = false
+ if (self._cb && !self._pause) {
+ const cb = self._cb
+ self._cb = undefined
+ cb()
+ }
+ }).on('part', function onPart (part) {
+ if (++self._nparts > partsLimit) {
+ self.parser.removeListener('part', onPart)
+ self.parser.on('part', skipPart)
+ boy.hitPartsLimit = true
+ boy.emit('partsLimit')
+ return skipPart(part)
}
- });
-
- req.on('upgrade', (res, socket, head) => {
- websocket.emit('upgrade', res);
- //
- // The user may have closed the connection from a listener of the
- // `'upgrade'` event.
- //
- if (websocket.readyState !== WebSocket.CONNECTING) return;
+ // hack because streams2 _always_ doesn't emit 'end' until nextTick, so let
+ // us emit 'end' early since we know the part has ended if we are already
+ // seeing the next part
+ if (curField) {
+ const field = curField
+ field.emit('end')
+ field.removeAllListeners('end')
+ }
- req = websocket._req = null;
+ part.on('header', function (header) {
+ let contype
+ let fieldname
+ let parsed
+ let charset
+ let encoding
+ let filename
+ let nsize = 0
- const upgrade = res.headers.upgrade;
+ if (header['content-type']) {
+ parsed = parseParams(header['content-type'][0])
+ if (parsed[0]) {
+ contype = parsed[0].toLowerCase()
+ for (i = 0, len = parsed.length; i < len; ++i) {
+ if (RE_CHARSET.test(parsed[i][0])) {
+ charset = parsed[i][1].toLowerCase()
+ break
+ }
+ }
+ }
+ }
- if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
- abortHandshake(websocket, socket, 'Invalid Upgrade header');
- return;
- }
+ if (contype === undefined) { contype = 'text/plain' }
+ if (charset === undefined) { charset = defCharset }
- const digest = createHash('sha1')
- .update(key + GUID)
- .digest('base64');
+ if (header['content-disposition']) {
+ parsed = parseParams(header['content-disposition'][0])
+ if (!RE_FIELD.test(parsed[0])) { return skipPart(part) }
+ for (i = 0, len = parsed.length; i < len; ++i) {
+ if (RE_NAME.test(parsed[i][0])) {
+ fieldname = parsed[i][1]
+ } else if (RE_FILENAME.test(parsed[i][0])) {
+ filename = parsed[i][1]
+ if (!preservePath) { filename = basename(filename) }
+ }
+ }
+ } else { return skipPart(part) }
- if (res.headers['sec-websocket-accept'] !== digest) {
- abortHandshake(websocket, socket, 'Invalid Sec-WebSocket-Accept header');
- return;
- }
+ if (header['content-transfer-encoding']) { encoding = header['content-transfer-encoding'][0].toLowerCase() } else { encoding = '7bit' }
- const serverProt = res.headers['sec-websocket-protocol'];
- let protError;
+ let onData,
+ onEnd
- if (serverProt !== undefined) {
- 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 (isPartAFile(fieldname, contype, filename)) {
+ // file/binary field
+ if (nfiles === filesLimit) {
+ if (!boy.hitFilesLimit) {
+ boy.hitFilesLimit = true
+ boy.emit('filesLimit')
+ }
+ return skipPart(part)
+ }
- if (protError) {
- abortHandshake(websocket, socket, protError);
- return;
- }
+ ++nfiles
- if (serverProt) websocket._protocol = serverProt;
+ if (boy.listenerCount('file') === 0) {
+ self.parser._ignore()
+ return
+ }
- const secWebSocketExtensions = res.headers['sec-websocket-extensions'];
+ ++nends
+ const file = new FileStream(fileOpts)
+ curFile = file
+ file.on('end', function () {
+ --nends
+ self._pause = false
+ checkFinished()
+ if (self._cb && !self._needDrain) {
+ const cb = self._cb
+ self._cb = undefined
+ cb()
+ }
+ })
+ file._read = function (n) {
+ if (!self._pause) { return }
+ self._pause = false
+ if (self._cb && !self._needDrain) {
+ const cb = self._cb
+ self._cb = undefined
+ cb()
+ }
+ }
+ boy.emit('file', fieldname, file, filename, encoding, contype)
- if (secWebSocketExtensions !== undefined) {
- if (!perMessageDeflate) {
- const message =
- 'Server sent a Sec-WebSocket-Extensions header but no extension ' +
- 'was requested';
- abortHandshake(websocket, socket, message);
- return;
- }
+ onData = function (data) {
+ if ((nsize += data.length) > fileSizeLimit) {
+ const extralen = fileSizeLimit - nsize + data.length
+ if (extralen > 0) { file.push(data.slice(0, extralen)) }
+ file.truncated = true
+ file.bytesRead = fileSizeLimit
+ part.removeAllListeners('data')
+ file.emit('limit')
+ return
+ } else if (!file.push(data)) { self._pause = true }
- let extensions;
+ file.bytesRead = nsize
+ }
- try {
- extensions = parse(secWebSocketExtensions);
- } catch (err) {
- const message = 'Invalid Sec-WebSocket-Extensions header';
- abortHandshake(websocket, socket, message);
- return;
- }
+ onEnd = function () {
+ curFile = undefined
+ file.push(null)
+ }
+ } else {
+ // non-file field
+ if (nfields === fieldsLimit) {
+ if (!boy.hitFieldsLimit) {
+ boy.hitFieldsLimit = true
+ boy.emit('fieldsLimit')
+ }
+ return skipPart(part)
+ }
- const extensionNames = Object.keys(extensions);
+ ++nfields
+ ++nends
+ let buffer = ''
+ let truncated = false
+ curField = part
- if (
- extensionNames.length !== 1 ||
- extensionNames[0] !== PerMessageDeflate.extensionName
- ) {
- const message = 'Server indicated an extension that was not requested';
- abortHandshake(websocket, socket, message);
- return;
- }
+ onData = function (data) {
+ if ((nsize += data.length) > fieldSizeLimit) {
+ const extralen = (fieldSizeLimit - (nsize - data.length))
+ buffer += data.toString('binary', 0, extralen)
+ truncated = true
+ part.removeAllListeners('data')
+ } else { buffer += data.toString('binary') }
+ }
- try {
- perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
- } catch (err) {
- const message = 'Invalid Sec-WebSocket-Extensions header';
- abortHandshake(websocket, socket, message);
- return;
+ onEnd = function () {
+ curField = undefined
+ if (buffer.length) { buffer = decodeText(buffer, 'binary', charset) }
+ boy.emit('field', fieldname, buffer, false, truncated, encoding, contype)
+ --nends
+ checkFinished()
+ }
}
- websocket._extensions[PerMessageDeflate.extensionName] =
- perMessageDeflate;
- }
+ /* As of node@2efe4ab761666 (v0.10.29+/v0.11.14+), busboy had become
+ broken. Streams2/streams3 is a huge black box of confusion, but
+ somehow overriding the sync state seems to fix things again (and still
+ seems to work for previous node versions).
+ */
+ part._readableState.sync = false
- websocket.setSocket(socket, head, {
- allowSynchronousEvents: opts.allowSynchronousEvents,
- generateMask: opts.generateMask,
- maxPayload: opts.maxPayload,
- skipUTF8Validation: opts.skipUTF8Validation
- });
- });
+ part.on('data', onData)
+ part.on('end', onEnd)
+ }).on('error', function (err) {
+ if (curFile) { curFile.emit('error', err) }
+ })
+ }).on('error', function (err) {
+ boy.emit('error', err)
+ }).on('finish', function () {
+ finished = true
+ checkFinished()
+ })
+}
- if (opts.finishRequest) {
- opts.finishRequest(req, websocket);
+Multipart.prototype.write = function (chunk, cb) {
+ const r = this.parser.write(chunk)
+ if (r && !this._pause) {
+ cb()
} else {
- req.end();
+ this._needDrain = !r
+ this._cb = cb
}
}
-/**
- * Emit the `'error'` and `'close'` events.
- *
- * @param {WebSocket} websocket The WebSocket instance
- * @param {Error} The error to emit
- * @private
- */
-function emitErrorAndClose(websocket, err) {
- websocket._readyState = WebSocket.CLOSING;
- //
- // The following assignment is practically useless and is done only for
- // consistency.
- //
- websocket._errorEmitted = true;
- websocket.emit('error', err);
- websocket.emitClose();
+Multipart.prototype.end = function () {
+ const self = this
+
+ if (self.parser.writable) {
+ self.parser.end()
+ } else if (!self._boy._done) {
+ process.nextTick(function () {
+ self._boy._done = true
+ self._boy.emit('finish')
+ })
+ }
}
-/**
- * Create a `net.Socket` and initiate a connection.
- *
- * @param {Object} options Connection options
- * @return {net.Socket} The newly created socket used to start the connection
- * @private
- */
-function netConnect(options) {
- options.path = options.socketPath;
- return net.connect(options);
+function skipPart (part) {
+ part.resume()
}
-/**
- * Create a `tls.TLSSocket` and initiate a connection.
- *
- * @param {Object} options Connection options
- * @return {tls.TLSSocket} The newly created socket used to start the connection
- * @private
- */
-function tlsConnect(options) {
- options.path = undefined;
+function FileStream (opts) {
+ Readable.call(this, opts)
- if (!options.servername && options.servername !== '') {
- options.servername = net.isIP(options.host) ? '' : options.host;
- }
+ this.bytesRead = 0
- return tls.connect(options);
+ this.truncated = false
}
-/**
- * Abort the handshake and emit an error.
- *
- * @param {WebSocket} websocket The WebSocket instance
- * @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
- * abort or the socket to destroy
- * @param {String} message The error message
- * @private
- */
-function abortHandshake(websocket, stream, message) {
- websocket._readyState = WebSocket.CLOSING;
+inherits(FileStream, Readable)
- const err = new Error(message);
- Error.captureStackTrace(err, abortHandshake);
+FileStream.prototype._read = function (n) {}
- if (stream.setHeader) {
- stream[kAborted] = true;
- stream.abort();
+module.exports = Multipart
- if (stream.socket && !stream.socket.destroyed) {
- //
- // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if
- // called after the request completed. See
- // https://github.com/websockets/ws/issues/1869.
- //
- 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));
- }
-}
+/***/ }),
-/**
- * Handle cases where the `ping()`, `pong()`, or `send()` methods are called
- * when the `readyState` attribute is `CLOSING` or `CLOSED`.
- *
- * @param {WebSocket} websocket The WebSocket instance
- * @param {*} [data] The data to send
- * @param {Function} [cb] Callback
- * @private
- */
-function sendAfterClose(websocket, data, cb) {
- if (data) {
- const length = isBlob(data) ? data.size : toBuffer(data).length;
+/***/ 80855:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- //
- // The `_bufferedAmount` property is used only when the peer is a client and
- // the opening handshake fails. Under these circumstances, in fact, the
- // `setSocket()` method is not called, so the `_socket` and `_sender`
- // properties are set to `null`.
- //
- if (websocket._socket) websocket._sender._bufferedBytes += length;
- else websocket._bufferedAmount += length;
- }
+"use strict";
- if (cb) {
- const err = new Error(
- `WebSocket is not open: readyState ${websocket.readyState} ` +
- `(${readyStates[websocket.readyState]})`
- );
- process.nextTick(cb, err);
+
+const Decoder = __nccwpck_require__(11496)
+const decodeText = __nccwpck_require__(72747)
+const getLimit = __nccwpck_require__(22393)
+
+const RE_CHARSET = /^charset$/i
+
+UrlEncoded.detect = /^application\/x-www-form-urlencoded/i
+function UrlEncoded (boy, cfg) {
+ const limits = cfg.limits
+ const parsedConType = cfg.parsedConType
+ this.boy = boy
+
+ this.fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024)
+ this.fieldNameSizeLimit = getLimit(limits, 'fieldNameSize', 100)
+ this.fieldsLimit = getLimit(limits, 'fields', Infinity)
+
+ let charset
+ for (var i = 0, len = parsedConType.length; i < len; ++i) { // eslint-disable-line no-var
+ if (Array.isArray(parsedConType[i]) &&
+ RE_CHARSET.test(parsedConType[i][0])) {
+ charset = parsedConType[i][1].toLowerCase()
+ break
+ }
}
+
+ if (charset === undefined) { charset = cfg.defCharset || 'utf8' }
+
+ this.decoder = new Decoder()
+ this.charset = charset
+ this._fields = 0
+ this._state = 'key'
+ this._checkingBytes = true
+ this._bytesKey = 0
+ this._bytesVal = 0
+ this._key = ''
+ this._val = ''
+ this._keyTrunc = false
+ this._valTrunc = false
+ this._hitLimit = false
}
-/**
- * The listener of the `Receiver` `'conclude'` event.
- *
- * @param {Number} code The status code
- * @param {Buffer} reason The reason for closing
- * @private
- */
-function receiverOnConclude(code, reason) {
- const websocket = this[kWebSocket];
+UrlEncoded.prototype.write = function (data, cb) {
+ if (this._fields === this.fieldsLimit) {
+ if (!this.boy.hitFieldsLimit) {
+ this.boy.hitFieldsLimit = true
+ this.boy.emit('fieldsLimit')
+ }
+ return cb()
+ }
- websocket._closeFrameReceived = true;
- websocket._closeMessage = reason;
- websocket._closeCode = code;
+ let idxeq; let idxamp; let i; let p = 0; const len = data.length
- if (websocket._socket[kWebSocket] === undefined) return;
+ while (p < len) {
+ if (this._state === 'key') {
+ idxeq = idxamp = undefined
+ for (i = p; i < len; ++i) {
+ if (!this._checkingBytes) { ++p }
+ if (data[i] === 0x3D/* = */) {
+ idxeq = i
+ break
+ } else if (data[i] === 0x26/* & */) {
+ idxamp = i
+ break
+ }
+ if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
+ this._hitLimit = true
+ break
+ } else if (this._checkingBytes) { ++this._bytesKey }
+ }
- websocket._socket.removeListener('data', socketOnData);
- process.nextTick(resume, websocket._socket);
+ if (idxeq !== undefined) {
+ // key with assignment
+ if (idxeq > p) { this._key += this.decoder.write(data.toString('binary', p, idxeq)) }
+ this._state = 'val'
- if (code === 1005) websocket.close();
- else websocket.close(code, reason);
-}
+ this._hitLimit = false
+ this._checkingBytes = true
+ this._val = ''
+ this._bytesVal = 0
+ this._valTrunc = false
+ this.decoder.reset()
-/**
- * The listener of the `Receiver` `'drain'` event.
- *
- * @private
- */
-function receiverOnDrain() {
- const websocket = this[kWebSocket];
+ p = idxeq + 1
+ } else if (idxamp !== undefined) {
+ // key with no assignment
+ ++this._fields
+ let key; const keyTrunc = this._keyTrunc
+ if (idxamp > p) { key = (this._key += this.decoder.write(data.toString('binary', p, idxamp))) } else { key = this._key }
- if (!websocket.isPaused) websocket._socket.resume();
-}
+ this._hitLimit = false
+ this._checkingBytes = true
+ this._key = ''
+ this._bytesKey = 0
+ this._keyTrunc = false
+ this.decoder.reset()
-/**
- * The listener of the `Receiver` `'error'` event.
- *
- * @param {(RangeError|Error)} err The emitted error
- * @private
- */
-function receiverOnError(err) {
- const websocket = this[kWebSocket];
+ if (key.length) {
+ this.boy.emit('field', decodeText(key, 'binary', this.charset),
+ '',
+ keyTrunc,
+ false)
+ }
- if (websocket._socket[kWebSocket] !== undefined) {
- websocket._socket.removeListener('data', socketOnData);
+ p = idxamp + 1
+ if (this._fields === this.fieldsLimit) { return cb() }
+ } else if (this._hitLimit) {
+ // we may not have hit the actual limit if there are encoded bytes...
+ if (i > p) { this._key += this.decoder.write(data.toString('binary', p, i)) }
+ p = i
+ if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
+ // yep, we actually did hit the limit
+ this._checkingBytes = false
+ this._keyTrunc = true
+ }
+ } else {
+ if (p < len) { this._key += this.decoder.write(data.toString('binary', p)) }
+ p = len
+ }
+ } else {
+ idxamp = undefined
+ for (i = p; i < len; ++i) {
+ if (!this._checkingBytes) { ++p }
+ if (data[i] === 0x26/* & */) {
+ idxamp = i
+ break
+ }
+ if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
+ this._hitLimit = true
+ break
+ } else if (this._checkingBytes) { ++this._bytesVal }
+ }
- //
- // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
- // https://github.com/websockets/ws/issues/1940.
- //
- process.nextTick(resume, websocket._socket);
+ if (idxamp !== undefined) {
+ ++this._fields
+ if (idxamp > p) { this._val += this.decoder.write(data.toString('binary', p, idxamp)) }
+ this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+ decodeText(this._val, 'binary', this.charset),
+ this._keyTrunc,
+ this._valTrunc)
+ this._state = 'key'
- websocket.close(err[kStatusCode]);
- }
+ this._hitLimit = false
+ this._checkingBytes = true
+ this._key = ''
+ this._bytesKey = 0
+ this._keyTrunc = false
+ this.decoder.reset()
- if (!websocket._errorEmitted) {
- websocket._errorEmitted = true;
- websocket.emit('error', err);
+ p = idxamp + 1
+ if (this._fields === this.fieldsLimit) { return cb() }
+ } else if (this._hitLimit) {
+ // we may not have hit the actual limit if there are encoded bytes...
+ if (i > p) { this._val += this.decoder.write(data.toString('binary', p, i)) }
+ p = i
+ if ((this._val === '' && this.fieldSizeLimit === 0) ||
+ (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
+ // yep, we actually did hit the limit
+ this._checkingBytes = false
+ this._valTrunc = true
+ }
+ } else {
+ if (p < len) { this._val += this.decoder.write(data.toString('binary', p)) }
+ p = len
+ }
+ }
}
+ cb()
}
-/**
- * The listener of the `Receiver` `'finish'` event.
- *
- * @private
- */
-function receiverOnFinish() {
- this[kWebSocket].emitClose();
-}
+UrlEncoded.prototype.end = function () {
+ if (this.boy._done) { return }
-/**
- * The listener of the `Receiver` `'message'` event.
- *
- * @param {Buffer|ArrayBuffer|Buffer[])} data The message
- * @param {Boolean} isBinary Specifies whether the message is binary or not
- * @private
- */
-function receiverOnMessage(data, isBinary) {
- this[kWebSocket].emit('message', data, isBinary);
+ if (this._state === 'key' && this._key.length > 0) {
+ this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+ '',
+ this._keyTrunc,
+ false)
+ } else if (this._state === 'val') {
+ this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+ decodeText(this._val, 'binary', this.charset),
+ this._keyTrunc,
+ this._valTrunc)
+ }
+ this.boy._done = true
+ this.boy.emit('finish')
}
-/**
- * The listener of the `Receiver` `'ping'` event.
- *
- * @param {Buffer} data The data included in the ping frame
- * @private
- */
-function receiverOnPing(data) {
- const websocket = this[kWebSocket];
+module.exports = UrlEncoded
- if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
- websocket.emit('ping', data);
-}
-/**
- * The listener of the `Receiver` `'pong'` event.
- *
- * @param {Buffer} data The data included in the pong frame
- * @private
- */
-function receiverOnPong(data) {
- this[kWebSocket].emit('pong', data);
-}
+/***/ }),
-/**
- * Resume a readable stream
- *
- * @param {Readable} stream The readable stream
- * @private
- */
-function resume(stream) {
- stream.resume();
-}
+/***/ 11496:
+/***/ ((module) => {
-/**
- * The `Sender` error event handler.
- *
- * @param {Error} The error
- * @private
- */
-function senderOnError(err) {
- const websocket = this[kWebSocket];
+"use strict";
- if (websocket.readyState === WebSocket.CLOSED) return;
- if (websocket.readyState === WebSocket.OPEN) {
- websocket._readyState = WebSocket.CLOSING;
- setCloseTimer(websocket);
- }
- //
- // `socket.end()` is used instead of `socket.destroy()` to allow the other
- // peer to finish sending queued data. There is no need to set a timer here
- // because `CLOSING` means that it is already set or not needed.
- //
- this._socket.end();
+const RE_PLUS = /\+/g
- if (!websocket._errorEmitted) {
- websocket._errorEmitted = true;
- websocket.emit('error', err);
- }
-}
+const HEX = [
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+]
-/**
- * Set a timer to destroy the underlying raw socket of a WebSocket.
- *
- * @param {WebSocket} websocket The WebSocket instance
- * @private
- */
-function setCloseTimer(websocket) {
- websocket._closeTimer = setTimeout(
- websocket._socket.destroy.bind(websocket._socket),
- closeTimeout
- );
+function Decoder () {
+ this.buffer = undefined
+}
+Decoder.prototype.write = function (str) {
+ // Replace '+' with ' ' before decoding
+ str = str.replace(RE_PLUS, ' ')
+ let res = ''
+ let i = 0; let p = 0; const len = str.length
+ for (; i < len; ++i) {
+ if (this.buffer !== undefined) {
+ if (!HEX[str.charCodeAt(i)]) {
+ res += '%' + this.buffer
+ this.buffer = undefined
+ --i // retry character
+ } else {
+ this.buffer += str[i]
+ ++p
+ if (this.buffer.length === 2) {
+ res += String.fromCharCode(parseInt(this.buffer, 16))
+ this.buffer = undefined
+ }
+ }
+ } else if (str[i] === '%') {
+ if (i > p) {
+ res += str.substring(p, i)
+ p = i
+ }
+ this.buffer = ''
+ ++p
+ }
+ }
+ if (p < len && this.buffer === undefined) { res += str.substring(p) }
+ return res
+}
+Decoder.prototype.reset = function () {
+ this.buffer = undefined
}
-/**
- * The listener of the socket `'close'` event.
- *
- * @private
- */
-function socketOnClose() {
- const websocket = this[kWebSocket];
-
- this.removeListener('close', socketOnClose);
- this.removeListener('data', socketOnData);
- this.removeListener('end', socketOnEnd);
-
- websocket._readyState = WebSocket.CLOSING;
+module.exports = Decoder
- let chunk;
- //
- // The close frame might not have been received or the `'end'` event emitted,
- // for example, if the socket was destroyed due to an error. Ensure that the
- // `receiver` stream is closed after writing any remaining buffered data to
- // it. If the readable side of the socket is in flowing mode then there is no
- // buffered data as everything has been already written and `readable.read()`
- // will return `null`. If instead, the socket is paused, any possible buffered
- // data will be read as a single chunk.
- //
- if (
- !this._readableState.endEmitted &&
- !websocket._closeFrameReceived &&
- !websocket._receiver._writableState.errorEmitted &&
- (chunk = websocket._socket.read()) !== null
- ) {
- websocket._receiver.write(chunk);
- }
+/***/ }),
- websocket._receiver.end();
+/***/ 20692:
+/***/ ((module) => {
- this[kWebSocket] = undefined;
+"use strict";
- 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);
+module.exports = function basename (path) {
+ if (typeof path !== 'string') { return '' }
+ for (var i = path.length - 1; i >= 0; --i) { // eslint-disable-line no-var
+ switch (path.charCodeAt(i)) {
+ case 0x2F: // '/'
+ case 0x5C: // '\'
+ path = path.slice(i + 1)
+ return (path === '..' || path === '.' ? '' : path)
+ }
}
+ return (path === '..' || path === '.' ? '' : path)
}
-/**
- * The listener of the socket `'data'` event.
- *
- * @param {Buffer} chunk A chunk of data
- * @private
- */
-function socketOnData(chunk) {
- if (!this[kWebSocket]._receiver.write(chunk)) {
- this.pause();
- }
-}
-/**
- * The listener of the socket `'end'` event.
- *
- * @private
- */
-function socketOnEnd() {
- const websocket = this[kWebSocket];
+/***/ }),
- websocket._readyState = WebSocket.CLOSING;
- websocket._receiver.end();
- this.end();
-}
+/***/ 72747:
+/***/ (function(module) {
-/**
- * The listener of the socket `'error'` event.
- *
- * @private
- */
-function socketOnError() {
- const websocket = this[kWebSocket];
+"use strict";
- this.removeListener('error', socketOnError);
- this.on('error', NOOP);
- if (websocket) {
- websocket._readyState = WebSocket.CLOSING;
- this.destroy();
+// Node has always utf-8
+const utf8Decoder = new TextDecoder('utf-8')
+const textDecoders = new Map([
+ ['utf-8', utf8Decoder],
+ ['utf8', utf8Decoder]
+])
+
+function getDecoder (charset) {
+ let lc
+ while (true) {
+ switch (charset) {
+ case 'utf-8':
+ case 'utf8':
+ return decoders.utf8
+ case 'latin1':
+ case 'ascii': // TODO: Make these a separate, strict decoder?
+ case 'us-ascii':
+ case 'iso-8859-1':
+ case 'iso8859-1':
+ case 'iso88591':
+ case 'iso_8859-1':
+ case 'windows-1252':
+ case 'iso_8859-1:1987':
+ case 'cp1252':
+ case 'x-cp1252':
+ return decoders.latin1
+ case 'utf16le':
+ case 'utf-16le':
+ case 'ucs2':
+ case 'ucs-2':
+ return decoders.utf16le
+ case 'base64':
+ return decoders.base64
+ default:
+ if (lc === undefined) {
+ lc = true
+ charset = charset.toLowerCase()
+ continue
+ }
+ return decoders.other.bind(charset)
+ }
}
}
+const decoders = {
+ utf8: (data, sourceEncoding) => {
+ if (data.length === 0) {
+ return ''
+ }
+ if (typeof data === 'string') {
+ data = Buffer.from(data, sourceEncoding)
+ }
+ return data.utf8Slice(0, data.length)
+ },
-/***/ }),
+ latin1: (data, sourceEncoding) => {
+ if (data.length === 0) {
+ return ''
+ }
+ if (typeof data === 'string') {
+ return data
+ }
+ return data.latin1Slice(0, data.length)
+ },
-/***/ 20663:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+ utf16le: (data, sourceEncoding) => {
+ if (data.length === 0) {
+ return ''
+ }
+ if (typeof data === 'string') {
+ data = Buffer.from(data, sourceEncoding)
+ }
+ return data.ucs2Slice(0, data.length)
+ },
-var fs = __nccwpck_require__(79896);
-var zlib = __nccwpck_require__(43106);
-var fd_slicer = __nccwpck_require__(23045);
-var crc32 = __nccwpck_require__(19776);
-var util = __nccwpck_require__(39023);
-var EventEmitter = (__nccwpck_require__(24434).EventEmitter);
-var Transform = (__nccwpck_require__(2203).Transform);
-var PassThrough = (__nccwpck_require__(2203).PassThrough);
-var Writable = (__nccwpck_require__(2203).Writable);
+ base64: (data, sourceEncoding) => {
+ if (data.length === 0) {
+ return ''
+ }
+ if (typeof data === 'string') {
+ data = Buffer.from(data, sourceEncoding)
+ }
+ return data.base64Slice(0, data.length)
+ },
-exports.open = open;
-exports.fromFd = fromFd;
-exports.fromBuffer = fromBuffer;
-exports.fromRandomAccessReader = fromRandomAccessReader;
-exports.dosDateTimeToDate = dosDateTimeToDate;
-exports.validateFileName = validateFileName;
-exports.ZipFile = ZipFile;
-exports.Entry = Entry;
-exports.RandomAccessReader = RandomAccessReader;
+ other: (data, sourceEncoding) => {
+ if (data.length === 0) {
+ return ''
+ }
+ if (typeof data === 'string') {
+ data = Buffer.from(data, sourceEncoding)
+ }
-function open(path, options, callback) {
- if (typeof options === "function") {
- callback = options;
- options = null;
+ if (textDecoders.has(this.toString())) {
+ try {
+ return textDecoders.get(this).decode(data)
+ } catch {}
+ }
+ return typeof data === 'string'
+ ? data
+ : data.toString()
}
- if (options == null) options = {};
- if (options.autoClose == null) options.autoClose = true;
- if (options.lazyEntries == null) options.lazyEntries = false;
- if (options.decodeStrings == null) options.decodeStrings = true;
- if (options.validateEntrySizes == null) options.validateEntrySizes = true;
- if (options.strictFileNames == null) options.strictFileNames = false;
- if (callback == null) callback = defaultCallback;
- fs.open(path, "r", function(err, fd) {
- if (err) return callback(err);
- fromFd(fd, options, function(err, zipfile) {
- if (err) fs.close(fd, defaultCallback);
- callback(err, zipfile);
- });
- });
}
-function fromFd(fd, options, callback) {
- if (typeof options === "function") {
- callback = options;
- options = null;
+function decodeText (text, sourceEncoding, destEncoding) {
+ if (text) {
+ return getDecoder(destEncoding)(text, sourceEncoding)
}
- if (options == null) options = {};
- if (options.autoClose == null) options.autoClose = false;
- if (options.lazyEntries == null) options.lazyEntries = false;
- if (options.decodeStrings == null) options.decodeStrings = true;
- if (options.validateEntrySizes == null) options.validateEntrySizes = true;
- if (options.strictFileNames == null) options.strictFileNames = false;
- if (callback == null) callback = defaultCallback;
- fs.fstat(fd, function(err, stats) {
- if (err) return callback(err);
- var reader = fd_slicer.createFromFd(fd, {autoClose: true});
- fromRandomAccessReader(reader, stats.size, options, callback);
- });
+ return text
}
-function fromBuffer(buffer, options, callback) {
- if (typeof options === "function") {
- callback = options;
- options = null;
- }
- if (options == null) options = {};
- options.autoClose = false;
- if (options.lazyEntries == null) options.lazyEntries = false;
- if (options.decodeStrings == null) options.decodeStrings = true;
- if (options.validateEntrySizes == null) options.validateEntrySizes = true;
- if (options.strictFileNames == null) options.strictFileNames = false;
- // limit the max chunk size. see https://github.com/thejoshwolfe/yauzl/issues/87
- var reader = fd_slicer.createFromBuffer(buffer, {maxChunkSize: 0x10000});
- fromRandomAccessReader(reader, buffer.length, options, callback);
-}
+module.exports = decodeText
-function fromRandomAccessReader(reader, totalSize, options, callback) {
- if (typeof options === "function") {
- callback = options;
- options = null;
- }
- if (options == null) options = {};
- if (options.autoClose == null) options.autoClose = true;
- if (options.lazyEntries == null) options.lazyEntries = false;
- if (options.decodeStrings == null) options.decodeStrings = true;
- var decodeStrings = !!options.decodeStrings;
- if (options.validateEntrySizes == null) options.validateEntrySizes = true;
- if (options.strictFileNames == null) options.strictFileNames = false;
- if (callback == null) callback = defaultCallback;
- if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
- if (totalSize > Number.MAX_SAFE_INTEGER) {
- throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
- }
- // the matching unref() call is in zipfile.close()
- reader.ref();
+/***/ }),
- // eocdr means End of Central Directory Record.
- // search backwards for the eocdr signature.
- // the last field of the eocdr is a variable-length comment.
- // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it.
- // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if a coherent eocdr was in the comment.
- // we search backwards for a eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment.
- var eocdrWithoutCommentSize = 22;
- var maxCommentSize = 0xffff; // 2-byte size
- var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
- var buffer = newBuffer(bufferSize);
- var bufferReadStart = totalSize - buffer.length;
- readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
- if (err) return callback(err);
- for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
- if (buffer.readUInt32LE(i) !== 0x06054b50) continue;
- // found eocdr
- var eocdrBuffer = buffer.slice(i);
+/***/ 22393:
+/***/ ((module) => {
- // 0 - End of central directory signature = 0x06054b50
- // 4 - Number of this disk
- var diskNumber = eocdrBuffer.readUInt16LE(4);
- if (diskNumber !== 0) {
- return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
- }
- // 6 - Disk where central directory starts
- // 8 - Number of central directory records on this disk
- // 10 - Total number of central directory records
- var entryCount = eocdrBuffer.readUInt16LE(10);
- // 12 - Size of central directory (bytes)
- // 16 - Offset of start of central directory, relative to start of archive
- var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
- // 20 - Comment length
- var commentLength = eocdrBuffer.readUInt16LE(20);
- var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
- if (commentLength !== expectedCommentLength) {
- return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
- }
- // 22 - Comment
- // the encoding is always cp437.
- var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false)
- : eocdrBuffer.slice(22);
+"use strict";
- if (!(entryCount === 0xffff || centralDirectoryOffset === 0xffffffff)) {
- return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
- }
- // ZIP64 format
+module.exports = function getLimit (limits, name, defaultLimit) {
+ if (
+ !limits ||
+ limits[name] === undefined ||
+ limits[name] === null
+ ) { return defaultLimit }
- // ZIP64 Zip64 end of central directory locator
- var zip64EocdlBuffer = newBuffer(20);
- var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
- readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err) {
- if (err) return callback(err);
+ if (
+ typeof limits[name] !== 'number' ||
+ isNaN(limits[name])
+ ) { throw new TypeError('Limit ' + name + ' is not a valid number') }
- // 0 - zip64 end of central dir locator signature = 0x07064b50
- if (zip64EocdlBuffer.readUInt32LE(0) !== 0x07064b50) {
- return callback(new Error("invalid zip64 end of central directory locator signature"));
- }
- // 4 - number of the disk with the start of the zip64 end of central directory
- // 8 - relative offset of the zip64 end of central directory record
- var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
- // 16 - total number of disks
+ return limits[name]
+}
- // ZIP64 end of central directory record
- var zip64EocdrBuffer = newBuffer(56);
- readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err) {
- if (err) return callback(err);
- // 0 - zip64 end of central dir signature 4 bytes (0x06064b50)
- if (zip64EocdrBuffer.readUInt32LE(0) !== 0x06064b50) {
- return callback(new Error("invalid zip64 end of central directory record signature"));
- }
- // 4 - size of zip64 end of central directory record 8 bytes
- // 12 - version made by 2 bytes
- // 14 - version needed to extract 2 bytes
- // 16 - number of this disk 4 bytes
- // 20 - number of the disk with the start of the central directory 4 bytes
- // 24 - total number of entries in the central directory on this disk 8 bytes
- // 32 - total number of entries in the central directory 8 bytes
- entryCount = readUInt64LE(zip64EocdrBuffer, 32);
- // 40 - size of the central directory 8 bytes
- // 48 - offset of start of central directory with respect to the starting disk number 8 bytes
- centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
- // 56 - zip64 extensible data sector (variable size)
- return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
- });
- });
- return;
- }
- callback(new Error("end of central directory record signature not found"));
- });
-}
+/***/ }),
-util.inherits(ZipFile, EventEmitter);
-function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
- var self = this;
- EventEmitter.call(self);
- self.reader = reader;
- // forward close events
- self.reader.on("error", function(err) {
- // error closing the fd
- emitError(self, err);
- });
- self.reader.once("close", function() {
- self.emit("close");
- });
- self.readEntryCursor = centralDirectoryOffset;
- self.fileSize = fileSize;
- self.entryCount = entryCount;
- self.comment = comment;
- self.entriesRead = 0;
- self.autoClose = !!autoClose;
- self.lazyEntries = !!lazyEntries;
- self.decodeStrings = !!decodeStrings;
- self.validateEntrySizes = !!validateEntrySizes;
- self.strictFileNames = !!strictFileNames;
- self.isOpen = true;
- self.emittedError = false;
+/***/ 8929:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
- if (!self.lazyEntries) self._readEntry();
-}
-ZipFile.prototype.close = function() {
- if (!this.isOpen) return;
- this.isOpen = false;
- this.reader.unref();
-};
+"use strict";
+/* eslint-disable object-property-newline */
-function emitErrorAndAutoClose(self, err) {
- if (self.autoClose) self.close();
- emitError(self, err);
+
+const decodeText = __nccwpck_require__(72747)
+
+const RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g
+
+const EncodedLookup = {
+ '%00': '\x00', '%01': '\x01', '%02': '\x02', '%03': '\x03', '%04': '\x04',
+ '%05': '\x05', '%06': '\x06', '%07': '\x07', '%08': '\x08', '%09': '\x09',
+ '%0a': '\x0a', '%0A': '\x0a', '%0b': '\x0b', '%0B': '\x0b', '%0c': '\x0c',
+ '%0C': '\x0c', '%0d': '\x0d', '%0D': '\x0d', '%0e': '\x0e', '%0E': '\x0e',
+ '%0f': '\x0f', '%0F': '\x0f', '%10': '\x10', '%11': '\x11', '%12': '\x12',
+ '%13': '\x13', '%14': '\x14', '%15': '\x15', '%16': '\x16', '%17': '\x17',
+ '%18': '\x18', '%19': '\x19', '%1a': '\x1a', '%1A': '\x1a', '%1b': '\x1b',
+ '%1B': '\x1b', '%1c': '\x1c', '%1C': '\x1c', '%1d': '\x1d', '%1D': '\x1d',
+ '%1e': '\x1e', '%1E': '\x1e', '%1f': '\x1f', '%1F': '\x1f', '%20': '\x20',
+ '%21': '\x21', '%22': '\x22', '%23': '\x23', '%24': '\x24', '%25': '\x25',
+ '%26': '\x26', '%27': '\x27', '%28': '\x28', '%29': '\x29', '%2a': '\x2a',
+ '%2A': '\x2a', '%2b': '\x2b', '%2B': '\x2b', '%2c': '\x2c', '%2C': '\x2c',
+ '%2d': '\x2d', '%2D': '\x2d', '%2e': '\x2e', '%2E': '\x2e', '%2f': '\x2f',
+ '%2F': '\x2f', '%30': '\x30', '%31': '\x31', '%32': '\x32', '%33': '\x33',
+ '%34': '\x34', '%35': '\x35', '%36': '\x36', '%37': '\x37', '%38': '\x38',
+ '%39': '\x39', '%3a': '\x3a', '%3A': '\x3a', '%3b': '\x3b', '%3B': '\x3b',
+ '%3c': '\x3c', '%3C': '\x3c', '%3d': '\x3d', '%3D': '\x3d', '%3e': '\x3e',
+ '%3E': '\x3e', '%3f': '\x3f', '%3F': '\x3f', '%40': '\x40', '%41': '\x41',
+ '%42': '\x42', '%43': '\x43', '%44': '\x44', '%45': '\x45', '%46': '\x46',
+ '%47': '\x47', '%48': '\x48', '%49': '\x49', '%4a': '\x4a', '%4A': '\x4a',
+ '%4b': '\x4b', '%4B': '\x4b', '%4c': '\x4c', '%4C': '\x4c', '%4d': '\x4d',
+ '%4D': '\x4d', '%4e': '\x4e', '%4E': '\x4e', '%4f': '\x4f', '%4F': '\x4f',
+ '%50': '\x50', '%51': '\x51', '%52': '\x52', '%53': '\x53', '%54': '\x54',
+ '%55': '\x55', '%56': '\x56', '%57': '\x57', '%58': '\x58', '%59': '\x59',
+ '%5a': '\x5a', '%5A': '\x5a', '%5b': '\x5b', '%5B': '\x5b', '%5c': '\x5c',
+ '%5C': '\x5c', '%5d': '\x5d', '%5D': '\x5d', '%5e': '\x5e', '%5E': '\x5e',
+ '%5f': '\x5f', '%5F': '\x5f', '%60': '\x60', '%61': '\x61', '%62': '\x62',
+ '%63': '\x63', '%64': '\x64', '%65': '\x65', '%66': '\x66', '%67': '\x67',
+ '%68': '\x68', '%69': '\x69', '%6a': '\x6a', '%6A': '\x6a', '%6b': '\x6b',
+ '%6B': '\x6b', '%6c': '\x6c', '%6C': '\x6c', '%6d': '\x6d', '%6D': '\x6d',
+ '%6e': '\x6e', '%6E': '\x6e', '%6f': '\x6f', '%6F': '\x6f', '%70': '\x70',
+ '%71': '\x71', '%72': '\x72', '%73': '\x73', '%74': '\x74', '%75': '\x75',
+ '%76': '\x76', '%77': '\x77', '%78': '\x78', '%79': '\x79', '%7a': '\x7a',
+ '%7A': '\x7a', '%7b': '\x7b', '%7B': '\x7b', '%7c': '\x7c', '%7C': '\x7c',
+ '%7d': '\x7d', '%7D': '\x7d', '%7e': '\x7e', '%7E': '\x7e', '%7f': '\x7f',
+ '%7F': '\x7f', '%80': '\x80', '%81': '\x81', '%82': '\x82', '%83': '\x83',
+ '%84': '\x84', '%85': '\x85', '%86': '\x86', '%87': '\x87', '%88': '\x88',
+ '%89': '\x89', '%8a': '\x8a', '%8A': '\x8a', '%8b': '\x8b', '%8B': '\x8b',
+ '%8c': '\x8c', '%8C': '\x8c', '%8d': '\x8d', '%8D': '\x8d', '%8e': '\x8e',
+ '%8E': '\x8e', '%8f': '\x8f', '%8F': '\x8f', '%90': '\x90', '%91': '\x91',
+ '%92': '\x92', '%93': '\x93', '%94': '\x94', '%95': '\x95', '%96': '\x96',
+ '%97': '\x97', '%98': '\x98', '%99': '\x99', '%9a': '\x9a', '%9A': '\x9a',
+ '%9b': '\x9b', '%9B': '\x9b', '%9c': '\x9c', '%9C': '\x9c', '%9d': '\x9d',
+ '%9D': '\x9d', '%9e': '\x9e', '%9E': '\x9e', '%9f': '\x9f', '%9F': '\x9f',
+ '%a0': '\xa0', '%A0': '\xa0', '%a1': '\xa1', '%A1': '\xa1', '%a2': '\xa2',
+ '%A2': '\xa2', '%a3': '\xa3', '%A3': '\xa3', '%a4': '\xa4', '%A4': '\xa4',
+ '%a5': '\xa5', '%A5': '\xa5', '%a6': '\xa6', '%A6': '\xa6', '%a7': '\xa7',
+ '%A7': '\xa7', '%a8': '\xa8', '%A8': '\xa8', '%a9': '\xa9', '%A9': '\xa9',
+ '%aa': '\xaa', '%Aa': '\xaa', '%aA': '\xaa', '%AA': '\xaa', '%ab': '\xab',
+ '%Ab': '\xab', '%aB': '\xab', '%AB': '\xab', '%ac': '\xac', '%Ac': '\xac',
+ '%aC': '\xac', '%AC': '\xac', '%ad': '\xad', '%Ad': '\xad', '%aD': '\xad',
+ '%AD': '\xad', '%ae': '\xae', '%Ae': '\xae', '%aE': '\xae', '%AE': '\xae',
+ '%af': '\xaf', '%Af': '\xaf', '%aF': '\xaf', '%AF': '\xaf', '%b0': '\xb0',
+ '%B0': '\xb0', '%b1': '\xb1', '%B1': '\xb1', '%b2': '\xb2', '%B2': '\xb2',
+ '%b3': '\xb3', '%B3': '\xb3', '%b4': '\xb4', '%B4': '\xb4', '%b5': '\xb5',
+ '%B5': '\xb5', '%b6': '\xb6', '%B6': '\xb6', '%b7': '\xb7', '%B7': '\xb7',
+ '%b8': '\xb8', '%B8': '\xb8', '%b9': '\xb9', '%B9': '\xb9', '%ba': '\xba',
+ '%Ba': '\xba', '%bA': '\xba', '%BA': '\xba', '%bb': '\xbb', '%Bb': '\xbb',
+ '%bB': '\xbb', '%BB': '\xbb', '%bc': '\xbc', '%Bc': '\xbc', '%bC': '\xbc',
+ '%BC': '\xbc', '%bd': '\xbd', '%Bd': '\xbd', '%bD': '\xbd', '%BD': '\xbd',
+ '%be': '\xbe', '%Be': '\xbe', '%bE': '\xbe', '%BE': '\xbe', '%bf': '\xbf',
+ '%Bf': '\xbf', '%bF': '\xbf', '%BF': '\xbf', '%c0': '\xc0', '%C0': '\xc0',
+ '%c1': '\xc1', '%C1': '\xc1', '%c2': '\xc2', '%C2': '\xc2', '%c3': '\xc3',
+ '%C3': '\xc3', '%c4': '\xc4', '%C4': '\xc4', '%c5': '\xc5', '%C5': '\xc5',
+ '%c6': '\xc6', '%C6': '\xc6', '%c7': '\xc7', '%C7': '\xc7', '%c8': '\xc8',
+ '%C8': '\xc8', '%c9': '\xc9', '%C9': '\xc9', '%ca': '\xca', '%Ca': '\xca',
+ '%cA': '\xca', '%CA': '\xca', '%cb': '\xcb', '%Cb': '\xcb', '%cB': '\xcb',
+ '%CB': '\xcb', '%cc': '\xcc', '%Cc': '\xcc', '%cC': '\xcc', '%CC': '\xcc',
+ '%cd': '\xcd', '%Cd': '\xcd', '%cD': '\xcd', '%CD': '\xcd', '%ce': '\xce',
+ '%Ce': '\xce', '%cE': '\xce', '%CE': '\xce', '%cf': '\xcf', '%Cf': '\xcf',
+ '%cF': '\xcf', '%CF': '\xcf', '%d0': '\xd0', '%D0': '\xd0', '%d1': '\xd1',
+ '%D1': '\xd1', '%d2': '\xd2', '%D2': '\xd2', '%d3': '\xd3', '%D3': '\xd3',
+ '%d4': '\xd4', '%D4': '\xd4', '%d5': '\xd5', '%D5': '\xd5', '%d6': '\xd6',
+ '%D6': '\xd6', '%d7': '\xd7', '%D7': '\xd7', '%d8': '\xd8', '%D8': '\xd8',
+ '%d9': '\xd9', '%D9': '\xd9', '%da': '\xda', '%Da': '\xda', '%dA': '\xda',
+ '%DA': '\xda', '%db': '\xdb', '%Db': '\xdb', '%dB': '\xdb', '%DB': '\xdb',
+ '%dc': '\xdc', '%Dc': '\xdc', '%dC': '\xdc', '%DC': '\xdc', '%dd': '\xdd',
+ '%Dd': '\xdd', '%dD': '\xdd', '%DD': '\xdd', '%de': '\xde', '%De': '\xde',
+ '%dE': '\xde', '%DE': '\xde', '%df': '\xdf', '%Df': '\xdf', '%dF': '\xdf',
+ '%DF': '\xdf', '%e0': '\xe0', '%E0': '\xe0', '%e1': '\xe1', '%E1': '\xe1',
+ '%e2': '\xe2', '%E2': '\xe2', '%e3': '\xe3', '%E3': '\xe3', '%e4': '\xe4',
+ '%E4': '\xe4', '%e5': '\xe5', '%E5': '\xe5', '%e6': '\xe6', '%E6': '\xe6',
+ '%e7': '\xe7', '%E7': '\xe7', '%e8': '\xe8', '%E8': '\xe8', '%e9': '\xe9',
+ '%E9': '\xe9', '%ea': '\xea', '%Ea': '\xea', '%eA': '\xea', '%EA': '\xea',
+ '%eb': '\xeb', '%Eb': '\xeb', '%eB': '\xeb', '%EB': '\xeb', '%ec': '\xec',
+ '%Ec': '\xec', '%eC': '\xec', '%EC': '\xec', '%ed': '\xed', '%Ed': '\xed',
+ '%eD': '\xed', '%ED': '\xed', '%ee': '\xee', '%Ee': '\xee', '%eE': '\xee',
+ '%EE': '\xee', '%ef': '\xef', '%Ef': '\xef', '%eF': '\xef', '%EF': '\xef',
+ '%f0': '\xf0', '%F0': '\xf0', '%f1': '\xf1', '%F1': '\xf1', '%f2': '\xf2',
+ '%F2': '\xf2', '%f3': '\xf3', '%F3': '\xf3', '%f4': '\xf4', '%F4': '\xf4',
+ '%f5': '\xf5', '%F5': '\xf5', '%f6': '\xf6', '%F6': '\xf6', '%f7': '\xf7',
+ '%F7': '\xf7', '%f8': '\xf8', '%F8': '\xf8', '%f9': '\xf9', '%F9': '\xf9',
+ '%fa': '\xfa', '%Fa': '\xfa', '%fA': '\xfa', '%FA': '\xfa', '%fb': '\xfb',
+ '%Fb': '\xfb', '%fB': '\xfb', '%FB': '\xfb', '%fc': '\xfc', '%Fc': '\xfc',
+ '%fC': '\xfc', '%FC': '\xfc', '%fd': '\xfd', '%Fd': '\xfd', '%fD': '\xfd',
+ '%FD': '\xfd', '%fe': '\xfe', '%Fe': '\xfe', '%fE': '\xfe', '%FE': '\xfe',
+ '%ff': '\xff', '%Ff': '\xff', '%fF': '\xff', '%FF': '\xff'
}
-function emitError(self, err) {
- if (self.emittedError) return;
- self.emittedError = true;
- self.emit("error", err);
+
+function encodedReplacer (match) {
+ return EncodedLookup[match]
}
-ZipFile.prototype.readEntry = function() {
- if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
- this._readEntry();
-};
-ZipFile.prototype._readEntry = function() {
- var self = this;
- if (self.entryCount === self.entriesRead) {
- // done with metadata
- setImmediate(function() {
- if (self.autoClose) self.close();
- if (self.emittedError) return;
- self.emit("end");
- });
- return;
+const STATE_KEY = 0
+const STATE_VALUE = 1
+const STATE_CHARSET = 2
+const STATE_LANG = 3
+
+function parseParams (str) {
+ const res = []
+ let state = STATE_KEY
+ let charset = ''
+ let inquote = false
+ let escaping = false
+ let p = 0
+ let tmp = ''
+ const len = str.length
+
+ for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
+ const char = str[i]
+ if (char === '\\' && inquote) {
+ if (escaping) { escaping = false } else {
+ escaping = true
+ continue
+ }
+ } else if (char === '"') {
+ if (!escaping) {
+ if (inquote) {
+ inquote = false
+ state = STATE_KEY
+ } else { inquote = true }
+ continue
+ } else { escaping = false }
+ } else {
+ if (escaping && inquote) { tmp += '\\' }
+ escaping = false
+ if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
+ if (state === STATE_CHARSET) {
+ state = STATE_LANG
+ charset = tmp.substring(1)
+ } else { state = STATE_VALUE }
+ tmp = ''
+ continue
+ } else if (state === STATE_KEY &&
+ (char === '*' || char === '=') &&
+ res.length) {
+ state = char === '*'
+ ? STATE_CHARSET
+ : STATE_VALUE
+ res[p] = [tmp, undefined]
+ tmp = ''
+ continue
+ } else if (!inquote && char === ';') {
+ state = STATE_KEY
+ if (charset) {
+ if (tmp.length) {
+ tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
+ 'binary',
+ charset)
+ }
+ charset = ''
+ } else if (tmp.length) {
+ tmp = decodeText(tmp, 'binary', 'utf8')
+ }
+ if (res[p] === undefined) { res[p] = tmp } else { res[p][1] = tmp }
+ tmp = ''
+ ++p
+ continue
+ } else if (!inquote && (char === ' ' || char === '\t')) { continue }
+ }
+ tmp += char
+ }
+ if (charset && tmp.length) {
+ tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
+ 'binary',
+ charset)
+ } else if (tmp) {
+ tmp = decodeText(tmp, 'binary', 'utf8')
}
- if (self.emittedError) return;
- var buffer = newBuffer(46);
- readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
- if (err) return emitErrorAndAutoClose(self, err);
- if (self.emittedError) return;
- var entry = new Entry();
- // 0 - Central directory file header signature
- var signature = buffer.readUInt32LE(0);
- if (signature !== 0x02014b50) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
- // 4 - Version made by
- entry.versionMadeBy = buffer.readUInt16LE(4);
- // 6 - Version needed to extract (minimum)
- entry.versionNeededToExtract = buffer.readUInt16LE(6);
- // 8 - General purpose bit flag
- entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
- // 10 - Compression method
- entry.compressionMethod = buffer.readUInt16LE(10);
- // 12 - File last modification time
- entry.lastModFileTime = buffer.readUInt16LE(12);
- // 14 - File last modification date
- entry.lastModFileDate = buffer.readUInt16LE(14);
- // 16 - CRC-32
- entry.crc32 = buffer.readUInt32LE(16);
- // 20 - Compressed size
- entry.compressedSize = buffer.readUInt32LE(20);
- // 24 - Uncompressed size
- entry.uncompressedSize = buffer.readUInt32LE(24);
- // 28 - File name length (n)
- entry.fileNameLength = buffer.readUInt16LE(28);
- // 30 - Extra field length (m)
- entry.extraFieldLength = buffer.readUInt16LE(30);
- // 32 - File comment length (k)
- entry.fileCommentLength = buffer.readUInt16LE(32);
- // 34 - Disk number where file starts
- // 36 - Internal file attributes
- entry.internalFileAttributes = buffer.readUInt16LE(36);
- // 38 - External file attributes
- entry.externalFileAttributes = buffer.readUInt32LE(38);
- // 42 - Relative offset of local file header
- entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
- if (entry.generalPurposeBitFlag & 0x40) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
+ if (res[p] === undefined) {
+ if (tmp) { res[p] = tmp }
+ } else { res[p][1] = tmp }
- self.readEntryCursor += 46;
+ return res
+}
- buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
- readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
- if (err) return emitErrorAndAutoClose(self, err);
- if (self.emittedError) return;
- // 46 - File name
- var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0;
- entry.fileName = self.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8)
- : buffer.slice(0, entry.fileNameLength);
+module.exports = parseParams
- // 46+n - Extra field
- var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
- var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
- entry.extraFields = [];
- var i = 0;
- while (i < extraFieldBuffer.length - 3) {
- var headerId = extraFieldBuffer.readUInt16LE(i + 0);
- var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
- var dataStart = i + 4;
- var dataEnd = dataStart + dataSize;
- if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self, new Error("extra field length exceeds extra field buffer size"));
- var dataBuffer = newBuffer(dataSize);
- extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
- entry.extraFields.push({
- id: headerId,
- data: dataBuffer,
- });
- i = dataEnd;
- }
- // 46+n+m - File comment
- entry.fileComment = self.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8)
- : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
- // compatibility hack for https://github.com/thejoshwolfe/yauzl/issues/47
- entry.comment = entry.fileComment;
+/***/ }),
- self.readEntryCursor += buffer.length;
- self.entriesRead += 1;
+/***/ 15206:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
- if (entry.uncompressedSize === 0xffffffff ||
- entry.compressedSize === 0xffffffff ||
- entry.relativeOffsetOfLocalHeader === 0xffffffff) {
- // ZIP64 format
- // find the Zip64 Extended Information Extra Field
- var zip64EiefBuffer = null;
- for (var i = 0; i < entry.extraFields.length; i++) {
- var extraField = entry.extraFields[i];
- if (extraField.id === 0x0001) {
- zip64EiefBuffer = extraField.data;
- break;
- }
+"use strict";
+
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) 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 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+ var ownKeys = function(o) {
+ ownKeys = Object.getOwnPropertyNames || function (o) {
+ var ar = [];
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o);
+ };
+ return function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+ __setModuleDefault(result, mod);
+ return result;
+ };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CLI = void 0;
+exports.makeProgressCallback = makeProgressCallback;
+const process_1 = __nccwpck_require__(932);
+const readline = __importStar(__nccwpck_require__(23785));
+const progress_1 = __importDefault(__nccwpck_require__(49243));
+const yargs_1 = __importDefault(__nccwpck_require__(15229));
+const helpers_1 = __nccwpck_require__(47763);
+const browser_data_js_1 = __nccwpck_require__(35255);
+const Cache_js_1 = __nccwpck_require__(95674);
+const detectPlatform_js_1 = __nccwpck_require__(79014);
+const install_js_1 = __nccwpck_require__(37619);
+const launch_js_1 = __nccwpck_require__(6485);
+/**
+ * @public
+ */
+class CLI {
+ #cachePath;
+ #rl;
+ #scriptName = '';
+ #allowCachePathOverride = true;
+ #pinnedBrowsers;
+ #prefixCommand;
+ constructor(opts, rl) {
+ if (!opts) {
+ opts = {};
}
- if (zip64EiefBuffer == null) {
- return emitErrorAndAutoClose(self, new Error("expected zip64 extended information extra field"));
+ if (typeof opts === 'string') {
+ opts = {
+ cachePath: opts,
+ };
}
- var index = 0;
- // 0 - Original Size 8 bytes
- if (entry.uncompressedSize === 0xffffffff) {
- if (index + 8 > zip64EiefBuffer.length) {
- return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
- }
- entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
- index += 8;
+ this.#cachePath = opts.cachePath ?? process.cwd();
+ this.#rl = rl;
+ this.#scriptName = opts.scriptName ?? '@puppeteer/browsers';
+ this.#allowCachePathOverride = opts.allowCachePathOverride ?? true;
+ this.#pinnedBrowsers = opts.pinnedBrowsers;
+ this.#prefixCommand = opts.prefixCommand;
+ }
+ #defineBrowserParameter(yargs) {
+ yargs.positional('browser', {
+ description: 'Which browser to install [@]. `latest` will try to find the latest available build. `buildId` is a browser-specific identifier such as a version or a revision.',
+ type: 'string',
+ coerce: (opt) => {
+ return {
+ name: this.#parseBrowser(opt),
+ buildId: this.#parseBuildId(opt),
+ };
+ },
+ });
+ }
+ #definePlatformParameter(yargs) {
+ yargs.option('platform', {
+ type: 'string',
+ desc: 'Platform that the binary needs to be compatible with.',
+ choices: Object.values(browser_data_js_1.BrowserPlatform),
+ defaultDescription: 'Auto-detected',
+ });
+ }
+ #definePathParameter(yargs, required = false) {
+ if (!this.#allowCachePathOverride) {
+ return;
}
- // 8 - Compressed Size 8 bytes
- if (entry.compressedSize === 0xffffffff) {
- if (index + 8 > zip64EiefBuffer.length) {
- return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
- }
- entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
- index += 8;
+ yargs.option('path', {
+ type: 'string',
+ desc: 'Path to the root folder for the browser downloads and installation. The installation folder structure is compatible with the cache structure used by Puppeteer.',
+ defaultDescription: 'Current working directory',
+ ...(required ? {} : { default: process.cwd() }),
+ });
+ if (required) {
+ yargs.demandOption('path');
}
- // 16 - Relative Header Offset 8 bytes
- if (entry.relativeOffsetOfLocalHeader === 0xffffffff) {
- if (index + 8 > zip64EiefBuffer.length) {
- return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
- }
- entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
- index += 8;
+ }
+ async run(argv) {
+ const yargsInstance = (0, yargs_1.default)((0, helpers_1.hideBin)(argv));
+ let target = yargsInstance.scriptName(this.#scriptName);
+ if (this.#prefixCommand) {
+ target = target.command(this.#prefixCommand.cmd, this.#prefixCommand.description, yargs => {
+ return this.#build(yargs);
+ });
}
- // 24 - Disk Start Number 4 bytes
- }
-
- // check for Info-ZIP Unicode Path Extra Field (0x7075)
- // see https://github.com/thejoshwolfe/yauzl/issues/33
- if (self.decodeStrings) {
- for (var i = 0; i < entry.extraFields.length; i++) {
- var extraField = entry.extraFields[i];
- if (extraField.id === 0x7075) {
- if (extraField.data.length < 6) {
- // too short to be meaningful
- continue;
+ else {
+ target = this.#build(target);
+ }
+ await target
+ .demandCommand(1)
+ .help()
+ .wrap(Math.min(120, yargsInstance.terminalWidth()))
+ .parse();
+ }
+ #build(yargs) {
+ const latestOrPinned = this.#pinnedBrowsers ? 'pinned' : 'latest';
+ // If there are pinned browsers allow the positional arg to be optional
+ const browserArgType = this.#pinnedBrowsers ? '[browser]' : '';
+ return yargs
+ .command(`install ${browserArgType}`, 'Download and install the specified browser. If successful, the command outputs the actual browser buildId that was installed and the absolute path to the browser executable (format: @ ).', yargs => {
+ this.#defineBrowserParameter(yargs);
+ this.#definePlatformParameter(yargs);
+ this.#definePathParameter(yargs);
+ yargs.option('base-url', {
+ type: 'string',
+ desc: 'Base URL to download from',
+ });
+ if (this.#pinnedBrowsers) {
+ yargs.example('$0 install', 'Install all pinned browsers');
}
- // Version 1 byte version of this extra field, currently 1
- if (extraField.data.readUInt8(0) !== 1) {
- // > Changes may not be backward compatible so this extra
- // > field should not be used if the version is not recognized.
- continue;
+ yargs.option('install-deps', {
+ type: 'boolean',
+ desc: 'Whether to attempt installing system dependencies (only supported on Linux, requires root privileges).',
+ default: false,
+ });
+ yargs.example('$0 install chrome', `Install the ${latestOrPinned} available build of the Chrome browser.`);
+ yargs.example('$0 install chrome@latest', 'Install the latest available build for the Chrome browser.');
+ yargs.example('$0 install chrome@stable', 'Install the latest available build for the Chrome browser from the stable channel.');
+ yargs.example('$0 install chrome@beta', 'Install the latest available build for the Chrome browser from the beta channel.');
+ yargs.example('$0 install chrome@dev', 'Install the latest available build for the Chrome browser from the dev channel.');
+ yargs.example('$0 install chrome@canary', 'Install the latest available build for the Chrome Canary browser.');
+ yargs.example('$0 install chrome@115', 'Install the latest available build for Chrome 115.');
+ yargs.example('$0 install chromedriver@canary', 'Install the latest available build for ChromeDriver Canary.');
+ yargs.example('$0 install chromedriver@115', 'Install the latest available build for ChromeDriver 115.');
+ yargs.example('$0 install chromedriver@115.0.5790', 'Install the latest available patch (115.0.5790.X) build for ChromeDriver.');
+ yargs.example('$0 install chrome-headless-shell', 'Install the latest available chrome-headless-shell build.');
+ yargs.example('$0 install chrome-headless-shell@beta', 'Install the latest available chrome-headless-shell build corresponding to the Beta channel.');
+ yargs.example('$0 install chrome-headless-shell@118', 'Install the latest available chrome-headless-shell 118 build.');
+ yargs.example('$0 install chromium@1083080', 'Install the revision 1083080 of the Chromium browser.');
+ yargs.example('$0 install firefox', 'Install the latest nightly available build of the Firefox browser.');
+ yargs.example('$0 install firefox@stable', 'Install the latest stable build of the Firefox browser.');
+ yargs.example('$0 install firefox@beta', 'Install the latest beta build of the Firefox browser.');
+ yargs.example('$0 install firefox@devedition', 'Install the latest devedition build of the Firefox browser.');
+ yargs.example('$0 install firefox@esr', 'Install the latest ESR build of the Firefox browser.');
+ yargs.example('$0 install firefox@nightly', 'Install the latest nightly build of the Firefox browser.');
+ yargs.example('$0 install firefox@stable_111.0.1', 'Install a specific version of the Firefox browser.');
+ yargs.example('$0 install firefox --platform mac', 'Install the latest Mac (Intel) build of the Firefox browser.');
+ if (this.#allowCachePathOverride) {
+ yargs.example('$0 install firefox --path /tmp/my-browser-cache', 'Install to the specified cache directory.');
}
- // NameCRC32 4 bytes File Name Field CRC32 Checksum
- var oldNameCrc32 = extraField.data.readUInt32LE(1);
- if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
- // > If the CRC check fails, this UTF-8 Path Extra Field should be
- // > ignored and the File Name field in the header should be used instead.
- continue;
+ }, async (argv) => {
+ const args = argv;
+ if (this.#pinnedBrowsers && !args.browser) {
+ // Use allSettled to avoid scenarios that
+ // a browser may fail early and leave the other
+ // installation in a faulty state
+ const result = await Promise.allSettled(Object.entries(this.#pinnedBrowsers).map(async ([browser, options]) => {
+ if (options.skipDownload) {
+ return;
+ }
+ await this.#install({
+ ...argv,
+ browser: {
+ name: browser,
+ buildId: options.buildId,
+ },
+ });
+ }));
+ for (const install of result) {
+ if (install.status === 'rejected') {
+ throw install.reason;
+ }
+ }
+ }
+ else {
+ await this.#install(args);
+ }
+ })
+ .command('launch ', 'Launch the specified browser', yargs => {
+ this.#defineBrowserParameter(yargs);
+ this.#definePlatformParameter(yargs);
+ this.#definePathParameter(yargs);
+ yargs.option('detached', {
+ type: 'boolean',
+ desc: 'Detach the child process.',
+ default: false,
+ });
+ yargs.option('system', {
+ type: 'boolean',
+ desc: 'Search for a browser installed on the system instead of the cache folder.',
+ default: false,
+ });
+ yargs.example('$0 launch chrome@115.0.5790.170', 'Launch Chrome 115.0.5790.170');
+ yargs.example('$0 launch firefox@112.0a1', 'Launch the Firefox browser identified by the milestone 112.0a1.');
+ yargs.example('$0 launch chrome@115.0.5790.170 --detached', 'Launch the browser but detach the sub-processes.');
+ yargs.example('$0 launch chrome@canary --system', 'Try to locate the Canary build of Chrome installed on the system and launch it.');
+ }, async (argv) => {
+ const args = argv;
+ const executablePath = args.system
+ ? (0, launch_js_1.computeSystemExecutablePath)({
+ browser: args.browser.name,
+ // TODO: throw an error if not a ChromeReleaseChannel is provided.
+ channel: args.browser.buildId,
+ platform: args.platform,
+ })
+ : (0, launch_js_1.computeExecutablePath)({
+ browser: args.browser.name,
+ buildId: args.browser.buildId,
+ cacheDir: args.path ?? this.#cachePath,
+ platform: args.platform,
+ });
+ (0, launch_js_1.launch)({
+ executablePath,
+ detached: args.detached,
+ });
+ })
+ .command('clear', this.#allowCachePathOverride
+ ? 'Removes all installed browsers from the specified cache directory'
+ : `Removes all installed browsers from ${this.#cachePath}`, yargs => {
+ this.#definePathParameter(yargs, true);
+ }, async (argv) => {
+ const args = argv;
+ const cacheDir = args.path ?? this.#cachePath;
+ const rl = this.#rl ?? readline.createInterface({ input: process_1.stdin, output: process_1.stdout });
+ rl.question(`Do you want to permanently and recursively delete the content of ${cacheDir} (yes/No)? `, answer => {
+ rl.close();
+ if (!['y', 'yes'].includes(answer.toLowerCase().trim())) {
+ console.log('Cancelled.');
+ return;
+ }
+ const cache = new Cache_js_1.Cache(cacheDir);
+ cache.clear();
+ console.log(`${cacheDir} cleared.`);
+ });
+ })
+ .command('list', 'List all installed browsers in the cache directory', yargs => {
+ this.#definePathParameter(yargs);
+ yargs.example('$0 list', 'List all installed browsers in the cache directory');
+ if (this.#allowCachePathOverride) {
+ yargs.example('$0 list --path /tmp/my-browser-cache', 'List browsers installed in the specified cache directory');
+ }
+ }, async (argv) => {
+ const args = argv;
+ const cacheDir = args.path ?? this.#cachePath;
+ const cache = new Cache_js_1.Cache(cacheDir);
+ const browsers = cache.getInstalledBrowsers();
+ for (const browser of browsers) {
+ console.log(`${browser.browser}@${browser.buildId} (${browser.platform}) ${browser.executablePath}`);
}
- // UnicodeName Variable UTF-8 version of the entry File Name
- entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
- break;
- }
+ })
+ .demandCommand(1)
+ .help();
+ }
+ #parseBrowser(version) {
+ return version.split('@').shift();
+ }
+ #parseBuildId(version) {
+ const parts = version.split('@');
+ return parts.length === 2
+ ? parts[1]
+ : this.#pinnedBrowsers
+ ? 'pinned'
+ : 'latest';
+ }
+ async #install(args) {
+ args.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ if (!args.browser) {
+ throw new Error(`No browser arg proveded`);
}
- }
-
- // validate file size
- if (self.validateEntrySizes && entry.compressionMethod === 0) {
- var expectedCompressedSize = entry.uncompressedSize;
- if (entry.isEncrypted()) {
- // traditional encryption prefixes the file data with a header
- expectedCompressedSize += 12;
+ if (!args.platform) {
+ throw new Error(`Could not resolve the current platform`);
}
- if (entry.compressedSize !== expectedCompressedSize) {
- var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
- return emitErrorAndAutoClose(self, new Error(msg));
+ if (args.browser.buildId === 'pinned') {
+ const options = this.#pinnedBrowsers?.[args.browser.name];
+ if (!options || !options.buildId) {
+ throw new Error(`No pinned version found for ${args.browser.name}`);
+ }
+ args.browser.buildId = options.buildId;
}
- }
-
- if (self.decodeStrings) {
- if (!self.strictFileNames) {
- // allow backslash
- entry.fileName = entry.fileName.replace(/\\/g, "/");
+ const originalBuildId = args.browser.buildId;
+ args.browser.buildId = await (0, browser_data_js_1.resolveBuildId)(args.browser.name, args.platform, args.browser.buildId);
+ await (0, install_js_1.install)({
+ browser: args.browser.name,
+ buildId: args.browser.buildId,
+ platform: args.platform,
+ cacheDir: args.path ?? this.#cachePath,
+ downloadProgressCallback: makeProgressCallback(args.browser.name, args.browser.buildId),
+ baseUrl: args.baseUrl,
+ buildIdAlias: originalBuildId !== args.browser.buildId ? originalBuildId : undefined,
+ installDeps: args.installDeps,
+ });
+ console.log(`${args.browser.name}@${args.browser.buildId} ${(0, launch_js_1.computeExecutablePath)({
+ browser: args.browser.name,
+ buildId: args.browser.buildId,
+ cacheDir: args.path ?? this.#cachePath,
+ platform: args.platform,
+ })}`);
+ }
+}
+exports.CLI = CLI;
+/**
+ * @public
+ */
+function makeProgressCallback(browser, buildId) {
+ let progressBar;
+ let lastDownloadedBytes = 0;
+ return (downloadedBytes, totalBytes) => {
+ if (!progressBar) {
+ progressBar = new progress_1.default(`Downloading ${browser} ${buildId} - ${toMegabytes(totalBytes)} [:bar] :percent :etas `, {
+ complete: '=',
+ incomplete: ' ',
+ width: 20,
+ total: totalBytes,
+ });
}
- var errorMessage = validateFileName(entry.fileName, self.validateFileNameOptions);
- if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
- }
- self.emit("entry", entry);
+ const delta = downloadedBytes - lastDownloadedBytes;
+ lastDownloadedBytes = downloadedBytes;
+ progressBar.tick(delta);
+ };
+}
+function toMegabytes(bytes) {
+ const mb = bytes / 1000 / 1000;
+ return `${Math.round(mb * 10) / 10} MB`;
+}
+//# sourceMappingURL=CLI.js.map
- if (!self.lazyEntries) self._readEntry();
- });
- });
-};
+/***/ }),
-ZipFile.prototype.openReadStream = function(entry, options, callback) {
- var self = this;
- // parameter validation
- var relativeStart = 0;
- var relativeEnd = entry.compressedSize;
- if (callback == null) {
- callback = options;
- options = {};
- } else {
- // validate options that the caller has no excuse to get wrong
- if (options.decrypt != null) {
- if (!entry.isEncrypted()) {
- throw new Error("options.decrypt can only be specified for encrypted entries");
- }
- if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
- if (entry.isCompressed()) {
- if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
- }
+/***/ 95674:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Cache = exports.InstalledBrowser = void 0;
+const fs_1 = __importDefault(__nccwpck_require__(79896));
+const os_1 = __importDefault(__nccwpck_require__(70857));
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const debug_1 = __importDefault(__nccwpck_require__(2830));
+const browser_data_js_1 = __nccwpck_require__(35255);
+const detectPlatform_js_1 = __nccwpck_require__(79014);
+const debugCache = (0, debug_1.default)('puppeteer:browsers:cache');
+/**
+ * @public
+ */
+class InstalledBrowser {
+ browser;
+ buildId;
+ platform;
+ executablePath;
+ #cache;
+ /**
+ * @internal
+ */
+ constructor(cache, browser, buildId, platform) {
+ this.#cache = cache;
+ this.browser = browser;
+ this.buildId = buildId;
+ this.platform = platform;
+ this.executablePath = cache.computeExecutablePath({
+ browser,
+ buildId,
+ platform,
+ });
}
- if (options.decompress != null) {
- if (!entry.isCompressed()) {
- throw new Error("options.decompress can only be specified for compressed entries");
- }
- if (!(options.decompress === false || options.decompress === true)) {
- throw new Error("invalid options.decompress value: " + options.decompress);
- }
+ /**
+ * Path to the root of the installation folder. Use
+ * {@link computeExecutablePath} to get the path to the executable binary.
+ */
+ get path() {
+ return this.#cache.installationDir(this.browser, this.platform, this.buildId);
}
- if (options.start != null || options.end != null) {
- if (entry.isCompressed() && options.decompress !== false) {
- throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
- }
- if (entry.isEncrypted() && options.decrypt !== false) {
- throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
- }
+ readMetadata() {
+ return this.#cache.readMetadata(this.browser);
}
- if (options.start != null) {
- relativeStart = options.start;
- if (relativeStart < 0) throw new Error("options.start < 0");
- if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
+ writeMetadata(metadata) {
+ this.#cache.writeMetadata(this.browser, metadata);
}
- if (options.end != null) {
- relativeEnd = options.end;
- if (relativeEnd < 0) throw new Error("options.end < 0");
- if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
- if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
+}
+exports.InstalledBrowser = InstalledBrowser;
+/**
+ * The cache used by Puppeteer relies on the following structure:
+ *
+ * - rootDir
+ * -- | browserRoot(browser1)
+ * ---- - | installationDir()
+ * ------ the browser-platform-buildId
+ * ------ specific structure.
+ * -- | browserRoot(browser2)
+ * ---- - | installationDir()
+ * ------ the browser-platform-buildId
+ * ------ specific structure.
+ * @internal
+ */
+class Cache {
+ #rootDir;
+ constructor(rootDir) {
+ this.#rootDir = rootDir;
}
- }
- // any further errors can either be caused by the zipfile,
- // or were introduced in a minor version of yauzl,
- // so should be passed to the client rather than thrown.
- if (!self.isOpen) return callback(new Error("closed"));
- if (entry.isEncrypted()) {
- if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
- }
- // make sure we don't lose the fd before we open the actual read stream
- self.reader.ref();
- var buffer = newBuffer(30);
- readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
- try {
- if (err) return callback(err);
- // 0 - Local file header signature = 0x04034b50
- var signature = buffer.readUInt32LE(0);
- if (signature !== 0x04034b50) {
- return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
- }
- // all this should be redundant
- // 4 - Version needed to extract (minimum)
- // 6 - General purpose bit flag
- // 8 - Compression method
- // 10 - File last modification time
- // 12 - File last modification date
- // 14 - CRC-32
- // 18 - Compressed size
- // 22 - Uncompressed size
- // 26 - File name length (n)
- var fileNameLength = buffer.readUInt16LE(26);
- // 28 - Extra field length (m)
- var extraFieldLength = buffer.readUInt16LE(28);
- // 30 - File name
- // 30+n - Extra field
- var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
- var decompress;
- if (entry.compressionMethod === 0) {
- // 0 - The file is stored (no compression)
- decompress = false;
- } else if (entry.compressionMethod === 8) {
- // 8 - The file is Deflated
- decompress = options.decompress != null ? options.decompress : true;
- } else {
- return callback(new Error("unsupported compression method: " + entry.compressionMethod));
- }
- var fileDataStart = localFileHeaderEnd;
- var fileDataEnd = fileDataStart + entry.compressedSize;
- if (entry.compressedSize !== 0) {
- // bounds check now, because the read streams will probably not complain loud enough.
- // since we're dealing with an unsigned offset plus an unsigned size,
- // we only have 1 thing to check for.
- if (fileDataEnd > self.fileSize) {
- return callback(new Error("file data overflows file bounds: " +
- fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+ /**
+ * @internal
+ */
+ get rootDir() {
+ return this.#rootDir;
+ }
+ browserRoot(browser) {
+ return path_1.default.join(this.#rootDir, browser);
+ }
+ metadataFile(browser) {
+ return path_1.default.join(this.browserRoot(browser), '.metadata');
+ }
+ readMetadata(browser) {
+ const metatadaPath = this.metadataFile(browser);
+ if (!fs_1.default.existsSync(metatadaPath)) {
+ return { aliases: {} };
}
- }
- var readStream = self.reader.createReadStream({
- start: fileDataStart + relativeStart,
- end: fileDataStart + relativeEnd,
- });
- var endpointStream = readStream;
- if (decompress) {
- var destroyed = false;
- var inflateFilter = zlib.createInflateRaw();
- readStream.on("error", function(err) {
- // setImmediate here because errors can be emitted during the first call to pipe()
- setImmediate(function() {
- if (!destroyed) inflateFilter.emit("error", err);
- });
+ // TODO: add type-safe parsing.
+ const data = JSON.parse(fs_1.default.readFileSync(metatadaPath, 'utf8'));
+ if (typeof data !== 'object') {
+ throw new Error('.metadata is not an object');
+ }
+ return data;
+ }
+ writeMetadata(browser, metadata) {
+ const metatadaPath = this.metadataFile(browser);
+ fs_1.default.mkdirSync(path_1.default.dirname(metatadaPath), { recursive: true });
+ fs_1.default.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2));
+ }
+ resolveAlias(browser, alias) {
+ const metadata = this.readMetadata(browser);
+ if (alias === 'latest') {
+ return Object.values(metadata.aliases || {})
+ .sort((0, browser_data_js_1.getVersionComparator)(browser))
+ .at(-1);
+ }
+ return metadata.aliases[alias];
+ }
+ installationDir(browser, platform, buildId) {
+ return path_1.default.join(this.browserRoot(browser), `${platform}-${buildId}`);
+ }
+ clear() {
+ fs_1.default.rmSync(this.#rootDir, {
+ force: true,
+ recursive: true,
+ maxRetries: 10,
+ retryDelay: 500,
});
- readStream.pipe(inflateFilter);
-
- if (self.validateEntrySizes) {
- endpointStream = new AssertByteCountStream(entry.uncompressedSize);
- inflateFilter.on("error", function(err) {
- // forward zlib errors to the client-visible stream
- setImmediate(function() {
- if (!destroyed) endpointStream.emit("error", err);
+ }
+ uninstall(browser, platform, buildId) {
+ const metadata = this.readMetadata(browser);
+ for (const alias of Object.keys(metadata.aliases)) {
+ if (metadata.aliases[alias] === buildId) {
+ delete metadata.aliases[alias];
+ }
+ }
+ fs_1.default.rmSync(this.installationDir(browser, platform, buildId), {
+ force: true,
+ recursive: true,
+ maxRetries: 10,
+ retryDelay: 500,
+ });
+ }
+ getInstalledBrowsers() {
+ if (!fs_1.default.existsSync(this.#rootDir)) {
+ return [];
+ }
+ const types = fs_1.default.readdirSync(this.#rootDir);
+ const browsers = types.filter((t) => {
+ return Object.values(browser_data_js_1.Browser).includes(t);
+ });
+ return browsers.flatMap(browser => {
+ const files = fs_1.default.readdirSync(this.browserRoot(browser));
+ return files
+ .map(file => {
+ const result = parseFolderPath(path_1.default.join(this.browserRoot(browser), file));
+ if (!result) {
+ return null;
+ }
+ return new InstalledBrowser(this, browser, result.buildId, result.platform);
+ })
+ .filter((item) => {
+ return item !== null;
});
- });
- inflateFilter.pipe(endpointStream);
- } else {
- // the zlib filter is the client-visible stream
- endpointStream = inflateFilter;
+ });
+ }
+ computeExecutablePath(options) {
+ options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ if (!options.platform) {
+ throw new Error(`Cannot download a binary for the provided platform: ${os_1.default.platform()} (${os_1.default.arch()})`);
}
- // this is part of yauzl's API, so implement this function on the client-visible stream
- endpointStream.destroy = function() {
- destroyed = true;
- if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
- readStream.unpipe(inflateFilter);
- // TODO: the inflateFilter may cause a memory leak. see Issue #27.
- readStream.destroy();
- };
- }
- callback(null, endpointStream);
- } finally {
- self.reader.unref();
+ try {
+ options.buildId =
+ this.resolveAlias(options.browser, options.buildId) ?? options.buildId;
+ }
+ catch {
+ debugCache('could not read .metadata file for the browser');
+ }
+ const installationDir = this.installationDir(options.browser, options.platform, options.buildId);
+ return path_1.default.join(installationDir, browser_data_js_1.executablePathByBrowser[options.browser](options.platform, options.buildId));
}
- });
-};
-
-function Entry() {
}
-Entry.prototype.getLastModDate = function() {
- return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
-};
-Entry.prototype.isEncrypted = function() {
- return (this.generalPurposeBitFlag & 0x1) !== 0;
-};
-Entry.prototype.isCompressed = function() {
- return this.compressionMethod === 8;
-};
+exports.Cache = Cache;
+function parseFolderPath(folderPath) {
+ const name = path_1.default.basename(folderPath);
+ const splits = name.split('-');
+ if (splits.length !== 2) {
+ return;
+ }
+ const [platform, buildId] = splits;
+ if (!buildId || !platform) {
+ return;
+ }
+ return { platform, buildId };
+}
+//# sourceMappingURL=Cache.js.map
-function dosDateTimeToDate(date, time) {
- var day = date & 0x1f; // 1-31
- var month = (date >> 5 & 0xf) - 1; // 1-12, 0-11
- var year = (date >> 9 & 0x7f) + 1980; // 0-128, 1980-2108
+/***/ }),
- var millisecond = 0;
- var second = (time & 0x1f) * 2; // 0-29, 0-58 (even numbers)
- var minute = time >> 5 & 0x3f; // 0-59
- var hour = time >> 11 & 0x1f; // 0-23
+/***/ 35255:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
- return new Date(year, month, day, hour, minute, second, millisecond);
-}
+"use strict";
-function validateFileName(fileName) {
- if (fileName.indexOf("\\") !== -1) {
- return "invalid characters in fileName: " + fileName;
- }
- if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
- return "absolute path: " + fileName;
- }
- if (fileName.split("/").indexOf("..") !== -1) {
- return "invalid relative path: " + fileName;
- }
- // all good
- return null;
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) 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 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+ var ownKeys = function(o) {
+ ownKeys = Object.getOwnPropertyNames || function (o) {
+ var ar = [];
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o);
+ };
+ return function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+ __setModuleDefault(result, mod);
+ return result;
+ };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ChromeReleaseChannel = exports.BrowserPlatform = exports.Browser = exports.versionComparators = exports.executablePathByBrowser = exports.downloadPaths = exports.downloadUrls = void 0;
+exports.resolveBuildId = resolveBuildId;
+exports.createProfile = createProfile;
+exports.resolveSystemExecutablePath = resolveSystemExecutablePath;
+exports.getVersionComparator = getVersionComparator;
+const chromeHeadlessShell = __importStar(__nccwpck_require__(17991));
+const chrome = __importStar(__nccwpck_require__(40826));
+const chromedriver = __importStar(__nccwpck_require__(51904));
+const chromium = __importStar(__nccwpck_require__(40060));
+const firefox = __importStar(__nccwpck_require__(62783));
+const types_js_1 = __nccwpck_require__(3299);
+Object.defineProperty(exports, "Browser", ({ enumerable: true, get: function () { return types_js_1.Browser; } }));
+Object.defineProperty(exports, "BrowserPlatform", ({ enumerable: true, get: function () { return types_js_1.BrowserPlatform; } }));
+Object.defineProperty(exports, "ChromeReleaseChannel", ({ enumerable: true, get: function () { return types_js_1.ChromeReleaseChannel; } }));
+exports.downloadUrls = {
+ [types_js_1.Browser.CHROMEDRIVER]: chromedriver.resolveDownloadUrl,
+ [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.resolveDownloadUrl,
+ [types_js_1.Browser.CHROME]: chrome.resolveDownloadUrl,
+ [types_js_1.Browser.CHROMIUM]: chromium.resolveDownloadUrl,
+ [types_js_1.Browser.FIREFOX]: firefox.resolveDownloadUrl,
+};
+exports.downloadPaths = {
+ [types_js_1.Browser.CHROMEDRIVER]: chromedriver.resolveDownloadPath,
+ [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.resolveDownloadPath,
+ [types_js_1.Browser.CHROME]: chrome.resolveDownloadPath,
+ [types_js_1.Browser.CHROMIUM]: chromium.resolveDownloadPath,
+ [types_js_1.Browser.FIREFOX]: firefox.resolveDownloadPath,
+};
+exports.executablePathByBrowser = {
+ [types_js_1.Browser.CHROMEDRIVER]: chromedriver.relativeExecutablePath,
+ [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.relativeExecutablePath,
+ [types_js_1.Browser.CHROME]: chrome.relativeExecutablePath,
+ [types_js_1.Browser.CHROMIUM]: chromium.relativeExecutablePath,
+ [types_js_1.Browser.FIREFOX]: firefox.relativeExecutablePath,
+};
+exports.versionComparators = {
+ [types_js_1.Browser.CHROMEDRIVER]: chromedriver.compareVersions,
+ [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.compareVersions,
+ [types_js_1.Browser.CHROME]: chrome.compareVersions,
+ [types_js_1.Browser.CHROMIUM]: chromium.compareVersions,
+ [types_js_1.Browser.FIREFOX]: firefox.compareVersions,
+};
+/**
+ * @internal
+ */
+async function resolveBuildIdForBrowserTag(browser, platform, tag) {
+ switch (browser) {
+ case types_js_1.Browser.FIREFOX:
+ switch (tag) {
+ case types_js_1.BrowserTag.LATEST:
+ return await firefox.resolveBuildId(firefox.FirefoxChannel.NIGHTLY);
+ case types_js_1.BrowserTag.BETA:
+ return await firefox.resolveBuildId(firefox.FirefoxChannel.BETA);
+ case types_js_1.BrowserTag.NIGHTLY:
+ return await firefox.resolveBuildId(firefox.FirefoxChannel.NIGHTLY);
+ case types_js_1.BrowserTag.DEVEDITION:
+ return await firefox.resolveBuildId(firefox.FirefoxChannel.DEVEDITION);
+ case types_js_1.BrowserTag.STABLE:
+ return await firefox.resolveBuildId(firefox.FirefoxChannel.STABLE);
+ case types_js_1.BrowserTag.ESR:
+ return await firefox.resolveBuildId(firefox.FirefoxChannel.ESR);
+ case types_js_1.BrowserTag.CANARY:
+ case types_js_1.BrowserTag.DEV:
+ throw new Error(`${tag.toUpperCase()} is not available for Firefox`);
+ }
+ case types_js_1.Browser.CHROME: {
+ switch (tag) {
+ case types_js_1.BrowserTag.LATEST:
+ return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
+ case types_js_1.BrowserTag.BETA:
+ return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.BETA);
+ case types_js_1.BrowserTag.CANARY:
+ return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
+ case types_js_1.BrowserTag.DEV:
+ return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.DEV);
+ case types_js_1.BrowserTag.STABLE:
+ return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.STABLE);
+ case types_js_1.BrowserTag.NIGHTLY:
+ case types_js_1.BrowserTag.DEVEDITION:
+ case types_js_1.BrowserTag.ESR:
+ throw new Error(`${tag.toUpperCase()} is not available for Chrome`);
+ }
+ }
+ case types_js_1.Browser.CHROMEDRIVER: {
+ switch (tag) {
+ case types_js_1.BrowserTag.LATEST:
+ case types_js_1.BrowserTag.CANARY:
+ return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
+ case types_js_1.BrowserTag.BETA:
+ return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.BETA);
+ case types_js_1.BrowserTag.DEV:
+ return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.DEV);
+ case types_js_1.BrowserTag.STABLE:
+ return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.STABLE);
+ case types_js_1.BrowserTag.NIGHTLY:
+ case types_js_1.BrowserTag.DEVEDITION:
+ case types_js_1.BrowserTag.ESR:
+ throw new Error(`${tag.toUpperCase()} is not available for ChromeDriver`);
+ }
+ }
+ case types_js_1.Browser.CHROMEHEADLESSSHELL: {
+ switch (tag) {
+ case types_js_1.BrowserTag.LATEST:
+ case types_js_1.BrowserTag.CANARY:
+ return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
+ case types_js_1.BrowserTag.BETA:
+ return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.BETA);
+ case types_js_1.BrowserTag.DEV:
+ return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.DEV);
+ case types_js_1.BrowserTag.STABLE:
+ return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.STABLE);
+ case types_js_1.BrowserTag.NIGHTLY:
+ case types_js_1.BrowserTag.DEVEDITION:
+ case types_js_1.BrowserTag.ESR:
+ throw new Error(`${tag} is not available for chrome-headless-shell`);
+ }
+ }
+ case types_js_1.Browser.CHROMIUM:
+ switch (tag) {
+ case types_js_1.BrowserTag.LATEST:
+ return await chromium.resolveBuildId(platform);
+ case types_js_1.BrowserTag.NIGHTLY:
+ case types_js_1.BrowserTag.CANARY:
+ case types_js_1.BrowserTag.DEV:
+ case types_js_1.BrowserTag.DEVEDITION:
+ case types_js_1.BrowserTag.BETA:
+ case types_js_1.BrowserTag.STABLE:
+ case types_js_1.BrowserTag.ESR:
+ throw new Error(`${tag} is not supported for Chromium. Use 'latest' instead.`);
+ }
+ }
}
-
-function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
- if (length === 0) {
- // fs.read will throw an out-of-bounds error if you try to read 0 bytes from a 0 byte file
- return setImmediate(function() { callback(null, newBuffer(0)); });
- }
- reader.read(buffer, offset, length, position, function(err, bytesRead) {
- if (err) return callback(err);
- if (bytesRead < length) {
- return callback(new Error("unexpected EOF"));
+/**
+ * @public
+ */
+async function resolveBuildId(browser, platform, tag) {
+ const browserTag = tag;
+ if (Object.values(types_js_1.BrowserTag).includes(browserTag)) {
+ return await resolveBuildIdForBrowserTag(browser, platform, browserTag);
+ }
+ switch (browser) {
+ case types_js_1.Browser.FIREFOX:
+ return tag;
+ case types_js_1.Browser.CHROME:
+ const chromeResult = await chrome.resolveBuildId(tag);
+ if (chromeResult) {
+ return chromeResult;
+ }
+ return tag;
+ case types_js_1.Browser.CHROMEDRIVER:
+ const chromeDriverResult = await chromedriver.resolveBuildId(tag);
+ if (chromeDriverResult) {
+ return chromeDriverResult;
+ }
+ return tag;
+ case types_js_1.Browser.CHROMEHEADLESSSHELL:
+ const chromeHeadlessShellResult = await chromeHeadlessShell.resolveBuildId(tag);
+ if (chromeHeadlessShellResult) {
+ return chromeHeadlessShellResult;
+ }
+ return tag;
+ case types_js_1.Browser.CHROMIUM:
+ return tag;
}
- callback();
- });
}
-
-util.inherits(AssertByteCountStream, Transform);
-function AssertByteCountStream(byteCount) {
- Transform.call(this);
- this.actualByteCount = 0;
- this.expectedByteCount = byteCount;
+/**
+ * @public
+ */
+async function createProfile(browser, opts) {
+ switch (browser) {
+ case types_js_1.Browser.FIREFOX:
+ return await firefox.createProfile(opts);
+ case types_js_1.Browser.CHROME:
+ case types_js_1.Browser.CHROMIUM:
+ throw new Error(`Profile creation is not support for ${browser} yet`);
+ }
}
-AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
- this.actualByteCount += chunk.length;
- if (this.actualByteCount > this.expectedByteCount) {
- var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
- return cb(new Error(msg));
- }
- cb(null, chunk);
-};
-AssertByteCountStream.prototype._flush = function(cb) {
- if (this.actualByteCount < this.expectedByteCount) {
- var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
- return cb(new Error(msg));
- }
- cb();
-};
-
-util.inherits(RandomAccessReader, EventEmitter);
-function RandomAccessReader() {
- EventEmitter.call(this);
- this.refCount = 0;
+/**
+ * @public
+ */
+function resolveSystemExecutablePath(browser, platform, channel) {
+ switch (browser) {
+ case types_js_1.Browser.CHROMEDRIVER:
+ case types_js_1.Browser.CHROMEHEADLESSSHELL:
+ case types_js_1.Browser.FIREFOX:
+ case types_js_1.Browser.CHROMIUM:
+ throw new Error(`System browser detection is not supported for ${browser} yet.`);
+ case types_js_1.Browser.CHROME:
+ return chrome.resolveSystemExecutablePath(platform, channel);
+ }
}
-RandomAccessReader.prototype.ref = function() {
- this.refCount += 1;
-};
-RandomAccessReader.prototype.unref = function() {
- var self = this;
- self.refCount -= 1;
+/**
+ * Returns a version comparator for the given browser that can be used to sort
+ * browser versions.
+ *
+ * @public
+ */
+function getVersionComparator(browser) {
+ return exports.versionComparators[browser];
+}
+//# sourceMappingURL=browser-data.js.map
- if (self.refCount > 0) return;
- if (self.refCount < 0) throw new Error("invalid unref");
+/***/ }),
- self.close(onCloseDone);
+/***/ 17991:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
- function onCloseDone(err) {
- if (err) return self.emit('error', err);
- self.emit('close');
- }
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
};
-RandomAccessReader.prototype.createReadStream = function(options) {
- var start = options.start;
- var end = options.end;
- if (start === end) {
- var emptyStream = new PassThrough();
- setImmediate(function() {
- emptyStream.end();
- });
- return emptyStream;
- }
- var stream = this._readStreamForRange(start, end);
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.compareVersions = exports.resolveBuildId = void 0;
+exports.resolveDownloadUrl = resolveDownloadUrl;
+exports.resolveDownloadPath = resolveDownloadPath;
+exports.relativeExecutablePath = relativeExecutablePath;
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const types_js_1 = __nccwpck_require__(3299);
+function folder(platform) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return 'linux64';
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return 'mac-arm64';
+ case types_js_1.BrowserPlatform.MAC:
+ return 'mac-x64';
+ case types_js_1.BrowserPlatform.WIN32:
+ return 'win32';
+ case types_js_1.BrowserPlatform.WIN64:
+ return 'win64';
+ }
+}
+function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public') {
+ return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+function resolveDownloadPath(platform, buildId) {
+ return [
+ buildId,
+ folder(platform),
+ `chrome-headless-shell-${folder(platform)}.zip`,
+ ];
+}
+function relativeExecutablePath(platform, _buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.MAC:
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return path_1.default.join('chrome-headless-shell-' + folder(platform), 'chrome-headless-shell');
+ case types_js_1.BrowserPlatform.LINUX:
+ return path_1.default.join('chrome-headless-shell-linux64', 'chrome-headless-shell');
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return path_1.default.join('chrome-headless-shell-' + folder(platform), 'chrome-headless-shell.exe');
+ }
+}
+var chrome_js_1 = __nccwpck_require__(40826);
+Object.defineProperty(exports, "resolveBuildId", ({ enumerable: true, get: function () { return chrome_js_1.resolveBuildId; } }));
+Object.defineProperty(exports, "compareVersions", ({ enumerable: true, get: function () { return chrome_js_1.compareVersions; } }));
+//# sourceMappingURL=chrome-headless-shell.js.map
- var destroyed = false;
- var refUnrefFilter = new RefUnrefFilter(this);
- stream.on("error", function(err) {
- setImmediate(function() {
- if (!destroyed) refUnrefFilter.emit("error", err);
- });
- });
- refUnrefFilter.destroy = function() {
- stream.unpipe(refUnrefFilter);
- refUnrefFilter.unref();
- stream.destroy();
- };
+/***/ }),
- var byteCounter = new AssertByteCountStream(end - start);
- refUnrefFilter.on("error", function(err) {
- setImmediate(function() {
- if (!destroyed) byteCounter.emit("error", err);
- });
- });
- byteCounter.destroy = function() {
- destroyed = true;
- refUnrefFilter.unpipe(byteCounter);
- refUnrefFilter.destroy();
- };
+/***/ 40826:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
- return stream.pipe(refUnrefFilter).pipe(byteCounter);
-};
-RandomAccessReader.prototype._readStreamForRange = function(start, end) {
- throw new Error("not implemented");
-};
-RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
- var readStream = this.createReadStream({start: position, end: position + length});
- var writeStream = new Writable();
- var written = 0;
- writeStream._write = function(chunk, encoding, cb) {
- chunk.copy(buffer, offset + written, 0, chunk.length);
- written += chunk.length;
- cb();
- };
- writeStream.on("finish", callback);
- readStream.on("error", function(error) {
- callback(error);
- });
- readStream.pipe(writeStream);
-};
-RandomAccessReader.prototype.close = function(callback) {
- setImmediate(callback);
-};
+"use strict";
-util.inherits(RefUnrefFilter, PassThrough);
-function RefUnrefFilter(context) {
- PassThrough.call(this);
- this.context = context;
- this.context.ref();
- this.unreffedYet = false;
-}
-RefUnrefFilter.prototype._flush = function(cb) {
- this.unref();
- cb();
-};
-RefUnrefFilter.prototype.unref = function(cb) {
- if (this.unreffedYet) return;
- this.unreffedYet = true;
- this.context.unref();
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
};
-
-var cp437 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
-function decodeBuffer(buffer, start, end, isUtf8) {
- if (isUtf8) {
- return buffer.toString("utf8", start, end);
- } else {
- var result = "";
- for (var i = start; i < end; i++) {
- result += cp437[buffer[i]];
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.resolveDownloadUrl = resolveDownloadUrl;
+exports.resolveDownloadPath = resolveDownloadPath;
+exports.relativeExecutablePath = relativeExecutablePath;
+exports.getLastKnownGoodReleaseForChannel = getLastKnownGoodReleaseForChannel;
+exports.getLastKnownGoodReleaseForMilestone = getLastKnownGoodReleaseForMilestone;
+exports.getLastKnownGoodReleaseForBuild = getLastKnownGoodReleaseForBuild;
+exports.resolveBuildId = resolveBuildId;
+exports.resolveSystemExecutablePath = resolveSystemExecutablePath;
+exports.compareVersions = compareVersions;
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const semver_1 = __importDefault(__nccwpck_require__(62088));
+const httpUtil_js_1 = __nccwpck_require__(80422);
+const types_js_1 = __nccwpck_require__(3299);
+function folder(platform) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return 'linux64';
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return 'mac-arm64';
+ case types_js_1.BrowserPlatform.MAC:
+ return 'mac-x64';
+ case types_js_1.BrowserPlatform.WIN32:
+ return 'win32';
+ case types_js_1.BrowserPlatform.WIN64:
+ return 'win64';
}
- return result;
- }
}
-
-function readUInt64LE(buffer, offset) {
- // there is no native function for this, because we can't actually store 64-bit integers precisely.
- // after 53 bits, JavaScript's Number type (IEEE 754 double) can't store individual integers anymore.
- // but since 53 bits is a whole lot more than 32 bits, we do our best anyway.
- var lower32 = buffer.readUInt32LE(offset);
- var upper32 = buffer.readUInt32LE(offset + 4);
- // we can't use bitshifting here, because JavaScript bitshifting only works on 32-bit integers.
- return upper32 * 0x100000000 + lower32;
- // as long as we're bounds checking the result of this function against the total file size,
- // we'll catch any overflow errors, because we already made sure the total file size was within reason.
+function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public') {
+ return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
}
-
-// Node 10 deprecated new Buffer().
-var newBuffer;
-if (typeof Buffer.allocUnsafe === "function") {
- newBuffer = function(len) {
- return Buffer.allocUnsafe(len);
- };
-} else {
- newBuffer = function(len) {
- return new Buffer(len);
- };
+function resolveDownloadPath(platform, buildId) {
+ return [buildId, folder(platform), `chrome-${folder(platform)}.zip`];
+}
+function relativeExecutablePath(platform, _buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.MAC:
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return path_1.default.join('chrome-' + folder(platform), 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
+ case types_js_1.BrowserPlatform.LINUX:
+ return path_1.default.join('chrome-linux64', 'chrome');
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return path_1.default.join('chrome-' + folder(platform), 'chrome.exe');
+ }
+}
+async function getLastKnownGoodReleaseForChannel(channel) {
+ const data = (await (0, httpUtil_js_1.getJSON)(new URL('https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json')));
+ for (const channel of Object.keys(data.channels)) {
+ data.channels[channel.toLowerCase()] = data.channels[channel];
+ delete data.channels[channel];
+ }
+ return data.channels[channel];
+}
+async function getLastKnownGoodReleaseForMilestone(milestone) {
+ const data = (await (0, httpUtil_js_1.getJSON)(new URL('https://googlechromelabs.github.io/chrome-for-testing/latest-versions-per-milestone.json')));
+ return data.milestones[milestone];
+}
+async function getLastKnownGoodReleaseForBuild(
+/**
+ * @example `112.0.23`,
+ */
+buildPrefix) {
+ const data = (await (0, httpUtil_js_1.getJSON)(new URL('https://googlechromelabs.github.io/chrome-for-testing/latest-patch-versions-per-build.json')));
+ return data.builds[buildPrefix];
+}
+async function resolveBuildId(channel) {
+ if (Object.values(types_js_1.ChromeReleaseChannel).includes(channel)) {
+ return (await getLastKnownGoodReleaseForChannel(channel)).version;
+ }
+ if (channel.match(/^\d+$/)) {
+ // Potentially a milestone.
+ return (await getLastKnownGoodReleaseForMilestone(channel))?.version;
+ }
+ if (channel.match(/^\d+\.\d+\.\d+$/)) {
+ // Potentially a build prefix without the patch version.
+ return (await getLastKnownGoodReleaseForBuild(channel))?.version;
+ }
+ return;
+}
+function resolveSystemExecutablePath(platform, channel) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.WIN64:
+ case types_js_1.BrowserPlatform.WIN32:
+ switch (channel) {
+ case types_js_1.ChromeReleaseChannel.STABLE:
+ return `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`;
+ case types_js_1.ChromeReleaseChannel.BETA:
+ return `${process.env['PROGRAMFILES']}\\Google\\Chrome Beta\\Application\\chrome.exe`;
+ case types_js_1.ChromeReleaseChannel.CANARY:
+ return `${process.env['PROGRAMFILES']}\\Google\\Chrome SxS\\Application\\chrome.exe`;
+ case types_js_1.ChromeReleaseChannel.DEV:
+ return `${process.env['PROGRAMFILES']}\\Google\\Chrome Dev\\Application\\chrome.exe`;
+ }
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ switch (channel) {
+ case types_js_1.ChromeReleaseChannel.STABLE:
+ return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+ case types_js_1.ChromeReleaseChannel.BETA:
+ return '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta';
+ case types_js_1.ChromeReleaseChannel.CANARY:
+ return '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary';
+ case types_js_1.ChromeReleaseChannel.DEV:
+ return '/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev';
+ }
+ case types_js_1.BrowserPlatform.LINUX:
+ switch (channel) {
+ case types_js_1.ChromeReleaseChannel.STABLE:
+ return '/opt/google/chrome/chrome';
+ case types_js_1.ChromeReleaseChannel.BETA:
+ return '/opt/google/chrome-beta/chrome';
+ case types_js_1.ChromeReleaseChannel.CANARY:
+ return '/opt/google/chrome-canary/chrome';
+ case types_js_1.ChromeReleaseChannel.DEV:
+ return '/opt/google/chrome-unstable/chrome';
+ }
+ }
}
-
-function defaultCallback(err) {
- if (err) throw err;
+function compareVersions(a, b) {
+ if (!semver_1.default.valid(a)) {
+ throw new Error(`Version ${a} is not a valid semver version`);
+ }
+ if (!semver_1.default.valid(b)) {
+ throw new Error(`Version ${b} is not a valid semver version`);
+ }
+ if (semver_1.default.gt(a, b)) {
+ return 1;
+ }
+ else if (semver_1.default.lt(a, b)) {
+ return -1;
+ }
+ else {
+ return 0;
+ }
}
-
+//# sourceMappingURL=chrome.js.map
/***/ }),
-/***/ 79407:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ 51904:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.compareVersions = exports.resolveBuildId = void 0;
+exports.resolveDownloadUrl = resolveDownloadUrl;
+exports.resolveDownloadPath = resolveDownloadPath;
+exports.relativeExecutablePath = relativeExecutablePath;
/**
- * The entrypoint for the action.
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
*/
-const main_1 = __nccwpck_require__(41730);
-// eslint-disable-next-line @typescript-eslint/no-floating-promises
-(0, main_1.run)();
-
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const types_js_1 = __nccwpck_require__(3299);
+function folder(platform) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return 'linux64';
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return 'mac-arm64';
+ case types_js_1.BrowserPlatform.MAC:
+ return 'mac-x64';
+ case types_js_1.BrowserPlatform.WIN32:
+ return 'win32';
+ case types_js_1.BrowserPlatform.WIN64:
+ return 'win64';
+ }
+}
+function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public') {
+ return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+function resolveDownloadPath(platform, buildId) {
+ return [buildId, folder(platform), `chromedriver-${folder(platform)}.zip`];
+}
+function relativeExecutablePath(platform, _buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.MAC:
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return path_1.default.join('chromedriver-' + folder(platform), 'chromedriver');
+ case types_js_1.BrowserPlatform.LINUX:
+ return path_1.default.join('chromedriver-linux64', 'chromedriver');
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return path_1.default.join('chromedriver-' + folder(platform), 'chromedriver.exe');
+ }
+}
+var chrome_js_1 = __nccwpck_require__(40826);
+Object.defineProperty(exports, "resolveBuildId", ({ enumerable: true, get: function () { return chrome_js_1.resolveBuildId; } }));
+Object.defineProperty(exports, "compareVersions", ({ enumerable: true, get: function () { return chrome_js_1.compareVersions; } }));
+//# sourceMappingURL=chromedriver.js.map
/***/ }),
-/***/ 41730:
+/***/ 40060:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) 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 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
- var ownKeys = function(o) {
- ownKeys = Object.getOwnPropertyNames || function (o) {
- var ar = [];
- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
- return ar;
- };
- return ownKeys(o);
- };
- return function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
- __setModuleDefault(result, mod);
- return result;
- };
-})();
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.run = run;
-const core = __importStar(__nccwpck_require__(37484));
-const puppeteer_1 = __importDefault(__nccwpck_require__(57699));
-const form_data_1 = __importDefault(__nccwpck_require__(96454));
-const axios_1 = __importDefault(__nccwpck_require__(87269));
-const fs_1 = __nccwpck_require__(79896);
-const utils_1 = __nccwpck_require__(71798);
-const path_1 = __nccwpck_require__(16928);
-const SSO_URL = 'https://portal-api.cfx.re/v1/auth/discourse?return=';
-/**
- * The main function for the action.
- * @returns {Promise} Resolves when the action is complete.
- */
-async function run() {
- await (0, utils_1.preparePuppeteer)();
- const browser = await puppeteer_1.default.launch({
- headless: true,
- args: ['--no-sandbox', '--disable-setuid-sandbox']
- });
- const page = await browser.newPage();
- try {
- const assetId = core.getInput('assetId');
- const zipPath = core.getInput('zipPath');
- const chunkSize = parseInt(core.getInput('chunkSize'));
- if (isNaN(chunkSize)) {
- core.setFailed('Invalid chunk size. Must be a number.');
- return;
- }
- core.info('Navigating to SSO URL ...');
- await page.goto(SSO_URL, {
- waitUntil: 'networkidle0'
- });
- core.info('Navigated to SSO URL. Parsing response body ...');
- const responseBody = await page.evaluate(() => JSON.parse(document.body.innerText));
- core.debug('Parsed response body.');
- const redirectUrl = responseBody.url;
- core.info('Redirected to Forum Origin ...');
- const forumUrl = new URL(redirectUrl).origin;
- await page.goto(forumUrl);
- core.info('Setting cookies ...');
- await browser.setCookie({
- name: '_t',
- value: core.getInput('cookie'),
- domain: 'forum.cfx.re',
- path: '/',
- expires: -1,
- size: 1,
- httpOnly: true,
- secure: true,
- session: false
- });
- await page.evaluate(() => document.write('Cookie' + document.cookie));
- core.info('Cookies set. Following redirect ...');
- await page.goto(redirectUrl, {
- waitUntil: 'networkidle0'
- });
- if (page.url().includes('portal.cfx.re')) {
- core.info('Redirected to CFX Portal. Uploading file ...');
- const cookies = await browser
- .cookies()
- .then(cookies => cookies.map(cookie => `${cookie.name}=${cookie.value}`).join('; '));
- const reUploadUrl = `https://portal-api.cfx.re/v1/assets/${assetId}/re-upload`;
- const uploadChunkUrl = `https://portal-api.cfx.re/v1/assets/${assetId}/upload-chunk`;
- const completeUploadUrl = `https://portal-api.cfx.re/v1/assets/${assetId}/complete-upload`;
- const stats = (0, fs_1.statSync)(zipPath);
- const totalSize = stats.size;
- const originalFileName = (0, path_1.basename)(zipPath);
- const chunkCount = Math.ceil(totalSize / chunkSize);
- core.info('Starting upload ...');
- core.debug(`Total size: ${totalSize}`);
- core.debug(`Original file name: ${originalFileName}`);
- core.debug(`Chunk size: ${chunkSize}`);
- core.debug(`Chunk count: ${chunkCount}`);
- const reUploadReponse = await axios_1.default.post(reUploadUrl, {
- chunk_count: chunkCount,
- chunk_size: chunkSize,
- name: originalFileName,
- original_file_name: originalFileName,
- total_size: totalSize
- }, {
- headers: {
- Cookie: cookies
- }
- });
- if (reUploadReponse.data.errors !== null) {
- core.debug(JSON.stringify(reUploadReponse.data.errors));
- core.setFailed('Failed to re-upload file. See debug logs for more information.');
- return;
- }
- const stream = (0, fs_1.createReadStream)(zipPath, {
- highWaterMark: chunkSize
- });
- let chunkIndex = 0;
- for await (const chunk of stream) {
- const form = new form_data_1.default();
- form.append('chunk_id', chunkIndex);
- form.append('chunk', chunk, {
- filename: 'blob',
- contentType: 'application/octet-stream'
- });
- await axios_1.default.post(uploadChunkUrl, form, {
- headers: {
- ...form.getHeaders(),
- Cookie: cookies
- }
- });
- core.info(`Uploaded chunk ${chunkIndex + 1}/${chunkCount}`);
- chunkIndex++;
- }
- await axios_1.default.post(completeUploadUrl, {}, {
- headers: {
- Cookie: cookies
- }
- });
- core.info('Upload completed.');
- }
- else {
- core.setFailed('Redirect failed. Make sure the provided Cookie is valid.');
- }
+exports.resolveDownloadUrl = resolveDownloadUrl;
+exports.resolveDownloadPath = resolveDownloadPath;
+exports.relativeExecutablePath = relativeExecutablePath;
+exports.resolveBuildId = resolveBuildId;
+exports.compareVersions = compareVersions;
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const httpUtil_js_1 = __nccwpck_require__(80422);
+const types_js_1 = __nccwpck_require__(3299);
+function archive(platform, buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return 'chrome-linux';
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ return 'chrome-mac';
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ // Windows archive name changed at r591479.
+ return parseInt(buildId, 10) > 591479 ? 'chrome-win' : 'chrome-win32';
}
- catch (error) {
- if (error instanceof Error) {
- core.setFailed(error.message);
- }
+}
+function folder(platform) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return 'Linux_x64';
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return 'Mac_Arm';
+ case types_js_1.BrowserPlatform.MAC:
+ return 'Mac';
+ case types_js_1.BrowserPlatform.WIN32:
+ return 'Win';
+ case types_js_1.BrowserPlatform.WIN64:
+ return 'Win_x64';
}
- finally {
- await browser.close();
+}
+function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chromium-browser-snapshots') {
+ return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+function resolveDownloadPath(platform, buildId) {
+ return [folder(platform), buildId, `${archive(platform, buildId)}.zip`];
+}
+function relativeExecutablePath(platform, _buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.MAC:
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ return path_1.default.join('chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium');
+ case types_js_1.BrowserPlatform.LINUX:
+ return path_1.default.join('chrome-linux', 'chrome');
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return path_1.default.join('chrome-win', 'chrome.exe');
}
}
-
+async function resolveBuildId(platform) {
+ return await (0, httpUtil_js_1.getText)(new URL(`https://storage.googleapis.com/chromium-browser-snapshots/${folder(platform)}/LAST_CHANGE`));
+}
+function compareVersions(a, b) {
+ return Number(a) - Number(b);
+}
+//# sourceMappingURL=chromium.js.map
/***/ }),
-/***/ 71798:
+/***/ 62783:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) 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 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
- var ownKeys = function(o) {
- ownKeys = Object.getOwnPropertyNames || function (o) {
- var ar = [];
- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
- return ar;
- };
- return ownKeys(o);
- };
- return function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
- __setModuleDefault(result, mod);
- return result;
- };
-})();
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.preparePuppeteer = preparePuppeteer;
-const browsers_1 = __nccwpck_require__(73403);
-const core = __importStar(__nccwpck_require__(37484));
-const CACHE_DIR = '/home/runner/.cache/puppeteer';
/**
- * Prepare the Puppeteer environment by installing the necessary browser.
- * @returns {Promise} Resolves when the environment is prepared.
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
*/
-async function preparePuppeteer() {
- if (process.env.RUNNER_TEMP === undefined) {
- core.info('Running locally, skipping Puppeteer setup ...');
- return;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.FirefoxChannel = void 0;
+exports.resolveDownloadUrl = resolveDownloadUrl;
+exports.resolveDownloadPath = resolveDownloadPath;
+exports.relativeExecutablePath = relativeExecutablePath;
+exports.resolveBuildId = resolveBuildId;
+exports.createProfile = createProfile;
+exports.compareVersions = compareVersions;
+const fs_1 = __importDefault(__nccwpck_require__(79896));
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const httpUtil_js_1 = __nccwpck_require__(80422);
+const types_js_1 = __nccwpck_require__(3299);
+function getFormat(buildId) {
+ const majorVersion = Number(buildId.split('.').shift());
+ return majorVersion >= 135 ? 'xz' : 'bz2';
+}
+function archiveNightly(platform, buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return `firefox-${buildId}.en-US.${platform}-x86_64.tar.${getFormat(buildId)}`;
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ return `firefox-${buildId}.en-US.mac.dmg`;
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return `firefox-${buildId}.en-US.${platform}.zip`;
}
- const installed = await (0, browsers_1.getInstalledBrowsers)({
- cacheDir: CACHE_DIR
- });
- if (!installed.some(browser => browser.browser === browsers_1.Browser.CHROME)) {
- core.info('Installing Chrome ...');
- await (0, browsers_1.install)({
- cacheDir: CACHE_DIR,
- browser: browsers_1.Browser.CHROME,
- buildId: '131.0.6778.108'
- });
+}
+function archive(platform, buildId) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return `firefox-${buildId}.tar.${getFormat(buildId)}`;
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ return `Firefox ${buildId}.dmg`;
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return `Firefox Setup ${buildId}.exe`;
}
}
-
-
-/***/ }),
-
-/***/ 18327:
-/***/ ((module) => {
-
-module.exports = eval("require")("bufferutil");
-
-
-/***/ }),
-
-/***/ 62414:
-/***/ ((module) => {
-
-module.exports = eval("require")("utf-8-validate");
-
-
-/***/ }),
-
-/***/ 51456:
-/***/ ((module) => {
-
-function webpackEmptyAsyncContext(req) {
- // Here Promise.resolve().then() is used instead of new Promise() to prevent
- // uncaught exception popping up in devtools
- return Promise.resolve().then(() => {
- var e = new Error("Cannot find module '" + req + "'");
- e.code = 'MODULE_NOT_FOUND';
- throw e;
- });
+function platformName(platform) {
+ switch (platform) {
+ case types_js_1.BrowserPlatform.LINUX:
+ return `linux-x86_64`;
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ return `mac`;
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return platform;
+ }
}
-webpackEmptyAsyncContext.keys = () => ([]);
-webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
-webpackEmptyAsyncContext.id = 51456;
-module.exports = webpackEmptyAsyncContext;
-
-/***/ }),
-
-/***/ 31421:
-/***/ ((module) => {
-
-function webpackEmptyContext(req) {
- var e = new Error("Cannot find module '" + req + "'");
- e.code = 'MODULE_NOT_FOUND';
- throw e;
+function parseBuildId(buildId) {
+ for (const value of Object.values(FirefoxChannel)) {
+ if (buildId.startsWith(value + '_')) {
+ buildId = buildId.substring(value.length + 1);
+ return [value, buildId];
+ }
+ }
+ // Older versions do not have channel as the prefix.«
+ return [FirefoxChannel.NIGHTLY, buildId];
}
-webpackEmptyContext.keys = () => ([]);
-webpackEmptyContext.resolve = webpackEmptyContext;
-webpackEmptyContext.id = 31421;
-module.exports = webpackEmptyContext;
-
-/***/ }),
-
-/***/ 84655:
-/***/ ((module) => {
-
-function webpackEmptyContext(req) {
- var e = new Error("Cannot find module '" + req + "'");
- e.code = 'MODULE_NOT_FOUND';
- throw e;
+function resolveDownloadUrl(platform, buildId, baseUrl) {
+ const [channel] = parseBuildId(buildId);
+ switch (channel) {
+ case FirefoxChannel.NIGHTLY:
+ baseUrl ??=
+ 'https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central';
+ break;
+ case FirefoxChannel.DEVEDITION:
+ baseUrl ??= 'https://archive.mozilla.org/pub/devedition/releases';
+ break;
+ case FirefoxChannel.BETA:
+ case FirefoxChannel.STABLE:
+ case FirefoxChannel.ESR:
+ baseUrl ??= 'https://archive.mozilla.org/pub/firefox/releases';
+ break;
+ }
+ return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
}
-webpackEmptyContext.keys = () => ([]);
-webpackEmptyContext.resolve = webpackEmptyContext;
-webpackEmptyContext.id = 84655;
-module.exports = webpackEmptyContext;
-
-/***/ }),
-
-/***/ 91500:
-/***/ ((module) => {
-
-function webpackEmptyContext(req) {
- var e = new Error("Cannot find module '" + req + "'");
- e.code = 'MODULE_NOT_FOUND';
- throw e;
+function resolveDownloadPath(platform, buildId) {
+ const [channel, resolvedBuildId] = parseBuildId(buildId);
+ switch (channel) {
+ case FirefoxChannel.NIGHTLY:
+ return [archiveNightly(platform, resolvedBuildId)];
+ case FirefoxChannel.DEVEDITION:
+ case FirefoxChannel.BETA:
+ case FirefoxChannel.STABLE:
+ case FirefoxChannel.ESR:
+ return [
+ resolvedBuildId,
+ platformName(platform),
+ 'en-US',
+ archive(platform, resolvedBuildId),
+ ];
+ }
}
-webpackEmptyContext.keys = () => ([]);
-webpackEmptyContext.resolve = webpackEmptyContext;
-webpackEmptyContext.id = 91500;
-module.exports = webpackEmptyContext;
-
-/***/ }),
-
-/***/ 42613:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("assert");
-
-/***/ }),
-
-/***/ 90290:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("async_hooks");
-
-/***/ }),
-
-/***/ 20181:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("buffer");
-
-/***/ }),
-
-/***/ 35317:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("child_process");
-
-/***/ }),
-
-/***/ 64236:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("console");
-
-/***/ }),
-
-/***/ 76982:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("crypto");
-
-/***/ }),
-
-/***/ 31637:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("diagnostics_channel");
-
-/***/ }),
-
-/***/ 72250:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("dns");
-
-/***/ }),
-
-/***/ 24434:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("events");
-
-/***/ }),
-
-/***/ 79896:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("fs");
-
-/***/ }),
-
-/***/ 91943:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("fs/promises");
-
-/***/ }),
-
-/***/ 58611:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("http");
-
-/***/ }),
-
-/***/ 85675:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("http2");
-
-/***/ }),
-
-/***/ 65692:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("https");
-
-/***/ }),
-
-/***/ 50264:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("inspector");
-
-/***/ }),
-
-/***/ 73339:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("module");
-
-/***/ }),
-
-/***/ 69278:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("net");
-
-/***/ }),
-
-/***/ 78474:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("node:events");
-
-/***/ }),
-
-/***/ 57075:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("node:stream");
-
-/***/ }),
-
-/***/ 57975:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("node:util");
-
-/***/ }),
-
-/***/ 70857:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("os");
-
-/***/ }),
-
-/***/ 16928:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("path");
-
-/***/ }),
-
-/***/ 82987:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("perf_hooks");
-
-/***/ }),
-
-/***/ 932:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("process");
-
-/***/ }),
-
-/***/ 83480:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("querystring");
-
-/***/ }),
-
-/***/ 23785:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("readline");
-
-/***/ }),
-
-/***/ 2203:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("stream");
-
-/***/ }),
-
-/***/ 63774:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("stream/web");
-
-/***/ }),
-
-/***/ 13193:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("string_decoder");
-
-/***/ }),
-
-/***/ 53557:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("timers");
-
-/***/ }),
-
-/***/ 64756:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("tls");
-
-/***/ }),
-
-/***/ 52018:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("tty");
-
-/***/ }),
-
-/***/ 87016:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("url");
-
-/***/ }),
-
-/***/ 39023:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("util");
-
-/***/ }),
-
-/***/ 98253:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("util/types");
-
-/***/ }),
-
-/***/ 28167:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("worker_threads");
-
-/***/ }),
-
-/***/ 43106:
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("zlib");
-
-/***/ }),
-
-/***/ 90147:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", ({
- value: true
-}));
-exports.codeFrameColumns = codeFrameColumns;
-exports["default"] = _default;
-var _highlight = __nccwpck_require__(26270);
-var _chalk = _interopRequireWildcard(__nccwpck_require__(43351), true);
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-let chalkWithForcedColor = undefined;
-function getChalk(forceColor) {
- if (forceColor) {
- var _chalkWithForcedColor;
- (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new _chalk.default.constructor({
- enabled: true,
- level: 1
+function relativeExecutablePath(platform, buildId) {
+ const [channel] = parseBuildId(buildId);
+ switch (channel) {
+ case FirefoxChannel.NIGHTLY:
+ switch (platform) {
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ return path_1.default.join('Firefox Nightly.app', 'Contents', 'MacOS', 'firefox');
+ case types_js_1.BrowserPlatform.LINUX:
+ return path_1.default.join('firefox', 'firefox');
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return path_1.default.join('firefox', 'firefox.exe');
+ }
+ case FirefoxChannel.BETA:
+ case FirefoxChannel.DEVEDITION:
+ case FirefoxChannel.ESR:
+ case FirefoxChannel.STABLE:
+ switch (platform) {
+ case types_js_1.BrowserPlatform.MAC_ARM:
+ case types_js_1.BrowserPlatform.MAC:
+ return path_1.default.join('Firefox.app', 'Contents', 'MacOS', 'firefox');
+ case types_js_1.BrowserPlatform.LINUX:
+ return path_1.default.join('firefox', 'firefox');
+ case types_js_1.BrowserPlatform.WIN32:
+ case types_js_1.BrowserPlatform.WIN64:
+ return path_1.default.join('core', 'firefox.exe');
+ }
+ }
+}
+var FirefoxChannel;
+(function (FirefoxChannel) {
+ FirefoxChannel["STABLE"] = "stable";
+ FirefoxChannel["ESR"] = "esr";
+ FirefoxChannel["DEVEDITION"] = "devedition";
+ FirefoxChannel["BETA"] = "beta";
+ FirefoxChannel["NIGHTLY"] = "nightly";
+})(FirefoxChannel || (exports.FirefoxChannel = FirefoxChannel = {}));
+async function resolveBuildId(channel = FirefoxChannel.NIGHTLY) {
+ const channelToVersionKey = {
+ [FirefoxChannel.ESR]: 'FIREFOX_ESR',
+ [FirefoxChannel.STABLE]: 'LATEST_FIREFOX_VERSION',
+ [FirefoxChannel.DEVEDITION]: 'FIREFOX_DEVEDITION',
+ [FirefoxChannel.BETA]: 'FIREFOX_DEVEDITION',
+ [FirefoxChannel.NIGHTLY]: 'FIREFOX_NIGHTLY',
+ };
+ const versions = (await (0, httpUtil_js_1.getJSON)(new URL('https://product-details.mozilla.org/1.0/firefox_versions.json')));
+ const version = versions[channelToVersionKey[channel]];
+ if (!version) {
+ throw new Error(`Channel ${channel} is not found.`);
+ }
+ return channel + '_' + version;
+}
+async function createProfile(options) {
+ if (!fs_1.default.existsSync(options.path)) {
+ await fs_1.default.promises.mkdir(options.path, {
+ recursive: true,
+ });
+ }
+ await syncPreferences({
+ preferences: {
+ ...defaultProfilePreferences(options.preferences),
+ ...options.preferences,
+ },
+ path: options.path,
});
- return chalkWithForcedColor;
- }
- return _chalk.default;
}
-let deprecationWarningShown = false;
-function getDefs(chalk) {
- return {
- gutter: chalk.grey,
- marker: chalk.red.bold,
- message: chalk.red.bold
- };
+function defaultProfilePreferences(extraPrefs) {
+ const server = 'dummy.test';
+ const defaultPrefs = {
+ // Make sure Shield doesn't hit the network.
+ 'app.normandy.api_url': '',
+ // Disable Firefox old build background check
+ 'app.update.checkInstallTime': false,
+ // Disable automatically upgrading Firefox
+ 'app.update.disabledForTesting': true,
+ // Increase the APZ content response timeout to 1 minute
+ 'apz.content_response_timeout': 60000,
+ // Prevent various error message on the console
+ // jest-puppeteer asserts that no error message is emitted by the console
+ 'browser.contentblocking.features.standard': '-tp,tpPrivate,cookieBehavior0,-cm,-fp',
+ // Enable the dump function: which sends messages to the system
+ // console
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1543115
+ 'browser.dom.window.dump.enabled': true,
+ // Disable topstories
+ 'browser.newtabpage.activity-stream.feeds.system.topstories': false,
+ // Always display a blank page
+ 'browser.newtabpage.enabled': false,
+ // Background thumbnails in particular cause grief: and disabling
+ // thumbnails in general cannot hurt
+ 'browser.pagethumbnails.capturing_disabled': true,
+ // Disable safebrowsing components.
+ 'browser.safebrowsing.blockedURIs.enabled': false,
+ 'browser.safebrowsing.downloads.enabled': false,
+ 'browser.safebrowsing.malware.enabled': false,
+ 'browser.safebrowsing.phishing.enabled': false,
+ // Disable updates to search engines.
+ 'browser.search.update': false,
+ // Do not restore the last open set of tabs if the browser has crashed
+ 'browser.sessionstore.resume_from_crash': false,
+ // Skip check for default browser on startup
+ 'browser.shell.checkDefaultBrowser': false,
+ // Disable newtabpage
+ 'browser.startup.homepage': 'about:blank',
+ // Do not redirect user when a milstone upgrade of Firefox is detected
+ 'browser.startup.homepage_override.mstone': 'ignore',
+ // Start with a blank page about:blank
+ 'browser.startup.page': 0,
+ // Do not allow background tabs to be zombified on Android: otherwise for
+ // tests that open additional tabs: the test harness tab itself might get
+ // unloaded
+ 'browser.tabs.disableBackgroundZombification': false,
+ // Do not warn when closing all other open tabs
+ 'browser.tabs.warnOnCloseOtherTabs': false,
+ // Do not warn when multiple tabs will be opened
+ 'browser.tabs.warnOnOpen': false,
+ // Do not automatically offer translations, as tests do not expect this.
+ 'browser.translations.automaticallyPopup': false,
+ // Disable the UI tour.
+ 'browser.uitour.enabled': false,
+ // Turn off search suggestions in the location bar so as not to trigger
+ // network connections.
+ 'browser.urlbar.suggest.searches': false,
+ // Disable first run splash page on Windows 10
+ 'browser.usedOnWindows10.introURL': '',
+ // Do not warn on quitting Firefox
+ 'browser.warnOnQuit': false,
+ // Defensively disable data reporting systems
+ 'datareporting.healthreport.documentServerURI': `http://${server}/dummy/healthreport/`,
+ 'datareporting.healthreport.logging.consoleEnabled': false,
+ 'datareporting.healthreport.service.enabled': false,
+ 'datareporting.healthreport.service.firstRun': false,
+ 'datareporting.healthreport.uploadEnabled': false,
+ // Do not show datareporting policy notifications which can interfere with tests
+ 'datareporting.policy.dataSubmissionEnabled': false,
+ 'datareporting.policy.dataSubmissionPolicyBypassNotification': true,
+ // DevTools JSONViewer sometimes fails to load dependencies with its require.js.
+ // This doesn't affect Puppeteer but spams console (Bug 1424372)
+ 'devtools.jsonview.enabled': false,
+ // Disable popup-blocker
+ 'dom.disable_open_during_load': false,
+ // Enable the support for File object creation in the content process
+ // Required for |Page.setFileInputFiles| protocol method.
+ 'dom.file.createInChild': true,
+ // Disable the ProcessHangMonitor
+ 'dom.ipc.reportProcessHangs': false,
+ // Disable slow script dialogues
+ 'dom.max_chrome_script_run_time': 0,
+ 'dom.max_script_run_time': 0,
+ // Only load extensions from the application and user profile
+ // AddonManager.SCOPE_PROFILE + AddonManager.SCOPE_APPLICATION
+ 'extensions.autoDisableScopes': 0,
+ 'extensions.enabledScopes': 5,
+ // Disable metadata caching for installed add-ons by default
+ 'extensions.getAddons.cache.enabled': false,
+ // Disable installing any distribution extensions or add-ons.
+ 'extensions.installDistroAddons': false,
+ // Disabled screenshots extension
+ 'extensions.screenshots.disabled': true,
+ // Turn off extension updates so they do not bother tests
+ 'extensions.update.enabled': false,
+ // Turn off extension updates so they do not bother tests
+ 'extensions.update.notifyUser': false,
+ // Make sure opening about:addons will not hit the network
+ 'extensions.webservice.discoverURL': `http://${server}/dummy/discoveryURL`,
+ // Allow the application to have focus even it runs in the background
+ 'focusmanager.testmode': true,
+ // Disable useragent updates
+ 'general.useragent.updates.enabled': false,
+ // Always use network provider for geolocation tests so we bypass the
+ // macOS dialog raised by the corelocation provider
+ 'geo.provider.testing': true,
+ // Do not scan Wifi
+ 'geo.wifi.scan': false,
+ // No hang monitor
+ 'hangmonitor.timeout': 0,
+ // Show chrome errors and warnings in the error console
+ 'javascript.options.showInConsole': true,
+ // Disable download and usage of OpenH264: and Widevine plugins
+ 'media.gmp-manager.updateEnabled': false,
+ // Disable the GFX sanity window
+ 'media.sanity-test.disabled': true,
+ // Disable experimental feature that is only available in Nightly
+ 'network.cookie.sameSite.laxByDefault': false,
+ // Do not prompt for temporary redirects
+ 'network.http.prompt-temp-redirect': false,
+ // Disable speculative connections so they are not reported as leaking
+ // when they are hanging around
+ 'network.http.speculative-parallel-limit': 0,
+ // Do not automatically switch between offline and online
+ 'network.manage-offline-status': false,
+ // Make sure SNTP requests do not hit the network
+ 'network.sntp.pools': server,
+ // Disable Flash.
+ 'plugin.state.flash': 0,
+ 'privacy.trackingprotection.enabled': false,
+ // Can be removed once Firefox 89 is no longer supported
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1710839
+ 'remote.enabled': true,
+ // Don't do network connections for mitm priming
+ 'security.certerrors.mitm.priming.enabled': false,
+ // Local documents have access to all other local documents,
+ // including directory listings
+ 'security.fileuri.strict_origin_policy': false,
+ // Do not wait for the notification button security delay
+ 'security.notification_enable_delay': 0,
+ // Ensure blocklist updates do not hit the network
+ 'services.settings.server': `http://${server}/dummy/blocklist/`,
+ // Do not automatically fill sign-in forms with known usernames and
+ // passwords
+ 'signon.autofillForms': false,
+ // Disable password capture, so that tests that include forms are not
+ // influenced by the presence of the persistent doorhanger notification
+ 'signon.rememberSignons': false,
+ // Disable first-run welcome page
+ 'startup.homepage_welcome_url': 'about:blank',
+ // Disable first-run welcome page
+ 'startup.homepage_welcome_url.additional': '',
+ // Disable browser animations (tabs, fullscreen, sliding alerts)
+ 'toolkit.cosmeticAnimations.enabled': false,
+ // Prevent starting into safe mode after application crashes
+ 'toolkit.startup.max_resumed_crashes': -1,
+ };
+ return Object.assign(defaultPrefs, extraPrefs);
}
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-function getMarkerLines(loc, source, opts) {
- const startLoc = Object.assign({
- column: 0,
- line: -1
- }, loc.start);
- const endLoc = Object.assign({}, startLoc, loc.end);
- const {
- linesAbove = 2,
- linesBelow = 3
- } = opts || {};
- const startLine = startLoc.line;
- const startColumn = startLoc.column;
- const endLine = endLoc.line;
- const endColumn = endLoc.column;
- let start = Math.max(startLine - (linesAbove + 1), 0);
- let end = Math.min(source.length, endLine + linesBelow);
- if (startLine === -1) {
- start = 0;
- }
- if (endLine === -1) {
- end = source.length;
- }
- const lineDiff = endLine - startLine;
- const markerLines = {};
- if (lineDiff) {
- for (let i = 0; i <= lineDiff; i++) {
- const lineNumber = i + startLine;
- if (!startColumn) {
- markerLines[lineNumber] = true;
- } else if (i === 0) {
- const sourceLength = source[lineNumber - 1].length;
- markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
- } else if (i === lineDiff) {
- markerLines[lineNumber] = [0, endColumn];
- } else {
- const sourceLength = source[lineNumber - i].length;
- markerLines[lineNumber] = [0, sourceLength];
- }
- }
- } else {
- if (startColumn === endColumn) {
- if (startColumn) {
- markerLines[startLine] = [startColumn, 0];
- } else {
- markerLines[startLine] = true;
- }
- } else {
- markerLines[startLine] = [startColumn, endColumn - startColumn];
+async function backupFile(input) {
+ if (!fs_1.default.existsSync(input)) {
+ return;
}
- }
- return {
- start,
- end,
- markerLines
- };
+ await fs_1.default.promises.copyFile(input, input + '.puppeteer');
}
-function codeFrameColumns(rawLines, loc, opts = {}) {
- const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
- const chalk = getChalk(opts.forceColor);
- const defs = getDefs(chalk);
- const maybeHighlight = (chalkFn, string) => {
- return highlighted ? chalkFn(string) : string;
- };
- const lines = rawLines.split(NEWLINE);
- const {
- start,
- end,
- markerLines
- } = getMarkerLines(loc, lines, opts);
- const hasColumns = loc.start && typeof loc.start.column === "number";
- const numberMaxWidth = String(end).length;
- const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
- let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
- const number = start + 1 + index;
- const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
- const gutter = ` ${paddedNumber} |`;
- const hasMarker = markerLines[number];
- const lastMarkerLine = !markerLines[number + 1];
- if (hasMarker) {
- let markerLine = "";
- if (Array.isArray(hasMarker)) {
- const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
- const numberOfMarkers = hasMarker[1] || 1;
- markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
- if (lastMarkerLine && opts.message) {
- markerLine += " " + maybeHighlight(defs.message, opts.message);
+/**
+ * Populates the user.js file with custom preferences as needed to allow
+ * Firefox's support to properly function. These preferences will be
+ * automatically copied over to prefs.js during startup of Firefox. To be
+ * able to restore the original values of preferences a backup of prefs.js
+ * will be created.
+ */
+async function syncPreferences(options) {
+ const prefsPath = path_1.default.join(options.path, 'prefs.js');
+ const userPath = path_1.default.join(options.path, 'user.js');
+ const lines = Object.entries(options.preferences).map(([key, value]) => {
+ return `user_pref(${JSON.stringify(key)}, ${JSON.stringify(value)});`;
+ });
+ // Use allSettled to prevent corruption.
+ const result = await Promise.allSettled([
+ backupFile(userPath).then(async () => {
+ await fs_1.default.promises.writeFile(userPath, lines.join('\n'));
+ }),
+ backupFile(prefsPath),
+ ]);
+ for (const command of result) {
+ if (command.status === 'rejected') {
+ throw command.reason;
}
- }
- return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
- } else {
- return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
}
- }).join("\n");
- if (opts.message && !hasColumns) {
- frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
- }
- if (highlighted) {
- return chalk.reset(frame);
- } else {
- return frame;
- }
}
-function _default(rawLines, lineNumber, colNumber, opts = {}) {
- if (!deprecationWarningShown) {
- deprecationWarningShown = true;
- const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
- if (process.emitWarning) {
- process.emitWarning(message, "DeprecationWarning");
- } else {
- const deprecationError = new Error(message);
- deprecationError.name = "DeprecationWarning";
- console.warn(new Error(message));
- }
- }
- colNumber = Math.max(colNumber, 0);
- const location = {
- start: {
- column: colNumber,
- line: lineNumber
- }
- };
- return codeFrameColumns(rawLines, location, opts);
+function compareVersions(a, b) {
+ // TODO: this is a not very reliable check.
+ return parseInt(a.replace('.', ''), 16) - parseInt(b.replace('.', ''), 16);
}
-
-//# sourceMappingURL=index.js.map
-
+//# sourceMappingURL=firefox.js.map
/***/ }),
-/***/ 92924:
+/***/ 3299:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
-
-Object.defineProperty(exports, "__esModule", ({
- value: true
-}));
-exports.isIdentifierChar = isIdentifierChar;
-exports.isIdentifierName = isIdentifierName;
-exports.isIdentifierStart = isIdentifierStart;
-let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
-const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
-function isInAstralSet(code, set) {
- let pos = 0x10000;
- for (let i = 0, length = set.length; i < length; i += 2) {
- pos += set[i];
- if (pos > code) return false;
- pos += set[i + 1];
- if (pos >= code) return true;
- }
- return false;
-}
-function isIdentifierStart(code) {
- if (code < 65) return code === 36;
- if (code <= 90) return true;
- if (code < 97) return code === 95;
- if (code <= 122) return true;
- if (code <= 0xffff) {
- return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
- }
- return isInAstralSet(code, astralIdentifierStartCodes);
-}
-function isIdentifierChar(code) {
- if (code < 48) return code === 36;
- if (code < 58) return true;
- if (code < 65) return false;
- if (code <= 90) return true;
- if (code < 97) return code === 95;
- if (code <= 122) return true;
- if (code <= 0xffff) {
- return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
- }
- return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
-}
-function isIdentifierName(name) {
- let isFirst = true;
- for (let i = 0; i < name.length; i++) {
- let cp = name.charCodeAt(i);
- if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
- const trail = name.charCodeAt(++i);
- if ((trail & 0xfc00) === 0xdc00) {
- cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
- }
- }
- if (isFirst) {
- isFirst = false;
- if (!isIdentifierStart(cp)) {
- return false;
- }
- } else if (!isIdentifierChar(cp)) {
- return false;
- }
- }
- return !isFirst;
-}
-
-//# sourceMappingURL=identifier.js.map
-
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ChromeReleaseChannel = exports.BrowserTag = exports.BrowserPlatform = exports.Browser = void 0;
+/**
+ * Supported browsers.
+ *
+ * @public
+ */
+var Browser;
+(function (Browser) {
+ Browser["CHROME"] = "chrome";
+ Browser["CHROMEHEADLESSSHELL"] = "chrome-headless-shell";
+ Browser["CHROMIUM"] = "chromium";
+ Browser["FIREFOX"] = "firefox";
+ Browser["CHROMEDRIVER"] = "chromedriver";
+})(Browser || (exports.Browser = Browser = {}));
+/**
+ * Platform names used to identify a OS platform x architecture combination in the way
+ * that is relevant for the browser download.
+ *
+ * @public
+ */
+var BrowserPlatform;
+(function (BrowserPlatform) {
+ BrowserPlatform["LINUX"] = "linux";
+ BrowserPlatform["MAC"] = "mac";
+ BrowserPlatform["MAC_ARM"] = "mac_arm";
+ BrowserPlatform["WIN32"] = "win32";
+ BrowserPlatform["WIN64"] = "win64";
+})(BrowserPlatform || (exports.BrowserPlatform = BrowserPlatform = {}));
+/**
+ * @public
+ */
+var BrowserTag;
+(function (BrowserTag) {
+ BrowserTag["CANARY"] = "canary";
+ BrowserTag["NIGHTLY"] = "nightly";
+ BrowserTag["BETA"] = "beta";
+ BrowserTag["DEV"] = "dev";
+ BrowserTag["DEVEDITION"] = "devedition";
+ BrowserTag["STABLE"] = "stable";
+ BrowserTag["ESR"] = "esr";
+ BrowserTag["LATEST"] = "latest";
+})(BrowserTag || (exports.BrowserTag = BrowserTag = {}));
+/**
+ * @public
+ */
+var ChromeReleaseChannel;
+(function (ChromeReleaseChannel) {
+ ChromeReleaseChannel["STABLE"] = "stable";
+ ChromeReleaseChannel["DEV"] = "dev";
+ ChromeReleaseChannel["CANARY"] = "canary";
+ ChromeReleaseChannel["BETA"] = "beta";
+})(ChromeReleaseChannel || (exports.ChromeReleaseChannel = ChromeReleaseChannel = {}));
+//# sourceMappingURL=types.js.map
/***/ }),
-/***/ 76599:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ 41387:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", ({
- value: true
-}));
-Object.defineProperty(exports, "isIdentifierChar", ({
- enumerable: true,
- get: function () {
- return _identifier.isIdentifierChar;
- }
-}));
-Object.defineProperty(exports, "isIdentifierName", ({
- enumerable: true,
- get: function () {
- return _identifier.isIdentifierName;
- }
-}));
-Object.defineProperty(exports, "isIdentifierStart", ({
- enumerable: true,
- get: function () {
- return _identifier.isIdentifierStart;
- }
-}));
-Object.defineProperty(exports, "isKeyword", ({
- enumerable: true,
- get: function () {
- return _keyword.isKeyword;
- }
-}));
-Object.defineProperty(exports, "isReservedWord", ({
- enumerable: true,
- get: function () {
- return _keyword.isReservedWord;
- }
-}));
-Object.defineProperty(exports, "isStrictBindOnlyReservedWord", ({
- enumerable: true,
- get: function () {
- return _keyword.isStrictBindOnlyReservedWord;
- }
-}));
-Object.defineProperty(exports, "isStrictBindReservedWord", ({
- enumerable: true,
- get: function () {
- return _keyword.isStrictBindReservedWord;
- }
-}));
-Object.defineProperty(exports, "isStrictReservedWord", ({
- enumerable: true,
- get: function () {
- return _keyword.isStrictReservedWord;
- }
-}));
-var _identifier = __nccwpck_require__(92924);
-var _keyword = __nccwpck_require__(49884);
-
-//# sourceMappingURL=index.js.map
-
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.debug = void 0;
+const debug_1 = __importDefault(__nccwpck_require__(2830));
+exports.debug = debug_1.default;
+//# sourceMappingURL=debug.js.map
/***/ }),
-/***/ 49884:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ 79014:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", ({
- value: true
-}));
-exports.isKeyword = isKeyword;
-exports.isReservedWord = isReservedWord;
-exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
-exports.isStrictBindReservedWord = isStrictBindReservedWord;
-exports.isStrictReservedWord = isStrictReservedWord;
-const reservedWords = {
- keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
- strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
- strictBind: ["eval", "arguments"]
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
};
-const keywords = new Set(reservedWords.keyword);
-const reservedWordsStrictSet = new Set(reservedWords.strict);
-const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
-function isReservedWord(word, inModule) {
- return inModule && word === "await" || word === "enum";
-}
-function isStrictReservedWord(word, inModule) {
- return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
-}
-function isStrictBindOnlyReservedWord(word) {
- return reservedWordsStrictBindSet.has(word);
-}
-function isStrictBindReservedWord(word, inModule) {
- return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.detectBrowserPlatform = detectBrowserPlatform;
+const os_1 = __importDefault(__nccwpck_require__(70857));
+const browser_data_js_1 = __nccwpck_require__(35255);
+/**
+ * @public
+ */
+function detectBrowserPlatform() {
+ const platform = os_1.default.platform();
+ switch (platform) {
+ case 'darwin':
+ return os_1.default.arch() === 'arm64'
+ ? browser_data_js_1.BrowserPlatform.MAC_ARM
+ : browser_data_js_1.BrowserPlatform.MAC;
+ case 'linux':
+ return browser_data_js_1.BrowserPlatform.LINUX;
+ case 'win32':
+ return os_1.default.arch() === 'x64' ||
+ // Windows 11 for ARM supports x64 emulation
+ (os_1.default.arch() === 'arm64' && isWindows11(os_1.default.release()))
+ ? browser_data_js_1.BrowserPlatform.WIN64
+ : browser_data_js_1.BrowserPlatform.WIN32;
+ default:
+ return undefined;
+ }
}
-function isKeyword(word) {
- return keywords.has(word);
+/**
+ * Windows 11 is identified by the version 10.0.22000 or greater
+ * @internal
+ */
+function isWindows11(version) {
+ const parts = version.split('.');
+ if (parts.length > 2) {
+ const major = parseInt(parts[0], 10);
+ const minor = parseInt(parts[1], 10);
+ const patch = parseInt(parts[2], 10);
+ return (major > 10 ||
+ (major === 10 && minor > 0) ||
+ (major === 10 && minor === 0 && patch >= 22000));
+ }
+ return false;
}
-
-//# sourceMappingURL=keyword.js.map
-
+//# sourceMappingURL=detectPlatform.js.map
/***/ }),
-/***/ 26270:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ 32152:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", ({
- value: true
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) 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 === undefined) k2 = k;
+ o[k2] = m[k];
}));
-exports["default"] = highlight;
-exports.shouldHighlight = shouldHighlight;
-var _jsTokens = __nccwpck_require__(85756);
-var _helperValidatorIdentifier = __nccwpck_require__(76599);
-var _chalk = _interopRequireWildcard(__nccwpck_require__(71318), true);
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
-function getDefs(chalk) {
- return {
- keyword: chalk.cyan,
- capitalized: chalk.yellow,
- jsxIdentifier: chalk.yellow,
- punctuator: chalk.yellow,
- number: chalk.magenta,
- string: chalk.green,
- regex: chalk.magenta,
- comment: chalk.grey,
- invalid: chalk.white.bgRed.bold
- };
-}
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-const BRACKET = /^[()[\]{}]$/;
-let tokenize;
-{
- const JSX_TAG = /^[a-z][\w-]*$/i;
- const getTokenType = function (token, offset, text) {
- if (token.type === "name") {
- if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) {
- return "keyword";
- }
- if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == " colorize(str)).join("\n");
- } else {
- highlighted += value;
+ else if (archivePath.endsWith('.tar.xz')) {
+ await extractTarXz(archivePath, folderPath);
+ }
+ else {
+ throw new Error(`Unsupported archive format: ${archivePath}`);
}
- }
- return highlighted;
-}
-function shouldHighlight(options) {
- return _chalk.default.level > 0 || options.forceColor;
}
-let chalkWithForcedColor = undefined;
-function getChalk(forceColor) {
- if (forceColor) {
- var _chalkWithForcedColor;
- (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new _chalk.default.constructor({
- enabled: true,
- level: 1
+/**
+ * @internal
+ */
+function extractTar(tarPath, folderPath) {
+ return new Promise((fulfill, reject) => {
+ const tarStream = tar_fs_1.default.extract(folderPath);
+ tarStream.on('error', reject);
+ tarStream.on('finish', fulfill);
+ const readStream = (0, fs_1.createReadStream)(tarPath);
+ readStream.pipe((0, unbzip2_stream_1.default)()).pipe(tarStream);
});
- return chalkWithForcedColor;
- }
- return _chalk.default;
-}
-{
- exports.getChalk = options => getChalk(options.forceColor);
-}
-function highlight(code, options = {}) {
- if (code !== "" && shouldHighlight(options)) {
- const defs = getDefs(getChalk(options.forceColor));
- return highlightTokens(defs, code);
- } else {
- return code;
- }
-}
-
-//# sourceMappingURL=index.js.map
-
-
-/***/ }),
-
-/***/ 27182:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-const WritableStream = (__nccwpck_require__(57075).Writable)
-const inherits = (__nccwpck_require__(57975).inherits)
-
-const StreamSearch = __nccwpck_require__(84136)
-
-const PartStream = __nccwpck_require__(50612)
-const HeaderParser = __nccwpck_require__(62271)
-
-const DASH = 45
-const B_ONEDASH = Buffer.from('-')
-const B_CRLF = Buffer.from('\r\n')
-const EMPTY_FN = function () {}
-
-function Dicer (cfg) {
- if (!(this instanceof Dicer)) { return new Dicer(cfg) }
- WritableStream.call(this, cfg)
-
- if (!cfg || (!cfg.headerFirst && typeof cfg.boundary !== 'string')) { throw new TypeError('Boundary required') }
-
- if (typeof cfg.boundary === 'string') { this.setBoundary(cfg.boundary) } else { this._bparser = undefined }
-
- this._headerFirst = cfg.headerFirst
-
- this._dashes = 0
- this._parts = 0
- this._finished = false
- this._realFinish = false
- this._isPreamble = true
- this._justMatched = false
- this._firstWrite = true
- this._inHeader = true
- this._part = undefined
- this._cb = undefined
- this._ignoreData = false
- this._partOpts = { highWaterMark: cfg.partHwm }
- this._pause = false
-
- const self = this
- this._hparser = new HeaderParser(cfg)
- this._hparser.on('header', function (header) {
- self._inHeader = false
- self._part.emit('header', header)
- })
}
-inherits(Dicer, WritableStream)
-
-Dicer.prototype.emit = function (ev) {
- if (ev === 'finish' && !this._realFinish) {
- if (!this._finished) {
- const self = this
- process.nextTick(function () {
- self.emit('error', new Error('Unexpected end of multipart data'))
- if (self._part && !self._ignoreData) {
- const type = (self._isPreamble ? 'Preamble' : 'Part')
- self._part.emit('error', new Error(type + ' terminated early due to unexpected end of multipart data'))
- self._part.push(null)
- process.nextTick(function () {
- self._realFinish = true
- self.emit('finish')
- self._realFinish = false
- })
- return
+/**
+ * @internal
+ */
+function createXzStream() {
+ const child = (0, child_process_1.spawn)('xz', ['-d']);
+ const stream = new stream_1.Stream.Transform({
+ transform(chunk, encoding, callback) {
+ if (!child.stdin.write(chunk, encoding)) {
+ child.stdin.once('drain', callback);
+ }
+ else {
+ callback();
+ }
+ },
+ flush(callback) {
+ if (child.stdout.destroyed) {
+ callback();
+ }
+ else {
+ child.stdin.end();
+ child.stdout.on('close', callback);
+ }
+ },
+ });
+ child.stdin.on('error', e => {
+ if ('code' in e && e.code === 'EPIPE') {
+ // finished before reading the file finished (i.e. head)
+ stream.emit('end');
}
- self._realFinish = true
- self.emit('finish')
- self._realFinish = false
- })
- }
- } else { WritableStream.prototype.emit.apply(this, arguments) }
-}
-
-Dicer.prototype._write = function (data, encoding, cb) {
- // ignore unexpected data (e.g. extra trailer data after finished)
- if (!this._hparser && !this._bparser) { return cb() }
-
- if (this._headerFirst && this._isPreamble) {
- if (!this._part) {
- this._part = new PartStream(this._partOpts)
- if (this.listenerCount('preamble') !== 0) { this.emit('preamble', this._part) } else { this._ignore() }
- }
- const r = this._hparser.push(data)
- if (!this._inHeader && r !== undefined && r < data.length) { data = data.slice(r) } else { return cb() }
- }
-
- // allows for "easier" testing
- if (this._firstWrite) {
- this._bparser.push(B_CRLF)
- this._firstWrite = false
- }
-
- this._bparser.push(data)
-
- if (this._pause) { this._cb = cb } else { cb() }
-}
-
-Dicer.prototype.reset = function () {
- this._part = undefined
- this._bparser = undefined
- this._hparser = undefined
-}
-
-Dicer.prototype.setBoundary = function (boundary) {
- const self = this
- this._bparser = new StreamSearch('\r\n--' + boundary)
- this._bparser.on('info', function (isMatch, data, start, end) {
- self._oninfo(isMatch, data, start, end)
- })
+ else {
+ stream.destroy(e);
+ }
+ });
+ child.stdout
+ .on('data', data => {
+ return stream.push(data);
+ })
+ .on('error', e => {
+ return stream.destroy(e);
+ });
+ return stream;
}
-
-Dicer.prototype._ignore = function () {
- if (this._part && !this._ignoreData) {
- this._ignoreData = true
- this._part.on('error', EMPTY_FN)
- // we must perform some kind of read on the stream even though we are
- // ignoring the data, otherwise node's Readable stream will not emit 'end'
- // after pushing null to the stream
- this._part.resume()
- }
+/**
+ * @internal
+ */
+function extractTarXz(tarPath, folderPath) {
+ return new Promise((fulfill, reject) => {
+ const tarStream = tar_fs_1.default.extract(folderPath);
+ tarStream.on('error', reject);
+ tarStream.on('finish', fulfill);
+ const readStream = (0, fs_1.createReadStream)(tarPath);
+ readStream.pipe(createXzStream()).pipe(tarStream);
+ });
}
-
-Dicer.prototype._oninfo = function (isMatch, data, start, end) {
- let buf; const self = this; let i = 0; let r; let shouldWriteMore = true
-
- if (!this._part && this._justMatched && data) {
- while (this._dashes < 2 && (start + i) < end) {
- if (data[start + i] === DASH) {
- ++i
- ++this._dashes
- } else {
- if (this._dashes) { buf = B_ONEDASH }
- this._dashes = 0
- break
- }
- }
- if (this._dashes === 2) {
- if ((start + i) < end && this.listenerCount('trailer') !== 0) { this.emit('trailer', data.slice(start + i, end)) }
- this.reset()
- this._finished = true
- // no more parts will be added
- if (self._parts === 0) {
- self._realFinish = true
- self.emit('finish')
- self._realFinish = false
- }
- }
- if (this._dashes) { return }
- }
- if (this._justMatched) { this._justMatched = false }
- if (!this._part) {
- this._part = new PartStream(this._partOpts)
- this._part._read = function (n) {
- self._unpause()
- }
- if (this._isPreamble && this.listenerCount('preamble') !== 0) {
- this.emit('preamble', this._part)
- } else if (this._isPreamble !== true && this.listenerCount('part') !== 0) {
- this.emit('part', this._part)
- } else {
- this._ignore()
+/**
+ * @internal
+ */
+async function installDMG(dmgPath, folderPath) {
+ const { stdout } = (0, child_process_1.spawnSync)(`hdiutil`, [
+ 'attach',
+ '-nobrowse',
+ '-noautoopen',
+ dmgPath,
+ ]);
+ const volumes = stdout.toString('utf8').match(/\/Volumes\/(.*)/m);
+ if (!volumes) {
+ throw new Error(`Could not find volume path in ${stdout}`);
}
- if (!this._isPreamble) { this._inHeader = true }
- }
- if (data && start < end && !this._ignoreData) {
- if (this._isPreamble || !this._inHeader) {
- if (buf) { shouldWriteMore = this._part.push(buf) }
- shouldWriteMore = this._part.push(data.slice(start, end))
- if (!shouldWriteMore) { this._pause = true }
- } else if (!this._isPreamble && this._inHeader) {
- if (buf) { this._hparser.push(buf) }
- r = this._hparser.push(data.slice(start, end))
- if (!this._inHeader && r !== undefined && r < end) { this._oninfo(false, data, start + r, end) }
+ const mountPath = volumes[0];
+ try {
+ const fileNames = await (0, promises_1.readdir)(mountPath);
+ const appName = fileNames.find(item => {
+ return typeof item === 'string' && item.endsWith('.app');
+ });
+ if (!appName) {
+ throw new Error(`Cannot find app in ${mountPath}`);
+ }
+ const mountedPath = path.join(mountPath, appName);
+ (0, child_process_1.spawnSync)('cp', ['-R', mountedPath, folderPath]);
}
- }
- if (isMatch) {
- this._hparser.reset()
- if (this._isPreamble) { this._isPreamble = false } else {
- if (start !== end) {
- ++this._parts
- this._part.on('end', function () {
- if (--self._parts === 0) {
- if (self._finished) {
- self._realFinish = true
- self.emit('finish')
- self._realFinish = false
- } else {
- self._unpause()
- }
- }
- })
- }
+ finally {
+ (0, child_process_1.spawnSync)('hdiutil', ['detach', mountPath, '-quiet']);
}
- this._part.push(null)
- this._part = undefined
- this._ignoreData = false
- this._justMatched = true
- this._dashes = 0
- }
-}
-
-Dicer.prototype._unpause = function () {
- if (!this._pause) { return }
-
- this._pause = false
- if (this._cb) {
- const cb = this._cb
- this._cb = undefined
- cb()
- }
}
-
-module.exports = Dicer
-
+//# sourceMappingURL=fileUtil.js.map
/***/ }),
-/***/ 62271:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 80422:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-
-const EventEmitter = (__nccwpck_require__(78474).EventEmitter)
-const inherits = (__nccwpck_require__(57975).inherits)
-const getLimit = __nccwpck_require__(22393)
-
-const StreamSearch = __nccwpck_require__(84136)
-
-const B_DCRLF = Buffer.from('\r\n\r\n')
-const RE_CRLF = /\r\n/g
-const RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/ // eslint-disable-line no-control-regex
-
-function HeaderParser (cfg) {
- EventEmitter.call(this)
-
- cfg = cfg || {}
- const self = this
- this.nread = 0
- this.maxed = false
- this.npairs = 0
- this.maxHeaderPairs = getLimit(cfg, 'maxHeaderPairs', 2000)
- this.maxHeaderSize = getLimit(cfg, 'maxHeaderSize', 80 * 1024)
- this.buffer = ''
- this.header = {}
- this.finished = false
- this.ss = new StreamSearch(B_DCRLF)
- this.ss.on('info', function (isMatch, data, start, end) {
- if (data && !self.maxed) {
- if (self.nread + end - start >= self.maxHeaderSize) {
- end = self.maxHeaderSize - self.nread + start
- self.nread = self.maxHeaderSize
- self.maxed = true
- } else { self.nread += (end - start) }
-
- self.buffer += data.toString('binary', start, end)
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) 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]; } };
}
- if (isMatch) { self._finish() }
- })
-}
-inherits(HeaderParser, EventEmitter)
-
-HeaderParser.prototype.push = function (data) {
- const r = this.ss.push(data)
- if (this.finished) { return r }
+ Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+ var ownKeys = function(o) {
+ ownKeys = Object.getOwnPropertyNames || function (o) {
+ var ar = [];
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o);
+ };
+ return function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+ __setModuleDefault(result, mod);
+ return result;
+ };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.headHttpRequest = headHttpRequest;
+exports.httpRequest = httpRequest;
+exports.downloadFile = downloadFile;
+exports.getJSON = getJSON;
+exports.getText = getText;
+const fs_1 = __nccwpck_require__(79896);
+const http = __importStar(__nccwpck_require__(58611));
+const https = __importStar(__nccwpck_require__(65692));
+const url_1 = __nccwpck_require__(87016);
+const proxy_agent_1 = __nccwpck_require__(75273);
+function headHttpRequest(url) {
+ return new Promise(resolve => {
+ const request = httpRequest(url, 'HEAD', response => {
+ // consume response data free node process
+ response.resume();
+ resolve(response.statusCode === 200);
+ }, false);
+ request.on('error', () => {
+ resolve(false);
+ });
+ });
}
-
-HeaderParser.prototype.reset = function () {
- this.finished = false
- this.buffer = ''
- this.header = {}
- this.ss.reset()
+function httpRequest(url, method, response, keepAlive = true) {
+ const options = {
+ protocol: url.protocol,
+ hostname: url.hostname,
+ port: url.port,
+ path: url.pathname + url.search,
+ method,
+ headers: keepAlive ? { Connection: 'keep-alive' } : undefined,
+ auth: (0, url_1.urlToHttpOptions)(url).auth,
+ agent: new proxy_agent_1.ProxyAgent(),
+ };
+ const requestCallback = (res) => {
+ if (res.statusCode &&
+ res.statusCode >= 300 &&
+ res.statusCode < 400 &&
+ res.headers.location) {
+ httpRequest(new url_1.URL(res.headers.location), method, response);
+ // consume response data to free up memory
+ // And prevents the connection from being kept alive
+ res.resume();
+ }
+ else {
+ response(res);
+ }
+ };
+ const request = options.protocol === 'https:'
+ ? https.request(options, requestCallback)
+ : http.request(options, requestCallback);
+ request.end();
+ return request;
}
-
-HeaderParser.prototype._finish = function () {
- if (this.buffer) { this._parseHeader() }
- this.ss.matches = this.ss.maxMatches
- const header = this.header
- this.header = {}
- this.buffer = ''
- this.finished = true
- this.nread = this.npairs = 0
- this.maxed = false
- this.emit('header', header)
+/**
+ * @internal
+ */
+function downloadFile(url, destinationPath, progressCallback) {
+ return new Promise((resolve, reject) => {
+ let downloadedBytes = 0;
+ let totalBytes = 0;
+ function onData(chunk) {
+ downloadedBytes += chunk.length;
+ progressCallback(downloadedBytes, totalBytes);
+ }
+ const request = httpRequest(url, 'GET', response => {
+ if (response.statusCode !== 200) {
+ const error = new Error(`Download failed: server returned code ${response.statusCode}. URL: ${url}`);
+ // consume response data to free up memory
+ response.resume();
+ reject(error);
+ return;
+ }
+ const file = (0, fs_1.createWriteStream)(destinationPath);
+ file.on('finish', () => {
+ return resolve();
+ });
+ file.on('error', error => {
+ return reject(error);
+ });
+ response.pipe(file);
+ totalBytes = parseInt(response.headers['content-length'], 10);
+ if (progressCallback) {
+ response.on('data', onData);
+ }
+ });
+ request.on('error', error => {
+ return reject(error);
+ });
+ });
}
-
-HeaderParser.prototype._parseHeader = function () {
- if (this.npairs === this.maxHeaderPairs) { return }
-
- const lines = this.buffer.split(RE_CRLF)
- const len = lines.length
- let m, h
-
- for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
- if (lines[i].length === 0) { continue }
- if (lines[i][0] === '\t' || lines[i][0] === ' ') {
- // folded header content
- // RFC2822 says to just remove the CRLF and not the whitespace following
- // it, so we follow the RFC and include the leading whitespace ...
- if (h) {
- this.header[h][this.header[h].length - 1] += lines[i]
- continue
- }
+async function getJSON(url) {
+ const text = await getText(url);
+ try {
+ return JSON.parse(text);
}
-
- const posColon = lines[i].indexOf(':')
- if (
- posColon === -1 ||
- posColon === 0
- ) {
- return
+ catch {
+ throw new Error('Could not parse JSON from ' + url.toString());
}
- m = RE_HDR.exec(lines[i])
- h = m[1].toLowerCase()
- this.header[h] = this.header[h] || []
- this.header[h].push((m[2] || ''))
- if (++this.npairs === this.maxHeaderPairs) { break }
- }
}
-
-module.exports = HeaderParser
-
-
-/***/ }),
-
-/***/ 50612:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-const inherits = (__nccwpck_require__(57975).inherits)
-const ReadableStream = (__nccwpck_require__(57075).Readable)
-
-function PartStream (opts) {
- ReadableStream.call(this, opts)
+function getText(url) {
+ return new Promise((resolve, reject) => {
+ const request = httpRequest(url, 'GET', response => {
+ let data = '';
+ if (response.statusCode && response.statusCode >= 400) {
+ return reject(new Error(`Got status code ${response.statusCode}`));
+ }
+ response.on('data', chunk => {
+ data += chunk;
+ });
+ response.on('end', () => {
+ try {
+ return resolve(String(data));
+ }
+ catch {
+ return reject(new Error('Chrome version not found'));
+ }
+ });
+ }, false);
+ request.on('error', err => {
+ reject(err);
+ });
+ });
}
-inherits(PartStream, ReadableStream)
-
-PartStream.prototype._read = function (n) {}
-
-module.exports = PartStream
-
+//# sourceMappingURL=httpUtil.js.map
/***/ }),
-/***/ 84136:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 37619:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-
/**
- * Copyright Brian White. All rights reserved.
- *
- * @see https://github.com/mscdex/streamsearch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- * Based heavily on the Streaming Boyer-Moore-Horspool C++ implementation
- * by Hongli Lai at: https://github.com/FooBarWidget/boyer-moore-horspool
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
*/
-const EventEmitter = (__nccwpck_require__(78474).EventEmitter)
-const inherits = (__nccwpck_require__(57975).inherits)
-
-function SBMH (needle) {
- if (typeof needle === 'string') {
- needle = Buffer.from(needle)
- }
-
- if (!Buffer.isBuffer(needle)) {
- throw new TypeError('The needle has to be a String or a Buffer.')
- }
-
- const needleLength = needle.length
-
- if (needleLength === 0) {
- throw new Error('The needle cannot be an empty String/Buffer.')
- }
-
- if (needleLength > 256) {
- throw new Error('The needle cannot have a length bigger than 256.')
- }
-
- this.maxMatches = Infinity
- this.matches = 0
-
- this._occ = new Array(256)
- .fill(needleLength) // Initialize occurrence table.
- this._lookbehind_size = 0
- this._needle = needle
- this._bufpos = 0
-
- this._lookbehind = Buffer.alloc(needleLength)
-
- // Populate occurrence table with analysis of the needle,
- // ignoring last letter.
- for (var i = 0; i < needleLength - 1; ++i) { // eslint-disable-line no-var
- this._occ[needle[i]] = needleLength - 1 - i
- }
-}
-inherits(SBMH, EventEmitter)
-
-SBMH.prototype.reset = function () {
- this._lookbehind_size = 0
- this.matches = 0
- this._bufpos = 0
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.install = install;
+exports.uninstall = uninstall;
+exports.getInstalledBrowsers = getInstalledBrowsers;
+exports.canDownload = canDownload;
+const assert_1 = __importDefault(__nccwpck_require__(42613));
+const child_process_1 = __nccwpck_require__(35317);
+const fs_1 = __nccwpck_require__(79896);
+const promises_1 = __nccwpck_require__(91943);
+const os_1 = __importDefault(__nccwpck_require__(70857));
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const browser_data_js_1 = __nccwpck_require__(35255);
+const Cache_js_1 = __nccwpck_require__(95674);
+const debug_js_1 = __nccwpck_require__(41387);
+const detectPlatform_js_1 = __nccwpck_require__(79014);
+const fileUtil_js_1 = __nccwpck_require__(32152);
+const httpUtil_js_1 = __nccwpck_require__(80422);
+const debugInstall = (0, debug_js_1.debug)('puppeteer:browsers:install');
+const times = new Map();
+function debugTime(label) {
+ times.set(label, process.hrtime());
}
-
-SBMH.prototype.push = function (chunk, pos) {
- if (!Buffer.isBuffer(chunk)) {
- chunk = Buffer.from(chunk, 'binary')
- }
- const chlen = chunk.length
- this._bufpos = pos || 0
- let r
- while (r !== chlen && this.matches < this.maxMatches) { r = this._sbmh_feed(chunk) }
- return r
+function debugTimeEnd(label) {
+ const end = process.hrtime();
+ const start = times.get(label);
+ if (!start) {
+ return;
+ }
+ const duration = end[0] * 1000 + end[1] / 1e6 - (start[0] * 1000 + start[1] / 1e6); // calculate duration in milliseconds
+ debugInstall(`Duration for ${label}: ${duration}ms`);
}
-
-SBMH.prototype._sbmh_feed = function (data) {
- const len = data.length
- const needle = this._needle
- const needleLength = needle.length
- const lastNeedleChar = needle[needleLength - 1]
-
- // Positive: points to a position in `data`
- // pos == 3 points to data[3]
- // Negative: points to a position in the lookbehind buffer
- // pos == -2 points to lookbehind[lookbehind_size - 2]
- let pos = -this._lookbehind_size
- let ch
-
- if (pos < 0) {
- // Lookbehind buffer is not empty. Perform Boyer-Moore-Horspool
- // search with character lookup code that considers both the
- // lookbehind buffer and the current round's haystack data.
- //
- // Loop until
- // there is a match.
- // or until
- // we've moved past the position that requires the
- // lookbehind buffer. In this case we switch to the
- // optimized loop.
- // or until
- // the character to look at lies outside the haystack.
- while (pos < 0 && pos <= len - needleLength) {
- ch = this._sbmh_lookup_char(data, pos + needleLength - 1)
-
- if (
- ch === lastNeedleChar &&
- this._sbmh_memcmp(data, pos, needleLength - 1)
- ) {
- this._lookbehind_size = 0
- ++this.matches
- this.emit('info', true)
-
- return (this._bufpos = pos + needleLength)
- }
- pos += this._occ[ch]
+async function install(options) {
+ options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ options.unpack ??= true;
+ if (!options.platform) {
+ throw new Error(`Cannot download a binary for the provided platform: ${os_1.default.platform()} (${os_1.default.arch()})`);
}
-
- // No match.
-
- if (pos < 0) {
- // There's too few data for Boyer-Moore-Horspool to run,
- // so let's use a different algorithm to skip as much as
- // we can.
- // Forward pos until
- // the trailing part of lookbehind + data
- // looks like the beginning of the needle
- // or until
- // pos == 0
- while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { ++pos }
+ const url = getDownloadUrl(options.browser, options.platform, options.buildId, options.baseUrl);
+ try {
+ return await installUrl(url, options);
}
-
- if (pos >= 0) {
- // Discard lookbehind buffer.
- this.emit('info', false, this._lookbehind, 0, this._lookbehind_size)
- this._lookbehind_size = 0
- } else {
- // Cut off part of the lookbehind buffer that has
- // been processed and append the entire haystack
- // into it.
- const bytesToCutOff = this._lookbehind_size + pos
- if (bytesToCutOff > 0) {
- // The cut off data is guaranteed not to contain the needle.
- this.emit('info', false, this._lookbehind, 0, bytesToCutOff)
- }
-
- this._lookbehind.copy(this._lookbehind, 0, bytesToCutOff,
- this._lookbehind_size - bytesToCutOff)
- this._lookbehind_size -= bytesToCutOff
-
- data.copy(this._lookbehind, this._lookbehind_size)
- this._lookbehind_size += len
-
- this._bufpos = len
- return len
+ catch (err) {
+ // If custom baseUrl is provided, do not fall back to CfT dashboard.
+ if (options.baseUrl && !options.forceFallbackForTesting) {
+ throw err;
+ }
+ debugInstall(`Error downloading from ${url}.`);
+ switch (options.browser) {
+ case browser_data_js_1.Browser.CHROME:
+ case browser_data_js_1.Browser.CHROMEDRIVER:
+ case browser_data_js_1.Browser.CHROMEHEADLESSSHELL: {
+ debugInstall(`Trying to find download URL via https://googlechromelabs.github.io/chrome-for-testing.`);
+ const version = (await (0, httpUtil_js_1.getJSON)(new URL(`https://googlechromelabs.github.io/chrome-for-testing/${options.buildId}.json`)));
+ let platform = '';
+ switch (options.platform) {
+ case browser_data_js_1.BrowserPlatform.LINUX:
+ platform = 'linux64';
+ break;
+ case browser_data_js_1.BrowserPlatform.MAC_ARM:
+ platform = 'mac-arm64';
+ break;
+ case browser_data_js_1.BrowserPlatform.MAC:
+ platform = 'mac-x64';
+ break;
+ case browser_data_js_1.BrowserPlatform.WIN32:
+ platform = 'win32';
+ break;
+ case browser_data_js_1.BrowserPlatform.WIN64:
+ platform = 'win64';
+ break;
+ }
+ const url = version.downloads[options.browser]?.find(link => {
+ return link['platform'] === platform;
+ })?.url;
+ if (url) {
+ debugInstall(`Falling back to downloading from ${url}.`);
+ return await installUrl(new URL(url), options);
+ }
+ throw err;
+ }
+ default:
+ throw err;
+ }
}
- }
-
- pos += (pos >= 0) * this._bufpos
-
- // Lookbehind buffer is now empty. We only need to check if the
- // needle is in the haystack.
- if (data.indexOf(needle, pos) !== -1) {
- pos = data.indexOf(needle, pos)
- ++this.matches
- if (pos > 0) { this.emit('info', true, data, this._bufpos, pos) } else { this.emit('info', true) }
-
- return (this._bufpos = pos + needleLength)
- } else {
- pos = len - needleLength
- }
-
- // There was no match. If there's trailing haystack data that we cannot
- // match yet using the Boyer-Moore-Horspool algorithm (because the trailing
- // data is less than the needle size) then match using a modified
- // algorithm that starts matching from the beginning instead of the end.
- // Whatever trailing data is left after running this algorithm is added to
- // the lookbehind buffer.
- while (
- pos < len &&
- (
- data[pos] !== needle[0] ||
- (
- (Buffer.compare(
- data.subarray(pos, pos + len - pos),
- needle.subarray(0, len - pos)
- ) !== 0)
- )
- )
- ) {
- ++pos
- }
- if (pos < len) {
- data.copy(this._lookbehind, 0, pos, pos + (len - pos))
- this._lookbehind_size = len - pos
- }
-
- // Everything until pos is guaranteed not to contain needle data.
- if (pos > 0) { this.emit('info', false, data, this._bufpos, pos < len ? pos : len) }
-
- this._bufpos = len
- return len
}
-
-SBMH.prototype._sbmh_lookup_char = function (data, pos) {
- return (pos < 0)
- ? this._lookbehind[this._lookbehind_size + pos]
- : data[pos]
+async function installDeps(installedBrowser) {
+ if (process.platform !== 'linux' ||
+ installedBrowser.platform !== browser_data_js_1.BrowserPlatform.LINUX) {
+ return;
+ }
+ // Currently, only Debian-like deps are supported.
+ const depsPath = path_1.default.join(path_1.default.dirname(installedBrowser.executablePath), 'deb.deps');
+ if (!(0, fs_1.existsSync)(depsPath)) {
+ debugInstall(`deb.deps file was not found at ${depsPath}`);
+ return;
+ }
+ const data = (0, fs_1.readFileSync)(depsPath, 'utf-8').split('\n').join(',');
+ if (process.getuid?.() !== 0) {
+ throw new Error('Installing system dependencies requires root privileges');
+ }
+ let result = (0, child_process_1.spawnSync)('apt-get', ['-v']);
+ if (result.status !== 0) {
+ throw new Error('Failed to install system dependencies: apt-get does not seem to be available');
+ }
+ debugInstall(`Trying to install dependencies: ${data}`);
+ result = (0, child_process_1.spawnSync)('apt-get', [
+ 'satisfy',
+ '-y',
+ data,
+ '--no-install-recommends',
+ ]);
+ if (result.status !== 0) {
+ throw new Error(`Failed to install system dependencies: status=${result.status},error=${result.error},stdout=${result.stdout.toString('utf8')},stderr=${result.stderr.toString('utf8')}`);
+ }
+ debugInstall(`Installed system dependencies ${data}`);
}
-
-SBMH.prototype._sbmh_memcmp = function (data, pos, len) {
- for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
- if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { return false }
- }
- return true
+async function installUrl(url, options) {
+ options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ if (!options.platform) {
+ throw new Error(`Cannot download a binary for the provided platform: ${os_1.default.platform()} (${os_1.default.arch()})`);
+ }
+ const fileName = url.toString().split('/').pop();
+ (0, assert_1.default)(fileName, `A malformed download URL was found: ${url}.`);
+ const cache = new Cache_js_1.Cache(options.cacheDir);
+ const browserRoot = cache.browserRoot(options.browser);
+ const archivePath = path_1.default.join(browserRoot, `${options.buildId}-${fileName}`);
+ if (!(0, fs_1.existsSync)(browserRoot)) {
+ await (0, promises_1.mkdir)(browserRoot, { recursive: true });
+ }
+ if (!options.unpack) {
+ if ((0, fs_1.existsSync)(archivePath)) {
+ return archivePath;
+ }
+ debugInstall(`Downloading binary from ${url}`);
+ debugTime('download');
+ await (0, httpUtil_js_1.downloadFile)(url, archivePath, options.downloadProgressCallback);
+ debugTimeEnd('download');
+ return archivePath;
+ }
+ const outputPath = cache.installationDir(options.browser, options.platform, options.buildId);
+ try {
+ if ((0, fs_1.existsSync)(outputPath)) {
+ const installedBrowser = new Cache_js_1.InstalledBrowser(cache, options.browser, options.buildId, options.platform);
+ if (!(0, fs_1.existsSync)(installedBrowser.executablePath)) {
+ throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
+ }
+ await runSetup(installedBrowser);
+ if (options.installDeps) {
+ await installDeps(installedBrowser);
+ }
+ return installedBrowser;
+ }
+ debugInstall(`Downloading binary from ${url}`);
+ try {
+ debugTime('download');
+ await (0, httpUtil_js_1.downloadFile)(url, archivePath, options.downloadProgressCallback);
+ }
+ finally {
+ debugTimeEnd('download');
+ }
+ debugInstall(`Installing ${archivePath} to ${outputPath}`);
+ try {
+ debugTime('extract');
+ await (0, fileUtil_js_1.unpackArchive)(archivePath, outputPath);
+ }
+ finally {
+ debugTimeEnd('extract');
+ }
+ const installedBrowser = new Cache_js_1.InstalledBrowser(cache, options.browser, options.buildId, options.platform);
+ if (options.buildIdAlias) {
+ const metadata = installedBrowser.readMetadata();
+ metadata.aliases[options.buildIdAlias] = options.buildId;
+ installedBrowser.writeMetadata(metadata);
+ }
+ await runSetup(installedBrowser);
+ if (options.installDeps) {
+ await installDeps(installedBrowser);
+ }
+ return installedBrowser;
+ }
+ finally {
+ if ((0, fs_1.existsSync)(archivePath)) {
+ await (0, promises_1.unlink)(archivePath);
+ }
+ }
}
-
-module.exports = SBMH
-
-
-/***/ }),
-
-/***/ 89581:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-const WritableStream = (__nccwpck_require__(57075).Writable)
-const { inherits } = __nccwpck_require__(57975)
-const Dicer = __nccwpck_require__(27182)
-
-const MultipartParser = __nccwpck_require__(41192)
-const UrlencodedParser = __nccwpck_require__(80855)
-const parseParams = __nccwpck_require__(8929)
-
-function Busboy (opts) {
- if (!(this instanceof Busboy)) { return new Busboy(opts) }
-
- if (typeof opts !== 'object') {
- throw new TypeError('Busboy expected an options-Object.')
- }
- if (typeof opts.headers !== 'object') {
- throw new TypeError('Busboy expected an options-Object with headers-attribute.')
- }
- if (typeof opts.headers['content-type'] !== 'string') {
- throw new TypeError('Missing Content-Type-header.')
- }
-
- const {
- headers,
- ...streamOptions
- } = opts
-
- this.opts = {
- autoDestroy: false,
- ...streamOptions
- }
- WritableStream.call(this, this.opts)
-
- this._done = false
- this._parser = this.getParserByHeaders(headers)
- this._finished = false
+async function runSetup(installedBrowser) {
+ // On Windows for Chrome invoke setup.exe to configure sandboxes.
+ if ((installedBrowser.platform === browser_data_js_1.BrowserPlatform.WIN32 ||
+ installedBrowser.platform === browser_data_js_1.BrowserPlatform.WIN64) &&
+ installedBrowser.browser === browser_data_js_1.Browser.CHROME &&
+ installedBrowser.platform === (0, detectPlatform_js_1.detectBrowserPlatform)()) {
+ try {
+ debugTime('permissions');
+ const browserDir = path_1.default.dirname(installedBrowser.executablePath);
+ const setupExePath = path_1.default.join(browserDir, 'setup.exe');
+ if (!(0, fs_1.existsSync)(setupExePath)) {
+ return;
+ }
+ (0, child_process_1.spawnSync)(path_1.default.join(browserDir, 'setup.exe'), [`--configure-browser-in-directory=` + browserDir], {
+ shell: true,
+ });
+ // TODO: Handle error here. Currently the setup.exe sometimes
+ // errors although it sets the permissions correctly.
+ }
+ finally {
+ debugTimeEnd('permissions');
+ }
+ }
}
-inherits(Busboy, WritableStream)
-
-Busboy.prototype.emit = function (ev) {
- if (ev === 'finish') {
- if (!this._done) {
- this._parser?.end()
- return
- } else if (this._finished) {
- return
+/**
+ *
+ * @public
+ */
+async function uninstall(options) {
+ options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ if (!options.platform) {
+ throw new Error(`Cannot detect the browser platform for: ${os_1.default.platform()} (${os_1.default.arch()})`);
}
- this._finished = true
- }
- WritableStream.prototype.emit.apply(this, arguments)
+ new Cache_js_1.Cache(options.cacheDir).uninstall(options.browser, options.platform, options.buildId);
}
-
-Busboy.prototype.getParserByHeaders = function (headers) {
- const parsed = parseParams(headers['content-type'])
-
- const cfg = {
- defCharset: this.opts.defCharset,
- fileHwm: this.opts.fileHwm,
- headers,
- highWaterMark: this.opts.highWaterMark,
- isPartAFile: this.opts.isPartAFile,
- limits: this.opts.limits,
- parsedConType: parsed,
- preservePath: this.opts.preservePath
- }
-
- if (MultipartParser.detect.test(parsed[0])) {
- return new MultipartParser(this, cfg)
- }
- if (UrlencodedParser.detect.test(parsed[0])) {
- return new UrlencodedParser(this, cfg)
- }
- throw new Error('Unsupported Content-Type.')
+/**
+ * Returns metadata about browsers installed in the cache directory.
+ *
+ * @public
+ */
+async function getInstalledBrowsers(options) {
+ return new Cache_js_1.Cache(options.cacheDir).getInstalledBrowsers();
}
-
-Busboy.prototype._write = function (chunk, encoding, cb) {
- this._parser.write(chunk, cb)
+/**
+ * @public
+ */
+async function canDownload(options) {
+ options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ if (!options.platform) {
+ throw new Error(`Cannot download a binary for the provided platform: ${os_1.default.platform()} (${os_1.default.arch()})`);
+ }
+ return await (0, httpUtil_js_1.headHttpRequest)(getDownloadUrl(options.browser, options.platform, options.buildId, options.baseUrl));
}
-
-module.exports = Busboy
-module.exports["default"] = Busboy
-module.exports.Busboy = Busboy
-
-module.exports.Dicer = Dicer
-
+function getDownloadUrl(browser, platform, buildId, baseUrl) {
+ return new URL(browser_data_js_1.downloadUrls[browser](platform, buildId, baseUrl));
+}
+//# sourceMappingURL=install.js.map
/***/ }),
-/***/ 41192:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 6485:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-
-// TODO:
-// * support 1 nested multipart level
-// (see second multipart example here:
-// http://www.w3.org/TR/html401/interact/forms.html#didx-multipartform-data)
-// * support limits.fieldNameSize
-// -- this will require modifications to utils.parseParams
-
-const { Readable } = __nccwpck_require__(57075)
-const { inherits } = __nccwpck_require__(57975)
-
-const Dicer = __nccwpck_require__(27182)
-
-const parseParams = __nccwpck_require__(8929)
-const decodeText = __nccwpck_require__(72747)
-const basename = __nccwpck_require__(20692)
-const getLimit = __nccwpck_require__(22393)
-
-const RE_BOUNDARY = /^boundary$/i
-const RE_FIELD = /^form-data$/i
-const RE_CHARSET = /^charset$/i
-const RE_FILENAME = /^filename$/i
-const RE_NAME = /^name$/i
-
-Multipart.detect = /^multipart\/form-data/i
-function Multipart (boy, cfg) {
- let i
- let len
- const self = this
- let boundary
- const limits = cfg.limits
- const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => (contentType === 'application/octet-stream' || fileName !== undefined))
- const parsedConType = cfg.parsedConType || []
- const defCharset = cfg.defCharset || 'utf8'
- const preservePath = cfg.preservePath
- const fileOpts = { highWaterMark: cfg.fileHwm }
-
- for (i = 0, len = parsedConType.length; i < len; ++i) {
- if (Array.isArray(parsedConType[i]) &&
- RE_BOUNDARY.test(parsedConType[i][0])) {
- boundary = parsedConType[i][1]
- break
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TimeoutError = exports.Process = exports.WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX = exports.CDP_WEBSOCKET_ENDPOINT_REGEX = void 0;
+exports.computeExecutablePath = computeExecutablePath;
+exports.computeSystemExecutablePath = computeSystemExecutablePath;
+exports.launch = launch;
+exports.isErrorLike = isErrorLike;
+exports.isErrnoException = isErrnoException;
+const child_process_1 = __importDefault(__nccwpck_require__(35317));
+const fs_1 = __nccwpck_require__(79896);
+const os_1 = __importDefault(__nccwpck_require__(70857));
+const readline_1 = __importDefault(__nccwpck_require__(23785));
+const browser_data_js_1 = __nccwpck_require__(35255);
+const Cache_js_1 = __nccwpck_require__(95674);
+const debug_js_1 = __nccwpck_require__(41387);
+const detectPlatform_js_1 = __nccwpck_require__(79014);
+const debugLaunch = (0, debug_js_1.debug)('puppeteer:browsers:launcher');
+/**
+ * @public
+ */
+function computeExecutablePath(options) {
+ return new Cache_js_1.Cache(options.cacheDir).computeExecutablePath(options);
+}
+/**
+ * @public
+ */
+function computeSystemExecutablePath(options) {
+ options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
+ if (!options.platform) {
+ throw new Error(`Cannot download a binary for the provided platform: ${os_1.default.platform()} (${os_1.default.arch()})`);
}
- }
-
- function checkFinished () {
- if (nends === 0 && finished && !boy._done) {
- finished = false
- self.end()
+ const path = (0, browser_data_js_1.resolveSystemExecutablePath)(options.browser, options.platform, options.channel);
+ try {
+ (0, fs_1.accessSync)(path);
}
- }
-
- if (typeof boundary !== 'string') { throw new Error('Multipart: Boundary not found') }
-
- const fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024)
- const fileSizeLimit = getLimit(limits, 'fileSize', Infinity)
- const filesLimit = getLimit(limits, 'files', Infinity)
- const fieldsLimit = getLimit(limits, 'fields', Infinity)
- const partsLimit = getLimit(limits, 'parts', Infinity)
- const headerPairsLimit = getLimit(limits, 'headerPairs', 2000)
- const headerSizeLimit = getLimit(limits, 'headerSize', 80 * 1024)
-
- let nfiles = 0
- let nfields = 0
- let nends = 0
- let curFile
- let curField
- let finished = false
-
- this._needDrain = false
- this._pause = false
- this._cb = undefined
- this._nparts = 0
- this._boy = boy
-
- const parserCfg = {
- boundary,
- maxHeaderPairs: headerPairsLimit,
- maxHeaderSize: headerSizeLimit,
- partHwm: fileOpts.highWaterMark,
- highWaterMark: cfg.highWaterMark
- }
-
- this.parser = new Dicer(parserCfg)
- this.parser.on('drain', function () {
- self._needDrain = false
- if (self._cb && !self._pause) {
- const cb = self._cb
- self._cb = undefined
- cb()
+ catch {
+ throw new Error(`Could not find Google Chrome executable for channel '${options.channel}' at '${path}'.`);
}
- }).on('part', function onPart (part) {
- if (++self._nparts > partsLimit) {
- self.parser.removeListener('part', onPart)
- self.parser.on('part', skipPart)
- boy.hitPartsLimit = true
- boy.emit('partsLimit')
- return skipPart(part)
+ return path;
+}
+/**
+ * Launches a browser process according to {@link LaunchOptions}.
+ *
+ * @public
+ */
+function launch(opts) {
+ return new Process(opts);
+}
+/**
+ * @public
+ */
+exports.CDP_WEBSOCKET_ENDPOINT_REGEX = /^DevTools listening on (ws:\/\/.*)$/;
+/**
+ * @public
+ */
+exports.WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX = /^WebDriver BiDi listening on (ws:\/\/.*)$/;
+const processListeners = new Map();
+const dispatchers = {
+ exit: (...args) => {
+ processListeners.get('exit')?.forEach(handler => {
+ return handler(...args);
+ });
+ },
+ SIGINT: (...args) => {
+ processListeners.get('SIGINT')?.forEach(handler => {
+ return handler(...args);
+ });
+ },
+ SIGHUP: (...args) => {
+ processListeners.get('SIGHUP')?.forEach(handler => {
+ return handler(...args);
+ });
+ },
+ SIGTERM: (...args) => {
+ processListeners.get('SIGTERM')?.forEach(handler => {
+ return handler(...args);
+ });
+ },
+};
+function subscribeToProcessEvent(event, handler) {
+ const listeners = processListeners.get(event) || [];
+ if (listeners.length === 0) {
+ process.on(event, dispatchers[event]);
}
-
- // hack because streams2 _always_ doesn't emit 'end' until nextTick, so let
- // us emit 'end' early since we know the part has ended if we are already
- // seeing the next part
- if (curField) {
- const field = curField
- field.emit('end')
- field.removeAllListeners('end')
+ listeners.push(handler);
+ processListeners.set(event, listeners);
+}
+function unsubscribeFromProcessEvent(event, handler) {
+ const listeners = processListeners.get(event) || [];
+ const existingListenerIdx = listeners.indexOf(handler);
+ if (existingListenerIdx === -1) {
+ return;
}
-
- part.on('header', function (header) {
- let contype
- let fieldname
- let parsed
- let charset
- let encoding
- let filename
- let nsize = 0
-
- if (header['content-type']) {
- parsed = parseParams(header['content-type'][0])
- if (parsed[0]) {
- contype = parsed[0].toLowerCase()
- for (i = 0, len = parsed.length; i < len; ++i) {
- if (RE_CHARSET.test(parsed[i][0])) {
- charset = parsed[i][1].toLowerCase()
- break
- }
- }
- }
- }
-
- if (contype === undefined) { contype = 'text/plain' }
- if (charset === undefined) { charset = defCharset }
-
- if (header['content-disposition']) {
- parsed = parseParams(header['content-disposition'][0])
- if (!RE_FIELD.test(parsed[0])) { return skipPart(part) }
- for (i = 0, len = parsed.length; i < len; ++i) {
- if (RE_NAME.test(parsed[i][0])) {
- fieldname = parsed[i][1]
- } else if (RE_FILENAME.test(parsed[i][0])) {
- filename = parsed[i][1]
- if (!preservePath) { filename = basename(filename) }
- }
- }
- } else { return skipPart(part) }
-
- if (header['content-transfer-encoding']) { encoding = header['content-transfer-encoding'][0].toLowerCase() } else { encoding = '7bit' }
-
- let onData,
- onEnd
-
- if (isPartAFile(fieldname, contype, filename)) {
- // file/binary field
- if (nfiles === filesLimit) {
- if (!boy.hitFilesLimit) {
- boy.hitFilesLimit = true
- boy.emit('filesLimit')
- }
- return skipPart(part)
+ listeners.splice(existingListenerIdx, 1);
+ processListeners.set(event, listeners);
+ if (listeners.length === 0) {
+ process.off(event, dispatchers[event]);
+ }
+}
+/**
+ * @public
+ */
+class Process {
+ #executablePath;
+ #args;
+ #browserProcess;
+ #exited = false;
+ // The browser process can be closed externally or from the driver process. We
+ // need to invoke the hooks only once though but we don't know how many times
+ // we will be invoked.
+ #hooksRan = false;
+ #onExitHook = async () => { };
+ #browserProcessExiting;
+ constructor(opts) {
+ this.#executablePath = opts.executablePath;
+ this.#args = opts.args ?? [];
+ opts.pipe ??= false;
+ opts.dumpio ??= false;
+ opts.handleSIGINT ??= true;
+ opts.handleSIGTERM ??= true;
+ opts.handleSIGHUP ??= true;
+ // On non-windows platforms, `detached: true` makes child process a
+ // leader of a new process group, making it possible to kill child
+ // process tree with `.kill(-pid)` command. @see
+ // https://nodejs.org/api/child_process.html#child_process_options_detached
+ opts.detached ??= process.platform !== 'win32';
+ const stdio = this.#configureStdio({
+ pipe: opts.pipe,
+ dumpio: opts.dumpio,
+ });
+ const env = opts.env || {};
+ debugLaunch(`Launching ${this.#executablePath} ${this.#args.join(' ')}`, {
+ detached: opts.detached,
+ env: Object.keys(env).reduce((res, key) => {
+ if (key.toLowerCase().startsWith('puppeteer_')) {
+ res[key] = env[key];
+ }
+ return res;
+ }, {}),
+ stdio,
+ });
+ this.#browserProcess = child_process_1.default.spawn(this.#executablePath, this.#args, {
+ detached: opts.detached,
+ env,
+ stdio,
+ });
+ debugLaunch(`Launched ${this.#browserProcess.pid}`);
+ if (opts.dumpio) {
+ this.#browserProcess.stderr?.pipe(process.stderr);
+ this.#browserProcess.stdout?.pipe(process.stdout);
}
-
- ++nfiles
-
- if (boy.listenerCount('file') === 0) {
- self.parser._ignore()
- return
+ subscribeToProcessEvent('exit', this.#onDriverProcessExit);
+ if (opts.handleSIGINT) {
+ subscribeToProcessEvent('SIGINT', this.#onDriverProcessSignal);
}
-
- ++nends
- const file = new FileStream(fileOpts)
- curFile = file
- file.on('end', function () {
- --nends
- self._pause = false
- checkFinished()
- if (self._cb && !self._needDrain) {
- const cb = self._cb
- self._cb = undefined
- cb()
- }
- })
- file._read = function (n) {
- if (!self._pause) { return }
- self._pause = false
- if (self._cb && !self._needDrain) {
- const cb = self._cb
- self._cb = undefined
- cb()
- }
+ if (opts.handleSIGTERM) {
+ subscribeToProcessEvent('SIGTERM', this.#onDriverProcessSignal);
}
- boy.emit('file', fieldname, file, filename, encoding, contype)
-
- onData = function (data) {
- if ((nsize += data.length) > fileSizeLimit) {
- const extralen = fileSizeLimit - nsize + data.length
- if (extralen > 0) { file.push(data.slice(0, extralen)) }
- file.truncated = true
- file.bytesRead = fileSizeLimit
- part.removeAllListeners('data')
- file.emit('limit')
- return
- } else if (!file.push(data)) { self._pause = true }
-
- file.bytesRead = nsize
+ if (opts.handleSIGHUP) {
+ subscribeToProcessEvent('SIGHUP', this.#onDriverProcessSignal);
}
-
- onEnd = function () {
- curFile = undefined
- file.push(null)
+ if (opts.onExit) {
+ this.#onExitHook = opts.onExit;
}
- } else {
- // non-file field
- if (nfields === fieldsLimit) {
- if (!boy.hitFieldsLimit) {
- boy.hitFieldsLimit = true
- boy.emit('fieldsLimit')
- }
- return skipPart(part)
+ this.#browserProcessExiting = new Promise((resolve, reject) => {
+ this.#browserProcess.once('exit', async () => {
+ debugLaunch(`Browser process ${this.#browserProcess.pid} onExit`);
+ this.#clearListeners();
+ this.#exited = true;
+ try {
+ await this.#runHooks();
+ }
+ catch (err) {
+ reject(err);
+ return;
+ }
+ resolve();
+ });
+ });
+ }
+ async #runHooks() {
+ if (this.#hooksRan) {
+ return;
}
-
- ++nfields
- ++nends
- let buffer = ''
- let truncated = false
- curField = part
-
- onData = function (data) {
- if ((nsize += data.length) > fieldSizeLimit) {
- const extralen = (fieldSizeLimit - (nsize - data.length))
- buffer += data.toString('binary', 0, extralen)
- truncated = true
- part.removeAllListeners('data')
- } else { buffer += data.toString('binary') }
+ this.#hooksRan = true;
+ await this.#onExitHook();
+ }
+ get nodeProcess() {
+ return this.#browserProcess;
+ }
+ #configureStdio(opts) {
+ if (opts.pipe) {
+ if (opts.dumpio) {
+ return ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'];
+ }
+ else {
+ return ['ignore', 'ignore', 'ignore', 'pipe', 'pipe'];
+ }
}
-
- onEnd = function () {
- curField = undefined
- if (buffer.length) { buffer = decodeText(buffer, 'binary', charset) }
- boy.emit('field', fieldname, buffer, false, truncated, encoding, contype)
- --nends
- checkFinished()
+ else {
+ if (opts.dumpio) {
+ return ['pipe', 'pipe', 'pipe'];
+ }
+ else {
+ return ['pipe', 'ignore', 'pipe'];
+ }
}
- }
-
- /* As of node@2efe4ab761666 (v0.10.29+/v0.11.14+), busboy had become
- broken. Streams2/streams3 is a huge black box of confusion, but
- somehow overriding the sync state seems to fix things again (and still
- seems to work for previous node versions).
- */
- part._readableState.sync = false
-
- part.on('data', onData)
- part.on('end', onEnd)
- }).on('error', function (err) {
- if (curFile) { curFile.emit('error', err) }
- })
- }).on('error', function (err) {
- boy.emit('error', err)
- }).on('finish', function () {
- finished = true
- checkFinished()
- })
-}
-
-Multipart.prototype.write = function (chunk, cb) {
- const r = this.parser.write(chunk)
- if (r && !this._pause) {
- cb()
- } else {
- this._needDrain = !r
- this._cb = cb
- }
-}
-
-Multipart.prototype.end = function () {
- const self = this
-
- if (self.parser.writable) {
- self.parser.end()
- } else if (!self._boy._done) {
- process.nextTick(function () {
- self._boy._done = true
- self._boy.emit('finish')
- })
- }
-}
-
-function skipPart (part) {
- part.resume()
-}
-
-function FileStream (opts) {
- Readable.call(this, opts)
-
- this.bytesRead = 0
-
- this.truncated = false
-}
-
-inherits(FileStream, Readable)
-
-FileStream.prototype._read = function (n) {}
-
-module.exports = Multipart
-
-
-/***/ }),
-
-/***/ 80855:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-const Decoder = __nccwpck_require__(11496)
-const decodeText = __nccwpck_require__(72747)
-const getLimit = __nccwpck_require__(22393)
-
-const RE_CHARSET = /^charset$/i
-
-UrlEncoded.detect = /^application\/x-www-form-urlencoded/i
-function UrlEncoded (boy, cfg) {
- const limits = cfg.limits
- const parsedConType = cfg.parsedConType
- this.boy = boy
-
- this.fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024)
- this.fieldNameSizeLimit = getLimit(limits, 'fieldNameSize', 100)
- this.fieldsLimit = getLimit(limits, 'fields', Infinity)
-
- let charset
- for (var i = 0, len = parsedConType.length; i < len; ++i) { // eslint-disable-line no-var
- if (Array.isArray(parsedConType[i]) &&
- RE_CHARSET.test(parsedConType[i][0])) {
- charset = parsedConType[i][1].toLowerCase()
- break
}
- }
-
- if (charset === undefined) { charset = cfg.defCharset || 'utf8' }
-
- this.decoder = new Decoder()
- this.charset = charset
- this._fields = 0
- this._state = 'key'
- this._checkingBytes = true
- this._bytesKey = 0
- this._bytesVal = 0
- this._key = ''
- this._val = ''
- this._keyTrunc = false
- this._valTrunc = false
- this._hitLimit = false
-}
-
-UrlEncoded.prototype.write = function (data, cb) {
- if (this._fields === this.fieldsLimit) {
- if (!this.boy.hitFieldsLimit) {
- this.boy.hitFieldsLimit = true
- this.boy.emit('fieldsLimit')
+ #clearListeners() {
+ unsubscribeFromProcessEvent('exit', this.#onDriverProcessExit);
+ unsubscribeFromProcessEvent('SIGINT', this.#onDriverProcessSignal);
+ unsubscribeFromProcessEvent('SIGTERM', this.#onDriverProcessSignal);
+ unsubscribeFromProcessEvent('SIGHUP', this.#onDriverProcessSignal);
}
- return cb()
- }
-
- let idxeq; let idxamp; let i; let p = 0; const len = data.length
-
- while (p < len) {
- if (this._state === 'key') {
- idxeq = idxamp = undefined
- for (i = p; i < len; ++i) {
- if (!this._checkingBytes) { ++p }
- if (data[i] === 0x3D/* = */) {
- idxeq = i
- break
- } else if (data[i] === 0x26/* & */) {
- idxamp = i
- break
+ #onDriverProcessExit = (_code) => {
+ this.kill();
+ };
+ #onDriverProcessSignal = (signal) => {
+ switch (signal) {
+ case 'SIGINT':
+ this.kill();
+ process.exit(130);
+ case 'SIGTERM':
+ case 'SIGHUP':
+ void this.close();
+ break;
}
- if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
- this._hitLimit = true
- break
- } else if (this._checkingBytes) { ++this._bytesKey }
- }
-
- if (idxeq !== undefined) {
- // key with assignment
- if (idxeq > p) { this._key += this.decoder.write(data.toString('binary', p, idxeq)) }
- this._state = 'val'
-
- this._hitLimit = false
- this._checkingBytes = true
- this._val = ''
- this._bytesVal = 0
- this._valTrunc = false
- this.decoder.reset()
-
- p = idxeq + 1
- } else if (idxamp !== undefined) {
- // key with no assignment
- ++this._fields
- let key; const keyTrunc = this._keyTrunc
- if (idxamp > p) { key = (this._key += this.decoder.write(data.toString('binary', p, idxamp))) } else { key = this._key }
-
- this._hitLimit = false
- this._checkingBytes = true
- this._key = ''
- this._bytesKey = 0
- this._keyTrunc = false
- this.decoder.reset()
-
- if (key.length) {
- this.boy.emit('field', decodeText(key, 'binary', this.charset),
- '',
- keyTrunc,
- false)
+ };
+ async close() {
+ await this.#runHooks();
+ if (!this.#exited) {
+ this.kill();
}
-
- p = idxamp + 1
- if (this._fields === this.fieldsLimit) { return cb() }
- } else if (this._hitLimit) {
- // we may not have hit the actual limit if there are encoded bytes...
- if (i > p) { this._key += this.decoder.write(data.toString('binary', p, i)) }
- p = i
- if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
- // yep, we actually did hit the limit
- this._checkingBytes = false
- this._keyTrunc = true
+ return await this.#browserProcessExiting;
+ }
+ hasClosed() {
+ return this.#browserProcessExiting;
+ }
+ kill() {
+ debugLaunch(`Trying to kill ${this.#browserProcess.pid}`);
+ // If the process failed to launch (for example if the browser executable path
+ // is invalid), then the process does not get a pid assigned. A call to
+ // `proc.kill` would error, as the `pid` to-be-killed can not be found.
+ if (this.#browserProcess &&
+ this.#browserProcess.pid &&
+ pidExists(this.#browserProcess.pid)) {
+ try {
+ debugLaunch(`Browser process ${this.#browserProcess.pid} exists`);
+ if (process.platform === 'win32') {
+ try {
+ child_process_1.default.execSync(`taskkill /pid ${this.#browserProcess.pid} /T /F`);
+ }
+ catch (error) {
+ debugLaunch(`Killing ${this.#browserProcess.pid} using taskkill failed`, error);
+ // taskkill can fail to kill the process e.g. due to missing permissions.
+ // Let's kill the process via Node API. This delays killing of all child
+ // processes of `this.proc` until the main Node.js process dies.
+ this.#browserProcess.kill();
+ }
+ }
+ else {
+ // on linux the process group can be killed with the group id prefixed with
+ // a minus sign. The process group id is the group leader's pid.
+ const processGroupId = -this.#browserProcess.pid;
+ try {
+ process.kill(processGroupId, 'SIGKILL');
+ }
+ catch (error) {
+ debugLaunch(`Killing ${this.#browserProcess.pid} using process.kill failed`, error);
+ // Killing the process group can fail due e.g. to missing permissions.
+ // Let's kill the process via Node API. This delays killing of all child
+ // processes of `this.proc` until the main Node.js process dies.
+ this.#browserProcess.kill('SIGKILL');
+ }
+ }
+ }
+ catch (error) {
+ throw new Error(`${PROCESS_ERROR_EXPLANATION}\nError cause: ${isErrorLike(error) ? error.stack : error}`);
+ }
}
- } else {
- if (p < len) { this._key += this.decoder.write(data.toString('binary', p)) }
- p = len
- }
- } else {
- idxamp = undefined
- for (i = p; i < len; ++i) {
- if (!this._checkingBytes) { ++p }
- if (data[i] === 0x26/* & */) {
- idxamp = i
- break
+ this.#clearListeners();
+ }
+ waitForLineOutput(regex, timeout = 0) {
+ if (!this.#browserProcess.stderr) {
+ throw new Error('`browserProcess` does not have stderr.');
}
- if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
- this._hitLimit = true
- break
- } else if (this._checkingBytes) { ++this._bytesVal }
- }
-
- if (idxamp !== undefined) {
- ++this._fields
- if (idxamp > p) { this._val += this.decoder.write(data.toString('binary', p, idxamp)) }
- this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
- decodeText(this._val, 'binary', this.charset),
- this._keyTrunc,
- this._valTrunc)
- this._state = 'key'
-
- this._hitLimit = false
- this._checkingBytes = true
- this._key = ''
- this._bytesKey = 0
- this._keyTrunc = false
- this.decoder.reset()
-
- p = idxamp + 1
- if (this._fields === this.fieldsLimit) { return cb() }
- } else if (this._hitLimit) {
- // we may not have hit the actual limit if there are encoded bytes...
- if (i > p) { this._val += this.decoder.write(data.toString('binary', p, i)) }
- p = i
- if ((this._val === '' && this.fieldSizeLimit === 0) ||
- (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
- // yep, we actually did hit the limit
- this._checkingBytes = false
- this._valTrunc = true
+ const rl = readline_1.default.createInterface(this.#browserProcess.stderr);
+ let stderr = '';
+ return new Promise((resolve, reject) => {
+ rl.on('line', onLine);
+ rl.on('close', onClose);
+ this.#browserProcess.on('exit', onClose);
+ this.#browserProcess.on('error', onClose);
+ const timeoutId = timeout > 0 ? setTimeout(onTimeout, timeout) : undefined;
+ const cleanup = () => {
+ if (timeoutId) {
+ clearTimeout(timeoutId);
+ }
+ rl.off('line', onLine);
+ rl.off('close', onClose);
+ this.#browserProcess.off('exit', onClose);
+ this.#browserProcess.off('error', onClose);
+ };
+ function onClose(error) {
+ cleanup();
+ reject(new Error([
+ `Failed to launch the browser process!${error ? ' ' + error.message : ''}`,
+ stderr,
+ '',
+ 'TROUBLESHOOTING: https://pptr.dev/troubleshooting',
+ '',
+ ].join('\n')));
+ }
+ function onTimeout() {
+ cleanup();
+ reject(new TimeoutError(`Timed out after ${timeout} ms while waiting for the WS endpoint URL to appear in stdout!`));
+ }
+ function onLine(line) {
+ stderr += line + '\n';
+ const match = line.match(regex);
+ if (!match) {
+ return;
+ }
+ cleanup();
+ // The RegExp matches, so this will obviously exist.
+ resolve(match[1]);
+ }
+ });
+ }
+}
+exports.Process = Process;
+const PROCESS_ERROR_EXPLANATION = `Puppeteer was unable to kill the process which ran the browser binary.
+This means that, on future Puppeteer launches, Puppeteer might not be able to launch the browser.
+Please check your open processes and ensure that the browser processes that Puppeteer launched have been killed.
+If you think this is a bug, please report it on the Puppeteer issue tracker.`;
+/**
+ * @internal
+ */
+function pidExists(pid) {
+ try {
+ return process.kill(pid, 0);
+ }
+ catch (error) {
+ if (isErrnoException(error)) {
+ if (error.code && error.code === 'ESRCH') {
+ return false;
+ }
}
- } else {
- if (p < len) { this._val += this.decoder.write(data.toString('binary', p)) }
- p = len
- }
+ throw error;
}
- }
- cb()
}
-
-UrlEncoded.prototype.end = function () {
- if (this.boy._done) { return }
-
- if (this._state === 'key' && this._key.length > 0) {
- this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
- '',
- this._keyTrunc,
- false)
- } else if (this._state === 'val') {
- this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
- decodeText(this._val, 'binary', this.charset),
- this._keyTrunc,
- this._valTrunc)
- }
- this.boy._done = true
- this.boy.emit('finish')
+/**
+ * @internal
+ */
+function isErrorLike(obj) {
+ return (typeof obj === 'object' && obj !== null && 'name' in obj && 'message' in obj);
}
-
-module.exports = UrlEncoded
-
-
-/***/ }),
-
-/***/ 11496:
-/***/ ((module) => {
-
-"use strict";
-
-
-const RE_PLUS = /\+/g
-
-const HEX = [
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
- 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-]
-
-function Decoder () {
- this.buffer = undefined
+/**
+ * @internal
+ */
+function isErrnoException(obj) {
+ return (isErrorLike(obj) &&
+ ('errno' in obj || 'code' in obj || 'path' in obj || 'syscall' in obj));
}
-Decoder.prototype.write = function (str) {
- // Replace '+' with ' ' before decoding
- str = str.replace(RE_PLUS, ' ')
- let res = ''
- let i = 0; let p = 0; const len = str.length
- for (; i < len; ++i) {
- if (this.buffer !== undefined) {
- if (!HEX[str.charCodeAt(i)]) {
- res += '%' + this.buffer
- this.buffer = undefined
- --i // retry character
- } else {
- this.buffer += str[i]
- ++p
- if (this.buffer.length === 2) {
- res += String.fromCharCode(parseInt(this.buffer, 16))
- this.buffer = undefined
- }
- }
- } else if (str[i] === '%') {
- if (i > p) {
- res += str.substring(p, i)
- p = i
- }
- this.buffer = ''
- ++p
+/**
+ * @public
+ */
+class TimeoutError extends Error {
+ /**
+ * @internal
+ */
+ constructor(message) {
+ super(message);
+ this.name = this.constructor.name;
+ Error.captureStackTrace(this, this.constructor);
}
- }
- if (p < len && this.buffer === undefined) { res += str.substring(p) }
- return res
-}
-Decoder.prototype.reset = function () {
- this.buffer = undefined
}
-
-module.exports = Decoder
-
+exports.TimeoutError = TimeoutError;
+//# sourceMappingURL=launch.js.map
/***/ }),
-/***/ 20692:
-/***/ ((module) => {
+/***/ 73403:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
-
-module.exports = function basename (path) {
- if (typeof path !== 'string') { return '' }
- for (var i = path.length - 1; i >= 0; --i) { // eslint-disable-line no-var
- switch (path.charCodeAt(i)) {
- case 0x2F: // '/'
- case 0x5C: // '\'
- path = path.slice(i + 1)
- return (path === '..' || path === '.' ? '' : path)
- }
- }
- return (path === '..' || path === '.' ? '' : path)
-}
-
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.InstalledBrowser = exports.Cache = exports.makeProgressCallback = exports.CLI = exports.getVersionComparator = exports.createProfile = exports.ChromeReleaseChannel = exports.BrowserPlatform = exports.Browser = exports.resolveBuildId = exports.detectBrowserPlatform = exports.uninstall = exports.canDownload = exports.getInstalledBrowsers = exports.install = exports.Process = exports.WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX = exports.CDP_WEBSOCKET_ENDPOINT_REGEX = exports.TimeoutError = exports.computeSystemExecutablePath = exports.computeExecutablePath = exports.launch = void 0;
+var launch_js_1 = __nccwpck_require__(6485);
+Object.defineProperty(exports, "launch", ({ enumerable: true, get: function () { return launch_js_1.launch; } }));
+Object.defineProperty(exports, "computeExecutablePath", ({ enumerable: true, get: function () { return launch_js_1.computeExecutablePath; } }));
+Object.defineProperty(exports, "computeSystemExecutablePath", ({ enumerable: true, get: function () { return launch_js_1.computeSystemExecutablePath; } }));
+Object.defineProperty(exports, "TimeoutError", ({ enumerable: true, get: function () { return launch_js_1.TimeoutError; } }));
+Object.defineProperty(exports, "CDP_WEBSOCKET_ENDPOINT_REGEX", ({ enumerable: true, get: function () { return launch_js_1.CDP_WEBSOCKET_ENDPOINT_REGEX; } }));
+Object.defineProperty(exports, "WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX", ({ enumerable: true, get: function () { return launch_js_1.WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX; } }));
+Object.defineProperty(exports, "Process", ({ enumerable: true, get: function () { return launch_js_1.Process; } }));
+var install_js_1 = __nccwpck_require__(37619);
+Object.defineProperty(exports, "install", ({ enumerable: true, get: function () { return install_js_1.install; } }));
+Object.defineProperty(exports, "getInstalledBrowsers", ({ enumerable: true, get: function () { return install_js_1.getInstalledBrowsers; } }));
+Object.defineProperty(exports, "canDownload", ({ enumerable: true, get: function () { return install_js_1.canDownload; } }));
+Object.defineProperty(exports, "uninstall", ({ enumerable: true, get: function () { return install_js_1.uninstall; } }));
+var detectPlatform_js_1 = __nccwpck_require__(79014);
+Object.defineProperty(exports, "detectBrowserPlatform", ({ enumerable: true, get: function () { return detectPlatform_js_1.detectBrowserPlatform; } }));
+var browser_data_js_1 = __nccwpck_require__(35255);
+Object.defineProperty(exports, "resolveBuildId", ({ enumerable: true, get: function () { return browser_data_js_1.resolveBuildId; } }));
+Object.defineProperty(exports, "Browser", ({ enumerable: true, get: function () { return browser_data_js_1.Browser; } }));
+Object.defineProperty(exports, "BrowserPlatform", ({ enumerable: true, get: function () { return browser_data_js_1.BrowserPlatform; } }));
+Object.defineProperty(exports, "ChromeReleaseChannel", ({ enumerable: true, get: function () { return browser_data_js_1.ChromeReleaseChannel; } }));
+Object.defineProperty(exports, "createProfile", ({ enumerable: true, get: function () { return browser_data_js_1.createProfile; } }));
+Object.defineProperty(exports, "getVersionComparator", ({ enumerable: true, get: function () { return browser_data_js_1.getVersionComparator; } }));
+var CLI_js_1 = __nccwpck_require__(15206);
+Object.defineProperty(exports, "CLI", ({ enumerable: true, get: function () { return CLI_js_1.CLI; } }));
+Object.defineProperty(exports, "makeProgressCallback", ({ enumerable: true, get: function () { return CLI_js_1.makeProgressCallback; } }));
+var Cache_js_1 = __nccwpck_require__(95674);
+Object.defineProperty(exports, "Cache", ({ enumerable: true, get: function () { return Cache_js_1.Cache; } }));
+Object.defineProperty(exports, "InstalledBrowser", ({ enumerable: true, get: function () { return Cache_js_1.InstalledBrowser; } }));
+//# sourceMappingURL=main.js.map
/***/ }),
-/***/ 72747:
-/***/ (function(module) {
+/***/ 68669:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
-
-// Node has always utf-8
-const utf8Decoder = new TextDecoder('utf-8')
-const textDecoders = new Map([
- ['utf-8', utf8Decoder],
- ['utf8', utf8Decoder]
-])
-
-function getDecoder (charset) {
- let lc
- while (true) {
- switch (charset) {
- case 'utf-8':
- case 'utf8':
- return decoders.utf8
- case 'latin1':
- case 'ascii': // TODO: Make these a separate, strict decoder?
- case 'us-ascii':
- case 'iso-8859-1':
- case 'iso8859-1':
- case 'iso88591':
- case 'iso_8859-1':
- case 'windows-1252':
- case 'iso_8859-1:1987':
- case 'cp1252':
- case 'x-cp1252':
- return decoders.latin1
- case 'utf16le':
- case 'utf-16le':
- case 'ucs2':
- case 'ucs-2':
- return decoders.utf16le
- case 'base64':
- return decoders.base64
- default:
- if (lc === undefined) {
- lc = true
- charset = charset.toLowerCase()
- continue
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Glob = void 0;
+const minimatch_1 = __nccwpck_require__(62883);
+const node_url_1 = __nccwpck_require__(73136);
+const path_scurry_1 = __nccwpck_require__(38958);
+const pattern_js_1 = __nccwpck_require__(2029);
+const walker_js_1 = __nccwpck_require__(83581);
+// if no process global, just call it linux.
+// so we default to case-sensitive, / separators
+const defaultPlatform = (typeof process === 'object' &&
+ process &&
+ typeof process.platform === 'string') ?
+ process.platform
+ : 'linux';
+/**
+ * An object that can perform glob pattern traversals.
+ */
+class Glob {
+ absolute;
+ cwd;
+ root;
+ dot;
+ dotRelative;
+ follow;
+ ignore;
+ magicalBraces;
+ mark;
+ matchBase;
+ maxDepth;
+ nobrace;
+ nocase;
+ nodir;
+ noext;
+ noglobstar;
+ pattern;
+ platform;
+ realpath;
+ scurry;
+ stat;
+ signal;
+ windowsPathsNoEscape;
+ withFileTypes;
+ includeChildMatches;
+ /**
+ * The options provided to the constructor.
+ */
+ opts;
+ /**
+ * An array of parsed immutable {@link Pattern} objects.
+ */
+ patterns;
+ /**
+ * All options are stored as properties on the `Glob` object.
+ *
+ * See {@link GlobOptions} for full options descriptions.
+ *
+ * Note that a previous `Glob` object can be passed as the
+ * `GlobOptions` to another `Glob` instantiation to re-use settings
+ * and caches with a new pattern.
+ *
+ * Traversal functions can be called multiple times to run the walk
+ * again.
+ */
+ constructor(pattern, opts) {
+ /* c8 ignore start */
+ if (!opts)
+ throw new TypeError('glob options required');
+ /* c8 ignore stop */
+ this.withFileTypes = !!opts.withFileTypes;
+ this.signal = opts.signal;
+ this.follow = !!opts.follow;
+ this.dot = !!opts.dot;
+ this.dotRelative = !!opts.dotRelative;
+ this.nodir = !!opts.nodir;
+ this.mark = !!opts.mark;
+ if (!opts.cwd) {
+ this.cwd = '';
+ }
+ else if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) {
+ opts.cwd = (0, node_url_1.fileURLToPath)(opts.cwd);
+ }
+ this.cwd = opts.cwd || '';
+ this.root = opts.root;
+ this.magicalBraces = !!opts.magicalBraces;
+ this.nobrace = !!opts.nobrace;
+ this.noext = !!opts.noext;
+ this.realpath = !!opts.realpath;
+ this.absolute = opts.absolute;
+ this.includeChildMatches = opts.includeChildMatches !== false;
+ this.noglobstar = !!opts.noglobstar;
+ this.matchBase = !!opts.matchBase;
+ this.maxDepth =
+ typeof opts.maxDepth === 'number' ? opts.maxDepth : Infinity;
+ this.stat = !!opts.stat;
+ this.ignore = opts.ignore;
+ if (this.withFileTypes && this.absolute !== undefined) {
+ throw new Error('cannot set absolute and withFileTypes:true');
+ }
+ if (typeof pattern === 'string') {
+ pattern = [pattern];
+ }
+ this.windowsPathsNoEscape =
+ !!opts.windowsPathsNoEscape ||
+ opts.allowWindowsEscape ===
+ false;
+ if (this.windowsPathsNoEscape) {
+ pattern = pattern.map(p => p.replace(/\\/g, '/'));
+ }
+ if (this.matchBase) {
+ if (opts.noglobstar) {
+ throw new TypeError('base matching requires globstar');
+ }
+ pattern = pattern.map(p => (p.includes('/') ? p : `./**/${p}`));
+ }
+ this.pattern = pattern;
+ this.platform = opts.platform || defaultPlatform;
+ this.opts = { ...opts, platform: this.platform };
+ if (opts.scurry) {
+ this.scurry = opts.scurry;
+ if (opts.nocase !== undefined &&
+ opts.nocase !== opts.scurry.nocase) {
+ throw new Error('nocase option contradicts provided scurry option');
+ }
}
- return decoders.other.bind(charset)
- }
- }
-}
-
-const decoders = {
- utf8: (data, sourceEncoding) => {
- if (data.length === 0) {
- return ''
- }
- if (typeof data === 'string') {
- data = Buffer.from(data, sourceEncoding)
- }
- return data.utf8Slice(0, data.length)
- },
-
- latin1: (data, sourceEncoding) => {
- if (data.length === 0) {
- return ''
- }
- if (typeof data === 'string') {
- return data
+ else {
+ const Scurry = opts.platform === 'win32' ? path_scurry_1.PathScurryWin32
+ : opts.platform === 'darwin' ? path_scurry_1.PathScurryDarwin
+ : opts.platform ? path_scurry_1.PathScurryPosix
+ : path_scurry_1.PathScurry;
+ this.scurry = new Scurry(this.cwd, {
+ nocase: opts.nocase,
+ fs: opts.fs,
+ });
+ }
+ this.nocase = this.scurry.nocase;
+ // If you do nocase:true on a case-sensitive file system, then
+ // we need to use regexps instead of strings for non-magic
+ // path portions, because statting `aBc` won't return results
+ // for the file `AbC` for example.
+ const nocaseMagicOnly = this.platform === 'darwin' || this.platform === 'win32';
+ const mmo = {
+ // default nocase based on platform
+ ...opts,
+ dot: this.dot,
+ matchBase: this.matchBase,
+ nobrace: this.nobrace,
+ nocase: this.nocase,
+ nocaseMagicOnly,
+ nocomment: true,
+ noext: this.noext,
+ nonegate: true,
+ optimizationLevel: 2,
+ platform: this.platform,
+ windowsPathsNoEscape: this.windowsPathsNoEscape,
+ debug: !!this.opts.debug,
+ };
+ const mms = this.pattern.map(p => new minimatch_1.Minimatch(p, mmo));
+ const [matchSet, globParts] = mms.reduce((set, m) => {
+ set[0].push(...m.set);
+ set[1].push(...m.globParts);
+ return set;
+ }, [[], []]);
+ this.patterns = matchSet.map((set, i) => {
+ const g = globParts[i];
+ /* c8 ignore start */
+ if (!g)
+ throw new Error('invalid pattern object');
+ /* c8 ignore stop */
+ return new pattern_js_1.Pattern(set, g, 0, this.platform);
+ });
}
- return data.latin1Slice(0, data.length)
- },
-
- utf16le: (data, sourceEncoding) => {
- if (data.length === 0) {
- return ''
+ async walk() {
+ // Walkers always return array of Path objects, so we just have to
+ // coerce them into the right shape. It will have already called
+ // realpath() if the option was set to do so, so we know that's cached.
+ // start out knowing the cwd, at least
+ return [
+ ...(await new walker_js_1.GlobWalker(this.patterns, this.scurry.cwd, {
+ ...this.opts,
+ maxDepth: this.maxDepth !== Infinity ?
+ this.maxDepth + this.scurry.cwd.depth()
+ : Infinity,
+ platform: this.platform,
+ nocase: this.nocase,
+ includeChildMatches: this.includeChildMatches,
+ }).walk()),
+ ];
}
- if (typeof data === 'string') {
- data = Buffer.from(data, sourceEncoding)
+ walkSync() {
+ return [
+ ...new walker_js_1.GlobWalker(this.patterns, this.scurry.cwd, {
+ ...this.opts,
+ maxDepth: this.maxDepth !== Infinity ?
+ this.maxDepth + this.scurry.cwd.depth()
+ : Infinity,
+ platform: this.platform,
+ nocase: this.nocase,
+ includeChildMatches: this.includeChildMatches,
+ }).walkSync(),
+ ];
}
- return data.ucs2Slice(0, data.length)
- },
-
- base64: (data, sourceEncoding) => {
- if (data.length === 0) {
- return ''
+ stream() {
+ return new walker_js_1.GlobStream(this.patterns, this.scurry.cwd, {
+ ...this.opts,
+ maxDepth: this.maxDepth !== Infinity ?
+ this.maxDepth + this.scurry.cwd.depth()
+ : Infinity,
+ platform: this.platform,
+ nocase: this.nocase,
+ includeChildMatches: this.includeChildMatches,
+ }).stream();
+ }
+ streamSync() {
+ return new walker_js_1.GlobStream(this.patterns, this.scurry.cwd, {
+ ...this.opts,
+ maxDepth: this.maxDepth !== Infinity ?
+ this.maxDepth + this.scurry.cwd.depth()
+ : Infinity,
+ platform: this.platform,
+ nocase: this.nocase,
+ includeChildMatches: this.includeChildMatches,
+ }).streamSync();
}
- if (typeof data === 'string') {
- data = Buffer.from(data, sourceEncoding)
+ /**
+ * Default sync iteration function. Returns a Generator that
+ * iterates over the results.
+ */
+ iterateSync() {
+ return this.streamSync()[Symbol.iterator]();
}
- return data.base64Slice(0, data.length)
- },
-
- other: (data, sourceEncoding) => {
- if (data.length === 0) {
- return ''
+ [Symbol.iterator]() {
+ return this.iterateSync();
}
- if (typeof data === 'string') {
- data = Buffer.from(data, sourceEncoding)
+ /**
+ * Default async iteration function. Returns an AsyncGenerator that
+ * iterates over the results.
+ */
+ iterate() {
+ return this.stream()[Symbol.asyncIterator]();
}
-
- if (textDecoders.has(this.toString())) {
- try {
- return textDecoders.get(this).decode(data)
- } catch {}
+ [Symbol.asyncIterator]() {
+ return this.iterate();
}
- return typeof data === 'string'
- ? data
- : data.toString()
- }
-}
-
-function decodeText (text, sourceEncoding, destEncoding) {
- if (text) {
- return getDecoder(destEncoding)(text, sourceEncoding)
- }
- return text
}
-
-module.exports = decodeText
-
+exports.Glob = Glob;
+//# sourceMappingURL=glob.js.map
/***/ }),
-/***/ 22393:
-/***/ ((module) => {
+/***/ 53413:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
-
-module.exports = function getLimit (limits, name, defaultLimit) {
- if (
- !limits ||
- limits[name] === undefined ||
- limits[name] === null
- ) { return defaultLimit }
-
- if (
- typeof limits[name] !== 'number' ||
- isNaN(limits[name])
- ) { throw new TypeError('Limit ' + name + ' is not a valid number') }
-
- return limits[name]
-}
-
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.hasMagic = void 0;
+const minimatch_1 = __nccwpck_require__(62883);
+/**
+ * Return true if the patterns provided contain any magic glob characters,
+ * given the options provided.
+ *
+ * Brace expansion is not considered "magic" unless the `magicalBraces` option
+ * is set, as brace expansion just turns one string into an array of strings.
+ * So a pattern like `'x{a,b}y'` would return `false`, because `'xay'` and
+ * `'xby'` both do not contain any magic glob characters, and it's treated the
+ * same as if you had called it on `['xay', 'xby']`. When `magicalBraces:true`
+ * is in the options, brace expansion _is_ treated as a pattern having magic.
+ */
+const hasMagic = (pattern, options = {}) => {
+ if (!Array.isArray(pattern)) {
+ pattern = [pattern];
+ }
+ for (const p of pattern) {
+ if (new minimatch_1.Minimatch(p, options).hasMagic())
+ return true;
+ }
+ return false;
+};
+exports.hasMagic = hasMagic;
+//# sourceMappingURL=has-magic.js.map
/***/ }),
-/***/ 8929:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 74941:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
-/* eslint-disable object-property-newline */
-
-const decodeText = __nccwpck_require__(72747)
-
-const RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g
-
-const EncodedLookup = {
- '%00': '\x00', '%01': '\x01', '%02': '\x02', '%03': '\x03', '%04': '\x04',
- '%05': '\x05', '%06': '\x06', '%07': '\x07', '%08': '\x08', '%09': '\x09',
- '%0a': '\x0a', '%0A': '\x0a', '%0b': '\x0b', '%0B': '\x0b', '%0c': '\x0c',
- '%0C': '\x0c', '%0d': '\x0d', '%0D': '\x0d', '%0e': '\x0e', '%0E': '\x0e',
- '%0f': '\x0f', '%0F': '\x0f', '%10': '\x10', '%11': '\x11', '%12': '\x12',
- '%13': '\x13', '%14': '\x14', '%15': '\x15', '%16': '\x16', '%17': '\x17',
- '%18': '\x18', '%19': '\x19', '%1a': '\x1a', '%1A': '\x1a', '%1b': '\x1b',
- '%1B': '\x1b', '%1c': '\x1c', '%1C': '\x1c', '%1d': '\x1d', '%1D': '\x1d',
- '%1e': '\x1e', '%1E': '\x1e', '%1f': '\x1f', '%1F': '\x1f', '%20': '\x20',
- '%21': '\x21', '%22': '\x22', '%23': '\x23', '%24': '\x24', '%25': '\x25',
- '%26': '\x26', '%27': '\x27', '%28': '\x28', '%29': '\x29', '%2a': '\x2a',
- '%2A': '\x2a', '%2b': '\x2b', '%2B': '\x2b', '%2c': '\x2c', '%2C': '\x2c',
- '%2d': '\x2d', '%2D': '\x2d', '%2e': '\x2e', '%2E': '\x2e', '%2f': '\x2f',
- '%2F': '\x2f', '%30': '\x30', '%31': '\x31', '%32': '\x32', '%33': '\x33',
- '%34': '\x34', '%35': '\x35', '%36': '\x36', '%37': '\x37', '%38': '\x38',
- '%39': '\x39', '%3a': '\x3a', '%3A': '\x3a', '%3b': '\x3b', '%3B': '\x3b',
- '%3c': '\x3c', '%3C': '\x3c', '%3d': '\x3d', '%3D': '\x3d', '%3e': '\x3e',
- '%3E': '\x3e', '%3f': '\x3f', '%3F': '\x3f', '%40': '\x40', '%41': '\x41',
- '%42': '\x42', '%43': '\x43', '%44': '\x44', '%45': '\x45', '%46': '\x46',
- '%47': '\x47', '%48': '\x48', '%49': '\x49', '%4a': '\x4a', '%4A': '\x4a',
- '%4b': '\x4b', '%4B': '\x4b', '%4c': '\x4c', '%4C': '\x4c', '%4d': '\x4d',
- '%4D': '\x4d', '%4e': '\x4e', '%4E': '\x4e', '%4f': '\x4f', '%4F': '\x4f',
- '%50': '\x50', '%51': '\x51', '%52': '\x52', '%53': '\x53', '%54': '\x54',
- '%55': '\x55', '%56': '\x56', '%57': '\x57', '%58': '\x58', '%59': '\x59',
- '%5a': '\x5a', '%5A': '\x5a', '%5b': '\x5b', '%5B': '\x5b', '%5c': '\x5c',
- '%5C': '\x5c', '%5d': '\x5d', '%5D': '\x5d', '%5e': '\x5e', '%5E': '\x5e',
- '%5f': '\x5f', '%5F': '\x5f', '%60': '\x60', '%61': '\x61', '%62': '\x62',
- '%63': '\x63', '%64': '\x64', '%65': '\x65', '%66': '\x66', '%67': '\x67',
- '%68': '\x68', '%69': '\x69', '%6a': '\x6a', '%6A': '\x6a', '%6b': '\x6b',
- '%6B': '\x6b', '%6c': '\x6c', '%6C': '\x6c', '%6d': '\x6d', '%6D': '\x6d',
- '%6e': '\x6e', '%6E': '\x6e', '%6f': '\x6f', '%6F': '\x6f', '%70': '\x70',
- '%71': '\x71', '%72': '\x72', '%73': '\x73', '%74': '\x74', '%75': '\x75',
- '%76': '\x76', '%77': '\x77', '%78': '\x78', '%79': '\x79', '%7a': '\x7a',
- '%7A': '\x7a', '%7b': '\x7b', '%7B': '\x7b', '%7c': '\x7c', '%7C': '\x7c',
- '%7d': '\x7d', '%7D': '\x7d', '%7e': '\x7e', '%7E': '\x7e', '%7f': '\x7f',
- '%7F': '\x7f', '%80': '\x80', '%81': '\x81', '%82': '\x82', '%83': '\x83',
- '%84': '\x84', '%85': '\x85', '%86': '\x86', '%87': '\x87', '%88': '\x88',
- '%89': '\x89', '%8a': '\x8a', '%8A': '\x8a', '%8b': '\x8b', '%8B': '\x8b',
- '%8c': '\x8c', '%8C': '\x8c', '%8d': '\x8d', '%8D': '\x8d', '%8e': '\x8e',
- '%8E': '\x8e', '%8f': '\x8f', '%8F': '\x8f', '%90': '\x90', '%91': '\x91',
- '%92': '\x92', '%93': '\x93', '%94': '\x94', '%95': '\x95', '%96': '\x96',
- '%97': '\x97', '%98': '\x98', '%99': '\x99', '%9a': '\x9a', '%9A': '\x9a',
- '%9b': '\x9b', '%9B': '\x9b', '%9c': '\x9c', '%9C': '\x9c', '%9d': '\x9d',
- '%9D': '\x9d', '%9e': '\x9e', '%9E': '\x9e', '%9f': '\x9f', '%9F': '\x9f',
- '%a0': '\xa0', '%A0': '\xa0', '%a1': '\xa1', '%A1': '\xa1', '%a2': '\xa2',
- '%A2': '\xa2', '%a3': '\xa3', '%A3': '\xa3', '%a4': '\xa4', '%A4': '\xa4',
- '%a5': '\xa5', '%A5': '\xa5', '%a6': '\xa6', '%A6': '\xa6', '%a7': '\xa7',
- '%A7': '\xa7', '%a8': '\xa8', '%A8': '\xa8', '%a9': '\xa9', '%A9': '\xa9',
- '%aa': '\xaa', '%Aa': '\xaa', '%aA': '\xaa', '%AA': '\xaa', '%ab': '\xab',
- '%Ab': '\xab', '%aB': '\xab', '%AB': '\xab', '%ac': '\xac', '%Ac': '\xac',
- '%aC': '\xac', '%AC': '\xac', '%ad': '\xad', '%Ad': '\xad', '%aD': '\xad',
- '%AD': '\xad', '%ae': '\xae', '%Ae': '\xae', '%aE': '\xae', '%AE': '\xae',
- '%af': '\xaf', '%Af': '\xaf', '%aF': '\xaf', '%AF': '\xaf', '%b0': '\xb0',
- '%B0': '\xb0', '%b1': '\xb1', '%B1': '\xb1', '%b2': '\xb2', '%B2': '\xb2',
- '%b3': '\xb3', '%B3': '\xb3', '%b4': '\xb4', '%B4': '\xb4', '%b5': '\xb5',
- '%B5': '\xb5', '%b6': '\xb6', '%B6': '\xb6', '%b7': '\xb7', '%B7': '\xb7',
- '%b8': '\xb8', '%B8': '\xb8', '%b9': '\xb9', '%B9': '\xb9', '%ba': '\xba',
- '%Ba': '\xba', '%bA': '\xba', '%BA': '\xba', '%bb': '\xbb', '%Bb': '\xbb',
- '%bB': '\xbb', '%BB': '\xbb', '%bc': '\xbc', '%Bc': '\xbc', '%bC': '\xbc',
- '%BC': '\xbc', '%bd': '\xbd', '%Bd': '\xbd', '%bD': '\xbd', '%BD': '\xbd',
- '%be': '\xbe', '%Be': '\xbe', '%bE': '\xbe', '%BE': '\xbe', '%bf': '\xbf',
- '%Bf': '\xbf', '%bF': '\xbf', '%BF': '\xbf', '%c0': '\xc0', '%C0': '\xc0',
- '%c1': '\xc1', '%C1': '\xc1', '%c2': '\xc2', '%C2': '\xc2', '%c3': '\xc3',
- '%C3': '\xc3', '%c4': '\xc4', '%C4': '\xc4', '%c5': '\xc5', '%C5': '\xc5',
- '%c6': '\xc6', '%C6': '\xc6', '%c7': '\xc7', '%C7': '\xc7', '%c8': '\xc8',
- '%C8': '\xc8', '%c9': '\xc9', '%C9': '\xc9', '%ca': '\xca', '%Ca': '\xca',
- '%cA': '\xca', '%CA': '\xca', '%cb': '\xcb', '%Cb': '\xcb', '%cB': '\xcb',
- '%CB': '\xcb', '%cc': '\xcc', '%Cc': '\xcc', '%cC': '\xcc', '%CC': '\xcc',
- '%cd': '\xcd', '%Cd': '\xcd', '%cD': '\xcd', '%CD': '\xcd', '%ce': '\xce',
- '%Ce': '\xce', '%cE': '\xce', '%CE': '\xce', '%cf': '\xcf', '%Cf': '\xcf',
- '%cF': '\xcf', '%CF': '\xcf', '%d0': '\xd0', '%D0': '\xd0', '%d1': '\xd1',
- '%D1': '\xd1', '%d2': '\xd2', '%D2': '\xd2', '%d3': '\xd3', '%D3': '\xd3',
- '%d4': '\xd4', '%D4': '\xd4', '%d5': '\xd5', '%D5': '\xd5', '%d6': '\xd6',
- '%D6': '\xd6', '%d7': '\xd7', '%D7': '\xd7', '%d8': '\xd8', '%D8': '\xd8',
- '%d9': '\xd9', '%D9': '\xd9', '%da': '\xda', '%Da': '\xda', '%dA': '\xda',
- '%DA': '\xda', '%db': '\xdb', '%Db': '\xdb', '%dB': '\xdb', '%DB': '\xdb',
- '%dc': '\xdc', '%Dc': '\xdc', '%dC': '\xdc', '%DC': '\xdc', '%dd': '\xdd',
- '%Dd': '\xdd', '%dD': '\xdd', '%DD': '\xdd', '%de': '\xde', '%De': '\xde',
- '%dE': '\xde', '%DE': '\xde', '%df': '\xdf', '%Df': '\xdf', '%dF': '\xdf',
- '%DF': '\xdf', '%e0': '\xe0', '%E0': '\xe0', '%e1': '\xe1', '%E1': '\xe1',
- '%e2': '\xe2', '%E2': '\xe2', '%e3': '\xe3', '%E3': '\xe3', '%e4': '\xe4',
- '%E4': '\xe4', '%e5': '\xe5', '%E5': '\xe5', '%e6': '\xe6', '%E6': '\xe6',
- '%e7': '\xe7', '%E7': '\xe7', '%e8': '\xe8', '%E8': '\xe8', '%e9': '\xe9',
- '%E9': '\xe9', '%ea': '\xea', '%Ea': '\xea', '%eA': '\xea', '%EA': '\xea',
- '%eb': '\xeb', '%Eb': '\xeb', '%eB': '\xeb', '%EB': '\xeb', '%ec': '\xec',
- '%Ec': '\xec', '%eC': '\xec', '%EC': '\xec', '%ed': '\xed', '%Ed': '\xed',
- '%eD': '\xed', '%ED': '\xed', '%ee': '\xee', '%Ee': '\xee', '%eE': '\xee',
- '%EE': '\xee', '%ef': '\xef', '%Ef': '\xef', '%eF': '\xef', '%EF': '\xef',
- '%f0': '\xf0', '%F0': '\xf0', '%f1': '\xf1', '%F1': '\xf1', '%f2': '\xf2',
- '%F2': '\xf2', '%f3': '\xf3', '%F3': '\xf3', '%f4': '\xf4', '%F4': '\xf4',
- '%f5': '\xf5', '%F5': '\xf5', '%f6': '\xf6', '%F6': '\xf6', '%f7': '\xf7',
- '%F7': '\xf7', '%f8': '\xf8', '%F8': '\xf8', '%f9': '\xf9', '%F9': '\xf9',
- '%fa': '\xfa', '%Fa': '\xfa', '%fA': '\xfa', '%FA': '\xfa', '%fb': '\xfb',
- '%Fb': '\xfb', '%fB': '\xfb', '%FB': '\xfb', '%fc': '\xfc', '%Fc': '\xfc',
- '%fC': '\xfc', '%FC': '\xfc', '%fd': '\xfd', '%Fd': '\xfd', '%fD': '\xfd',
- '%FD': '\xfd', '%fe': '\xfe', '%Fe': '\xfe', '%fE': '\xfe', '%FE': '\xfe',
- '%ff': '\xff', '%Ff': '\xff', '%fF': '\xff', '%FF': '\xff'
+// give it a pattern, and it'll be able to tell you if
+// a given path should be ignored.
+// Ignoring a path ignores its children if the pattern ends in /**
+// Ignores are always parsed in dot:true mode
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Ignore = void 0;
+const minimatch_1 = __nccwpck_require__(62883);
+const pattern_js_1 = __nccwpck_require__(2029);
+const defaultPlatform = (typeof process === 'object' &&
+ process &&
+ typeof process.platform === 'string') ?
+ process.platform
+ : 'linux';
+/**
+ * Class used to process ignored patterns
+ */
+class Ignore {
+ relative;
+ relativeChildren;
+ absolute;
+ absoluteChildren;
+ platform;
+ mmopts;
+ constructor(ignored, { nobrace, nocase, noext, noglobstar, platform = defaultPlatform, }) {
+ this.relative = [];
+ this.absolute = [];
+ this.relativeChildren = [];
+ this.absoluteChildren = [];
+ this.platform = platform;
+ this.mmopts = {
+ dot: true,
+ nobrace,
+ nocase,
+ noext,
+ noglobstar,
+ optimizationLevel: 2,
+ platform,
+ nocomment: true,
+ nonegate: true,
+ };
+ for (const ign of ignored)
+ this.add(ign);
+ }
+ add(ign) {
+ // this is a little weird, but it gives us a clean set of optimized
+ // minimatch matchers, without getting tripped up if one of them
+ // ends in /** inside a brace section, and it's only inefficient at
+ // the start of the walk, not along it.
+ // It'd be nice if the Pattern class just had a .test() method, but
+ // handling globstars is a bit of a pita, and that code already lives
+ // in minimatch anyway.
+ // Another way would be if maybe Minimatch could take its set/globParts
+ // as an option, and then we could at least just use Pattern to test
+ // for absolute-ness.
+ // Yet another way, Minimatch could take an array of glob strings, and
+ // a cwd option, and do the right thing.
+ const mm = new minimatch_1.Minimatch(ign, this.mmopts);
+ for (let i = 0; i < mm.set.length; i++) {
+ const parsed = mm.set[i];
+ const globParts = mm.globParts[i];
+ /* c8 ignore start */
+ if (!parsed || !globParts) {
+ throw new Error('invalid pattern object');
+ }
+ // strip off leading ./ portions
+ // https://github.com/isaacs/node-glob/issues/570
+ while (parsed[0] === '.' && globParts[0] === '.') {
+ parsed.shift();
+ globParts.shift();
+ }
+ /* c8 ignore stop */
+ const p = new pattern_js_1.Pattern(parsed, globParts, 0, this.platform);
+ const m = new minimatch_1.Minimatch(p.globString(), this.mmopts);
+ const children = globParts[globParts.length - 1] === '**';
+ const absolute = p.isAbsolute();
+ if (absolute)
+ this.absolute.push(m);
+ else
+ this.relative.push(m);
+ if (children) {
+ if (absolute)
+ this.absoluteChildren.push(m);
+ else
+ this.relativeChildren.push(m);
+ }
+ }
+ }
+ ignored(p) {
+ const fullpath = p.fullpath();
+ const fullpaths = `${fullpath}/`;
+ const relative = p.relative() || '.';
+ const relatives = `${relative}/`;
+ for (const m of this.relative) {
+ if (m.match(relative) || m.match(relatives))
+ return true;
+ }
+ for (const m of this.absolute) {
+ if (m.match(fullpath) || m.match(fullpaths))
+ return true;
+ }
+ return false;
+ }
+ childrenIgnored(p) {
+ const fullpath = p.fullpath() + '/';
+ const relative = (p.relative() || '.') + '/';
+ for (const m of this.relativeChildren) {
+ if (m.match(relative))
+ return true;
+ }
+ for (const m of this.absoluteChildren) {
+ if (m.match(fullpath))
+ return true;
+ }
+ return false;
+ }
}
+exports.Ignore = Ignore;
+//# sourceMappingURL=ignore.js.map
-function encodedReplacer (match) {
- return EncodedLookup[match]
-}
+/***/ }),
-const STATE_KEY = 0
-const STATE_VALUE = 1
-const STATE_CHARSET = 2
-const STATE_LANG = 3
+/***/ 46171:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-function parseParams (str) {
- const res = []
- let state = STATE_KEY
- let charset = ''
- let inquote = false
- let escaping = false
- let p = 0
- let tmp = ''
- const len = str.length
+"use strict";
- for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
- const char = str[i]
- if (char === '\\' && inquote) {
- if (escaping) { escaping = false } else {
- escaping = true
- continue
- }
- } else if (char === '"') {
- if (!escaping) {
- if (inquote) {
- inquote = false
- state = STATE_KEY
- } else { inquote = true }
- continue
- } else { escaping = false }
- } else {
- if (escaping && inquote) { tmp += '\\' }
- escaping = false
- if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
- if (state === STATE_CHARSET) {
- state = STATE_LANG
- charset = tmp.substring(1)
- } else { state = STATE_VALUE }
- tmp = ''
- continue
- } else if (state === STATE_KEY &&
- (char === '*' || char === '=') &&
- res.length) {
- state = char === '*'
- ? STATE_CHARSET
- : STATE_VALUE
- res[p] = [tmp, undefined]
- tmp = ''
- continue
- } else if (!inquote && char === ';') {
- state = STATE_KEY
- if (charset) {
- if (tmp.length) {
- tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
- 'binary',
- charset)
- }
- charset = ''
- } else if (tmp.length) {
- tmp = decodeText(tmp, 'binary', 'utf8')
- }
- if (res[p] === undefined) { res[p] = tmp } else { res[p][1] = tmp }
- tmp = ''
- ++p
- continue
- } else if (!inquote && (char === ' ' || char === '\t')) { continue }
- }
- tmp += char
- }
- if (charset && tmp.length) {
- tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
- 'binary',
- charset)
- } else if (tmp) {
- tmp = decodeText(tmp, 'binary', 'utf8')
- }
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.glob = exports.sync = exports.iterate = exports.iterateSync = exports.stream = exports.streamSync = exports.Ignore = exports.hasMagic = exports.Glob = exports.unescape = exports.escape = void 0;
+exports.globStreamSync = globStreamSync;
+exports.globStream = globStream;
+exports.globSync = globSync;
+exports.globIterateSync = globIterateSync;
+exports.globIterate = globIterate;
+const minimatch_1 = __nccwpck_require__(62883);
+const glob_js_1 = __nccwpck_require__(68669);
+const has_magic_js_1 = __nccwpck_require__(53413);
+var minimatch_2 = __nccwpck_require__(62883);
+Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return minimatch_2.escape; } }));
+Object.defineProperty(exports, "unescape", ({ enumerable: true, get: function () { return minimatch_2.unescape; } }));
+var glob_js_2 = __nccwpck_require__(68669);
+Object.defineProperty(exports, "Glob", ({ enumerable: true, get: function () { return glob_js_2.Glob; } }));
+var has_magic_js_2 = __nccwpck_require__(53413);
+Object.defineProperty(exports, "hasMagic", ({ enumerable: true, get: function () { return has_magic_js_2.hasMagic; } }));
+var ignore_js_1 = __nccwpck_require__(74941);
+Object.defineProperty(exports, "Ignore", ({ enumerable: true, get: function () { return ignore_js_1.Ignore; } }));
+function globStreamSync(pattern, options = {}) {
+ return new glob_js_1.Glob(pattern, options).streamSync();
+}
+function globStream(pattern, options = {}) {
+ return new glob_js_1.Glob(pattern, options).stream();
+}
+function globSync(pattern, options = {}) {
+ return new glob_js_1.Glob(pattern, options).walkSync();
+}
+async function glob_(pattern, options = {}) {
+ return new glob_js_1.Glob(pattern, options).walk();
+}
+function globIterateSync(pattern, options = {}) {
+ return new glob_js_1.Glob(pattern, options).iterateSync();
+}
+function globIterate(pattern, options = {}) {
+ return new glob_js_1.Glob(pattern, options).iterate();
+}
+// aliases: glob.sync.stream() glob.stream.sync() glob.sync() etc
+exports.streamSync = globStreamSync;
+exports.stream = Object.assign(globStream, { sync: globStreamSync });
+exports.iterateSync = globIterateSync;
+exports.iterate = Object.assign(globIterate, {
+ sync: globIterateSync,
+});
+exports.sync = Object.assign(globSync, {
+ stream: globStreamSync,
+ iterate: globIterateSync,
+});
+exports.glob = Object.assign(glob_, {
+ glob: glob_,
+ globSync,
+ sync: exports.sync,
+ globStream,
+ stream: exports.stream,
+ globStreamSync,
+ streamSync: exports.streamSync,
+ globIterate,
+ iterate: exports.iterate,
+ globIterateSync,
+ iterateSync: exports.iterateSync,
+ Glob: glob_js_1.Glob,
+ hasMagic: has_magic_js_1.hasMagic,
+ escape: minimatch_1.escape,
+ unescape: minimatch_1.unescape,
+});
+exports.glob.glob = exports.glob;
+//# sourceMappingURL=index.js.map
- if (res[p] === undefined) {
- if (tmp) { res[p] = tmp }
- } else { res[p][1] = tmp }
+/***/ }),
- return res
-}
+/***/ 2029:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-module.exports = parseParams
+"use strict";
+// this is just a very light wrapper around 2 arrays with an offset index
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Pattern = void 0;
+const minimatch_1 = __nccwpck_require__(62883);
+const isPatternList = (pl) => pl.length >= 1;
+const isGlobList = (gl) => gl.length >= 1;
+/**
+ * An immutable-ish view on an array of glob parts and their parsed
+ * results
+ */
+class Pattern {
+ #patternList;
+ #globList;
+ #index;
+ length;
+ #platform;
+ #rest;
+ #globString;
+ #isDrive;
+ #isUNC;
+ #isAbsolute;
+ #followGlobstar = true;
+ constructor(patternList, globList, index, platform) {
+ if (!isPatternList(patternList)) {
+ throw new TypeError('empty pattern list');
+ }
+ if (!isGlobList(globList)) {
+ throw new TypeError('empty glob list');
+ }
+ if (globList.length !== patternList.length) {
+ throw new TypeError('mismatched pattern list and glob list lengths');
+ }
+ this.length = patternList.length;
+ if (index < 0 || index >= this.length) {
+ throw new TypeError('index out of range');
+ }
+ this.#patternList = patternList;
+ this.#globList = globList;
+ this.#index = index;
+ this.#platform = platform;
+ // normalize root entries of absolute patterns on initial creation.
+ if (this.#index === 0) {
+ // c: => ['c:/']
+ // C:/ => ['C:/']
+ // C:/x => ['C:/', 'x']
+ // //host/share => ['//host/share/']
+ // //host/share/ => ['//host/share/']
+ // //host/share/x => ['//host/share/', 'x']
+ // /etc => ['/', 'etc']
+ // / => ['/']
+ if (this.isUNC()) {
+ // '' / '' / 'host' / 'share'
+ const [p0, p1, p2, p3, ...prest] = this.#patternList;
+ const [g0, g1, g2, g3, ...grest] = this.#globList;
+ if (prest[0] === '') {
+ // ends in /
+ prest.shift();
+ grest.shift();
+ }
+ const p = [p0, p1, p2, p3, ''].join('/');
+ const g = [g0, g1, g2, g3, ''].join('/');
+ this.#patternList = [p, ...prest];
+ this.#globList = [g, ...grest];
+ this.length = this.#patternList.length;
+ }
+ else if (this.isDrive() || this.isAbsolute()) {
+ const [p1, ...prest] = this.#patternList;
+ const [g1, ...grest] = this.#globList;
+ if (prest[0] === '') {
+ // ends in /
+ prest.shift();
+ grest.shift();
+ }
+ const p = p1 + '/';
+ const g = g1 + '/';
+ this.#patternList = [p, ...prest];
+ this.#globList = [g, ...grest];
+ this.length = this.#patternList.length;
+ }
+ }
+ }
+ /**
+ * The first entry in the parsed list of patterns
+ */
+ pattern() {
+ return this.#patternList[this.#index];
+ }
+ /**
+ * true of if pattern() returns a string
+ */
+ isString() {
+ return typeof this.#patternList[this.#index] === 'string';
+ }
+ /**
+ * true of if pattern() returns GLOBSTAR
+ */
+ isGlobstar() {
+ return this.#patternList[this.#index] === minimatch_1.GLOBSTAR;
+ }
+ /**
+ * true if pattern() returns a regexp
+ */
+ isRegExp() {
+ return this.#patternList[this.#index] instanceof RegExp;
+ }
+ /**
+ * The /-joined set of glob parts that make up this pattern
+ */
+ globString() {
+ return (this.#globString =
+ this.#globString ||
+ (this.#index === 0 ?
+ this.isAbsolute() ?
+ this.#globList[0] + this.#globList.slice(1).join('/')
+ : this.#globList.join('/')
+ : this.#globList.slice(this.#index).join('/')));
+ }
+ /**
+ * true if there are more pattern parts after this one
+ */
+ hasMore() {
+ return this.length > this.#index + 1;
+ }
+ /**
+ * The rest of the pattern after this part, or null if this is the end
+ */
+ rest() {
+ if (this.#rest !== undefined)
+ return this.#rest;
+ if (!this.hasMore())
+ return (this.#rest = null);
+ this.#rest = new Pattern(this.#patternList, this.#globList, this.#index + 1, this.#platform);
+ this.#rest.#isAbsolute = this.#isAbsolute;
+ this.#rest.#isUNC = this.#isUNC;
+ this.#rest.#isDrive = this.#isDrive;
+ return this.#rest;
+ }
+ /**
+ * true if the pattern represents a //unc/path/ on windows
+ */
+ isUNC() {
+ const pl = this.#patternList;
+ return this.#isUNC !== undefined ?
+ this.#isUNC
+ : (this.#isUNC =
+ this.#platform === 'win32' &&
+ this.#index === 0 &&
+ pl[0] === '' &&
+ pl[1] === '' &&
+ typeof pl[2] === 'string' &&
+ !!pl[2] &&
+ typeof pl[3] === 'string' &&
+ !!pl[3]);
+ }
+ // pattern like C:/...
+ // split = ['C:', ...]
+ // XXX: would be nice to handle patterns like `c:*` to test the cwd
+ // in c: for *, but I don't know of a way to even figure out what that
+ // cwd is without actually chdir'ing into it?
+ /**
+ * True if the pattern starts with a drive letter on Windows
+ */
+ isDrive() {
+ const pl = this.#patternList;
+ return this.#isDrive !== undefined ?
+ this.#isDrive
+ : (this.#isDrive =
+ this.#platform === 'win32' &&
+ this.#index === 0 &&
+ this.length > 1 &&
+ typeof pl[0] === 'string' &&
+ /^[a-z]:$/i.test(pl[0]));
+ }
+ // pattern = '/' or '/...' or '/x/...'
+ // split = ['', ''] or ['', ...] or ['', 'x', ...]
+ // Drive and UNC both considered absolute on windows
+ /**
+ * True if the pattern is rooted on an absolute path
+ */
+ isAbsolute() {
+ const pl = this.#patternList;
+ return this.#isAbsolute !== undefined ?
+ this.#isAbsolute
+ : (this.#isAbsolute =
+ (pl[0] === '' && pl.length > 1) ||
+ this.isDrive() ||
+ this.isUNC());
+ }
+ /**
+ * consume the root of the pattern, and return it
+ */
+ root() {
+ const p = this.#patternList[0];
+ return (typeof p === 'string' && this.isAbsolute() && this.#index === 0) ?
+ p
+ : '';
+ }
+ /**
+ * Check to see if the current globstar pattern is allowed to follow
+ * a symbolic link.
+ */
+ checkFollowGlobstar() {
+ return !(this.#index === 0 ||
+ !this.isGlobstar() ||
+ !this.#followGlobstar);
+ }
+ /**
+ * Mark that the current globstar pattern is following a symbolic link
+ */
+ markFollowGlobstar() {
+ if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar)
+ return false;
+ this.#followGlobstar = false;
+ return true;
+ }
+}
+exports.Pattern = Pattern;
+//# sourceMappingURL=pattern.js.map
/***/ }),
-/***/ 15206:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+/***/ 74827:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
+// synchronous utility for filtering entries and calculating subwalks
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Processor = exports.SubWalks = exports.MatchRecord = exports.HasWalkedCache = void 0;
+const minimatch_1 = __nccwpck_require__(62883);
/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
+ * A cache of which patterns have been processed for a given Path
*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) 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]; } };
+class HasWalkedCache {
+ store;
+ constructor(store = new Map()) {
+ this.store = store;
}
- Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
- var ownKeys = function(o) {
- ownKeys = Object.getOwnPropertyNames || function (o) {
- var ar = [];
- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
- return ar;
- };
- return ownKeys(o);
- };
- return function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
- __setModuleDefault(result, mod);
- return result;
- };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
- return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CLI = void 0;
-exports.makeProgressCallback = makeProgressCallback;
-const process_1 = __nccwpck_require__(932);
-const readline = __importStar(__nccwpck_require__(23785));
-const progress_1 = __importDefault(__nccwpck_require__(49243));
-const yargs_1 = __importDefault(__nccwpck_require__(15229));
-const helpers_1 = __nccwpck_require__(47763);
-const browser_data_js_1 = __nccwpck_require__(35255);
-const Cache_js_1 = __nccwpck_require__(95674);
-const detectPlatform_js_1 = __nccwpck_require__(79014);
-const install_js_1 = __nccwpck_require__(37619);
-const launch_js_1 = __nccwpck_require__(6485);
+ copy() {
+ return new HasWalkedCache(new Map(this.store));
+ }
+ hasWalked(target, pattern) {
+ return this.store.get(target.fullpath())?.has(pattern.globString());
+ }
+ storeWalked(target, pattern) {
+ const fullpath = target.fullpath();
+ const cached = this.store.get(fullpath);
+ if (cached)
+ cached.add(pattern.globString());
+ else
+ this.store.set(fullpath, new Set([pattern.globString()]));
+ }
+}
+exports.HasWalkedCache = HasWalkedCache;
/**
- * @public
+ * A record of which paths have been matched in a given walk step,
+ * and whether they only are considered a match if they are a directory,
+ * and whether their absolute or relative path should be returned.
*/
-class CLI {
- #cachePath;
- #rl;
- #scriptName = '';
- #allowCachePathOverride = true;
- #pinnedBrowsers;
- #prefixCommand;
- constructor(opts, rl) {
- if (!opts) {
- opts = {};
- }
- if (typeof opts === 'string') {
- opts = {
- cachePath: opts,
- };
- }
- this.#cachePath = opts.cachePath ?? process.cwd();
- this.#rl = rl;
- this.#scriptName = opts.scriptName ?? '@puppeteer/browsers';
- this.#allowCachePathOverride = opts.allowCachePathOverride ?? true;
- this.#pinnedBrowsers = opts.pinnedBrowsers;
- this.#prefixCommand = opts.prefixCommand;
- }
- #defineBrowserParameter(yargs) {
- yargs.positional('browser', {
- description: 'Which browser to install [@]. `latest` will try to find the latest available build. `buildId` is a browser-specific identifier such as a version or a revision.',
- type: 'string',
- coerce: (opt) => {
- return {
- name: this.#parseBrowser(opt),
- buildId: this.#parseBuildId(opt),
- };
- },
- });
+class MatchRecord {
+ store = new Map();
+ add(target, absolute, ifDir) {
+ const n = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
+ const current = this.store.get(target);
+ this.store.set(target, current === undefined ? n : n & current);
}
- #definePlatformParameter(yargs) {
- yargs.option('platform', {
- type: 'string',
- desc: 'Platform that the binary needs to be compatible with.',
- choices: Object.values(browser_data_js_1.BrowserPlatform),
- defaultDescription: 'Auto-detected',
- });
+ // match, absolute, ifdir
+ entries() {
+ return [...this.store.entries()].map(([path, n]) => [
+ path,
+ !!(n & 2),
+ !!(n & 1),
+ ]);
}
- #definePathParameter(yargs, required = false) {
- if (!this.#allowCachePathOverride) {
+}
+exports.MatchRecord = MatchRecord;
+/**
+ * A collection of patterns that must be processed in a subsequent step
+ * for a given path.
+ */
+class SubWalks {
+ store = new Map();
+ add(target, pattern) {
+ if (!target.canReaddir()) {
return;
}
- yargs.option('path', {
- type: 'string',
- desc: 'Path to the root folder for the browser downloads and installation. The installation folder structure is compatible with the cache structure used by Puppeteer.',
- defaultDescription: 'Current working directory',
- ...(required ? {} : { default: process.cwd() }),
- });
- if (required) {
- yargs.demandOption('path');
+ const subs = this.store.get(target);
+ if (subs) {
+ if (!subs.find(p => p.globString() === pattern.globString())) {
+ subs.push(pattern);
+ }
}
+ else
+ this.store.set(target, [pattern]);
}
- async run(argv) {
- const yargsInstance = (0, yargs_1.default)((0, helpers_1.hideBin)(argv));
- let target = yargsInstance.scriptName(this.#scriptName);
- if (this.#prefixCommand) {
- target = target.command(this.#prefixCommand.cmd, this.#prefixCommand.description, yargs => {
- return this.#build(yargs);
- });
- }
- else {
- target = this.#build(target);
+ get(target) {
+ const subs = this.store.get(target);
+ /* c8 ignore start */
+ if (!subs) {
+ throw new Error('attempting to walk unknown path');
}
- await target
- .demandCommand(1)
- .help()
- .wrap(Math.min(120, yargsInstance.terminalWidth()))
- .parse();
+ /* c8 ignore stop */
+ return subs;
}
- #build(yargs) {
- const latestOrPinned = this.#pinnedBrowsers ? 'pinned' : 'latest';
- // If there are pinned browsers allow the positional arg to be optional
- const browserArgType = this.#pinnedBrowsers ? '[browser]' : '';
- return yargs
- .command(`install ${browserArgType}`, 'Download and install the specified browser. If successful, the command outputs the actual browser buildId that was installed and the absolute path to the browser executable (format: @ ).', yargs => {
- this.#defineBrowserParameter(yargs);
- this.#definePlatformParameter(yargs);
- this.#definePathParameter(yargs);
- yargs.option('base-url', {
- type: 'string',
- desc: 'Base URL to download from',
- });
- if (this.#pinnedBrowsers) {
- yargs.example('$0 install', 'Install all pinned browsers');
+ entries() {
+ return this.keys().map(k => [k, this.store.get(k)]);
+ }
+ keys() {
+ return [...this.store.keys()].filter(t => t.canReaddir());
+ }
+}
+exports.SubWalks = SubWalks;
+/**
+ * The class that processes patterns for a given path.
+ *
+ * Handles child entry filtering, and determining whether a path's
+ * directory contents must be read.
+ */
+class Processor {
+ hasWalkedCache;
+ matches = new MatchRecord();
+ subwalks = new SubWalks();
+ patterns;
+ follow;
+ dot;
+ opts;
+ constructor(opts, hasWalkedCache) {
+ this.opts = opts;
+ this.follow = !!opts.follow;
+ this.dot = !!opts.dot;
+ this.hasWalkedCache =
+ hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache();
+ }
+ processPatterns(target, patterns) {
+ this.patterns = patterns;
+ const processingSet = patterns.map(p => [target, p]);
+ // map of paths to the magic-starting subwalks they need to walk
+ // first item in patterns is the filter
+ for (let [t, pattern] of processingSet) {
+ this.hasWalkedCache.storeWalked(t, pattern);
+ const root = pattern.root();
+ const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
+ // start absolute patterns at root
+ if (root) {
+ t = t.resolve(root === '/' && this.opts.root !== undefined ?
+ this.opts.root
+ : root);
+ const rest = pattern.rest();
+ if (!rest) {
+ this.matches.add(t, true, false);
+ continue;
+ }
+ else {
+ pattern = rest;
+ }
}
- yargs.option('install-deps', {
- type: 'boolean',
- desc: 'Whether to attempt installing system dependencies (only supported on Linux, requires root privileges).',
- default: false,
- });
- yargs.example('$0 install chrome', `Install the ${latestOrPinned} available build of the Chrome browser.`);
- yargs.example('$0 install chrome@latest', 'Install the latest available build for the Chrome browser.');
- yargs.example('$0 install chrome@stable', 'Install the latest available build for the Chrome browser from the stable channel.');
- yargs.example('$0 install chrome@beta', 'Install the latest available build for the Chrome browser from the beta channel.');
- yargs.example('$0 install chrome@dev', 'Install the latest available build for the Chrome browser from the dev channel.');
- yargs.example('$0 install chrome@canary', 'Install the latest available build for the Chrome Canary browser.');
- yargs.example('$0 install chrome@115', 'Install the latest available build for Chrome 115.');
- yargs.example('$0 install chromedriver@canary', 'Install the latest available build for ChromeDriver Canary.');
- yargs.example('$0 install chromedriver@115', 'Install the latest available build for ChromeDriver 115.');
- yargs.example('$0 install chromedriver@115.0.5790', 'Install the latest available patch (115.0.5790.X) build for ChromeDriver.');
- yargs.example('$0 install chrome-headless-shell', 'Install the latest available chrome-headless-shell build.');
- yargs.example('$0 install chrome-headless-shell@beta', 'Install the latest available chrome-headless-shell build corresponding to the Beta channel.');
- yargs.example('$0 install chrome-headless-shell@118', 'Install the latest available chrome-headless-shell 118 build.');
- yargs.example('$0 install chromium@1083080', 'Install the revision 1083080 of the Chromium browser.');
- yargs.example('$0 install firefox', 'Install the latest nightly available build of the Firefox browser.');
- yargs.example('$0 install firefox@stable', 'Install the latest stable build of the Firefox browser.');
- yargs.example('$0 install firefox@beta', 'Install the latest beta build of the Firefox browser.');
- yargs.example('$0 install firefox@devedition', 'Install the latest devedition build of the Firefox browser.');
- yargs.example('$0 install firefox@esr', 'Install the latest ESR build of the Firefox browser.');
- yargs.example('$0 install firefox@nightly', 'Install the latest nightly build of the Firefox browser.');
- yargs.example('$0 install firefox@stable_111.0.1', 'Install a specific version of the Firefox browser.');
- yargs.example('$0 install firefox --platform mac', 'Install the latest Mac (Intel) build of the Firefox browser.');
- if (this.#allowCachePathOverride) {
- yargs.example('$0 install firefox --path /tmp/my-browser-cache', 'Install to the specified cache directory.');
+ if (t.isENOENT())
+ continue;
+ let p;
+ let rest;
+ let changed = false;
+ while (typeof (p = pattern.pattern()) === 'string' &&
+ (rest = pattern.rest())) {
+ const c = t.resolve(p);
+ t = c;
+ pattern = rest;
+ changed = true;
+ }
+ p = pattern.pattern();
+ rest = pattern.rest();
+ if (changed) {
+ if (this.hasWalkedCache.hasWalked(t, pattern))
+ continue;
+ this.hasWalkedCache.storeWalked(t, pattern);
+ }
+ // now we have either a final string for a known entry,
+ // more strings for an unknown entry,
+ // or a pattern starting with magic, mounted on t.
+ if (typeof p === 'string') {
+ // must not be final entry, otherwise we would have
+ // concatenated it earlier.
+ const ifDir = p === '..' || p === '' || p === '.';
+ this.matches.add(t.resolve(p), absolute, ifDir);
+ continue;
}
- }, async (argv) => {
- const args = argv;
- if (this.#pinnedBrowsers && !args.browser) {
- // Use allSettled to avoid scenarios that
- // a browser may fail early and leave the other
- // installation in a faulty state
- const result = await Promise.allSettled(Object.entries(this.#pinnedBrowsers).map(async ([browser, options]) => {
- if (options.skipDownload) {
- return;
- }
- await this.#install({
- ...argv,
- browser: {
- name: browser,
- buildId: options.buildId,
- },
- });
- }));
- for (const install of result) {
- if (install.status === 'rejected') {
- throw install.reason;
+ else if (p === minimatch_1.GLOBSTAR) {
+ // if no rest, match and subwalk pattern
+ // if rest, process rest and subwalk pattern
+ // if it's a symlink, but we didn't get here by way of a
+ // globstar match (meaning it's the first time THIS globstar
+ // has traversed a symlink), then we follow it. Otherwise, stop.
+ if (!t.isSymbolicLink() ||
+ this.follow ||
+ pattern.checkFollowGlobstar()) {
+ this.subwalks.add(t, pattern);
+ }
+ const rp = rest?.pattern();
+ const rrest = rest?.rest();
+ if (!rest || ((rp === '' || rp === '.') && !rrest)) {
+ // only HAS to be a dir if it ends in **/ or **/.
+ // but ending in ** will match files as well.
+ this.matches.add(t, absolute, rp === '' || rp === '.');
+ }
+ else {
+ if (rp === '..') {
+ // this would mean you're matching **/.. at the fs root,
+ // and no thanks, I'm not gonna test that specific case.
+ /* c8 ignore start */
+ const tp = t.parent || t;
+ /* c8 ignore stop */
+ if (!rrest)
+ this.matches.add(tp, absolute, true);
+ else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
+ this.subwalks.add(tp, rrest);
+ }
}
}
}
- else {
- await this.#install(args);
+ else if (p instanceof RegExp) {
+ this.subwalks.add(t, pattern);
}
- })
- .command('launch ', 'Launch the specified browser', yargs => {
- this.#defineBrowserParameter(yargs);
- this.#definePlatformParameter(yargs);
- this.#definePathParameter(yargs);
- yargs.option('detached', {
- type: 'boolean',
- desc: 'Detach the child process.',
- default: false,
- });
- yargs.option('system', {
- type: 'boolean',
- desc: 'Search for a browser installed on the system instead of the cache folder.',
- default: false,
- });
- yargs.example('$0 launch chrome@115.0.5790.170', 'Launch Chrome 115.0.5790.170');
- yargs.example('$0 launch firefox@112.0a1', 'Launch the Firefox browser identified by the milestone 112.0a1.');
- yargs.example('$0 launch chrome@115.0.5790.170 --detached', 'Launch the browser but detach the sub-processes.');
- yargs.example('$0 launch chrome@canary --system', 'Try to locate the Canary build of Chrome installed on the system and launch it.');
- }, async (argv) => {
- const args = argv;
- const executablePath = args.system
- ? (0, launch_js_1.computeSystemExecutablePath)({
- browser: args.browser.name,
- // TODO: throw an error if not a ChromeReleaseChannel is provided.
- channel: args.browser.buildId,
- platform: args.platform,
- })
- : (0, launch_js_1.computeExecutablePath)({
- browser: args.browser.name,
- buildId: args.browser.buildId,
- cacheDir: args.path ?? this.#cachePath,
- platform: args.platform,
- });
- (0, launch_js_1.launch)({
- executablePath,
- detached: args.detached,
- });
- })
- .command('clear', this.#allowCachePathOverride
- ? 'Removes all installed browsers from the specified cache directory'
- : `Removes all installed browsers from ${this.#cachePath}`, yargs => {
- this.#definePathParameter(yargs, true);
- }, async (argv) => {
- const args = argv;
- const cacheDir = args.path ?? this.#cachePath;
- const rl = this.#rl ?? readline.createInterface({ input: process_1.stdin, output: process_1.stdout });
- rl.question(`Do you want to permanently and recursively delete the content of ${cacheDir} (yes/No)? `, answer => {
- rl.close();
- if (!['y', 'yes'].includes(answer.toLowerCase().trim())) {
- console.log('Cancelled.');
- return;
+ }
+ return this;
+ }
+ subwalkTargets() {
+ return this.subwalks.keys();
+ }
+ child() {
+ return new Processor(this.opts, this.hasWalkedCache);
+ }
+ // return a new Processor containing the subwalks for each
+ // child entry, and a set of matches, and
+ // a hasWalkedCache that's a copy of this one
+ // then we're going to call
+ filterEntries(parent, entries) {
+ const patterns = this.subwalks.get(parent);
+ // put matches and entry walks into the results processor
+ const results = this.child();
+ for (const e of entries) {
+ for (const pattern of patterns) {
+ const absolute = pattern.isAbsolute();
+ const p = pattern.pattern();
+ const rest = pattern.rest();
+ if (p === minimatch_1.GLOBSTAR) {
+ results.testGlobstar(e, pattern, rest, absolute);
+ }
+ else if (p instanceof RegExp) {
+ results.testRegExp(e, p, rest, absolute);
+ }
+ else {
+ results.testString(e, p, rest, absolute);
}
- const cache = new Cache_js_1.Cache(cacheDir);
- cache.clear();
- console.log(`${cacheDir} cleared.`);
- });
- })
- .command('list', 'List all installed browsers in the cache directory', yargs => {
- this.#definePathParameter(yargs);
- yargs.example('$0 list', 'List all installed browsers in the cache directory');
- if (this.#allowCachePathOverride) {
- yargs.example('$0 list --path /tmp/my-browser-cache', 'List browsers installed in the specified cache directory');
- }
- }, async (argv) => {
- const args = argv;
- const cacheDir = args.path ?? this.#cachePath;
- const cache = new Cache_js_1.Cache(cacheDir);
- const browsers = cache.getInstalledBrowsers();
- for (const browser of browsers) {
- console.log(`${browser.browser}@${browser.buildId} (${browser.platform}) ${browser.executablePath}`);
}
- })
- .demandCommand(1)
- .help();
- }
- #parseBrowser(version) {
- return version.split('@').shift();
- }
- #parseBuildId(version) {
- const parts = version.split('@');
- return parts.length === 2
- ? parts[1]
- : this.#pinnedBrowsers
- ? 'pinned'
- : 'latest';
- }
- async #install(args) {
- args.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
- if (!args.browser) {
- throw new Error(`No browser arg proveded`);
}
- if (!args.platform) {
- throw new Error(`Could not resolve the current platform`);
+ return results;
+ }
+ testGlobstar(e, pattern, rest, absolute) {
+ if (this.dot || !e.name.startsWith('.')) {
+ if (!pattern.hasMore()) {
+ this.matches.add(e, absolute, false);
+ }
+ if (e.canReaddir()) {
+ // if we're in follow mode or it's not a symlink, just keep
+ // testing the same pattern. If there's more after the globstar,
+ // then this symlink consumes the globstar. If not, then we can
+ // follow at most ONE symlink along the way, so we mark it, which
+ // also checks to ensure that it wasn't already marked.
+ if (this.follow || !e.isSymbolicLink()) {
+ this.subwalks.add(e, pattern);
+ }
+ else if (e.isSymbolicLink()) {
+ if (rest && pattern.checkFollowGlobstar()) {
+ this.subwalks.add(e, rest);
+ }
+ else if (pattern.markFollowGlobstar()) {
+ this.subwalks.add(e, pattern);
+ }
+ }
+ }
}
- if (args.browser.buildId === 'pinned') {
- const options = this.#pinnedBrowsers?.[args.browser.name];
- if (!options || !options.buildId) {
- throw new Error(`No pinned version found for ${args.browser.name}`);
+ // if the NEXT thing matches this entry, then also add
+ // the rest.
+ if (rest) {
+ const rp = rest.pattern();
+ if (typeof rp === 'string' &&
+ // dots and empty were handled already
+ rp !== '..' &&
+ rp !== '' &&
+ rp !== '.') {
+ this.testString(e, rp, rest.rest(), absolute);
+ }
+ else if (rp === '..') {
+ /* c8 ignore start */
+ const ep = e.parent || e;
+ /* c8 ignore stop */
+ this.subwalks.add(ep, rest);
+ }
+ else if (rp instanceof RegExp) {
+ this.testRegExp(e, rp, rest.rest(), absolute);
}
- args.browser.buildId = options.buildId;
}
- const originalBuildId = args.browser.buildId;
- args.browser.buildId = await (0, browser_data_js_1.resolveBuildId)(args.browser.name, args.platform, args.browser.buildId);
- await (0, install_js_1.install)({
- browser: args.browser.name,
- buildId: args.browser.buildId,
- platform: args.platform,
- cacheDir: args.path ?? this.#cachePath,
- downloadProgressCallback: makeProgressCallback(args.browser.name, args.browser.buildId),
- baseUrl: args.baseUrl,
- buildIdAlias: originalBuildId !== args.browser.buildId ? originalBuildId : undefined,
- installDeps: args.installDeps,
- });
- console.log(`${args.browser.name}@${args.browser.buildId} ${(0, launch_js_1.computeExecutablePath)({
- browser: args.browser.name,
- buildId: args.browser.buildId,
- cacheDir: args.path ?? this.#cachePath,
- platform: args.platform,
- })}`);
}
-}
-exports.CLI = CLI;
-/**
- * @public
- */
-function makeProgressCallback(browser, buildId) {
- let progressBar;
- let lastDownloadedBytes = 0;
- return (downloadedBytes, totalBytes) => {
- if (!progressBar) {
- progressBar = new progress_1.default(`Downloading ${browser} ${buildId} - ${toMegabytes(totalBytes)} [:bar] :percent :etas `, {
- complete: '=',
- incomplete: ' ',
- width: 20,
- total: totalBytes,
- });
+ testRegExp(e, p, rest, absolute) {
+ if (!p.test(e.name))
+ return;
+ if (!rest) {
+ this.matches.add(e, absolute, false);
}
- const delta = downloadedBytes - lastDownloadedBytes;
- lastDownloadedBytes = downloadedBytes;
- progressBar.tick(delta);
- };
-}
-function toMegabytes(bytes) {
- const mb = bytes / 1000 / 1000;
- return `${Math.round(mb * 10) / 10} MB`;
+ else {
+ this.subwalks.add(e, rest);
+ }
+ }
+ testString(e, p, rest, absolute) {
+ // should never happen?
+ if (!e.isNamed(p))
+ return;
+ if (!rest) {
+ this.matches.add(e, absolute, false);
+ }
+ else {
+ this.subwalks.add(e, rest);
+ }
+ }
}
-//# sourceMappingURL=CLI.js.map
+exports.Processor = Processor;
+//# sourceMappingURL=processor.js.map
/***/ }),
-/***/ 95674:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+/***/ 83581:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
-/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
- return (mod && mod.__esModule) ? mod : { "default": mod };
-};
Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Cache = exports.InstalledBrowser = void 0;
-const fs_1 = __importDefault(__nccwpck_require__(79896));
-const os_1 = __importDefault(__nccwpck_require__(70857));
-const path_1 = __importDefault(__nccwpck_require__(16928));
-const debug_1 = __importDefault(__nccwpck_require__(2830));
-const browser_data_js_1 = __nccwpck_require__(35255);
-const detectPlatform_js_1 = __nccwpck_require__(79014);
-const debugCache = (0, debug_1.default)('puppeteer:browsers:cache');
+exports.GlobStream = exports.GlobWalker = exports.GlobUtil = void 0;
/**
- * @public
- */
-class InstalledBrowser {
- browser;
- buildId;
- platform;
- executablePath;
- #cache;
- /**
- * @internal
- */
- constructor(cache, browser, buildId, platform) {
- this.#cache = cache;
- this.browser = browser;
- this.buildId = buildId;
- this.platform = platform;
- this.executablePath = cache.computeExecutablePath({
- browser,
- buildId,
- platform,
- });
- }
- /**
- * Path to the root of the installation folder. Use
- * {@link computeExecutablePath} to get the path to the executable binary.
- */
- get path() {
- return this.#cache.installationDir(this.browser, this.platform, this.buildId);
+ * Single-use utility classes to provide functionality to the {@link Glob}
+ * methods.
+ *
+ * @module
+ */
+const minipass_1 = __nccwpck_require__(78275);
+const ignore_js_1 = __nccwpck_require__(74941);
+const processor_js_1 = __nccwpck_require__(74827);
+const makeIgnore = (ignore, opts) => typeof ignore === 'string' ? new ignore_js_1.Ignore([ignore], opts)
+ : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts)
+ : ignore;
+/**
+ * basic walking utilities that all the glob walker types use
+ */
+class GlobUtil {
+ path;
+ patterns;
+ opts;
+ seen = new Set();
+ paused = false;
+ aborted = false;
+ #onResume = [];
+ #ignore;
+ #sep;
+ signal;
+ maxDepth;
+ includeChildMatches;
+ constructor(patterns, path, opts) {
+ this.patterns = patterns;
+ this.path = path;
+ this.opts = opts;
+ this.#sep = !opts.posix && opts.platform === 'win32' ? '\\' : '/';
+ this.includeChildMatches = opts.includeChildMatches !== false;
+ if (opts.ignore || !this.includeChildMatches) {
+ this.#ignore = makeIgnore(opts.ignore ?? [], opts);
+ if (!this.includeChildMatches &&
+ typeof this.#ignore.add !== 'function') {
+ const m = 'cannot ignore child matches, ignore lacks add() method.';
+ throw new Error(m);
+ }
+ }
+ // ignore, always set with maxDepth, but it's optional on the
+ // GlobOptions type
+ /* c8 ignore start */
+ this.maxDepth = opts.maxDepth || Infinity;
+ /* c8 ignore stop */
+ if (opts.signal) {
+ this.signal = opts.signal;
+ this.signal.addEventListener('abort', () => {
+ this.#onResume.length = 0;
+ });
+ }
}
- readMetadata() {
- return this.#cache.readMetadata(this.browser);
+ #ignored(path) {
+ return this.seen.has(path) || !!this.#ignore?.ignored?.(path);
}
- writeMetadata(metadata) {
- this.#cache.writeMetadata(this.browser, metadata);
+ #childrenIgnored(path) {
+ return !!this.#ignore?.childrenIgnored?.(path);
}
-}
-exports.InstalledBrowser = InstalledBrowser;
-/**
- * The cache used by Puppeteer relies on the following structure:
- *
- * - rootDir
- * -- | browserRoot(browser1)
- * ---- - | installationDir()
- * ------ the browser-platform-buildId
- * ------ specific structure.
- * -- | browserRoot(browser2)
- * ---- - | installationDir()
- * ------ the browser-platform-buildId
- * ------ specific structure.
- * @internal
- */
-class Cache {
- #rootDir;
- constructor(rootDir) {
- this.#rootDir = rootDir;
+ // backpressure mechanism
+ pause() {
+ this.paused = true;
}
- /**
- * @internal
- */
- get rootDir() {
- return this.#rootDir;
+ resume() {
+ /* c8 ignore start */
+ if (this.signal?.aborted)
+ return;
+ /* c8 ignore stop */
+ this.paused = false;
+ let fn = undefined;
+ while (!this.paused && (fn = this.#onResume.shift())) {
+ fn();
+ }
}
- browserRoot(browser) {
- return path_1.default.join(this.#rootDir, browser);
+ onResume(fn) {
+ if (this.signal?.aborted)
+ return;
+ /* c8 ignore start */
+ if (!this.paused) {
+ fn();
+ }
+ else {
+ /* c8 ignore stop */
+ this.#onResume.push(fn);
+ }
}
- metadataFile(browser) {
- return path_1.default.join(this.browserRoot(browser), '.metadata');
+ // do the requisite realpath/stat checking, and return the path
+ // to add or undefined to filter it out.
+ async matchCheck(e, ifDir) {
+ if (ifDir && this.opts.nodir)
+ return undefined;
+ let rpc;
+ if (this.opts.realpath) {
+ rpc = e.realpathCached() || (await e.realpath());
+ if (!rpc)
+ return undefined;
+ e = rpc;
+ }
+ const needStat = e.isUnknown() || this.opts.stat;
+ const s = needStat ? await e.lstat() : e;
+ if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+ const target = await s.realpath();
+ /* c8 ignore start */
+ if (target && (target.isUnknown() || this.opts.stat)) {
+ await target.lstat();
+ }
+ /* c8 ignore stop */
+ }
+ return this.matchCheckTest(s, ifDir);
+ }
+ matchCheckTest(e, ifDir) {
+ return (e &&
+ (this.maxDepth === Infinity || e.depth() <= this.maxDepth) &&
+ (!ifDir || e.canReaddir()) &&
+ (!this.opts.nodir || !e.isDirectory()) &&
+ (!this.opts.nodir ||
+ !this.opts.follow ||
+ !e.isSymbolicLink() ||
+ !e.realpathCached()?.isDirectory()) &&
+ !this.#ignored(e)) ?
+ e
+ : undefined;
}
- readMetadata(browser) {
- const metatadaPath = this.metadataFile(browser);
- if (!fs_1.default.existsSync(metatadaPath)) {
- return { aliases: {} };
+ matchCheckSync(e, ifDir) {
+ if (ifDir && this.opts.nodir)
+ return undefined;
+ let rpc;
+ if (this.opts.realpath) {
+ rpc = e.realpathCached() || e.realpathSync();
+ if (!rpc)
+ return undefined;
+ e = rpc;
}
- // TODO: add type-safe parsing.
- const data = JSON.parse(fs_1.default.readFileSync(metatadaPath, 'utf8'));
- if (typeof data !== 'object') {
- throw new Error('.metadata is not an object');
+ const needStat = e.isUnknown() || this.opts.stat;
+ const s = needStat ? e.lstatSync() : e;
+ if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+ const target = s.realpathSync();
+ if (target && (target?.isUnknown() || this.opts.stat)) {
+ target.lstatSync();
+ }
}
- return data;
+ return this.matchCheckTest(s, ifDir);
}
- writeMetadata(browser, metadata) {
- const metatadaPath = this.metadataFile(browser);
- fs_1.default.mkdirSync(path_1.default.dirname(metatadaPath), { recursive: true });
- fs_1.default.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2));
+ matchFinish(e, absolute) {
+ if (this.#ignored(e))
+ return;
+ // we know we have an ignore if this is false, but TS doesn't
+ if (!this.includeChildMatches && this.#ignore?.add) {
+ const ign = `${e.relativePosix()}/**`;
+ this.#ignore.add(ign);
+ }
+ const abs = this.opts.absolute === undefined ? absolute : this.opts.absolute;
+ this.seen.add(e);
+ const mark = this.opts.mark && e.isDirectory() ? this.#sep : '';
+ // ok, we have what we need!
+ if (this.opts.withFileTypes) {
+ this.matchEmit(e);
+ }
+ else if (abs) {
+ const abs = this.opts.posix ? e.fullpathPosix() : e.fullpath();
+ this.matchEmit(abs + mark);
+ }
+ else {
+ const rel = this.opts.posix ? e.relativePosix() : e.relative();
+ const pre = this.opts.dotRelative && !rel.startsWith('..' + this.#sep) ?
+ '.' + this.#sep
+ : '';
+ this.matchEmit(!rel ? '.' + mark : pre + rel + mark);
+ }
+ }
+ async match(e, absolute, ifDir) {
+ const p = await this.matchCheck(e, ifDir);
+ if (p)
+ this.matchFinish(p, absolute);
+ }
+ matchSync(e, absolute, ifDir) {
+ const p = this.matchCheckSync(e, ifDir);
+ if (p)
+ this.matchFinish(p, absolute);
+ }
+ walkCB(target, patterns, cb) {
+ /* c8 ignore start */
+ if (this.signal?.aborted)
+ cb();
+ /* c8 ignore stop */
+ this.walkCB2(target, patterns, new processor_js_1.Processor(this.opts), cb);
}
- resolveAlias(browser, alias) {
- const metadata = this.readMetadata(browser);
- if (alias === 'latest') {
- return Object.values(metadata.aliases || {})
- .sort((0, browser_data_js_1.getVersionComparator)(browser))
- .at(-1);
+ walkCB2(target, patterns, processor, cb) {
+ if (this.#childrenIgnored(target))
+ return cb();
+ if (this.signal?.aborted)
+ cb();
+ if (this.paused) {
+ this.onResume(() => this.walkCB2(target, patterns, processor, cb));
+ return;
}
- return metadata.aliases[alias];
+ processor.processPatterns(target, patterns);
+ // done processing. all of the above is sync, can be abstracted out.
+ // subwalks is a map of paths to the entry filters they need
+ // matches is a map of paths to [absolute, ifDir] tuples.
+ let tasks = 1;
+ const next = () => {
+ if (--tasks === 0)
+ cb();
+ };
+ for (const [m, absolute, ifDir] of processor.matches.entries()) {
+ if (this.#ignored(m))
+ continue;
+ tasks++;
+ this.match(m, absolute, ifDir).then(() => next());
+ }
+ for (const t of processor.subwalkTargets()) {
+ if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+ continue;
+ }
+ tasks++;
+ const childrenCached = t.readdirCached();
+ if (t.calledReaddir())
+ this.walkCB3(t, childrenCached, processor, next);
+ else {
+ t.readdirCB((_, entries) => this.walkCB3(t, entries, processor, next), true);
+ }
+ }
+ next();
}
- installationDir(browser, platform, buildId) {
- return path_1.default.join(this.browserRoot(browser), `${platform}-${buildId}`);
+ walkCB3(target, entries, processor, cb) {
+ processor = processor.filterEntries(target, entries);
+ let tasks = 1;
+ const next = () => {
+ if (--tasks === 0)
+ cb();
+ };
+ for (const [m, absolute, ifDir] of processor.matches.entries()) {
+ if (this.#ignored(m))
+ continue;
+ tasks++;
+ this.match(m, absolute, ifDir).then(() => next());
+ }
+ for (const [target, patterns] of processor.subwalks.entries()) {
+ tasks++;
+ this.walkCB2(target, patterns, processor.child(), next);
+ }
+ next();
}
- clear() {
- fs_1.default.rmSync(this.#rootDir, {
- force: true,
- recursive: true,
- maxRetries: 10,
- retryDelay: 500,
- });
+ walkCBSync(target, patterns, cb) {
+ /* c8 ignore start */
+ if (this.signal?.aborted)
+ cb();
+ /* c8 ignore stop */
+ this.walkCB2Sync(target, patterns, new processor_js_1.Processor(this.opts), cb);
}
- uninstall(browser, platform, buildId) {
- const metadata = this.readMetadata(browser);
- for (const alias of Object.keys(metadata.aliases)) {
- if (metadata.aliases[alias] === buildId) {
- delete metadata.aliases[alias];
+ walkCB2Sync(target, patterns, processor, cb) {
+ if (this.#childrenIgnored(target))
+ return cb();
+ if (this.signal?.aborted)
+ cb();
+ if (this.paused) {
+ this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
+ return;
+ }
+ processor.processPatterns(target, patterns);
+ // done processing. all of the above is sync, can be abstracted out.
+ // subwalks is a map of paths to the entry filters they need
+ // matches is a map of paths to [absolute, ifDir] tuples.
+ let tasks = 1;
+ const next = () => {
+ if (--tasks === 0)
+ cb();
+ };
+ for (const [m, absolute, ifDir] of processor.matches.entries()) {
+ if (this.#ignored(m))
+ continue;
+ this.matchSync(m, absolute, ifDir);
+ }
+ for (const t of processor.subwalkTargets()) {
+ if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+ continue;
}
+ tasks++;
+ const children = t.readdirSync();
+ this.walkCB3Sync(t, children, processor, next);
}
- fs_1.default.rmSync(this.installationDir(browser, platform, buildId), {
- force: true,
- recursive: true,
- maxRetries: 10,
- retryDelay: 500,
- });
+ next();
}
- getInstalledBrowsers() {
- if (!fs_1.default.existsSync(this.#rootDir)) {
- return [];
+ walkCB3Sync(target, entries, processor, cb) {
+ processor = processor.filterEntries(target, entries);
+ let tasks = 1;
+ const next = () => {
+ if (--tasks === 0)
+ cb();
+ };
+ for (const [m, absolute, ifDir] of processor.matches.entries()) {
+ if (this.#ignored(m))
+ continue;
+ this.matchSync(m, absolute, ifDir);
}
- const types = fs_1.default.readdirSync(this.#rootDir);
- const browsers = types.filter((t) => {
- return Object.values(browser_data_js_1.Browser).includes(t);
- });
- return browsers.flatMap(browser => {
- const files = fs_1.default.readdirSync(this.browserRoot(browser));
- return files
- .map(file => {
- const result = parseFolderPath(path_1.default.join(this.browserRoot(browser), file));
- if (!result) {
- return null;
+ for (const [target, patterns] of processor.subwalks.entries()) {
+ tasks++;
+ this.walkCB2Sync(target, patterns, processor.child(), next);
+ }
+ next();
+ }
+}
+exports.GlobUtil = GlobUtil;
+class GlobWalker extends GlobUtil {
+ matches = new Set();
+ constructor(patterns, path, opts) {
+ super(patterns, path, opts);
+ }
+ matchEmit(e) {
+ this.matches.add(e);
+ }
+ async walk() {
+ if (this.signal?.aborted)
+ throw this.signal.reason;
+ if (this.path.isUnknown()) {
+ await this.path.lstat();
+ }
+ await new Promise((res, rej) => {
+ this.walkCB(this.path, this.patterns, () => {
+ if (this.signal?.aborted) {
+ rej(this.signal.reason);
+ }
+ else {
+ res(this.matches);
}
- return new InstalledBrowser(this, browser, result.buildId, result.platform);
- })
- .filter((item) => {
- return item !== null;
});
});
+ return this.matches;
+ }
+ walkSync() {
+ if (this.signal?.aborted)
+ throw this.signal.reason;
+ if (this.path.isUnknown()) {
+ this.path.lstatSync();
+ }
+ // nothing for the callback to do, because this never pauses
+ this.walkCBSync(this.path, this.patterns, () => {
+ if (this.signal?.aborted)
+ throw this.signal.reason;
+ });
+ return this.matches;
}
- computeExecutablePath(options) {
- options.platform ??= (0, detectPlatform_js_1.detectBrowserPlatform)();
- if (!options.platform) {
- throw new Error(`Cannot download a binary for the provided platform: ${os_1.default.platform()} (${os_1.default.arch()})`);
+}
+exports.GlobWalker = GlobWalker;
+class GlobStream extends GlobUtil {
+ results;
+ constructor(patterns, path, opts) {
+ super(patterns, path, opts);
+ this.results = new minipass_1.Minipass({
+ signal: this.signal,
+ objectMode: true,
+ });
+ this.results.on('drain', () => this.resume());
+ this.results.on('resume', () => this.resume());
+ }
+ matchEmit(e) {
+ this.results.write(e);
+ if (!this.results.flowing)
+ this.pause();
+ }
+ stream() {
+ const target = this.path;
+ if (target.isUnknown()) {
+ target.lstat().then(() => {
+ this.walkCB(target, this.patterns, () => this.results.end());
+ });
}
- try {
- options.buildId =
- this.resolveAlias(options.browser, options.buildId) ?? options.buildId;
+ else {
+ this.walkCB(target, this.patterns, () => this.results.end());
}
- catch {
- debugCache('could not read .metadata file for the browser');
+ return this.results;
+ }
+ streamSync() {
+ if (this.path.isUnknown()) {
+ this.path.lstatSync();
}
- const installationDir = this.installationDir(options.browser, options.platform, options.buildId);
- return path_1.default.join(installationDir, browser_data_js_1.executablePathByBrowser[options.browser](options.platform, options.buildId));
+ this.walkCBSync(this.path, this.patterns, () => this.results.end());
+ return this.results;
}
}
-exports.Cache = Cache;
-function parseFolderPath(folderPath) {
- const name = path_1.default.basename(folderPath);
- const splits = name.split('-');
- if (splits.length !== 2) {
- return;
+exports.GlobStream = GlobStream;
+//# sourceMappingURL=walker.js.map
+
+/***/ }),
+
+/***/ 86177:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.assertValidPattern = void 0;
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+ if (typeof pattern !== 'string') {
+ throw new TypeError('invalid pattern');
}
- const [platform, buildId] = splits;
- if (!buildId || !platform) {
- return;
+ if (pattern.length > MAX_PATTERN_LENGTH) {
+ throw new TypeError('pattern is too long');
}
- return { platform, buildId };
-}
-//# sourceMappingURL=Cache.js.map
+};
+exports.assertValidPattern = assertValidPattern;
+//# sourceMappingURL=assert-valid-pattern.js.map
/***/ }),
-/***/ 35255:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+/***/ 2275:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
-/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) 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 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
- var ownKeys = function(o) {
- ownKeys = Object.getOwnPropertyNames || function (o) {
- var ar = [];
- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
- return ar;
- };
- return ownKeys(o);
- };
- return function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
- __setModuleDefault(result, mod);
- return result;
- };
-})();
+// parse a single path portion
Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ChromeReleaseChannel = exports.BrowserPlatform = exports.Browser = exports.versionComparators = exports.executablePathByBrowser = exports.downloadPaths = exports.downloadUrls = void 0;
-exports.resolveBuildId = resolveBuildId;
-exports.createProfile = createProfile;
-exports.resolveSystemExecutablePath = resolveSystemExecutablePath;
-exports.getVersionComparator = getVersionComparator;
-const chromeHeadlessShell = __importStar(__nccwpck_require__(17991));
-const chrome = __importStar(__nccwpck_require__(40826));
-const chromedriver = __importStar(__nccwpck_require__(51904));
-const chromium = __importStar(__nccwpck_require__(40060));
-const firefox = __importStar(__nccwpck_require__(62783));
-const types_js_1 = __nccwpck_require__(3299);
-Object.defineProperty(exports, "Browser", ({ enumerable: true, get: function () { return types_js_1.Browser; } }));
-Object.defineProperty(exports, "BrowserPlatform", ({ enumerable: true, get: function () { return types_js_1.BrowserPlatform; } }));
-Object.defineProperty(exports, "ChromeReleaseChannel", ({ enumerable: true, get: function () { return types_js_1.ChromeReleaseChannel; } }));
-exports.downloadUrls = {
- [types_js_1.Browser.CHROMEDRIVER]: chromedriver.resolveDownloadUrl,
- [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.resolveDownloadUrl,
- [types_js_1.Browser.CHROME]: chrome.resolveDownloadUrl,
- [types_js_1.Browser.CHROMIUM]: chromium.resolveDownloadUrl,
- [types_js_1.Browser.FIREFOX]: firefox.resolveDownloadUrl,
-};
-exports.downloadPaths = {
- [types_js_1.Browser.CHROMEDRIVER]: chromedriver.resolveDownloadPath,
- [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.resolveDownloadPath,
- [types_js_1.Browser.CHROME]: chrome.resolveDownloadPath,
- [types_js_1.Browser.CHROMIUM]: chromium.resolveDownloadPath,
- [types_js_1.Browser.FIREFOX]: firefox.resolveDownloadPath,
-};
-exports.executablePathByBrowser = {
- [types_js_1.Browser.CHROMEDRIVER]: chromedriver.relativeExecutablePath,
- [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.relativeExecutablePath,
- [types_js_1.Browser.CHROME]: chrome.relativeExecutablePath,
- [types_js_1.Browser.CHROMIUM]: chromium.relativeExecutablePath,
- [types_js_1.Browser.FIREFOX]: firefox.relativeExecutablePath,
-};
-exports.versionComparators = {
- [types_js_1.Browser.CHROMEDRIVER]: chromedriver.compareVersions,
- [types_js_1.Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.compareVersions,
- [types_js_1.Browser.CHROME]: chrome.compareVersions,
- [types_js_1.Browser.CHROMIUM]: chromium.compareVersions,
- [types_js_1.Browser.FIREFOX]: firefox.compareVersions,
-};
-/**
- * @internal
- */
-async function resolveBuildIdForBrowserTag(browser, platform, tag) {
- switch (browser) {
- case types_js_1.Browser.FIREFOX:
- switch (tag) {
- case types_js_1.BrowserTag.LATEST:
- return await firefox.resolveBuildId(firefox.FirefoxChannel.NIGHTLY);
- case types_js_1.BrowserTag.BETA:
- return await firefox.resolveBuildId(firefox.FirefoxChannel.BETA);
- case types_js_1.BrowserTag.NIGHTLY:
- return await firefox.resolveBuildId(firefox.FirefoxChannel.NIGHTLY);
- case types_js_1.BrowserTag.DEVEDITION:
- return await firefox.resolveBuildId(firefox.FirefoxChannel.DEVEDITION);
- case types_js_1.BrowserTag.STABLE:
- return await firefox.resolveBuildId(firefox.FirefoxChannel.STABLE);
- case types_js_1.BrowserTag.ESR:
- return await firefox.resolveBuildId(firefox.FirefoxChannel.ESR);
- case types_js_1.BrowserTag.CANARY:
- case types_js_1.BrowserTag.DEV:
- throw new Error(`${tag.toUpperCase()} is not available for Firefox`);
+exports.AST = void 0;
+const brace_expressions_js_1 = __nccwpck_require__(90570);
+const unescape_js_1 = __nccwpck_require__(28075);
+const types = new Set(['!', '?', '+', '*', '@']);
+const isExtglobType = (c) => types.has(c);
+// Patterns that get prepended to bind to the start of either the
+// entire string, or just a single path portion, to prevent dots
+// and/or traversal patterns, when needed.
+// Exts don't need the ^ or / bit, because the root binds that already.
+const startNoTraversal = '(?!(?:^|/)\\.\\.?(?:$|/))';
+const startNoDot = '(?!\\.)';
+// characters that indicate a start of pattern needs the "no dots" bit,
+// because a dot *might* be matched. ( is not in the list, because in
+// the case of a child extglob, it will handle the prevention itself.
+const addPatternStart = new Set(['[', '.']);
+// cases where traversal is A-OK, no dot prevention needed
+const justDots = new Set(['..', '.']);
+const reSpecials = new Set('().*{}+?[]^$\\!');
+const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+// any single thing other than /
+const qmark = '[^/]';
+// * => any number of characters
+const star = qmark + '*?';
+// use + when we need to ensure that *something* matches, because the * is
+// the only thing in the path portion.
+const starNoEmpty = qmark + '+?';
+// remove the \ chars that we added if we end up doing a nonmagic compare
+// const deslash = (s: string) => s.replace(/\\(.)/g, '$1')
+class AST {
+ type;
+ #root;
+ #hasMagic;
+ #uflag = false;
+ #parts = [];
+ #parent;
+ #parentIndex;
+ #negs;
+ #filledNegs = false;
+ #options;
+ #toString;
+ // set to true if it's an extglob with no children
+ // (which really means one child of '')
+ #emptyExt = false;
+ constructor(type, parent, options = {}) {
+ this.type = type;
+ // extglobs are inherently magical
+ if (type)
+ this.#hasMagic = true;
+ this.#parent = parent;
+ this.#root = this.#parent ? this.#parent.#root : this;
+ this.#options = this.#root === this ? options : this.#root.#options;
+ this.#negs = this.#root === this ? [] : this.#root.#negs;
+ if (type === '!' && !this.#root.#filledNegs)
+ this.#negs.push(this);
+ this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+ }
+ get hasMagic() {
+ /* c8 ignore start */
+ if (this.#hasMagic !== undefined)
+ return this.#hasMagic;
+ /* c8 ignore stop */
+ for (const p of this.#parts) {
+ if (typeof p === 'string')
+ continue;
+ if (p.type || p.hasMagic)
+ return (this.#hasMagic = true);
+ }
+ // note: will be undefined until we generate the regexp src and find out
+ return this.#hasMagic;
+ }
+ // reconstructs the pattern
+ toString() {
+ if (this.#toString !== undefined)
+ return this.#toString;
+ if (!this.type) {
+ return (this.#toString = this.#parts.map(p => String(p)).join(''));
+ }
+ else {
+ return (this.#toString =
+ this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');
+ }
+ }
+ #fillNegs() {
+ /* c8 ignore start */
+ if (this !== this.#root)
+ throw new Error('should only call on root');
+ if (this.#filledNegs)
+ return this;
+ /* c8 ignore stop */
+ // call toString() once to fill this out
+ this.toString();
+ this.#filledNegs = true;
+ let n;
+ while ((n = this.#negs.pop())) {
+ if (n.type !== '!')
+ continue;
+ // walk up the tree, appending everthing that comes AFTER parentIndex
+ let p = n;
+ let pp = p.#parent;
+ while (pp) {
+ for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+ for (const part of n.#parts) {
+ /* c8 ignore start */
+ if (typeof part === 'string') {
+ throw new Error('string part in extglob AST??');
+ }
+ /* c8 ignore stop */
+ part.copyIn(pp.#parts[i]);
+ }
+ }
+ p = pp;
+ pp = p.#parent;
}
- case types_js_1.Browser.CHROME: {
- switch (tag) {
- case types_js_1.BrowserTag.LATEST:
- return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
- case types_js_1.BrowserTag.BETA:
- return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.BETA);
- case types_js_1.BrowserTag.CANARY:
- return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
- case types_js_1.BrowserTag.DEV:
- return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.DEV);
- case types_js_1.BrowserTag.STABLE:
- return await chrome.resolveBuildId(types_js_1.ChromeReleaseChannel.STABLE);
- case types_js_1.BrowserTag.NIGHTLY:
- case types_js_1.BrowserTag.DEVEDITION:
- case types_js_1.BrowserTag.ESR:
- throw new Error(`${tag.toUpperCase()} is not available for Chrome`);
+ }
+ return this;
+ }
+ push(...parts) {
+ for (const p of parts) {
+ if (p === '')
+ continue;
+ /* c8 ignore start */
+ if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {
+ throw new Error('invalid part: ' + p);
}
+ /* c8 ignore stop */
+ this.#parts.push(p);
}
- case types_js_1.Browser.CHROMEDRIVER: {
- switch (tag) {
- case types_js_1.BrowserTag.LATEST:
- case types_js_1.BrowserTag.CANARY:
- return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
- case types_js_1.BrowserTag.BETA:
- return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.BETA);
- case types_js_1.BrowserTag.DEV:
- return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.DEV);
- case types_js_1.BrowserTag.STABLE:
- return await chromedriver.resolveBuildId(types_js_1.ChromeReleaseChannel.STABLE);
- case types_js_1.BrowserTag.NIGHTLY:
- case types_js_1.BrowserTag.DEVEDITION:
- case types_js_1.BrowserTag.ESR:
- throw new Error(`${tag.toUpperCase()} is not available for ChromeDriver`);
+ }
+ toJSON() {
+ const ret = this.type === null
+ ? this.#parts.slice().map(p => (typeof p === 'string' ? p : p.toJSON()))
+ : [this.type, ...this.#parts.map(p => p.toJSON())];
+ if (this.isStart() && !this.type)
+ ret.unshift([]);
+ if (this.isEnd() &&
+ (this === this.#root ||
+ (this.#root.#filledNegs && this.#parent?.type === '!'))) {
+ ret.push({});
+ }
+ return ret;
+ }
+ isStart() {
+ if (this.#root === this)
+ return true;
+ // if (this.type) return !!this.#parent?.isStart()
+ if (!this.#parent?.isStart())
+ return false;
+ if (this.#parentIndex === 0)
+ return true;
+ // if everything AHEAD of this is a negation, then it's still the "start"
+ const p = this.#parent;
+ for (let i = 0; i < this.#parentIndex; i++) {
+ const pp = p.#parts[i];
+ if (!(pp instanceof AST && pp.type === '!')) {
+ return false;
}
}
- case types_js_1.Browser.CHROMEHEADLESSSHELL: {
- switch (tag) {
- case types_js_1.BrowserTag.LATEST:
- case types_js_1.BrowserTag.CANARY:
- return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.CANARY);
- case types_js_1.BrowserTag.BETA:
- return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.BETA);
- case types_js_1.BrowserTag.DEV:
- return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.DEV);
- case types_js_1.BrowserTag.STABLE:
- return await chromeHeadlessShell.resolveBuildId(types_js_1.ChromeReleaseChannel.STABLE);
- case types_js_1.BrowserTag.NIGHTLY:
- case types_js_1.BrowserTag.DEVEDITION:
- case types_js_1.BrowserTag.ESR:
- throw new Error(`${tag} is not available for chrome-headless-shell`);
+ return true;
+ }
+ isEnd() {
+ if (this.#root === this)
+ return true;
+ if (this.#parent?.type === '!')
+ return true;
+ if (!this.#parent?.isEnd())
+ return false;
+ if (!this.type)
+ return this.#parent?.isEnd();
+ // if not root, it'll always have a parent
+ /* c8 ignore start */
+ const pl = this.#parent ? this.#parent.#parts.length : 0;
+ /* c8 ignore stop */
+ return this.#parentIndex === pl - 1;
+ }
+ copyIn(part) {
+ if (typeof part === 'string')
+ this.push(part);
+ else
+ this.push(part.clone(this));
+ }
+ clone(parent) {
+ const c = new AST(this.type, parent);
+ for (const p of this.#parts) {
+ c.copyIn(p);
+ }
+ return c;
+ }
+ static #parseAST(str, ast, pos, opt) {
+ let escaping = false;
+ let inBrace = false;
+ let braceStart = -1;
+ let braceNeg = false;
+ if (ast.type === null) {
+ // outside of a extglob, append until we find a start
+ let i = pos;
+ let acc = '';
+ while (i < str.length) {
+ const c = str.charAt(i++);
+ // still accumulate escapes at this point, but we do ignore
+ // starts that are escaped
+ if (escaping || c === '\\') {
+ escaping = !escaping;
+ acc += c;
+ continue;
+ }
+ if (inBrace) {
+ if (i === braceStart + 1) {
+ if (c === '^' || c === '!') {
+ braceNeg = true;
+ }
+ }
+ else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {
+ inBrace = false;
+ }
+ acc += c;
+ continue;
+ }
+ else if (c === '[') {
+ inBrace = true;
+ braceStart = i;
+ braceNeg = false;
+ acc += c;
+ continue;
+ }
+ if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {
+ ast.push(acc);
+ acc = '';
+ const ext = new AST(c, ast);
+ i = AST.#parseAST(str, ext, i, opt);
+ ast.push(ext);
+ continue;
+ }
+ acc += c;
}
+ ast.push(acc);
+ return i;
}
- case types_js_1.Browser.CHROMIUM:
- switch (tag) {
- case types_js_1.BrowserTag.LATEST:
- return await chromium.resolveBuildId(platform);
- case types_js_1.BrowserTag.NIGHTLY:
- case types_js_1.BrowserTag.CANARY:
- case types_js_1.BrowserTag.DEV:
- case types_js_1.BrowserTag.DEVEDITION:
- case types_js_1.BrowserTag.BETA:
- case types_js_1.BrowserTag.STABLE:
- case types_js_1.BrowserTag.ESR:
- throw new Error(`${tag} is not supported for Chromium. Use 'latest' instead.`);
+ // some kind of extglob, pos is at the (
+ // find the next | or )
+ let i = pos + 1;
+ let part = new AST(null, ast);
+ const parts = [];
+ let acc = '';
+ while (i < str.length) {
+ const c = str.charAt(i++);
+ // still accumulate escapes at this point, but we do ignore
+ // starts that are escaped
+ if (escaping || c === '\\') {
+ escaping = !escaping;
+ acc += c;
+ continue;
}
- }
-}
-/**
- * @public
- */
-async function resolveBuildId(browser, platform, tag) {
- const browserTag = tag;
- if (Object.values(types_js_1.BrowserTag).includes(browserTag)) {
- return await resolveBuildIdForBrowserTag(browser, platform, browserTag);
- }
- switch (browser) {
- case types_js_1.Browser.FIREFOX:
- return tag;
- case types_js_1.Browser.CHROME:
- const chromeResult = await chrome.resolveBuildId(tag);
- if (chromeResult) {
- return chromeResult;
+ if (inBrace) {
+ if (i === braceStart + 1) {
+ if (c === '^' || c === '!') {
+ braceNeg = true;
+ }
+ }
+ else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {
+ inBrace = false;
+ }
+ acc += c;
+ continue;
}
- return tag;
- case types_js_1.Browser.CHROMEDRIVER:
- const chromeDriverResult = await chromedriver.resolveBuildId(tag);
- if (chromeDriverResult) {
- return chromeDriverResult;
+ else if (c === '[') {
+ inBrace = true;
+ braceStart = i;
+ braceNeg = false;
+ acc += c;
+ continue;
}
- return tag;
- case types_js_1.Browser.CHROMEHEADLESSSHELL:
- const chromeHeadlessShellResult = await chromeHeadlessShell.resolveBuildId(tag);
- if (chromeHeadlessShellResult) {
- return chromeHeadlessShellResult;
+ if (isExtglobType(c) && str.charAt(i) === '(') {
+ part.push(acc);
+ acc = '';
+ const ext = new AST(c, part);
+ part.push(ext);
+ i = AST.#parseAST(str, ext, i, opt);
+ continue;
}
- return tag;
- case types_js_1.Browser.CHROMIUM:
- return tag;
+ if (c === '|') {
+ part.push(acc);
+ acc = '';
+ parts.push(part);
+ part = new AST(null, ast);
+ continue;
+ }
+ if (c === ')') {
+ if (acc === '' && ast.#parts.length === 0) {
+ ast.#emptyExt = true;
+ }
+ part.push(acc);
+ acc = '';
+ ast.push(...parts, part);
+ return i;
+ }
+ acc += c;
+ }
+ // unfinished extglob
+ // if we got here, it was a malformed extglob! not an extglob, but
+ // maybe something else in there.
+ ast.type = null;
+ ast.#hasMagic = undefined;
+ ast.#parts = [str.substring(pos - 1)];
+ return i;
}
-}
-/**
- * @public
- */
-async function createProfile(browser, opts) {
- switch (browser) {
- case types_js_1.Browser.FIREFOX:
- return await firefox.createProfile(opts);
- case types_js_1.Browser.CHROME:
- case types_js_1.Browser.CHROMIUM:
- throw new Error(`Profile creation is not support for ${browser} yet`);
+ static fromGlob(pattern, options = {}) {
+ const ast = new AST(null, undefined, options);
+ AST.#parseAST(pattern, ast, 0, options);
+ return ast;
+ }
+ // returns the regular expression if there's magic, or the unescaped
+ // string if not.
+ toMMPattern() {
+ // should only be called on root
+ /* c8 ignore start */
+ if (this !== this.#root)
+ return this.#root.toMMPattern();
+ /* c8 ignore stop */
+ const glob = this.toString();
+ const [re, body, hasMagic, uflag] = this.toRegExpSource();
+ // if we're in nocase mode, and not nocaseMagicOnly, then we do
+ // still need a regular expression if we have to case-insensitively
+ // match capital/lowercase characters.
+ const anyMagic = hasMagic ||
+ this.#hasMagic ||
+ (this.#options.nocase &&
+ !this.#options.nocaseMagicOnly &&
+ glob.toUpperCase() !== glob.toLowerCase());
+ if (!anyMagic) {
+ return body;
+ }
+ const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');
+ return Object.assign(new RegExp(`^${re}$`, flags), {
+ _src: re,
+ _glob: glob,
+ });
}
-}
-/**
- * @public
- */
-function resolveSystemExecutablePath(browser, platform, channel) {
- switch (browser) {
- case types_js_1.Browser.CHROMEDRIVER:
- case types_js_1.Browser.CHROMEHEADLESSSHELL:
- case types_js_1.Browser.FIREFOX:
- case types_js_1.Browser.CHROMIUM:
- throw new Error(`System browser detection is not supported for ${browser} yet.`);
- case types_js_1.Browser.CHROME:
- return chrome.resolveSystemExecutablePath(platform, channel);
+ get options() {
+ return this.#options;
+ }
+ // returns the string match, the regexp source, whether there's magic
+ // in the regexp (so a regular expression is required) and whether or
+ // not the uflag is needed for the regular expression (for posix classes)
+ // TODO: instead of injecting the start/end at this point, just return
+ // the BODY of the regexp, along with the start/end portions suitable
+ // for binding the start/end in either a joined full-path makeRe context
+ // (where we bind to (^|/), or a standalone matchPart context (where
+ // we bind to ^, and not /). Otherwise slashes get duped!
+ //
+ // In part-matching mode, the start is:
+ // - if not isStart: nothing
+ // - if traversal possible, but not allowed: ^(?!\.\.?$)
+ // - if dots allowed or not possible: ^
+ // - if dots possible and not allowed: ^(?!\.)
+ // end is:
+ // - if not isEnd(): nothing
+ // - else: $
+ //
+ // In full-path matching mode, we put the slash at the START of the
+ // pattern, so start is:
+ // - if first pattern: same as part-matching mode
+ // - if not isStart(): nothing
+ // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+ // - if dots allowed or not possible: /
+ // - if dots possible and not allowed: /(?!\.)
+ // end is:
+ // - if last pattern, same as part-matching mode
+ // - else nothing
+ //
+ // Always put the (?:$|/) on negated tails, though, because that has to be
+ // there to bind the end of the negated pattern portion, and it's easier to
+ // just stick it in now rather than try to inject it later in the middle of
+ // the pattern.
+ //
+ // We can just always return the same end, and leave it up to the caller
+ // to know whether it's going to be used joined or in parts.
+ // And, if the start is adjusted slightly, can do the same there:
+ // - if not isStart: nothing
+ // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+ // - if dots allowed or not possible: (?:/|^)
+ // - if dots possible and not allowed: (?:/|^)(?!\.)
+ //
+ // But it's better to have a simpler binding without a conditional, for
+ // performance, so probably better to return both start options.
+ //
+ // Then the caller just ignores the end if it's not the first pattern,
+ // and the start always gets applied.
+ //
+ // But that's always going to be $ if it's the ending pattern, or nothing,
+ // so the caller can just attach $ at the end of the pattern when building.
+ //
+ // So the todo is:
+ // - better detect what kind of start is needed
+ // - return both flavors of starting pattern
+ // - attach $ at the end of the pattern when creating the actual RegExp
+ //
+ // Ah, but wait, no, that all only applies to the root when the first pattern
+ // is not an extglob. If the first pattern IS an extglob, then we need all
+ // that dot prevention biz to live in the extglob portions, because eg
+ // +(*|.x*) can match .xy but not .yx.
+ //
+ // So, return the two flavors if it's #root and the first child is not an
+ // AST, otherwise leave it to the child AST to handle it, and there,
+ // use the (?:^|/) style of start binding.
+ //
+ // Even simplified further:
+ // - Since the start for a join is eg /(?!\.) and the start for a part
+ // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+ // or start or whatever) and prepend ^ or / at the Regexp construction.
+ toRegExpSource(allowDot) {
+ const dot = allowDot ?? !!this.#options.dot;
+ if (this.#root === this)
+ this.#fillNegs();
+ if (!this.type) {
+ const noEmpty = this.isStart() && this.isEnd();
+ const src = this.#parts
+ .map(p => {
+ const [re, _, hasMagic, uflag] = typeof p === 'string'
+ ? AST.#parseGlob(p, this.#hasMagic, noEmpty)
+ : p.toRegExpSource(allowDot);
+ this.#hasMagic = this.#hasMagic || hasMagic;
+ this.#uflag = this.#uflag || uflag;
+ return re;
+ })
+ .join('');
+ let start = '';
+ if (this.isStart()) {
+ if (typeof this.#parts[0] === 'string') {
+ // this is the string that will match the start of the pattern,
+ // so we need to protect against dots and such.
+ // '.' and '..' cannot match unless the pattern is that exactly,
+ // even if it starts with . or dot:true is set.
+ const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+ if (!dotTravAllowed) {
+ const aps = addPatternStart;
+ // check if we have a possibility of matching . or ..,
+ // and prevent that.
+ const needNoTrav =
+ // dots are allowed, and the pattern starts with [ or .
+ (dot && aps.has(src.charAt(0))) ||
+ // the pattern starts with \., and then [ or .
+ (src.startsWith('\\.') && aps.has(src.charAt(2))) ||
+ // the pattern starts with \.\., and then [ or .
+ (src.startsWith('\\.\\.') && aps.has(src.charAt(4)));
+ // no need to prevent dots if it can't match a dot, or if a
+ // sub-pattern will be preventing it anyway.
+ const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+ start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';
+ }
+ }
+ }
+ // append the "end of path portion" pattern to negation tails
+ let end = '';
+ if (this.isEnd() &&
+ this.#root.#filledNegs &&
+ this.#parent?.type === '!') {
+ end = '(?:$|\\/)';
+ }
+ const final = start + src + end;
+ return [
+ final,
+ (0, unescape_js_1.unescape)(src),
+ (this.#hasMagic = !!this.#hasMagic),
+ this.#uflag,
+ ];
+ }
+ // We need to calculate the body *twice* if it's a repeat pattern
+ // at the start, once in nodot mode, then again in dot mode, so a
+ // pattern like *(?) can match 'x.y'
+ const repeated = this.type === '*' || this.type === '+';
+ // some kind of extglob
+ const start = this.type === '!' ? '(?:(?!(?:' : '(?:';
+ let body = this.#partsToRegExp(dot);
+ if (this.isStart() && this.isEnd() && !body && this.type !== '!') {
+ // invalid extglob, has to at least be *something* present, if it's
+ // the entire path portion.
+ const s = this.toString();
+ this.#parts = [s];
+ this.type = null;
+ this.#hasMagic = undefined;
+ return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];
+ }
+ // XXX abstract out this map method
+ let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot
+ ? ''
+ : this.#partsToRegExp(true);
+ if (bodyDotAllowed === body) {
+ bodyDotAllowed = '';
+ }
+ if (bodyDotAllowed) {
+ body = `(?:${body})(?:${bodyDotAllowed})*?`;
+ }
+ // an empty !() is exactly equivalent to a starNoEmpty
+ let final = '';
+ if (this.type === '!' && this.#emptyExt) {
+ final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;
+ }
+ else {
+ const close = this.type === '!'
+ ? // !() must match something,but !(x) can match ''
+ '))' +
+ (this.isStart() && !dot && !allowDot ? startNoDot : '') +
+ star +
+ ')'
+ : this.type === '@'
+ ? ')'
+ : this.type === '?'
+ ? ')?'
+ : this.type === '+' && bodyDotAllowed
+ ? ')'
+ : this.type === '*' && bodyDotAllowed
+ ? `)?`
+ : `)${this.type}`;
+ final = start + body + close;
+ }
+ return [
+ final,
+ (0, unescape_js_1.unescape)(body),
+ (this.#hasMagic = !!this.#hasMagic),
+ this.#uflag,
+ ];
+ }
+ #partsToRegExp(dot) {
+ return this.#parts
+ .map(p => {
+ // extglob ASTs should only contain parent ASTs
+ /* c8 ignore start */
+ if (typeof p === 'string') {
+ throw new Error('string type in extglob ast??');
+ }
+ /* c8 ignore stop */
+ // can ignore hasMagic, because extglobs are already always magic
+ const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+ this.#uflag = this.#uflag || uflag;
+ return re;
+ })
+ .filter(p => !(this.isStart() && this.isEnd()) || !!p)
+ .join('|');
+ }
+ static #parseGlob(glob, hasMagic, noEmpty = false) {
+ let escaping = false;
+ let re = '';
+ let uflag = false;
+ for (let i = 0; i < glob.length; i++) {
+ const c = glob.charAt(i);
+ if (escaping) {
+ escaping = false;
+ re += (reSpecials.has(c) ? '\\' : '') + c;
+ continue;
+ }
+ if (c === '\\') {
+ if (i === glob.length - 1) {
+ re += '\\\\';
+ }
+ else {
+ escaping = true;
+ }
+ continue;
+ }
+ if (c === '[') {
+ const [src, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(glob, i);
+ if (consumed) {
+ re += src;
+ uflag = uflag || needUflag;
+ i += consumed - 1;
+ hasMagic = hasMagic || magic;
+ continue;
+ }
+ }
+ if (c === '*') {
+ if (noEmpty && glob === '*')
+ re += starNoEmpty;
+ else
+ re += star;
+ hasMagic = true;
+ continue;
+ }
+ if (c === '?') {
+ re += qmark;
+ hasMagic = true;
+ continue;
+ }
+ re += regExpEscape(c);
+ }
+ return [re, (0, unescape_js_1.unescape)(glob), !!hasMagic, uflag];
}
}
-/**
- * Returns a version comparator for the given browser that can be used to sort
- * browser versions.
- *
- * @public
- */
-function getVersionComparator(browser) {
- return exports.versionComparators[browser];
-}
-//# sourceMappingURL=browser-data.js.map
+exports.AST = AST;
+//# sourceMappingURL=ast.js.map
+
+/***/ }),
+
+/***/ 90570:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+// translate the various posix character classes into unicode properties
+// this works across all unicode locales
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.parseClass = void 0;
+// { : [, /u flag required, negated]
+const posixClasses = {
+ '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}', true],
+ '[:alpha:]': ['\\p{L}\\p{Nl}', true],
+ '[:ascii:]': ['\\x' + '00-\\x' + '7f', false],
+ '[:blank:]': ['\\p{Zs}\\t', true],
+ '[:cntrl:]': ['\\p{Cc}', true],
+ '[:digit:]': ['\\p{Nd}', true],
+ '[:graph:]': ['\\p{Z}\\p{C}', true, true],
+ '[:lower:]': ['\\p{Ll}', true],
+ '[:print:]': ['\\p{C}', true],
+ '[:punct:]': ['\\p{P}', true],
+ '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f', true],
+ '[:upper:]': ['\\p{Lu}', true],
+ '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}', true],
+ '[:xdigit:]': ['A-Fa-f0-9', false],
+};
+// only need to escape a few things inside of brace expressions
+// escapes: [ \ ] -
+const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
+// escape all regexp magic characters
+const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+// everything has already been escaped, we just have to join
+const rangesToString = (ranges) => ranges.join('');
+// takes a glob string at a posix brace expression, and returns
+// an equivalent regular expression source, and boolean indicating
+// whether the /u flag needs to be applied, and the number of chars
+// consumed to parse the character class.
+// This also removes out of order ranges, and returns ($.) if the
+// entire class just no good.
+const parseClass = (glob, position) => {
+ const pos = position;
+ /* c8 ignore start */
+ if (glob.charAt(pos) !== '[') {
+ throw new Error('not in a brace expression');
+ }
+ /* c8 ignore stop */
+ const ranges = [];
+ const negs = [];
+ let i = pos + 1;
+ let sawStart = false;
+ let uflag = false;
+ let escaping = false;
+ let negate = false;
+ let endPos = pos;
+ let rangeStart = '';
+ WHILE: while (i < glob.length) {
+ const c = glob.charAt(i);
+ if ((c === '!' || c === '^') && i === pos + 1) {
+ negate = true;
+ i++;
+ continue;
+ }
+ if (c === ']' && sawStart && !escaping) {
+ endPos = i + 1;
+ break;
+ }
+ sawStart = true;
+ if (c === '\\') {
+ if (!escaping) {
+ escaping = true;
+ i++;
+ continue;
+ }
+ // escaped \ char, fall through and treat like normal char
+ }
+ if (c === '[' && !escaping) {
+ // either a posix class, a collation equivalent, or just a [
+ for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+ if (glob.startsWith(cls, i)) {
+ // invalid, [a-[] is fine, but not [a-[:alpha]]
+ if (rangeStart) {
+ return ['$.', false, glob.length - pos, true];
+ }
+ i += cls.length;
+ if (neg)
+ negs.push(unip);
+ else
+ ranges.push(unip);
+ uflag = uflag || u;
+ continue WHILE;
+ }
+ }
+ }
+ // now it's just a normal character, effectively
+ escaping = false;
+ if (rangeStart) {
+ // throw this range away if it's not valid, but others
+ // can still match.
+ if (c > rangeStart) {
+ ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
+ }
+ else if (c === rangeStart) {
+ ranges.push(braceEscape(c));
+ }
+ rangeStart = '';
+ i++;
+ continue;
+ }
+ // now might be the start of a range.
+ // can be either c-d or c-] or c] or c] at this point
+ if (glob.startsWith('-]', i + 1)) {
+ ranges.push(braceEscape(c + '-'));
+ i += 2;
+ continue;
+ }
+ if (glob.startsWith('-', i + 1)) {
+ rangeStart = c;
+ i += 2;
+ continue;
+ }
+ // not the start of a range, just a single character
+ ranges.push(braceEscape(c));
+ i++;
+ }
+ if (endPos < i) {
+ // didn't see the end of the class, not a valid class,
+ // but might still be valid as a literal match.
+ return ['', false, 0, false];
+ }
+ // if we got no ranges and no negates, then we have a range that
+ // cannot possibly match anything, and that poisons the whole glob
+ if (!ranges.length && !negs.length) {
+ return ['$.', false, glob.length - pos, true];
+ }
+ // if we got one positive range, and it's a single character, then that's
+ // not actually a magic pattern, it's just that one literal character.
+ // we should not treat that as "magic", we should just return the literal
+ // character. [_] is a perfectly valid way to escape glob magic chars.
+ if (negs.length === 0 &&
+ ranges.length === 1 &&
+ /^\\?.$/.test(ranges[0]) &&
+ !negate) {
+ const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+ return [regexpEscape(r), false, endPos - pos, false];
+ }
+ const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
+ const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
+ const comb = ranges.length && negs.length
+ ? '(' + sranges + '|' + snegs + ')'
+ : ranges.length
+ ? sranges
+ : snegs;
+ return [comb, uflag, endPos - pos, true];
+};
+exports.parseClass = parseClass;
+//# sourceMappingURL=brace-expressions.js.map
/***/ }),
-/***/ 17991:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+/***/ 42600:
+/***/ ((__unused_webpack_module, exports) => {
"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
- return (mod && mod.__esModule) ? mod : { "default": mod };
-};
Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.compareVersions = exports.resolveBuildId = void 0;
-exports.resolveDownloadUrl = resolveDownloadUrl;
-exports.resolveDownloadPath = resolveDownloadPath;
-exports.relativeExecutablePath = relativeExecutablePath;
+exports.escape = void 0;
/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-const path_1 = __importDefault(__nccwpck_require__(16928));
-const types_js_1 = __nccwpck_require__(3299);
-function folder(platform) {
- switch (platform) {
- case types_js_1.BrowserPlatform.LINUX:
- return 'linux64';
- case types_js_1.BrowserPlatform.MAC_ARM:
- return 'mac-arm64';
- case types_js_1.BrowserPlatform.MAC:
- return 'mac-x64';
- case types_js_1.BrowserPlatform.WIN32:
- return 'win32';
- case types_js_1.BrowserPlatform.WIN64:
- return 'win64';
- }
-}
-function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public') {
- return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
-}
-function resolveDownloadPath(platform, buildId) {
- return [
- buildId,
- folder(platform),
- `chrome-headless-shell-${folder(platform)}.zip`,
- ];
-}
-function relativeExecutablePath(platform, _buildId) {
- switch (platform) {
- case types_js_1.BrowserPlatform.MAC:
- case types_js_1.BrowserPlatform.MAC_ARM:
- return path_1.default.join('chrome-headless-shell-' + folder(platform), 'chrome-headless-shell');
- case types_js_1.BrowserPlatform.LINUX:
- return path_1.default.join('chrome-headless-shell-linux64', 'chrome-headless-shell');
- case types_js_1.BrowserPlatform.WIN32:
- case types_js_1.BrowserPlatform.WIN64:
- return path_1.default.join('chrome-headless-shell-' + folder(platform), 'chrome-headless-shell.exe');
- }
-}
-var chrome_js_1 = __nccwpck_require__(40826);
-Object.defineProperty(exports, "resolveBuildId", ({ enumerable: true, get: function () { return chrome_js_1.resolveBuildId; } }));
-Object.defineProperty(exports, "compareVersions", ({ enumerable: true, get: function () { return chrome_js_1.compareVersions; } }));
-//# sourceMappingURL=chrome-headless-shell.js.map
+ * Escape all magic characters in a glob pattern.
+ *
+ * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
+ * option is used, then characters are escaped by wrapping in `[]`, because
+ * a magic character wrapped in a character class can only be satisfied by
+ * that exact character. In this mode, `\` is _not_ escaped, because it is
+ * not interpreted as a magic character, but instead as a path separator.
+ */
+const escape = (s, { windowsPathsNoEscape = false, } = {}) => {
+ // don't need to escape +@! because we escape the parens
+ // that make those magic, and escaping ! as [!] isn't valid,
+ // because [!]] is a valid glob class meaning not ']'.
+ return windowsPathsNoEscape
+ ? s.replace(/[?*()[\]]/g, '[$&]')
+ : s.replace(/[?*()[\]\\]/g, '\\$&');
+};
+exports.escape = escape;
+//# sourceMappingURL=escape.js.map
/***/ }),
-/***/ 40826:
+/***/ 62883:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
-/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.resolveDownloadUrl = resolveDownloadUrl;
-exports.resolveDownloadPath = resolveDownloadPath;
-exports.relativeExecutablePath = relativeExecutablePath;
-exports.getLastKnownGoodReleaseForChannel = getLastKnownGoodReleaseForChannel;
-exports.getLastKnownGoodReleaseForMilestone = getLastKnownGoodReleaseForMilestone;
-exports.getLastKnownGoodReleaseForBuild = getLastKnownGoodReleaseForBuild;
-exports.resolveBuildId = resolveBuildId;
-exports.resolveSystemExecutablePath = resolveSystemExecutablePath;
-exports.compareVersions = compareVersions;
-const path_1 = __importDefault(__nccwpck_require__(16928));
-const semver_1 = __importDefault(__nccwpck_require__(62088));
-const httpUtil_js_1 = __nccwpck_require__(80422);
-const types_js_1 = __nccwpck_require__(3299);
-function folder(platform) {
- switch (platform) {
- case types_js_1.BrowserPlatform.LINUX:
- return 'linux64';
- case types_js_1.BrowserPlatform.MAC_ARM:
- return 'mac-arm64';
- case types_js_1.BrowserPlatform.MAC:
- return 'mac-x64';
- case types_js_1.BrowserPlatform.WIN32:
- return 'win32';
- case types_js_1.BrowserPlatform.WIN64:
- return 'win64';
- }
-}
-function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public') {
- return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
-}
-function resolveDownloadPath(platform, buildId) {
- return [buildId, folder(platform), `chrome-${folder(platform)}.zip`];
-}
-function relativeExecutablePath(platform, _buildId) {
- switch (platform) {
- case types_js_1.BrowserPlatform.MAC:
- case types_js_1.BrowserPlatform.MAC_ARM:
- return path_1.default.join('chrome-' + folder(platform), 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
- case types_js_1.BrowserPlatform.LINUX:
- return path_1.default.join('chrome-linux64', 'chrome');
- case types_js_1.BrowserPlatform.WIN32:
- case types_js_1.BrowserPlatform.WIN64:
- return path_1.default.join('chrome-' + folder(platform), 'chrome.exe');
+exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;
+const brace_expansion_1 = __importDefault(__nccwpck_require__(94691));
+const assert_valid_pattern_js_1 = __nccwpck_require__(86177);
+const ast_js_1 = __nccwpck_require__(2275);
+const escape_js_1 = __nccwpck_require__(42600);
+const unescape_js_1 = __nccwpck_require__(28075);
+const minimatch = (p, pattern, options = {}) => {
+ (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ return false;
}
-}
-async function getLastKnownGoodReleaseForChannel(channel) {
- const data = (await (0, httpUtil_js_1.getJSON)(new URL('https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json')));
- for (const channel of Object.keys(data.channels)) {
- data.channels[channel.toLowerCase()] = data.channels[channel];
- delete data.channels[channel];
+ return new Minimatch(pattern, options).match(p);
+};
+exports.minimatch = minimatch;
+// Optimized checking for the most common glob patterns.
+const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);
+const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
+const starDotExtTestNocase = (ext) => {
+ ext = ext.toLowerCase();
+ return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);
+};
+const starDotExtTestNocaseDot = (ext) => {
+ ext = ext.toLowerCase();
+ return (f) => f.toLowerCase().endsWith(ext);
+};
+const starDotStarRE = /^\*+\.\*+$/;
+const starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');
+const starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');
+const dotStarRE = /^\.\*+$/;
+const dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');
+const starRE = /^\*+$/;
+const starTest = (f) => f.length !== 0 && !f.startsWith('.');
+const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';
+const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+const qmarksTestNocase = ([$0, ext = '']) => {
+ const noext = qmarksTestNoExt([$0]);
+ if (!ext)
+ return noext;
+ ext = ext.toLowerCase();
+ return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestNocaseDot = ([$0, ext = '']) => {
+ const noext = qmarksTestNoExtDot([$0]);
+ if (!ext)
+ return noext;
+ ext = ext.toLowerCase();
+ return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestDot = ([$0, ext = '']) => {
+ const noext = qmarksTestNoExtDot([$0]);
+ return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTest = ([$0, ext = '']) => {
+ const noext = qmarksTestNoExt([$0]);
+ return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTestNoExt = ([$0]) => {
+ const len = $0.length;
+ return (f) => f.length === len && !f.startsWith('.');
+};
+const qmarksTestNoExtDot = ([$0]) => {
+ const len = $0.length;
+ return (f) => f.length === len && f !== '.' && f !== '..';
+};
+/* c8 ignore start */
+const defaultPlatform = (typeof process === 'object' && process
+ ? (typeof process.env === 'object' &&
+ process.env &&
+ process.env.__MINIMATCH_TESTING_PLATFORM__) ||
+ process.platform
+ : 'posix');
+const path = {
+ win32: { sep: '\\' },
+ posix: { sep: '/' },
+};
+/* c8 ignore stop */
+exports.sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;
+exports.minimatch.sep = exports.sep;
+exports.GLOBSTAR = Symbol('globstar **');
+exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+const qmark = '[^/]';
+// * => any number of characters
+const star = qmark + '*?';
+// ** when dots are allowed. Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+const twoStarDot = '(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?';
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+const twoStarNoDot = '(?:(?!(?:\\/|^)\\.).)*?';
+const filter = (pattern, options = {}) => (p) => (0, exports.minimatch)(p, pattern, options);
+exports.filter = filter;
+exports.minimatch.filter = exports.filter;
+const ext = (a, b = {}) => Object.assign({}, a, b);
+const defaults = (def) => {
+ if (!def || typeof def !== 'object' || !Object.keys(def).length) {
+ return exports.minimatch;
+ }
+ const orig = exports.minimatch;
+ const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+ return Object.assign(m, {
+ Minimatch: class Minimatch extends orig.Minimatch {
+ constructor(pattern, options = {}) {
+ super(pattern, ext(def, options));
+ }
+ static defaults(options) {
+ return orig.defaults(ext(def, options)).Minimatch;
+ }
+ },
+ AST: class AST extends orig.AST {
+ /* c8 ignore start */
+ constructor(type, parent, options = {}) {
+ super(type, parent, ext(def, options));
+ }
+ /* c8 ignore stop */
+ static fromGlob(pattern, options = {}) {
+ return orig.AST.fromGlob(pattern, ext(def, options));
+ }
+ },
+ unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+ escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+ filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+ defaults: (options) => orig.defaults(ext(def, options)),
+ makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+ braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+ match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+ sep: orig.sep,
+ GLOBSTAR: exports.GLOBSTAR,
+ });
+};
+exports.defaults = defaults;
+exports.minimatch.defaults = exports.defaults;
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+const braceExpand = (pattern, options = {}) => {
+ (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
+ // Thanks to Yeting Li for
+ // improving this regexp to avoid a ReDOS vulnerability.
+ if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+ // shortcut. no need to expand.
+ return [pattern];
+ }
+ return (0, brace_expansion_1.default)(pattern);
+};
+exports.braceExpand = braceExpand;
+exports.minimatch.braceExpand = exports.braceExpand;
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+exports.makeRe = makeRe;
+exports.minimatch.makeRe = exports.makeRe;
+const match = (list, pattern, options = {}) => {
+ const mm = new Minimatch(pattern, options);
+ list = list.filter(f => mm.match(f));
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
}
- return data.channels[channel];
-}
-async function getLastKnownGoodReleaseForMilestone(milestone) {
- const data = (await (0, httpUtil_js_1.getJSON)(new URL('https://googlechromelabs.github.io/chrome-for-testing/latest-versions-per-milestone.json')));
- return data.milestones[milestone];
-}
-async function getLastKnownGoodReleaseForBuild(
-/**
- * @example `112.0.23`,
- */
-buildPrefix) {
- const data = (await (0, httpUtil_js_1.getJSON)(new URL('https://googlechromelabs.github.io/chrome-for-testing/latest-patch-versions-per-build.json')));
- return data.builds[buildPrefix];
-}
-async function resolveBuildId(channel) {
- if (Object.values(types_js_1.ChromeReleaseChannel).includes(channel)) {
- return (await getLastKnownGoodReleaseForChannel(channel)).version;
+ return list;
+};
+exports.match = match;
+exports.minimatch.match = exports.match;
+// replace stuff like \* with *
+const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+class Minimatch {
+ options;
+ set;
+ pattern;
+ windowsPathsNoEscape;
+ nonegate;
+ negate;
+ comment;
+ empty;
+ preserveMultipleSlashes;
+ partial;
+ globSet;
+ globParts;
+ nocase;
+ isWindows;
+ platform;
+ windowsNoMagicRoot;
+ regexp;
+ constructor(pattern, options = {}) {
+ (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
+ options = options || {};
+ this.options = options;
+ this.pattern = pattern;
+ this.platform = options.platform || defaultPlatform;
+ this.isWindows = this.platform === 'win32';
+ this.windowsPathsNoEscape =
+ !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+ if (this.windowsPathsNoEscape) {
+ this.pattern = this.pattern.replace(/\\/g, '/');
+ }
+ this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+ this.regexp = null;
+ this.negate = false;
+ this.nonegate = !!options.nonegate;
+ this.comment = false;
+ this.empty = false;
+ this.partial = !!options.partial;
+ this.nocase = !!this.options.nocase;
+ this.windowsNoMagicRoot =
+ options.windowsNoMagicRoot !== undefined
+ ? options.windowsNoMagicRoot
+ : !!(this.isWindows && this.nocase);
+ this.globSet = [];
+ this.globParts = [];
+ this.set = [];
+ // make the set of regexps etc.
+ this.make();
+ }
+ hasMagic() {
+ if (this.options.magicalBraces && this.set.length > 1) {
+ return true;
+ }
+ for (const pattern of this.set) {
+ for (const part of pattern) {
+ if (typeof part !== 'string')
+ return true;
+ }
+ }
+ return false;
}
- if (channel.match(/^\d+$/)) {
- // Potentially a milestone.
- return (await getLastKnownGoodReleaseForMilestone(channel))?.version;
+ debug(..._) { }
+ make() {
+ const pattern = this.pattern;
+ const options = this.options;
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ this.comment = true;
+ return;
+ }
+ if (!pattern) {
+ this.empty = true;
+ return;
+ }
+ // step 1: figure out negation, etc.
+ this.parseNegate();
+ // step 2: expand braces
+ this.globSet = [...new Set(this.braceExpand())];
+ if (options.debug) {
+ this.debug = (...args) => console.error(...args);
+ }
+ this.debug(this.pattern, this.globSet);
+ // step 3: now we have a set, so turn each one into a series of
+ // path-portion matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ //
+ // First, we preprocess to make the glob pattern sets a bit simpler
+ // and deduped. There are some perf-killing patterns that can cause
+ // problems with a glob walk, but we can simplify them down a bit.
+ const rawGlobParts = this.globSet.map(s => this.slashSplit(s));
+ this.globParts = this.preprocess(rawGlobParts);
+ this.debug(this.pattern, this.globParts);
+ // glob --> regexps
+ let set = this.globParts.map((s, _, __) => {
+ if (this.isWindows && this.windowsNoMagicRoot) {
+ // check if it's a drive or unc path.
+ const isUNC = s[0] === '' &&
+ s[1] === '' &&
+ (s[2] === '?' || !globMagic.test(s[2])) &&
+ !globMagic.test(s[3]);
+ const isDrive = /^[a-z]:/i.test(s[0]);
+ if (isUNC) {
+ return [...s.slice(0, 4), ...s.slice(4).map(ss => this.parse(ss))];
+ }
+ else if (isDrive) {
+ return [s[0], ...s.slice(1).map(ss => this.parse(ss))];
+ }
+ }
+ return s.map(ss => this.parse(ss));
+ });
+ this.debug(this.pattern, set);
+ // filter out everything that didn't compile properly.
+ this.set = set.filter(s => s.indexOf(false) === -1);
+ // do not treat the ? in UNC paths as magic
+ if (this.isWindows) {
+ for (let i = 0; i < this.set.length; i++) {
+ const p = this.set[i];
+ if (p[0] === '' &&
+ p[1] === '' &&
+ this.globParts[i][2] === '?' &&
+ typeof p[3] === 'string' &&
+ /^[a-z]:$/i.test(p[3])) {
+ p[2] = '?';
+ }
+ }
+ }
+ this.debug(this.pattern, this.set);
+ }
+ // various transforms to equivalent pattern sets that are
+ // faster to process in a filesystem walk. The goal is to
+ // eliminate what we can, and push all ** patterns as far
+ // to the right as possible, even if it increases the number
+ // of patterns that we have to process.
+ preprocess(globParts) {
+ // if we're not in globstar mode, then turn all ** into *
+ if (this.options.noglobstar) {
+ for (let i = 0; i < globParts.length; i++) {
+ for (let j = 0; j < globParts[i].length; j++) {
+ if (globParts[i][j] === '**') {
+ globParts[i][j] = '*';
+ }
+ }
+ }
+ }
+ const { optimizationLevel = 1 } = this.options;
+ if (optimizationLevel >= 2) {
+ // aggressive optimization for the purpose of fs walking
+ globParts = this.firstPhasePreProcess(globParts);
+ globParts = this.secondPhasePreProcess(globParts);
+ }
+ else if (optimizationLevel >= 1) {
+ // just basic optimizations to remove some .. parts
+ globParts = this.levelOneOptimize(globParts);
+ }
+ else {
+ // just collapse multiple ** portions into one
+ globParts = this.adjascentGlobstarOptimize(globParts);
+ }
+ return globParts;
+ }
+ // just get rid of adjascent ** portions
+ adjascentGlobstarOptimize(globParts) {
+ return globParts.map(parts => {
+ let gs = -1;
+ while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+ let i = gs;
+ while (parts[i + 1] === '**') {
+ i++;
+ }
+ if (i !== gs) {
+ parts.splice(gs, i - gs);
+ }
+ }
+ return parts;
+ });
}
- if (channel.match(/^\d+\.\d+\.\d+$/)) {
- // Potentially a build prefix without the patch version.
- return (await getLastKnownGoodReleaseForBuild(channel))?.version;
+ // get rid of adjascent ** and resolve .. portions
+ levelOneOptimize(globParts) {
+ return globParts.map(parts => {
+ parts = parts.reduce((set, part) => {
+ const prev = set[set.length - 1];
+ if (part === '**' && prev === '**') {
+ return set;
+ }
+ if (part === '..') {
+ if (prev && prev !== '..' && prev !== '.' && prev !== '**') {
+ set.pop();
+ return set;
+ }
+ }
+ set.push(part);
+ return set;
+ }, []);
+ return parts.length === 0 ? [''] : parts;
+ });
}
- return;
-}
-function resolveSystemExecutablePath(platform, channel) {
- switch (platform) {
- case types_js_1.BrowserPlatform.WIN64:
- case types_js_1.BrowserPlatform.WIN32:
- switch (channel) {
- case types_js_1.ChromeReleaseChannel.STABLE:
- return `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`;
- case types_js_1.ChromeReleaseChannel.BETA:
- return `${process.env['PROGRAMFILES']}\\Google\\Chrome Beta\\Application\\chrome.exe`;
- case types_js_1.ChromeReleaseChannel.CANARY:
- return `${process.env['PROGRAMFILES']}\\Google\\Chrome SxS\\Application\\chrome.exe`;
- case types_js_1.ChromeReleaseChannel.DEV:
- return `${process.env['PROGRAMFILES']}\\Google\\Chrome Dev\\Application\\chrome.exe`;
+ levelTwoFileOptimize(parts) {
+ if (!Array.isArray(parts)) {
+ parts = this.slashSplit(parts);
+ }
+ let didSomething = false;
+ do {
+ didSomething = false;
+ // // -> /
+ if (!this.preserveMultipleSlashes) {
+ for (let i = 1; i < parts.length - 1; i++) {
+ const p = parts[i];
+ // don't squeeze out UNC patterns
+ if (i === 1 && p === '' && parts[0] === '')
+ continue;
+ if (p === '.' || p === '') {
+ didSomething = true;
+ parts.splice(i, 1);
+ i--;
+ }
+ }
+ if (parts[0] === '.' &&
+ parts.length === 2 &&
+ (parts[1] === '.' || parts[1] === '')) {
+ didSomething = true;
+ parts.pop();
+ }
}
- case types_js_1.BrowserPlatform.MAC_ARM:
- case types_js_1.BrowserPlatform.MAC:
- switch (channel) {
- case types_js_1.ChromeReleaseChannel.STABLE:
- return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
- case types_js_1.ChromeReleaseChannel.BETA:
- return '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta';
- case types_js_1.ChromeReleaseChannel.CANARY:
- return '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary';
- case types_js_1.ChromeReleaseChannel.DEV:
- return '/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev';
+ // //../ -> /
+ let dd = 0;
+ while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+ const p = parts[dd - 1];
+ if (p && p !== '.' && p !== '..' && p !== '**') {
+ didSomething = true;
+ parts.splice(dd - 1, 2);
+ dd -= 2;
+ }
}
- case types_js_1.BrowserPlatform.LINUX:
- switch (channel) {
- case types_js_1.ChromeReleaseChannel.STABLE:
- return '/opt/google/chrome/chrome';
- case types_js_1.ChromeReleaseChannel.BETA:
- return '/opt/google/chrome-beta/chrome';
- case types_js_1.ChromeReleaseChannel.CANARY:
- return '/opt/google/chrome-canary/chrome';
- case types_js_1.ChromeReleaseChannel.DEV:
- return '/opt/google/chrome-unstable/chrome';
+ } while (didSomething);
+ return parts.length === 0 ? [''] : parts;
+ }
+ // First phase: single-pattern processing
+ // is 1 or more portions
+ // is 1 or more portions
+ // is any portion other than ., .., '', or **
+ // is . or ''
+ //
+ // **/.. is *brutal* for filesystem walking performance, because
+ // it effectively resets the recursive walk each time it occurs,
+ // and ** cannot be reduced out by a .. pattern part like a regexp
+ // or most strings (other than .., ., and '') can be.
+ //
+ // /**/..//
/ -> {/..//
/,/**//
/}
+ // // -> /
+ // //../ -> /
+ // **/**/ -> **/
+ //
+ // **/*/ -> */**/ <== not valid because ** doesn't follow
+ // this WOULD be allowed if ** did follow symlinks, or * didn't
+ firstPhasePreProcess(globParts) {
+ let didSomething = false;
+ do {
+ didSomething = false;
+ // /**/..//
/ -> {/..//
/,/**//
/}
+ for (let parts of globParts) {
+ let gs = -1;
+ while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+ let gss = gs;
+ while (parts[gss + 1] === '**') {
+ // /**/**/ -> /**/
+ gss++;
+ }
+ // eg, if gs is 2 and gss is 4, that means we have 3 **
+ // parts, and can remove 2 of them.
+ if (gss > gs) {
+ parts.splice(gs + 1, gss - gs);
+ }
+ let next = parts[gs + 1];
+ const p = parts[gs + 2];
+ const p2 = parts[gs + 3];
+ if (next !== '..')
+ continue;
+ if (!p ||
+ p === '.' ||
+ p === '..' ||
+ !p2 ||
+ p2 === '.' ||
+ p2 === '..') {
+ continue;
+ }
+ didSomething = true;
+ // edit parts in place, and push the new one
+ parts.splice(gs, 1);
+ const other = parts.slice(0);
+ other[gs] = '**';
+ globParts.push(other);
+ gs--;
+ }
+ // // -> /
+ if (!this.preserveMultipleSlashes) {
+ for (let i = 1; i < parts.length - 1; i++) {
+ const p = parts[i];
+ // don't squeeze out UNC patterns
+ if (i === 1 && p === '' && parts[0] === '')
+ continue;
+ if (p === '.' || p === '') {
+ didSomething = true;
+ parts.splice(i, 1);
+ i--;
+ }
+ }
+ if (parts[0] === '.' &&
+ parts.length === 2 &&
+ (parts[1] === '.' || parts[1] === '')) {
+ didSomething = true;
+ parts.pop();
+ }
+ }
+ // //../ -> /
+ let dd = 0;
+ while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+ const p = parts[dd - 1];
+ if (p && p !== '.' && p !== '..' && p !== '**') {
+ didSomething = true;
+ const needDot = dd === 1 && parts[dd + 1] === '**';
+ const splin = needDot ? ['.'] : [];
+ parts.splice(dd - 1, 2, ...splin);
+ if (parts.length === 0)
+ parts.push('');
+ dd -= 2;
+ }
+ }
}
+ } while (didSomething);
+ return globParts;
}
-}
-function compareVersions(a, b) {
- if (!semver_1.default.valid(a)) {
- throw new Error(`Version ${a} is not a valid semver version`);
+ // second phase: multi-pattern dedupes
+ // {/*/,//} -> /*/
+ // {/,/} -> /
+ // {/**/