ronds-metadata 1.2.10 → 1.2.12

package/es/framework/http/msgpack5/lib/codecs/DateCodec.js

@@ -0,0 +1,71 @@
+var type = -1;
+
+function encode(dt) {
+  var millis = dt * 1;
+  var seconds = Math.floor(millis / 1000);
+  var nanos = (millis - seconds * 1000) * 1e6;
+
+  if (nanos || seconds > 0xffffffff) {
+    // Timestamp64
+    var encoded = Buffer.allocUnsafe(9);
+    encoded[0] = -1;
+    var upperNanos = nanos * 4;
+    var upperSeconds = seconds / Math.pow(2, 32);
+    var upper = upperNanos + upperSeconds & 0xffffffff;
+    var lower = seconds & 0xffffffff;
+    encoded.writeInt32BE(upper, 1);
+    encoded.writeInt32BE(lower, 5);
+    return encoded;
+  } else {
+    // Timestamp32
+    var _encoded = Buffer.allocUnsafe(5);
+
+    _encoded[0] = -1;
+
+    _encoded.writeUInt32BE(Math.floor(millis / 1000), 1);
+
+    return _encoded;
+  }
+}
+
+function check(obj) {
+  return typeof obj.getDate === 'function';
+}
+
+function decode(buf) {
+  // console.log(buf, 'msgpack');
+  var seconds;
+  var nanoseconds = 0;
+
+  switch (buf.length) {
+    case 4:
+      // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
+      seconds = buf.readUInt32BE(0);
+      break;
+
+    case 8:
+      // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
+      // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
+      var upper = buf.readUInt32BE(0);
+      var lower = buf.readUInt32BE(4);
+      nanoseconds = upper / 4;
+      seconds = (upper & 0x03) * Math.pow(2, 32) + lower; // If we use bitwise operators, we get truncated to 32bits
+
+      break;
+    // 修改了下这里 不让他报错
+
+    case 12:
+      // throw new Error('timestamp 96 is not yet implemented');
+      return undefined;
+  }
+
+  var millis = seconds * 1000 + Math.round(nanoseconds / 1e6);
+  return new Date(millis);
+}
+
+module.exports = {
+  check: check,
+  type: type,
+  encode: encode,
+  decode: decode
+};

package/es/framework/http/msgpack5/lib/decoder.js

