@tinycloud/cli 0.7.0-beta.22 → 0.7.0-beta.23

package/dist/{_esm-3NTT6V2X.js → _esm-6RCT7X34.js}

@@ -5,111 +5,18 @@ import {
   __toESM
 } from "./chunk-PLDDJCW6.js";
 
-// ../../node_modules/ws/lib/stream.js
-var require_stream = __commonJS({
-  "../../node_modules/ws/lib/stream.js"(exports, module) {
-    "use strict";
-    var { Duplex } = __require("stream");
-    function emitClose(stream) {
-      stream.emit("close");
-    }
-    function duplexOnEnd() {
-      if (!this.destroyed && this._writableState.finished) {
-        this.destroy();
-      }
-    }
-    function duplexOnError(err) {
-      this.removeListener("error", duplexOnError);
-      this.destroy();
-      if (this.listenerCount("error") === 0) {
-        this.emit("error", err);
-      }
-    }
-    function createWebSocketStream2(ws, options) {
-      let terminateOnDestroy = true;
-      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;
-        if (!duplex.push(data)) ws.pause();
-      });
-      ws.once("error", function error(err) {
-        if (duplex.destroyed) return;
-        terminateOnDestroy = false;
-        duplex.destroy(err);
-      });
-      ws.once("close", function close() {
-        if (duplex.destroyed) return;
-        duplex.push(null);
-      });
-      duplex._destroy = function(err, callback) {
-        if (ws.readyState === ws.CLOSED) {
-          callback(err);
-          process.nextTick(emitClose, duplex);
-          return;
-        }
-        let called = false;
-        ws.once("error", function error(err2) {
-          called = true;
-          callback(err2);
-        });
-        ws.once("close", function close() {
-          if (!called) callback(err);
-          process.nextTick(emitClose, duplex);
-        });
-        if (terminateOnDestroy) ws.terminate();
-      };
-      duplex._final = function(callback) {
-        if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
-            duplex._final(callback);
-          });
-          return;
-        }
-        if (ws._socket === null) return;
-        if (ws._socket._writableState.finished) {
-          callback();
-          if (duplex._readableState.endEmitted) duplex.destroy();
-        } else {
-          ws._socket.once("finish", function finish() {
-            callback();
-          });
-          ws.close();
-        }
-      };
-      duplex._read = function() {
-        if (ws.isPaused) ws.resume();
-      };
-      duplex._write = function(chunk, encoding, callback) {
-        if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
-            duplex._write(chunk, encoding, callback);
-          });
-          return;
-        }
-        ws.send(chunk, callback);
-      };
-      duplex.on("end", duplexOnEnd);
-      duplex.on("error", duplexOnError);
-      return duplex;
-    }
-    module.exports = createWebSocketStream2;
-  }
-});
-
 // ../../node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "../../node_modules/ws/lib/constants.js"(exports, module) {
     "use strict";
