@slicemachine/manager 0.1.1-dev-plugins.3 → 0.1.1-dev-plugins.5

package/dist/__node_modules/busboy/lib/types/multipart.js

@@ -1,1047 +0,0 @@
-import require$$0 from "stream";
-import sbmh from "../../../streamsearch/lib/sbmh.js";
-import utils from "../utils.js";
-const { Readable, Writable } = require$$0;
-const StreamSearch = sbmh;
-const {
-  basename,
-  convertToUTF8,
-  getDecoder,
-  parseContentType,
-  parseDisposition
-} = utils;
-const BUF_CRLF = Buffer.from("\r\n");
-const BUF_CR = Buffer.from("\r");
-const BUF_DASH = Buffer.from("-");
-function noop() {
-}
-const MAX_HEADER_PAIRS = 2e3;
-const MAX_HEADER_SIZE = 16 * 1024;
-const HPARSER_NAME = 0;
-const HPARSER_PRE_OWS = 1;
-const HPARSER_VALUE = 2;
-class HeaderParser {
-  constructor(cb) {
-    this.header = /* @__PURE__ */ Object.create(null);
-    this.pairCount = 0;
-    this.byteCount = 0;
-    this.state = HPARSER_NAME;
-    this.name = "";
-    this.value = "";
-    this.crlf = 0;
-    this.cb = cb;
-  }
-  reset() {
-    this.header = /* @__PURE__ */ Object.create(null);
-    this.pairCount = 0;
-    this.byteCount = 0;
-    this.state = HPARSER_NAME;
-    this.name = "";
-    this.value = "";
-    this.crlf = 0;
-  }
-  push(chunk, pos, end) {
-    let start = pos;
-    while (pos < end) {
-      switch (this.state) {
-        case HPARSER_NAME: {
-          let done = false;
-          for (; pos < end; ++pos) {
-            if (this.byteCount === MAX_HEADER_SIZE)
-              return -1;
-            ++this.byteCount;
-            const code = chunk[pos];
-            if (TOKEN[code] !== 1) {
-              if (code !== 58)
-                return -1;
-              this.name += chunk.latin1Slice(start, pos);
-              if (this.name.length === 0)
-                return -1;
-              ++pos;
-              done = true;
-              this.state = HPARSER_PRE_OWS;
-              break;
-            }
-          }
-          if (!done) {
-            this.name += chunk.latin1Slice(start, pos);
-            break;
-          }
-        }
-        case HPARSER_PRE_OWS: {
-          let done = false;
-          for (; pos < end; ++pos) {
-            if (this.byteCount === MAX_HEADER_SIZE)
-              return -1;
-            ++this.byteCount;
-            const code = chunk[pos];
-            if (code !== 32 && code !== 9) {
-              start = pos;
-              done = true;
-              this.state = HPARSER_VALUE;
-              break;
-            }
-          }
-          if (!done)
-            break;
-        }
-        case HPARSER_VALUE:
-          switch (this.crlf) {
-            case 0:
-              for (; pos < end; ++pos) {
-                if (this.byteCount === MAX_HEADER_SIZE)
-                  return -1;
-                ++this.byteCount;
-                const code = chunk[pos];
-                if (FIELD_VCHAR[code] !== 1) {
-                  if (code !== 13)
-                    return -1;
-                  ++this.crlf;
-                  break;
-                }
-              }
-              this.value += chunk.latin1Slice(start, pos++);
-              break;
-            case 1:
-              if (this.byteCount === MAX_HEADER_SIZE)
-                return -1;
-              ++this.byteCount;
-              if (chunk[pos++] !== 10)
-                return -1;
-              ++this.crlf;
-              break;
-            case 2: {
-              if (this.byteCount === MAX_HEADER_SIZE)
-                return -1;
-              ++this.byteCount;
-              const code = chunk[pos];
-              if (code === 32 || code === 9) {
-                start = pos;
-                this.crlf = 0;
-              } else {
-                if (++this.pairCount < MAX_HEADER_PAIRS) {
-                  this.name = this.name.toLowerCase();
-                  if (this.header[this.name] === void 0)
-                    this.header[this.name] = [this.value];
-                  else
-                    this.header[this.name].push(this.value);
-                }
-                if (code === 13) {
-                  ++this.crlf;
-                  ++pos;
-                } else {
-                  start = pos;
-                  this.crlf = 0;
-                  this.state = HPARSER_NAME;
-                  this.name = "";
-                  this.value = "";
-                }
-              }
-              break;
-            }
-            case 3: {
-              if (this.byteCount === MAX_HEADER_SIZE)
-                return -1;
-              ++this.byteCount;
-              if (chunk[pos++] !== 10)
-                return -1;
-              const header = this.header;
-              this.reset();
-              this.cb(header);
-              return pos;
-            }
-          }
-          break;
-      }
-    }
-    return pos;
-  }
-}
-class FileStream extends Readable {
-  constructor(opts, owner) {
-    super(opts);
-    this.truncated = false;
-    this._readcb = null;
-    this.once("end", () => {
-      this._read();
-      if (--owner._fileEndsLeft === 0 && owner._finalcb) {
-        const cb = owner._finalcb;
-        owner._finalcb = null;
-        process.nextTick(cb);
-      }
-    });
-  }
-  _read(n) {
-    const cb = this._readcb;
-    if (cb) {
-      this._readcb = null;
-      cb();
-    }
-  }
-}
-const ignoreData = {
-  push: (chunk, pos) => {
-  },
-  destroy: () => {
-  }
-};
-function callAndUnsetCb(self, err) {
-  const cb = self._writecb;
-  self._writecb = null;
-  if (err)
-    self.destroy(err);
-  else if (cb)
-    cb();
-}
-function nullDecoder(val, hint) {
-  return val;
-}
-class Multipart extends Writable {
-  constructor(cfg) {
-    const streamOpts = {
-      autoDestroy: true,
-      emitClose: true,
-      highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
-    };
-    super(streamOpts);
-    if (!cfg.conType.params || typeof cfg.conType.params.boundary !== "string")
-      throw new Error("Multipart: Boundary not found");
-    const boundary = cfg.conType.params.boundary;
-    const paramDecoder = typeof cfg.defParamCharset === "string" && cfg.defParamCharset ? getDecoder(cfg.defParamCharset) : nullDecoder;
-    const defCharset = cfg.defCharset || "utf8";
-    const preservePath = cfg.preservePath;
-    const fileOpts = {
-      autoDestroy: true,
-      emitClose: true,
-      highWaterMark: typeof cfg.fileHwm === "number" ? cfg.fileHwm : void 0
-    };
-    const limits = cfg.limits;
-    const fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
-    const fileSizeLimit = limits && typeof limits.fileSize === "number" ? limits.fileSize : Infinity;
-    const filesLimit = limits && typeof limits.files === "number" ? limits.files : Infinity;
-    const fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
-    const partsLimit = limits && typeof limits.parts === "number" ? limits.parts : Infinity;
-    let parts = -1;
-    let fields = 0;
-    let files = 0;
-    let skipPart = false;
-    this._fileEndsLeft = 0;
-    this._fileStream = void 0;
-    this._complete = false;
-    let fileSize = 0;
-    let field;
-    let fieldSize = 0;
-    let partCharset;
-    let partEncoding;
-    let partType;
-    let partName;
-    let partTruncated = false;
-    let hitFilesLimit = false;
-    let hitFieldsLimit = false;
-    this._hparser = null;
-    const hparser = new HeaderParser((header) => {
-      this._hparser = null;
-      skipPart = false;
-      partType = "text/plain";
-      partCharset = defCharset;
-      partEncoding = "7bit";
-      partName = void 0;
-      partTruncated = false;
-      let filename;
-      if (!header["content-disposition"]) {
-        skipPart = true;
-        return;
-      }
-      const disp = parseDisposition(
-        header["content-disposition"][0],
-        paramDecoder
-      );
-      if (!disp || disp.type !== "form-data") {
-        skipPart = true;
-        return;
-      }
-      if (disp.params) {
-        if (disp.params.name)
-          partName = disp.params.name;
-        if (disp.params["filename*"])
-          filename = disp.params["filename*"];
-        else if (disp.params.filename)
-          filename = disp.params.filename;
-        if (filename !== void 0 && !preservePath)
-          filename = basename(filename);
-      }
-      if (header["content-type"]) {
-        const conType = parseContentType(header["content-type"][0]);
-        if (conType) {
-          partType = `${conType.type}/${conType.subtype}`;
-          if (conType.params && typeof conType.params.charset === "string")
-            partCharset = conType.params.charset.toLowerCase();
-        }
-      }
-      if (header["content-transfer-encoding"])
-        partEncoding = header["content-transfer-encoding"][0].toLowerCase();
-      if (partType === "application/octet-stream" || filename !== void 0) {
-        if (files === filesLimit) {
-          if (!hitFilesLimit) {
-            hitFilesLimit = true;
-            this.emit("filesLimit");
-          }
-          skipPart = true;
-          return;
-        }
-        ++files;
-        if (this.listenerCount("file") === 0) {
-          skipPart = true;
-          return;
-        }
-        fileSize = 0;
-        this._fileStream = new FileStream(fileOpts, this);
-        ++this._fileEndsLeft;
-        this.emit(
-          "file",
-          partName,
-          this._fileStream,
-          {
-            filename,
-            encoding: partEncoding,
-            mimeType: partType
-          }
-        );
-      } else {
-        if (fields === fieldsLimit) {
-          if (!hitFieldsLimit) {
-            hitFieldsLimit = true;
-            this.emit("fieldsLimit");
-          }
-          skipPart = true;
-          return;
-        }
-        ++fields;
-        if (this.listenerCount("field") === 0) {
-          skipPart = true;
-          return;
-        }
-        field = [];
-        fieldSize = 0;
-      }
-    });
-    let matchPostBoundary = 0;
-    const ssCb = (isMatch, data, start, end, isDataSafe) => {
-      retrydata:
-        while (data) {
-          if (this._hparser !== null) {
-            const ret = this._hparser.push(data, start, end);
-            if (ret === -1) {
-              this._hparser = null;
-              hparser.reset();
-              this.emit("error", new Error("Malformed part header"));
-              break;
-            }
-            start = ret;
-          }
-          if (start === end)
-            break;
-          if (matchPostBoundary !== 0) {
-            if (matchPostBoundary === 1) {
-              switch (data[start]) {
-                case 45:
-                  matchPostBoundary = 2;
-                  ++start;
-                  break;
-                case 13:
-                  matchPostBoundary = 3;
-                  ++start;
-                  break;
-                default:
-                  matchPostBoundary = 0;
-              }
-              if (start === end)
-                return;
-            }
-            if (matchPostBoundary === 2) {
-              matchPostBoundary = 0;
-              if (data[start] === 45) {
-                this._complete = true;
-                this._bparser = ignoreData;
-                return;
-              }
-              const writecb = this._writecb;
-              this._writecb = noop;
-              ssCb(false, BUF_DASH, 0, 1, false);
-              this._writecb = writecb;
-            } else if (matchPostBoundary === 3) {
-              matchPostBoundary = 0;
-              if (data[start] === 10) {
-                ++start;
-                if (parts >= partsLimit)
-                  break;
-                this._hparser = hparser;
-                if (start === end)
-                  break;
-                continue retrydata;
-              } else {
-                const writecb = this._writecb;
-                this._writecb = noop;
-                ssCb(false, BUF_CR, 0, 1, false);
-                this._writecb = writecb;
-              }
-            }
-          }
-          if (!skipPart) {
-            if (this._fileStream) {
-              let chunk;
-              const actualLen = Math.min(end - start, fileSizeLimit - fileSize);
-              if (!isDataSafe) {
-                chunk = Buffer.allocUnsafe(actualLen);
-                data.copy(chunk, 0, start, start + actualLen);
-              } else {
-                chunk = data.slice(start, start + actualLen);
-              }
-              fileSize += chunk.length;
-              if (fileSize === fileSizeLimit) {
-                if (chunk.length > 0)
-                  this._fileStream.push(chunk);
-                this._fileStream.emit("limit");
-                this._fileStream.truncated = true;
-                skipPart = true;
-              } else if (!this._fileStream.push(chunk)) {
-                if (this._writecb)
-                  this._fileStream._readcb = this._writecb;
-                this._writecb = null;
-              }
-            } else if (field !== void 0) {
-              let chunk;
-              const actualLen = Math.min(
-                end - start,
-                fieldSizeLimit - fieldSize
-              );
-              if (!isDataSafe) {
-                chunk = Buffer.allocUnsafe(actualLen);
-                data.copy(chunk, 0, start, start + actualLen);
-              } else {
-                chunk = data.slice(start, start + actualLen);
-              }
-              fieldSize += actualLen;
-              field.push(chunk);
-              if (fieldSize === fieldSizeLimit) {
-                skipPart = true;
-                partTruncated = true;
-              }
-            }
-          }
-          break;
-        }
-      if (isMatch) {
-        matchPostBoundary = 1;
-        if (this._fileStream) {
-          this._fileStream.push(null);
-          this._fileStream = null;
-        } else if (field !== void 0) {
-          let data2;
-          switch (field.length) {
-            case 0:
-              data2 = "";
-              break;
-            case 1:
-              data2 = convertToUTF8(field[0], partCharset, 0);
-              break;
-            default:
-              data2 = convertToUTF8(
-                Buffer.concat(field, fieldSize),
-                partCharset,
-                0
-              );
-          }
-          field = void 0;
-          fieldSize = 0;
-          this.emit(
-            "field",
-            partName,
-            data2,
-            {
-              nameTruncated: false,
-              valueTruncated: partTruncated,
-              encoding: partEncoding,
-              mimeType: partType
-            }
-          );
-        }
-        if (++parts === partsLimit)
-          this.emit("partsLimit");
-      }
-    };
-    this._bparser = new StreamSearch(`\r
---${boundary}`, ssCb);
-    this._writecb = null;
-    this._finalcb = null;
-    this.write(BUF_CRLF);
-  }
-  static detect(conType) {
-    return conType.type === "multipart" && conType.subtype === "form-data";
-  }
-  _write(chunk, enc, cb) {
-    this._writecb = cb;
-    this._bparser.push(chunk, 0);
-    if (this._writecb)
-      callAndUnsetCb(this);
-  }
-  _destroy(err, cb) {
-    this._hparser = null;
-    this._bparser = ignoreData;
-    if (!err)
-      err = checkEndState(this);
-    const fileStream = this._fileStream;
-    if (fileStream) {
-      this._fileStream = null;
-      fileStream.destroy(err);
-    }
-    cb(err);
-  }
-  _final(cb) {
-    this._bparser.destroy();
-    if (!this._complete)
-      return cb(new Error("Unexpected end of form"));
-    if (this._fileEndsLeft)
-      this._finalcb = finalcb.bind(null, this, cb);
-    else
-      finalcb(this, cb);
-  }
-}
-function finalcb(self, cb, err) {
-  if (err)
-    return cb(err);
-  err = checkEndState(self);
-  cb(err);
-}
-function checkEndState(self) {
-  if (self._hparser)
-    return new Error("Malformed part header");
-  const fileStream = self._fileStream;
-  if (fileStream) {
-    self._fileStream = null;
-    fileStream.destroy(new Error("Unexpected end of file"));
-  }
-  if (!self._complete)
-    return new Error("Unexpected end of form");
-}
-const TOKEN = [
-  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,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  1,
-  1,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  0,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  1,
-  0,
-  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,
-  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,
-  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,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0
-];
-const FIELD_VCHAR = [
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  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,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1
-];
-var multipart = Multipart;
-export {
-  multipart as default
-};
-//# sourceMappingURL=multipart.js.map