@@ -0,0 +1,287 @@
+'use strict';
+
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import bl from 'bl';
+import { IncompleteBufferError } from './helpers.js';
+var SIZES = {
+  0xc4: 2,
+  0xc5: 3,
+  0xc6: 5,
+  0xc7: 3,
+  0xc8: 4,
+  0xc9: 6,
+  0xca: 5,
+  0xcb: 9,
+  0xcc: 2,
+  0xcd: 3,
+  0xce: 5,
+  0xcf: 9,
+  0xd0: 2,
+  0xd1: 3,
+  0xd2: 5,
+  0xd3: 9,
+  0xd4: 3,
+  0xd5: 4,
+  0xd6: 6,
+  0xd7: 10,
+  0xd8: 18,
+  0xd9: 2,
+  0xda: 3,
+  0xdb: 5,
+  0xde: 3,
+  0xdc: 3,
+  0xdd: 5
+};
+
+function isValidDataSize(dataLength, bufLength, headerLength) {
+  return bufLength >= headerLength + dataLength;
+}
+
+export function buildDecode(decodingTypes) {
+  return decode;
+
+  function decode(buf) {
+    // TODO: Make it into ensureBl handler ?
+    if (!(buf instanceof bl)) {
+      buf = bl().append(buf);
+    }
+
+    var result = tryDecode(buf, 0); // Handle worst case ASAP and keep code flat
+
+    if (!result) throw new IncompleteBufferError();
+    buf.consume(result[1]);
+    return result[0];
+  }
+
+  function tryDecode(buf, initialOffset) {
+    if (buf.length <= initialOffset) return null;
+    var bufLength = buf.length - initialOffset;
+    var offset = initialOffset;
+    var first = buf.readUInt8(offset);
+    offset += 1;
+    var size = SIZES[first] || -1;
+    if (bufLength < size) return null;
+
+    var inRange = function inRange(start, end) {
+      return first >= start && first <= end;
+    };
+
+    if (first < 0x80) return [first, 1]; // 7-bits positive ints
+
+    if ((first & 0xf0) === 0x80) {
+      var length = first & 0x0f;
+      var headerSize = offset - initialOffset; // we have an array with less than 15 elements
+
+      return decodeMap(buf, offset, length, headerSize);
+    }
+
+    if ((first & 0xf0) === 0x90) {
+      var _length = first & 0x0f;
+
+      var _headerSize = offset - initialOffset; // we have a map with less than 15 elements
+
+
+      return decodeArray(buf, offset, _length, _headerSize);
+    }
+
+    if ((first & 0xe0) === 0xa0) {
+      // fixstr up to 31 bytes
+      var _length2 = first & 0x1f;
+
+      if (!isValidDataSize(_length2, bufLength, 1)) return null;
+      var result = buf.toString('utf8', offset, offset + _length2);
+      return [result, _length2 + 1];
+    }
+
+    if (inRange(0xc0, 0xc3)) return decodeConstants(first);
+
+    if (inRange(0xc4, 0xc6)) {
+      var _length3 = buf.readUIntBE(offset, size - 1);
+
+      offset += size - 1;
+      if (!isValidDataSize(_length3, bufLength, size)) return null;
+
+      var _result = buf.slice(offset, offset + _length3);
+
+      return [_result, size + _length3];
+    }
+
+    if (inRange(0xc7, 0xc9)) {
+      var _length4 = buf.readUIntBE(offset, size - 2);
+
+      offset += size - 2;
+
+      var _type = buf.readInt8(offset);
+
+      offset += 1;
+      if (!isValidDataSize(_length4, bufLength, size)) return null;
+      return decodeExt(buf, offset, _type, _length4, size);
+    }
+
+    if (inRange(0xca, 0xcb)) return decodeFloat(buf, offset, size - 1);
+    if (inRange(0xcc, 0xcf)) return decodeUnsignedInt(buf, offset, size - 1);
+    if (inRange(0xd0, 0xd3)) return decodeSigned(buf, offset, size - 1);
+
+    if (inRange(0xd4, 0xd8)) {
+      var type = buf.readInt8(offset); // Signed
+
+      offset += 1;
+      return decodeExt(buf, offset, type, size - 2, 2);
+    }
+
+    if (inRange(0xd9, 0xdb)) {
+      var _length5 = buf.readUIntBE(offset, size - 1);
+
+      offset += size - 1;
+      if (!isValidDataSize(_length5, bufLength, size)) return null;
+
+      var _result2 = buf.toString('utf8', offset, offset + _length5);
+
+      return [_result2, size + _length5];
+    }
+
+    if (inRange(0xdc, 0xdd)) {
+      var _length6 = buf.readUIntBE(offset, size - 1);
+
+      offset += size - 1;
+      return decodeArray(buf, offset, _length6, size);
+    }
+
+    if (inRange(0xde, 0xdf)) {
+      var _length7;
+
+      switch (first) {
+        case 0xde:
+          // maps up to 2^16 elements - 2 bytes
+          _length7 = buf.readUInt16BE(offset);
+          offset += 2; // console.log(offset - initialOffset)
+
+          return decodeMap(buf, offset, _length7, 3);
+
+        case 0xdf:
+          _length7 = buf.readUInt32BE(offset);
+          offset += 4;
+          return decodeMap(buf, offset, _length7, 5);
+      }
+    }
+
+    if (first >= 0xe0) return [first - 0x100, 1]; // 5 bits negative ints
+
+    throw new Error('not implemented yet');
+  }
+
+  function decodeArray(buf, initialOffset, length, headerLength) {
+    var offset = initialOffset;
+    var result = [];
+    var i = 0;
+
+    while (i++ < length) {
+      var decodeResult = tryDecode(buf, offset);
+      if (!decodeResult) return null;
+      result.push(decodeResult[0]);
+      offset += decodeResult[1];
+    }
+
+    return [result, headerLength + offset - initialOffset];
+  }
+
+  function decodeMap(buf, offset, length, headerLength) {
+    var _temp = decodeArray(buf, offset, 2 * length, headerLength);
+
+    if (!_temp) return null;
+
+    var _temp2 = _slicedToArray(_temp, 2),
+        result = _temp2[0],
+        consumedBytes = _temp2[1];
+
+    var isPlainObject = true;
+
+    for (var i = 0; i < 2 * length; i += 2) {
+      if (typeof result[i] !== 'string') {
+        isPlainObject = false;
+        break;
+      }
+    }
+
+    if (isPlainObject) {
+      var object = {};
+
+      for (var _i = 0; _i < 2 * length; _i += 2) {
+        var key = result[_i];
+        var val = result[_i + 1];
+        object[key] = val;
+      }
+
+      return [object, consumedBytes];
+    } else {
+      var mapping = new Map();
+
+      for (var _i2 = 0; _i2 < 2 * length; _i2 += 2) {
+        var _key = result[_i2];
+        var _val = result[_i2 + 1];
+        mapping.set(_key, _val);
+      }
+
+      return [mapping, consumedBytes];
+    }
+  }
+
+  function readInt64BE(buf, offset) {
+    var negate = (buf[offset] & 0x80) == 0x80; // eslint-disable-line
+
+    if (negate) {
+      var carry = 1;
+
+      for (var i = offset + 7; i >= offset; i--) {
+        var v = (buf[i] ^ 0xff) + carry;
+        buf[i] = v & 0xff;
+        carry = v >> 8;
+      }
+    }
+
+    var hi = buf.readUInt32BE(offset + 0);
+    var lo = buf.readUInt32BE(offset + 4);
+    return (hi * 4294967296 + lo) * (negate ? -1 : +1);
+  }
+
+  function decodeUnsignedInt(buf, offset, size) {
+    var maxOffset = offset + size;
+    var result = 0;
+
+    while (offset < maxOffset) {
+      result += buf.readUInt8(offset++) * Math.pow(256, maxOffset - offset);
+    }
+
+    return [result, size + 1];
+  }
+
+  function decodeConstants(first) {
+    if (first === 0xc0) return [null, 1];
+    if (first === 0xc2) return [false, 1];
+    if (first === 0xc3) return [true, 1];
+  }
+
+  function decodeSigned(buf, offset, size) {
+    var result;
+    if (size === 1) result = buf.readInt8(offset);
+    if (size === 2) result = buf.readInt16BE(offset);
+    if (size === 4) result = buf.readInt32BE(offset);
+    if (size === 8) result = readInt64BE(buf.slice(offset, offset + 8), 0);
+    return [result, size + 1];
+  }
+
+  function decodeFloat(buf, offset, size) {
+    var result;
+    if (size === 4) result = buf.readFloatBE(offset);
+    if (size === 8) result = buf.readDoubleBE(offset);
+    return [result, size + 1];
+  }
+
+  function decodeExt(buf, offset, type, size, headerSize) {
+    var toDecode = buf.slice(offset, offset + size);
+    var decode = decodingTypes.get(type);
+    if (!decode) throw new Error('unable to find ext type ' + type);
+    var value = decode(toDecode);
+    return [value, headerSize + size];
+  }
+}

