@nhtio/lucid-resourceful 0.1.0-master-29dd5a13 → 0.1.0-master-641df8fc

package/integration/middlewares/resourceful_encoded_request.d.ts

@@ -3,5 +3,5 @@
  * Resourceful encoding utility.
  * @module @nhtio/lucid-resourceful/integration/middlewares/resourceful_encoded_request
  */
-import { ResourcefulEncodedRequestMiddleware } from '../../private/router_macro/middlewares/resourceful_encoded_request'
+import { ResourcefulEncodedRequestMiddleware } from "../../private/router_macro/middlewares/resourceful_encoded_request";
 export default ResourcefulEncodedRequestMiddleware;

package/integration/middlewares/resourceful_encoded_request.mjs

@@ -2,11 +2,99 @@ import { decode } from "../../encoding.mjs";
 import { r as requireInherits, o as commonjsGlobal, n as getDefaultExportFromCjs, p as E_ENCODED_BODY_PARSING_FAILED } from "../../errors-b4tqg-tH.js";
 import { p as process$1 } from "../../index-C9zyi90j.js";
 import { B as Buffer } from "../../index-DsojAcQ4.js";
-import { r as requireBytes } from "../../index-CpIq4gOr.js";
 import require$$0$2 from "path";
 import require$$0$3 from "buffer";
 import { r as requireString_decoder } from "../../string_decoder-BY7OVkQb.js";
 import require$$3$1 from "zlib";
+var bytes = { exports: {} };
+var hasRequiredBytes;
+function requireBytes() {
+  if (hasRequiredBytes) return bytes.exports;
+  hasRequiredBytes = 1;
+  bytes.exports = bytes$1;
+  bytes.exports.format = format;
+  bytes.exports.parse = parse;
+  var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
+  var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
+  var map = {
+    b: 1,
+    kb: 1 << 10,
+    mb: 1 << 20,
+    gb: 1 << 30,
+    tb: Math.pow(1024, 4),
+    pb: Math.pow(1024, 5)
+  };
+  var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+  function bytes$1(value, options) {
+    if (typeof value === "string") {
+      return parse(value);
+    }
+    if (typeof value === "number") {
+      return format(value, options);
+    }
+    return null;
+  }
+  function format(value, options) {
+    if (!Number.isFinite(value)) {
+      return null;
+    }
+    var mag = Math.abs(value);
+    var thousandsSeparator = options && options.thousandsSeparator || "";
+    var unitSeparator = options && options.unitSeparator || "";
+    var decimalPlaces = options && options.decimalPlaces !== void 0 ? options.decimalPlaces : 2;
+    var fixedDecimals = Boolean(options && options.fixedDecimals);
+    var unit = options && options.unit || "";
+    if (!unit || !map[unit.toLowerCase()]) {
+      if (mag >= map.pb) {
+        unit = "PB";
+      } else if (mag >= map.tb) {
+        unit = "TB";
+      } else if (mag >= map.gb) {
+        unit = "GB";
+      } else if (mag >= map.mb) {
+        unit = "MB";
+      } else if (mag >= map.kb) {
+        unit = "KB";
+      } else {
+        unit = "B";
+      }
+    }
+    var val = value / map[unit.toLowerCase()];
+    var str = val.toFixed(decimalPlaces);
+    if (!fixedDecimals) {
+      str = str.replace(formatDecimalsRegExp, "$1");
+    }
+    if (thousandsSeparator) {
+      str = str.split(".").map(function(s, i) {
+        return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s;
+      }).join(".");
+    }
+    return str + unitSeparator + unit;
+  }
+  function parse(val) {
+    if (typeof val === "number" && !isNaN(val)) {
+      return val;
+    }
+    if (typeof val !== "string") {
+      return null;
+    }
+    var results = parseRegExp.exec(val);
+    var floatValue;
+    var unit = "b";
+    if (!results) {
+      floatValue = parseInt(val, 10);
+      unit = "b";
+    } else {
+      floatValue = parseFloat(results[1]);
+      unit = results[4].toLowerCase();
+    }
+    if (isNaN(floatValue)) {
+      return null;
+    }
+    return Math.floor(map[unit] * floatValue);
+  }
+  return bytes.exports;
+}
 var httpErrors = { exports: {} };
 var depd_1;
 var hasRequiredDepd;
@@ -2319,18 +2407,18 @@ function requireDbcsCodec() {
   DBCSCodec.prototype.encoder = DBCSEncoder;
   DBCSCodec.prototype.decoder = DBCSDecoder;
   DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
-    var bytes = [];
+    var bytes2 = [];
     for (; addr > 0; addr >>>= 8) {
-      bytes.push(addr & 255);
+      bytes2.push(addr & 255);
     }
-    if (bytes.length == 0) {
-      bytes.push(0);
+    if (bytes2.length == 0) {
+      bytes2.push(0);
     }
     var node = this.decodeTables[0];
-    for (var i2 = bytes.length - 1; i2 > 0; i2--) {
-      var val = node[bytes[i2]];
+    for (var i2 = bytes2.length - 1; i2 > 0; i2--) {
+      var val = node[bytes2[i2]];
       if (val == UNASSIGNED) {
-        node[bytes[i2]] = NODE_START - this.decodeTables.length;
+        node[bytes2[i2]] = NODE_START - this.decodeTables.length;
         this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
       } else if (val <= NODE_START) {
         node = this.decodeTables[NODE_START - val];
@@ -4545,7 +4633,7 @@ function requireRawBody() {
   if (hasRequiredRawBody) return rawBody;
   hasRequiredRawBody = 1;
   var asyncHooks = tryRequireAsyncHooks();
-  var bytes = requireBytes();
+  var bytes2 = requireBytes();
   var createError = requireHttpErrors();
   var iconv = requireLib();
   var unpipe = requireUnpipe();
@@ -4587,7 +4675,7 @@ function requireRawBody() {
       throw new TypeError("argument callback is required");
     }
     var encoding = opts.encoding !== true ? opts.encoding : "utf-8";
-    var limit = bytes.parse(opts.limit);
+    var limit = bytes2.parse(opts.limit);
     var length = opts.length != null && !isNaN(opts.length) ? parseInt(opts.length, 10) : null;
     if (done) {
       return readStream(stream, encoding, length, limit, wrap(done));