ronds-metadata 1.2.9 → 1.2.10

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

@@ -1,71 +0,0 @@
-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

@@ -1,287 +0,0 @@
-'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

@@ -1,252 +0,0 @@
-'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

@@ -1,23 +0,0 @@
-'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 */
-}