+    var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+    var hasBlob = typeof Blob !== "undefined";
+    if (hasBlob) BINARY_TYPES.push("blob");
     module.exports = {
-      BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
+      BINARY_TYPES,
       EMPTY_BUFFER: Buffer.alloc(0),
       GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+      hasBlob,
       kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"),
       kListener: /* @__PURE__ */ Symbol("kListener"),
       kStatusCode: /* @__PURE__ */ Symbol("status-code"),
@@ -832,6 +739,10 @@ var require_permessage_deflate = __commonJS({
     }
     function inflateOnError(err) {
       this[kPerMessageDeflate]._inflate = null;
+      if (this[kError]) {
+        this[kCallback](this[kError]);
+        return;
+      }
       err[kStatusCode] = 1007;
       this[kCallback](err);
     }
@@ -892,6 +803,7 @@ var require_validation = __commonJS({
   "../../node_modules/ws/lib/validation.js"(exports, module) {
     "use strict";
     var { isUtf8 } = __require("buffer");
+    var { hasBlob } = require_constants();
     var tokenChars = [
       0,
       0,
@@ -1062,7 +974,11 @@ var require_validation = __commonJS({
       }
       return true;
     }
+    function isBlob(value) {
+      return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
+    }
     module.exports = {
+      isBlob,
       isValidStatusCode,
       isValidUTF8: _isValidUTF8,
       tokenChars
@@ -1544,6 +1460,8 @@ var require_receiver = __commonJS({
             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;
           }
@@ -1680,14 +1598,17 @@ var require_sender = __commonJS({
     var { Duplex } = __require("stream");
     var { randomFillSync } = __require("crypto");
     var PerMessageDeflate = require_permessage_deflate();
-    var { EMPTY_BUFFER } = require_constants();
-    var { isValidStatusCode } = require_validation();
+    var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
+    var { isBlob, isValidStatusCode } = require_validation();
     var { mask: applyMask, toBuffer } = require_buffer_util();
     var kByteLength = /* @__PURE__ */ Symbol("kByteLength");
     var maskBuffer = Buffer.alloc(4);
     var RANDOM_POOL_SIZE = 8 * 1024;
     var randomPool;
     var randomPoolPointer = RANDOM_POOL_SIZE;
+    var DEFAULT = 0;
+    var DEFLATING = 1;
+    var GET_BLOB_DATA = 2;
     var Sender2 = class _Sender {
       /**
        * Creates a Sender instance.
@@ -1707,8 +1628,10 @@ var require_sender = __commonJS({
         this._firstFragment = true;
         this._compress = false;
         this._bufferedBytes = 0;
-        this._deflating = false;
         this._queue = [];
+        this._state = DEFAULT;
+        this.onerror = NOOP;
+        this[kWebSocket] = void 0;
       }
       /**
        * Frames a piece of data according to the HyBi WebSocket protocol.
@@ -1841,7 +1764,7 @@ var require_sender = __commonJS({
           readOnly: false,
           rsv1: false
         };
-        if (this._deflating) {
+        if (this._state !== DEFAULT) {
           this.enqueue([this.dispatch, buf, false, options, cb]);
         } else {
           this.sendFrame(_Sender.frame(buf, options), cb);
@@ -1861,6 +1784,9 @@ var require_sender = __commonJS({
         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;
@@ -1879,7 +1805,13 @@ var require_sender = __commonJS({
           readOnly,
           rsv1: false
         };
-        if (this._deflating) {
+        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);
@@ -1899,6 +1831,9 @@ var require_sender = __commonJS({
         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;
@@ -1917,7 +1852,13 @@ var require_sender = __commonJS({
           readOnly,
           rsv1: false
         };
-        if (this._deflating) {
+        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);
@@ -1948,6 +1889,9 @@ var require_sender = __commonJS({
         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;
@@ -1964,38 +1908,75 @@ var require_sender = __commonJS({
           opcode = 0;
         }
         if (options.fin) this._firstFragment = true;
-        if (perMessageDeflate) {
-          const opts = {
-            [kByteLength]: byteLength,
-            fin: options.fin,
-            generateMask: this._generateMask,
-            mask: options.mask,
-            maskBuffer: this._maskBuffer,
-            opcode,
-            readOnly,
-            rsv1
-          };
-          if (this._deflating) {
-            this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+        const opts = {
+          [kByteLength]: byteLength,
+          fin: options.fin,
+          generateMask: this._generateMask,
+          mask: options.mask,
+          maskBuffer: this._maskBuffer,
+          opcode,
+          readOnly,
+          rsv1
+        };
+        if (isBlob(data)) {
+          if (this._state !== DEFAULT) {
+            this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
           } else {
-            this.dispatch(data, this._compress, opts, cb);
+            this.getBlobData(data, this._compress, opts, cb);
           }
+        } else if (this._state !== DEFAULT) {
+          this.enqueue([this.dispatch, data, this._compress, opts, cb]);
         } else {
-          this.sendFrame(
-            _Sender.frame(data, {
-              [kByteLength]: byteLength,
-              fin: options.fin,
-              generateMask: this._generateMask,
-              mask: options.mask,
-              maskBuffer: this._maskBuffer,
-              opcode,
-              readOnly,
-              rsv1: false
-            }),
-            cb
-          );
+          this.dispatch(data, this._compress, opts, cb);
         }
       }
+      /**
+       * Gets the contents of a blob as binary data.
+       *
+       * @param {Blob} blob The blob
+       * @param {Boolean} [compress=false] Specifies whether or not to compress
+       *     the data
+       * @param {Object} options Options object
+       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+       *     FIN bit
+       * @param {Function} [options.generateMask] The function used to generate the
+       *     masking key
+       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+       *     `data`
+       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+       *     key
+       * @param {Number} options.opcode The opcode
+       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+       *     modified
+       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+       *     RSV1 bit
+       * @param {Function} [cb] Callback
+       * @private
+       */
+      getBlobData(blob, compress, options, cb) {
+        this._bufferedBytes += options[kByteLength];
+        this._state = GET_BLOB_DATA;
+        blob.arrayBuffer().then((arrayBuffer) => {
+          if (this._socket.destroyed) {
+            const err = new Error(
+              "The socket was closed while the blob was being read"
+            );
+            process.nextTick(callCallbacks, this, err, cb);
+            return;
+          }
+          this._bufferedBytes -= options[kByteLength];
+          const data = toBuffer(arrayBuffer);
+          if (!compress) {
+            this._state = DEFAULT;
+            this.sendFrame(_Sender.frame(data, options), cb);
+            this.dequeue();
+          } else {
+            this.dispatch(data, compress, options, cb);
+          }
+        }).catch((err) => {
+          process.nextTick(onError, this, err, cb);
+        });
+      }
       /**
        * Dispatches a message.
        *
@@ -2026,22 +2007,17 @@ var require_sender = __commonJS({
         }
         const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
         this._bufferedBytes += options[kByteLength];
-        this._deflating = true;
+        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"
             );
-            if (typeof cb === "function") cb(err);
-            for (let i = 0; i < this._queue.length; i++) {
-              const params = this._queue[i];
-              const callback = params[params.length - 1];
-              if (typeof callback === "function") callback(err);
-            }
+            callCallbacks(this, err, cb);
             return;
           }
           this._bufferedBytes -= options[kByteLength];
-          this._deflating = false;
+          this._state = DEFAULT;
           options.readOnly = false;
           this.sendFrame(_Sender.frame(buf, options), cb);
           this.dequeue();
@@ -2053,7 +2029,7 @@ var require_sender = __commonJS({
        * @private
        */
       dequeue() {
-        while (!this._deflating && this._queue.length) {
+        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));
@@ -2072,7 +2048,7 @@ var require_sender = __commonJS({
       /**
        * Sends a frame.
        *
-       * @param {Buffer[]} list The frame to send
+       * @param {(Buffer | String)[]} list The frame to send
        * @param {Function} [cb] Callback
        * @private
        */
@@ -2088,6 +2064,18 @@ var require_sender = __commonJS({
       }
     };
     module.exports = Sender2;
+    function callCallbacks(sender, err, cb) {
+      if (typeof cb === "function") cb(err);
+      for (let i = 0; i < sender._queue.length; i++) {
+        const params = sender._queue[i];
+        const callback = params[params.length - 1];
+        if (typeof callback === "function") callback(err);
+      }
+    }
+    function onError(sender, err, cb) {
+      callCallbacks(sender, err, cb);
+      sender.onerror(err);
+    }
   }
 });
 
@@ -2488,6 +2476,7 @@ var require_websocket = __commonJS({
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
+    var { isBlob } = require_validation();
     var {
       BINARY_TYPES,
       EMPTY_BUFFER,
@@ -2524,6 +2513,7 @@ var require_websocket = __commonJS({
         this._closeFrameSent = false;
         this._closeMessage = EMPTY_BUFFER;
         this._closeTimer = null;
+        this._errorEmitted = false;
         this._extensions = {};
         this._paused = false;
         this._protocol = "";
@@ -2552,9 +2542,8 @@ var require_websocket = __commonJS({
         }
       }
       /**
-       * This deviates from the WHATWG interface since ws doesn't support the
-       * required default "blob" type (instead we define a custom "nodebuffer"
-       * type).
+       * For historical reasons, the custom "nodebuffer" type is used by the default
+       * instead of "blob".
        *
        * @type {String}
        */
@@ -2656,10 +2645,12 @@ var require_websocket = __commonJS({
           maxPayload: options.maxPayload,
           skipUTF8Validation: options.skipUTF8Validation
         });
-        this._sender = new Sender2(socket, this._extensions, options.generateMask);
+        const sender = new Sender2(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);
@@ -2667,6 +2658,7 @@ var require_websocket = __commonJS({
         receiver.on("message", receiverOnMessage);
         receiver.on("ping", receiverOnPing);
         receiver.on("pong", receiverOnPong);
+        sender.onerror = senderOnError;
         if (socket.setTimeout) socket.setTimeout(0);
         if (socket.setNoDelay) socket.setNoDelay();
         if (head.length > 0) socket.unshift(head);
@@ -2736,10 +2728,7 @@ var require_websocket = __commonJS({
             this._socket.end();
           }
         });
-        this._closeTimer = setTimeout(
-          this._socket.destroy.bind(this._socket),
-          closeTimeout
-        );
+        setCloseTimer(this);
       }
       /**
        * Pause the socket.
@@ -2992,7 +2981,7 @@ var require_websocket = __commonJS({
       const isIpcUrl = parsedUrl.protocol === "ws+unix:";
       let invalidUrlMessage;
       if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
-        invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https", or "ws+unix:"`;
+        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) {
@@ -3204,6 +3193,7 @@ var require_websocket = __commonJS({
     }
     function emitErrorAndClose(websocket, err) {
       websocket._readyState = WebSocket4.CLOSING;
+      websocket._errorEmitted = true;
       websocket.emit("error", err);
       websocket.emitClose();
     }
@@ -3237,7 +3227,7 @@ var require_websocket = __commonJS({
     }
     function sendAfterClose(websocket, data, cb) {
       if (data) {
-        const length = toBuffer(data).length;
+        const length = isBlob(data) ? data.size : toBuffer(data).length;
         if (websocket._socket) websocket._sender._bufferedBytes += length;
         else websocket._bufferedAmount += length;
       }
@@ -3270,7 +3260,10 @@ var require_websocket = __commonJS({
         process.nextTick(resume, websocket._socket);
         websocket.close(err[kStatusCode]);
       }
-      websocket.emit("error", err);
+      if (!websocket._errorEmitted) {
+        websocket._errorEmitted = true;
+        websocket.emit("error", err);
+      }
     }
     function receiverOnFinish() {
       this[kWebSocket].emitClose();
@@ -3289,6 +3282,25 @@ var require_websocket = __commonJS({
     function resume(stream) {
       stream.resume();
     }
+    function senderOnError(err) {
+      const websocket = this[kWebSocket];
+      if (websocket.readyState === WebSocket4.CLOSED) return;
+      if (websocket.readyState === WebSocket4.OPEN) {
+        websocket._readyState = WebSocket4.CLOSING;
+        setCloseTimer(websocket);
+      }
+      this._socket.end();
+      if (!websocket._errorEmitted) {
+        websocket._errorEmitted = true;
+        websocket.emit("error", err);
+      }
+    }
+    function setCloseTimer(websocket) {
+      websocket._closeTimer = setTimeout(
+        websocket._socket.destroy.bind(websocket._socket),
+        closeTimeout
+      );
+    }
     function socketOnClose() {
       const websocket = this[kWebSocket];
       this.removeListener("close", socketOnClose);
@@ -3332,6 +3344,104 @@ var require_websocket = __commonJS({
   }
 });
 
+// ../../node_modules/ws/lib/stream.js
+var require_stream = __commonJS({
+  "../../node_modules/ws/lib/stream.js"(exports, module) {
+    "use strict";
+    var WebSocket4 = require_websocket();
+    var { Duplex } = __require("stream");
+    function emitClose(stream) {
+      stream.emit("close");
+    }
+    function duplexOnEnd() {
+      if (!this.destroyed && this._writableState.finished) {
+        this.destroy();
+      }
+    }
+    function duplexOnError(err) {
+      this.removeListener("error", duplexOnError);
+      this.destroy();
+      if (this.listenerCount("error") === 0) {
+        this.emit("error", err);
+      }
+    }
+    function createWebSocketStream2(ws, options) {
+      let terminateOnDestroy = true;
+      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;
+        if (!duplex.push(data)) ws.pause();
+      });
+      ws.once("error", function error(err) {
+        if (duplex.destroyed) return;
+        terminateOnDestroy = false;
+        duplex.destroy(err);
+      });
+      ws.once("close", function close() {
+        if (duplex.destroyed) return;
+        duplex.push(null);
+      });
+      duplex._destroy = function(err, callback) {
+        if (ws.readyState === ws.CLOSED) {
+          callback(err);
+          process.nextTick(emitClose, duplex);
+          return;
+        }
+        let called = false;
+        ws.once("error", function error(err2) {
+          called = true;
+          callback(err2);
+        });
+        ws.once("close", function close() {
+          if (!called) callback(err);
+          process.nextTick(emitClose, duplex);
+        });
+        if (terminateOnDestroy) ws.terminate();
+      };
+      duplex._final = function(callback) {
+        if (ws.readyState === ws.CONNECTING) {
+          ws.once("open", function open() {
+            duplex._final(callback);
+          });
+          return;
+        }
+        if (ws._socket === null) return;
+        if (ws._socket._writableState.finished) {
+          callback();
+          if (duplex._readableState.endEmitted) duplex.destroy();
+        } else {
+          ws._socket.once("finish", function finish() {
+            callback();
+          });
+          ws.close();
+        }
+      };
+      duplex._read = function() {
+        if (ws.isPaused) ws.resume();
+      };
+      duplex._write = function(chunk, encoding, callback) {
+        if (ws.readyState === ws.CONNECTING) {
+          ws.once("open", function open() {
+            duplex._write(chunk, encoding, callback);
+          });
+          return;
+        }
+        ws.send(chunk, callback);
+      };
+      duplex.on("end", duplexOnEnd);
+      duplex.on("error", duplexOnError);
+      return duplex;
+    }
+    module.exports = createWebSocketStream2;
+  }
+});
+
 // ../../node_modules/ws/lib/subprotocol.js
 var require_subprotocol = __commonJS({
   "../../node_modules/ws/lib/subprotocol.js"(exports, module) {
@@ -3591,9 +3701,11 @@ var require_websocket_server = __commonJS({
           abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
           return;
         }
-        if (version !== 8 && version !== 13) {
+        if (version !== 13 && version !== 8) {
           const message = "Missing or invalid Sec-WebSocket-Version header";
-          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+            "Sec-WebSocket-Version": "13, 8"
+          });
           return;
         }
         if (!this.shouldHandle(req)) {
@@ -3752,13 +3864,13 @@ var require_websocket_server = __commonJS({
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
-    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
       if (server.listenerCount("wsClientError")) {
         const err = new Error(message);
         Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
         server.emit("wsClientError", err, socket, req);
       } else {
-        abortHandshake(socket, code, message);
+        abortHandshake(socket, code, message, headers);
       }
     }
   }
@@ -3807,4 +3919,4 @@ var WebSocket3 = (() => {
 export {
   WebSocket3 as WebSocket
 };
-//# sourceMappingURL=_esm-3NTT6V2X.js.map
+//# sourceMappingURL=_esm-6RCT7X34.js.map