package/es/framework/http/msgpack5/lib/encoder.js

@@ -0,0 +1,252 @@
+'use strict';
+
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { Buffer } from 'safe-buffer';
+import bl from 'bl';
+import { isNaN, isFloat } from './helpers.js';
+export function buildEncode(encodingTypes, options) {
+  function encode(obj) {
+    if (obj === undefined) throw new Error('undefined is not encodable in msgpack!');
+    if (isNaN(obj)) throw new Error('NaN is not encodable in msgpack!');
+    if (obj === null) return Buffer.from([0xc0]);
+    if (obj === true) return Buffer.from([0xc3]);
+    if (obj === false) return Buffer.from([0xc2]);
+    if (obj instanceof Map) return encodeMap(obj, options, encode);
+    if (typeof obj === 'string') return encodeString(obj, options);
+
+    if (obj && (obj.readUInt32LE || obj instanceof Uint8Array)) {
+      if (obj instanceof Uint8Array) {
+        obj = Buffer.from(obj);
+      } // weird hack to support Buffer
+      // and Buffer-like objects
+
+
+      return bl([getBufferHeader(obj.length), obj]);
+    }
+
+    if (Array.isArray(obj)) return bl().append([getHeader(obj.length, 0x90, 0xdc)].concat(_toConsumableArray(obj.map(encode))));
+    if (_typeof(obj) === 'object') return encodeExt(obj, encodingTypes) || encodeObject(obj, options, encode);
+    if (typeof obj === 'number') return encodeNumber(obj, options);
+    throw new Error('not implemented yet');
+  }
+
+  return function (obj) {
+    return encode(obj).slice();
+  };
+} //
+//
+// === MENTAL SEPARATOR ===
+//
+//
+
+function encodeMap(map, options, encode) {
+  var acc = [getHeader(map.size, 0x80, 0xde)];
+
+  var keys = _toConsumableArray(map.keys());
+
+  if (keys.every(function (item) {
+    return typeof item === 'string';
+  })) {
+    console.warn('Map with string only keys will be deserialized as an object!');
+  }
+
+  keys.forEach(function (key) {
+    acc.push(encode(key), encode(map.get(key)));
+  });
+  return bl(acc);
+}
+
+function encodeObject(obj, options, encode) {
+  var keys = [];
+
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key) && obj[key] !== undefined && typeof obj[key] !== 'function') {
+      keys.push(key);
+    }
+  }
+
+  var acc = [getHeader(keys.length, 0x80, 0xde)];
+  if (options.sortKeys) keys.sort();
+  keys.forEach(function (key) {
+    acc.push(encode(key), encode(obj[key]));
+  });
+  return bl(acc);
+}
+
+function write64BitUint(buf, offset, num) {
+  var lo = num % 4294967296;
+  var hi = Math.floor(num / 4294967296);
+  buf.writeUInt32BE(hi, offset + 0);
+  buf.writeUInt32BE(lo, offset + 4);
+}
+
+function write64BitInt(buf, offset, num) {
+  var negate = num < 0;
+  num = Math.abs(num);
+  write64BitUint(buf, offset, num);
+  if (negate) negate64BitInt(buf, offset);
+}
+
+function negate64BitInt(buf, offset) {
+  var i = offset + 8; // Optimization based on the fact that:
+  // buf[i] == 0x00  => (buf[i] ^ 0xff) + 1 = 0x100 = 0x00 + 1 curry
+
+  while (i-- > offset) {
+    if (buf[i] === 0x00) continue;
+    buf[i] = (buf[i] ^ 0xff) + 1;
+    break;
+  }
+
+  while (i-- > offset) {
+    buf[i] = buf[i] ^ 0xff;
+  }
+}
+
+var fround = Math.fround;
+
+function encodeFloat(obj, forceFloat64) {
+  var buf;
+
+  if (forceFloat64 || !fround || fround(obj) !== obj) {
+    buf = Buffer.allocUnsafe(9);
+    buf[0] = 0xcb;
+    buf.writeDoubleBE(obj, 1);
+  } else {
+    buf = Buffer.allocUnsafe(5);
+    buf[0] = 0xca;
+    buf.writeFloatBE(obj, 1);
+  }
+
+  return buf;
+}
+
+function encodeExt(obj, encodingTypes) {
+  var codec = encodingTypes.find(function (codec) {
+    return codec.check(obj);
+  });
+  if (!codec) return null;
+  var encoded = codec.encode(obj);
+  if (!encoded) return null;
+  return bl([getExtHeader(encoded.length - 1), encoded]);
+}
+
+function getExtHeader(length) {
+  if (length === 1) return Buffer.from([0xd4]);
+  if (length === 2) return Buffer.from([0xd5]);
+  if (length === 4) return Buffer.from([0xd6]);
+  if (length === 8) return Buffer.from([0xd7]);
+  if (length === 16) return Buffer.from([0xd8]);
+  if (length < 256) return Buffer.from([0xc7, length]);
+  if (length < 0x10000) return Buffer.from([0xc8, length >> 8, length & 0x00ff]);
+  return Buffer.from([0xc9, length >> 24, length >> 16 & 0x000000ff, length >> 8 & 0x000000ff, length & 0x000000ff]);
+}
+
+function getHeader(length, tag1, tag2) {
+  if (length < 16) return Buffer.from([tag1 | length]);
+  var size = length < 0x10000 ? 2 : 4;
+  var buf = Buffer.allocUnsafe(1 + size);
+  buf[0] = length < 0x10000 ? tag2 : tag2 + 1;
+  buf.writeUIntBE(length, 1, size);
+  return buf;
+}
+
+function encodeString(obj, options) {
+  var len = Buffer.byteLength(obj);
+  var buf;
+
+  if (len < 32) {
+    buf = Buffer.allocUnsafe(1 + len);
+    buf[0] = 0xa0 | len;
+
+    if (len > 0) {
+      buf.write(obj, 1);
+    }
+  } else if (len <= 0xff && !options.compatibilityMode) {
+    // str8, but only when not in compatibility mode
+    buf = Buffer.allocUnsafe(2 + len);
+    buf[0] = 0xd9;
+    buf[1] = len;
+    buf.write(obj, 2);
+  } else if (len <= 0xffff) {
+    buf = Buffer.allocUnsafe(3 + len);
+    buf[0] = 0xda;
+    buf.writeUInt16BE(len, 1);
+    buf.write(obj, 3);
+  } else {
+    buf = Buffer.allocUnsafe(5 + len);
+    buf[0] = 0xdb;
+    buf.writeUInt32BE(len, 1);
+    buf.write(obj, 5);
+  }
+
+  return buf;
+}
+
+function getBufferHeader(length) {
+  var header;
+
+  if (length <= 0xff) {
+    header = Buffer.allocUnsafe(2);
+    header[0] = 0xc4;
+    header[1] = length;
+  } else if (length <= 0xffff) {
+    header = Buffer.allocUnsafe(3);
+    header[0] = 0xc5;
+    header.writeUInt16BE(length, 1);
+  } else {
+    header = Buffer.allocUnsafe(5);
+    header[0] = 0xc6;
+    header.writeUInt32BE(length, 1);
+  }
+
+  return header;
+}
+
+function encodeNumber(obj, options) {
+  var buf;
+  if (isFloat(obj)) return encodeFloat(obj, options.forceFloat64);
+
+  if (Math.abs(obj) > 9007199254740991) {
+    return encodeFloat(obj, true);
+  }
+
+  if (obj >= 0) {
+    if (obj < 128) {
+      return Buffer.from([obj]);
+    } else if (obj < 256) {
+      return Buffer.from([0xcc, obj]);
+    } else if (obj < 65536) {
+      return Buffer.from([0xcd, 0xff & obj >> 8, 0xff & obj]);
+    } else if (obj <= 0xffffffff) {
+      return Buffer.from([0xce, 0xff & obj >> 24, 0xff & obj >> 16, 0xff & obj >> 8, 0xff & obj]);
+    } else if (obj <= 9007199254740991) {
+      buf = Buffer.allocUnsafe(9);
+      buf[0] = 0xcf;
+      write64BitUint(buf, 1, obj);
+    }
+  } else {
+    if (obj >= -32) {
+      buf = Buffer.allocUnsafe(1);
+      buf[0] = 0x100 + obj;
+    } else if (obj >= -128) {
+      buf = Buffer.allocUnsafe(2);
+      buf[0] = 0xd0;
+      buf.writeInt8(obj, 1);
+    } else if (obj >= -32768) {
+      buf = Buffer.allocUnsafe(3);
+      buf[0] = 0xd1;
+      buf.writeInt16BE(obj, 1);
+    } else if (obj > -214748365) {
+      buf = Buffer.allocUnsafe(5);
+      buf[0] = 0xd2;
+      buf.writeInt32BE(obj, 1);
+    } else if (obj >= -9007199254740991) {
+      buf = Buffer.allocUnsafe(9);
+      buf[0] = 0xd3;
+      write64BitInt(buf, 1, obj);
+    }
+  }
+
+  return buf;
+}

package/es/framework/http/msgpack5/lib/helpers.js

@@ -0,0 +1,23 @@
+'use strict';
+
+import util from 'util'; // exports.IncompleteBufferError = IncompleteBufferError;
+
+export function IncompleteBufferError(message) {
+  Error.call(this); // super constructor
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor); // super helper method to include stack trace in error object
+  }
+
+  this.name = this.constructor.name;
+  this.message = message || 'unable to decode';
+}
+util.inherits(IncompleteBufferError, Error);
+export function isFloat(n) {
+  return n % 1 !== 0;
+}
+export function isNaN(n) {
+  /* eslint-disable no-self-compare */
+  return n !== n && typeof n === 'number';
+  /* eslint-enable no-self-compare */
+}