eservices-core 1.0.310 → 1.0.311

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
-  * eservices-core v1.0.310
+  * eservices-core v1.0.311
   * (c) 2022 ESERVICES
   */
 'use strict';
@@ -10,12 +10,10 @@ var vue = require('vue');
 var jenesiusVueModal = require('jenesius-vue-modal');
 var vueRouter = require('vue-router');
 var dateAndTime = require('date-and-time');
-var require$$0 = require('crypto');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var dateAndTime__default = /*#__PURE__*/_interopDefaultLegacy(dateAndTime);
-var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 
 var script$R = vue.defineComponent({
 	props: {
@@ -4723,464 +4721,426 @@ styleInject(css_248z$d);
 script$e.__scopeId = "data-v-476fe206";
 script$e.__file = "core/widgets/interface/interface-navigation-row.vue";
 
-var objectHash = {exports: {}};
+var lib = {exports: {}};
 
-(function (module, exports) {
+var util = {exports: {}};
 
-var crypto = require$$0__default["default"];
+(function (module) {
+const util = module.exports;
+
+util.digitCount = function digitCount (value) {
+  // Add a digit for negative numbers, as the sign will be prefixed
+  const sign = value < 0 ? 1 : 0;
+  // Guard against negative numbers & zero going into log10(),
+  // as that would return -Infinity
+  value = Math.abs(Number(value || 1));
+  return Math.floor(Math.log10(value)) + 1 + sign
+};
+
+util.getType = function getType (value) {
+  if (Buffer.isBuffer(value)) return 'buffer'
+  if (ArrayBuffer.isView(value)) return 'arraybufferview'
+  if (Array.isArray(value)) return 'array'
+  if (value instanceof Number) return 'number'
+  if (value instanceof Boolean) return 'boolean'
+  if (value instanceof Set) return 'set'
+  if (value instanceof Map) return 'map'
+  if (value instanceof String) return 'string'
+  if (value instanceof ArrayBuffer) return 'arraybuffer'
+  return typeof value
+};
+}(util));
+
+const { getType: getType$1 } = util.exports;
 
 /**
- * Exported function
- *
- * Options:
- *
- *  - `algorithm` hash algo to be used by this instance: *'sha1', 'md5'
- *  - `excludeValues` {true|*false} hash object keys, values ignored
- *  - `encoding` hash encoding, supports 'buffer', '*hex', 'binary', 'base64'
- *  - `ignoreUnknown` {true|*false} ignore unknown object types
- *  - `replacer` optional function that replaces values before hashing
- *  - `respectFunctionProperties` {*true|false} consider function properties when hashing
- *  - `respectFunctionNames` {*true|false} consider 'name' property of functions for hashing
- *  - `respectType` {*true|false} Respect special properties (prototype, constructor)
- *    when hashing to distinguish between types
- *  - `unorderedArrays` {true|*false} Sort all arrays before hashing
- *  - `unorderedSets` {*true|false} Sort `Set` and `Map` instances before hashing
- *  * = default
+ * Encodes data in bencode.
  *
- * @param {object} object value to hash
- * @param {object} options hashing options
- * @return {string} hash value
- * @api public
+ * @param  {Buffer|Array|String|Object|Number|Boolean} data
+ * @return {Buffer}
  */
-exports = module.exports = objectHash;
+function encode (data, buffer, offset) {
+  const buffers = [];
+  let result = null;
 
-function objectHash(object, options){
-  options = applyDefaults(object, options);
+  encode._encode(buffers, data);
+  result = Buffer.concat(buffers);
+  encode.bytes = result.length;
 
-  return hash(object, options);
+  if (Buffer.isBuffer(buffer)) {
+    result.copy(buffer, offset);
+    return buffer
+  }
+
+  return result
 }
 
-/**
- * Exported sugar methods
- *
- * @param {object} object value to hash
- * @return {string} hash value
- * @api public
- */
-exports.sha1 = function(object){
-  return objectHash(object);
+encode.bytes = -1;
+encode._floatConversionDetected = false;
+
+encode._encode = function (buffers, data) {
+  if (data == null) { return }
+
+  switch (getType$1(data)) {
+    case 'buffer': encode.buffer(buffers, data); break
+    case 'object': encode.dict(buffers, data); break
+    case 'map': encode.dictMap(buffers, data); break
+    case 'array': encode.list(buffers, data); break
+    case 'set': encode.listSet(buffers, data); break
+    case 'string': encode.string(buffers, data); break
+    case 'number': encode.number(buffers, data); break
+    case 'boolean': encode.number(buffers, data); break
+    case 'arraybufferview': encode.buffer(buffers, Buffer.from(data.buffer, data.byteOffset, data.byteLength)); break
+    case 'arraybuffer': encode.buffer(buffers, Buffer.from(data)); break
+  }
 };
-exports.keys = function(object){
-  return objectHash(object, {excludeValues: true, algorithm: 'sha1', encoding: 'hex'});
+
+const buffE = Buffer.from('e');
+const buffD = Buffer.from('d');
+const buffL = Buffer.from('l');
+
+encode.buffer = function (buffers, data) {
+  buffers.push(Buffer.from(data.length + ':'), data);
 };
-exports.MD5 = function(object){
-  return objectHash(object, {algorithm: 'md5', encoding: 'hex'});
+
+encode.string = function (buffers, data) {
+  buffers.push(Buffer.from(Buffer.byteLength(data) + ':' + data));
 };
-exports.keysMD5 = function(object){
-  return objectHash(object, {algorithm: 'md5', encoding: 'hex', excludeValues: true});
+
+encode.number = function (buffers, data) {
+  const maxLo = 0x80000000;
+  const hi = (data / maxLo) << 0;
+  const lo = (data % maxLo) << 0;
+  const val = hi * maxLo + lo;
+
+  buffers.push(Buffer.from('i' + val + 'e'));
+
+  if (val !== data && !encode._floatConversionDetected) {
+    encode._floatConversionDetected = true;
+    console.warn(
+      'WARNING: Possible data corruption detected with value "' + data + '":',
+      'Bencoding only defines support for integers, value was converted to "' + val + '"'
+    );
+    console.trace();
+  }
 };
 
-// Internals
-var hashes = crypto.getHashes ? crypto.getHashes().slice() : ['sha1', 'md5'];
-hashes.push('passthrough');
-var encodings = ['buffer', 'hex', 'binary', 'base64'];
-
-function applyDefaults(object, sourceOptions){
-  sourceOptions = sourceOptions || {};
-
-  // create a copy rather than mutating
-  var options = {};
-  options.algorithm = sourceOptions.algorithm || 'sha1';
-  options.encoding = sourceOptions.encoding || 'hex';
-  options.excludeValues = sourceOptions.excludeValues ? true : false;
-  options.algorithm = options.algorithm.toLowerCase();
-  options.encoding = options.encoding.toLowerCase();
-  options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true; // default to false
-  options.respectType = sourceOptions.respectType === false ? false : true; // default to true
-  options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
-  options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
-  options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true; // default to false
-  options.unorderedSets = sourceOptions.unorderedSets === false ? false : true; // default to false
-  options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true; // default to true
-  options.replacer = sourceOptions.replacer || undefined;
-  options.excludeKeys = sourceOptions.excludeKeys || undefined;
-
-  if(typeof object === 'undefined') {
-    throw new Error('Object argument required.');
+encode.dict = function (buffers, data) {
+  buffers.push(buffD);
+
+  let j = 0;
+  let k;
+  // fix for issue #13 - sorted dicts
+  const keys = Object.keys(data).sort();
+  const kl = keys.length;
+
+  for (; j < kl; j++) {
+    k = keys[j];
+    if (data[k] == null) continue
+    encode.string(buffers, k);
+    encode._encode(buffers, data[k]);
   }
 
-  // if there is a case-insensitive match in the hashes list, accept it
-  // (i.e. SHA256 for sha256)
-  for (var i = 0; i < hashes.length; ++i) {
-    if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
-      options.algorithm = hashes[i];
-    }
+  buffers.push(buffE);
+};
+
+encode.dictMap = function (buffers, data) {
+  buffers.push(buffD);
+
+  const keys = Array.from(data.keys()).sort();
+
+  for (const key of keys) {
+    if (data.get(key) == null) continue
+    Buffer.isBuffer(key)
+      ? encode._encode(buffers, key)
+      : encode.string(buffers, String(key));
+    encode._encode(buffers, data.get(key));
+  }
+
+  buffers.push(buffE);
+};
+
+encode.list = function (buffers, data) {
+  let i = 0;
+  const c = data.length;
+  buffers.push(buffL);
+
+  for (; i < c; i++) {
+    if (data[i] == null) continue
+    encode._encode(buffers, data[i]);
   }
 
-  if(hashes.indexOf(options.algorithm) === -1){
-    throw new Error('Algorithm "' + options.algorithm + '"  not supported. ' +
-      'supported values: ' + hashes.join(', '));
+  buffers.push(buffE);
+};
+
+encode.listSet = function (buffers, data) {
+  buffers.push(buffL);
+
+  for (const item of data) {
+    if (item == null) continue
+    encode._encode(buffers, item);
   }
 
-  if(encodings.indexOf(options.encoding) === -1 &&
-     options.algorithm !== 'passthrough'){
-    throw new Error('Encoding "' + options.encoding + '"  not supported. ' +
-      'supported values: ' + encodings.join(', '));
+  buffers.push(buffE);
+};
+
+var encode_1 = encode;
+
+const INTEGER_START = 0x69; // 'i'
+const STRING_DELIM = 0x3A; // ':'
+const DICTIONARY_START = 0x64; // 'd'
+const LIST_START = 0x6C; // 'l'
+const END_OF_TYPE = 0x65; // 'e'
+
+/**
+ * replaces parseInt(buffer.toString('ascii', start, end)).
+ * For strings with less then ~30 charachters, this is actually a lot faster.
+ *
+ * @param {Buffer} data
+ * @param {Number} start
+ * @param {Number} end
+ * @return {Number} calculated number
+ */
+function getIntFromBuffer (buffer, start, end) {
+  let sum = 0;
+  let sign = 1;
+
+  for (let i = start; i < end; i++) {
+    const num = buffer[i];
+
+    if (num < 58 && num >= 48) {
+      sum = sum * 10 + (num - 48);
+      continue
+    }
+
+    if (i === start && num === 43) { // +
+      continue
+    }
+
+    if (i === start && num === 45) { // -
+      sign = -1;
+      continue
+    }
+
+    if (num === 46) { // .
+      // its a float. break here.
+      break
+    }
+
+    throw new Error('not a number: buffer[' + i + '] = ' + num)
   }
 
-  return options;
+  return sum * sign
 }
 
-/** Check if the given function is a native function */
-function isNativeFunction(f) {
-  if ((typeof f) !== 'function') {
-    return false;
+/**
+ * Decodes bencoded data.
+ *
+ * @param  {Buffer} data
+ * @param  {Number} start (optional)
+ * @param  {Number} end (optional)
+ * @param  {String} encoding (optional)
+ * @return {Object|Array|Buffer|String|Number}
+ */
+function decode (data, start, end, encoding) {
+  if (data == null || data.length === 0) {
+    return null
+  }
+
+  if (typeof start !== 'number' && encoding == null) {
+    encoding = start;
+    start = undefined;
+  }
+
+  if (typeof end !== 'number' && encoding == null) {
+    encoding = end;
+    end = undefined;
   }
-  var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
-  return exp.exec(Function.prototype.toString.call(f)) != null;
+
+  decode.position = 0;
+  decode.encoding = encoding || null;
+
+  decode.data = !(Buffer.isBuffer(data))
+    ? Buffer.from(data)
+    : data.slice(start, end);
+
+  decode.bytes = decode.data.length;
+
+  return decode.next()
 }
 
-function hash(object, options) {
-  var hashingStream;
+decode.bytes = 0;
+decode.position = 0;
+decode.data = null;
+decode.encoding = null;
+
+decode.next = function () {
+  switch (decode.data[decode.position]) {
+    case DICTIONARY_START:
+      return decode.dictionary()
+    case LIST_START:
+      return decode.list()
+    case INTEGER_START:
+      return decode.integer()
+    default:
+      return decode.buffer()
+  }
+};
 
-  if (options.algorithm !== 'passthrough') {
-    hashingStream = crypto.createHash(options.algorithm);
-  } else {
-    hashingStream = new PassThrough();
+decode.find = function (chr) {
+  let i = decode.position;
+  const c = decode.data.length;
+  const d = decode.data;
+
+  while (i < c) {
+    if (d[i] === chr) return i
+    i++;
   }
 
-  if (typeof hashingStream.write === 'undefined') {
-    hashingStream.write = hashingStream.update;
-    hashingStream.end   = hashingStream.update;
+  throw new Error(
+    'Invalid data: Missing delimiter "' +
+    String.fromCharCode(chr) + '" [0x' +
+    chr.toString(16) + ']'
+  )
+};
+
+decode.dictionary = function () {
+  decode.position++;
+
+  const dict = {};
+
+  while (decode.data[decode.position] !== END_OF_TYPE) {
+    dict[decode.buffer()] = decode.next();
   }
 
-  var hasher = typeHasher(options, hashingStream);
-  hasher.dispatch(object);
-  if (!hashingStream.update) {
-    hashingStream.end('');
+  decode.position++;
+
+  return dict
+};
+
+decode.list = function () {
+  decode.position++;
+
+  const lst = [];
+
+  while (decode.data[decode.position] !== END_OF_TYPE) {
+    lst.push(decode.next());
   }
 
-  if (hashingStream.digest) {
-    return hashingStream.digest(options.encoding === 'buffer' ? undefined : options.encoding);
+  decode.position++;
+
+  return lst
+};
+
+decode.integer = function () {
+  const end = decode.find(END_OF_TYPE);
+  const number = getIntFromBuffer(decode.data, decode.position + 1, end);
+
+  decode.position += end + 1 - decode.position;
+
+  return number
+};
+
+decode.buffer = function () {
+  let sep = decode.find(STRING_DELIM);
+  const length = getIntFromBuffer(decode.data, decode.position, sep);
+  const end = ++sep + length;
+
+  decode.position = end;
+
+  return decode.encoding
+    ? decode.data.toString(decode.encoding, sep, end)
+    : decode.data.slice(sep, end)
+};
+
+var decode_1 = decode;
+
+const { digitCount, getType } = util.exports;
+
+function listLength (list) {
+  let length = 1 + 1; // type marker + end-of-type marker
+
+  for (const value of list) {
+    length += encodingLength(value);
   }
 
-  var buf = hashingStream.read();
-  if (options.encoding === 'buffer') {
-    return buf;
+  return length
+}
+
+function mapLength (map) {
+  let length = 1 + 1; // type marker + end-of-type marker
+
+  for (const [key, value] of map) {
+    const keyLength = Buffer.byteLength(key);
+    length += digitCount(keyLength) + 1 + keyLength;
+    length += encodingLength(value);
   }
 
-  return buf.toString(options.encoding);
+  return length
 }
 
-/**
- * Expose streaming API
- *
- * @param {object} object  Value to serialize
- * @param {object} options  Options, as for hash()
- * @param {object} stream  A stream to write the serializiation to
- * @api public
- */
-exports.writeToStream = function(object, options, stream) {
-  if (typeof stream === 'undefined') {
-    stream = options;
-    options = {};
+function objectLength (value) {
+  let length = 1 + 1; // type marker + end-of-type marker
+  const keys = Object.keys(value);
+
+  for (let i = 0; i < keys.length; i++) {
+    const keyLength = Buffer.byteLength(keys[i]);
+    length += digitCount(keyLength) + 1 + keyLength;
+    length += encodingLength(value[keys[i]]);
   }
 
-  options = applyDefaults(object, options);
+  return length
+}
 
-  return typeHasher(options, stream).dispatch(object);
-};
+function stringLength (value) {
+  const length = Buffer.byteLength(value);
+  return digitCount(length) + 1 + length
+}
 
-function typeHasher(options, writeTo, context){
-  context = context || [];
-  var write = function(str) {
-    if (writeTo.update) {
-      return writeTo.update(str, 'utf8');
-    } else {
-      return writeTo.write(str, 'utf8');
-    }
-  };
-
-  return {
-    dispatch: function(value){
-      if (options.replacer) {
-        value = options.replacer(value);
-      }
-
-      var type = typeof value;
-      if (value === null) {
-        type = 'null';
-      }
-
-      //console.log("[DEBUG] Dispatch: ", value, "->", type, " -> ", "_" + type);
-
-      return this['_' + type](value);
-    },
-    _object: function(object) {
-      var pattern = (/\[object (.*)\]/i);
-      var objString = Object.prototype.toString.call(object);
-      var objType = pattern.exec(objString);
-      if (!objType) { // object type did not match [object ...]
-        objType = 'unknown:[' + objString + ']';
-      } else {
-        objType = objType[1]; // take only the class name
-      }
-
-      objType = objType.toLowerCase();
-
-      var objectNumber = null;
-
-      if ((objectNumber = context.indexOf(object)) >= 0) {
-        return this.dispatch('[CIRCULAR:' + objectNumber + ']');
-      } else {
-        context.push(object);
-      }
-
-      if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(object)) {
-        write('buffer:');
-        return write(object);
-      }
-
-      if(objType !== 'object' && objType !== 'function' && objType !== 'asyncfunction') {
-        if(this['_' + objType]) {
-          this['_' + objType](object);
-        } else if (options.ignoreUnknown) {
-          return write('[' + objType + ']');
-        } else {
-          throw new Error('Unknown object type "' + objType + '"');
-        }
-      }else {
-        var keys = Object.keys(object);
-        if (options.unorderedObjects) {
-          keys = keys.sort();
-        }
-        // Make sure to incorporate special properties, so
-        // Types with different prototypes will produce
-        // a different hash and objects derived from
-        // different functions (`new Foo`, `new Bar`) will
-        // produce different hashes.
-        // We never do this for native functions since some
-        // seem to break because of that.
-        if (options.respectType !== false && !isNativeFunction(object)) {
-          keys.splice(0, 0, 'prototype', '__proto__', 'constructor');
-        }
-
-        if (options.excludeKeys) {
-          keys = keys.filter(function(key) { return !options.excludeKeys(key); });
-        }
-
-        write('object:' + keys.length + ':');
-        var self = this;
-        return keys.forEach(function(key){
-          self.dispatch(key);
-          write(':');
-          if(!options.excludeValues) {
-            self.dispatch(object[key]);
-          }
-          write(',');
-        });
-      }
-    },
-    _array: function(arr, unordered){
-      unordered = typeof unordered !== 'undefined' ? unordered :
-        options.unorderedArrays !== false; // default to options.unorderedArrays
-
-      var self = this;
-      write('array:' + arr.length + ':');
-      if (!unordered || arr.length <= 1) {
-        return arr.forEach(function(entry) {
-          return self.dispatch(entry);
-        });
-      }
-
-      // the unordered case is a little more complicated:
-      // since there is no canonical ordering on objects,
-      // i.e. {a:1} < {a:2} and {a:1} > {a:2} are both false,
-      // we first serialize each entry using a PassThrough stream
-      // before sorting.
-      // also: we can’t use the same context array for all entries
-      // since the order of hashing should *not* matter. instead,
-      // we keep track of the additions to a copy of the context array
-      // and add all of them to the global context array when we’re done
-      var contextAdditions = [];
-      var entries = arr.map(function(entry) {
-        var strm = new PassThrough();
-        var localContext = context.slice(); // make copy
-        var hasher = typeHasher(options, strm, localContext);
-        hasher.dispatch(entry);
-        // take only what was added to localContext and append it to contextAdditions
-        contextAdditions = contextAdditions.concat(localContext.slice(context.length));
-        return strm.read().toString();
-      });
-      context = context.concat(contextAdditions);
-      entries.sort();
-      return this._array(entries, false);
-    },
-    _date: function(date){
-      return write('date:' + date.toJSON());
-    },
-    _symbol: function(sym){
-      return write('symbol:' + sym.toString());
-    },
-    _error: function(err){
-      return write('error:' + err.toString());
-    },
-    _boolean: function(bool){
-      return write('bool:' + bool.toString());
-    },
-    _string: function(string){
-      write('string:' + string.length + ':');
-      write(string.toString());
-    },
-    _function: function(fn){
-      write('fn:');
-      if (isNativeFunction(fn)) {
-        this.dispatch('[native]');
-      } else {
-        this.dispatch(fn.toString());
-      }
-
-      if (options.respectFunctionNames !== false) {
-        // Make sure we can still distinguish native functions
-        // by their name, otherwise String and Function will
-        // have the same hash
-        this.dispatch("function-name:" + String(fn.name));
-      }
-
-      if (options.respectFunctionProperties) {
-        this._object(fn);
-      }
-    },
-    _number: function(number){
-      return write('number:' + number.toString());
-    },
-    _xml: function(xml){
-      return write('xml:' + xml.toString());
-    },
-    _null: function() {
-      return write('Null');
-    },
-    _undefined: function() {
-      return write('Undefined');
-    },
-    _regexp: function(regex){
-      return write('regex:' + regex.toString());
-    },
-    _uint8array: function(arr){
-      write('uint8array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _uint8clampedarray: function(arr){
-      write('uint8clampedarray:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _int8array: function(arr){
-      write('int8array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _uint16array: function(arr){
-      write('uint16array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _int16array: function(arr){
-      write('int16array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _uint32array: function(arr){
-      write('uint32array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _int32array: function(arr){
-      write('int32array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _float32array: function(arr){
-      write('float32array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _float64array: function(arr){
-      write('float64array:');
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _arraybuffer: function(arr){
-      write('arraybuffer:');
-      return this.dispatch(new Uint8Array(arr));
-    },
-    _url: function(url) {
-      return write('url:' + url.toString());
-    },
-    _map: function(map) {
-      write('map:');
-      var arr = Array.from(map);
-      return this._array(arr, options.unorderedSets !== false);
-    },
-    _set: function(set) {
-      write('set:');
-      var arr = Array.from(set);
-      return this._array(arr, options.unorderedSets !== false);
-    },
-    _file: function(file) {
-      write('file:');
-      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
-    },
-    _blob: function() {
-      if (options.ignoreUnknown) {
-        return write('[blob]');
-      }
-
-      throw Error('Hashing Blob objects is currently not supported\n' +
-        '(see https://github.com/puleos/object-hash/issues/26)\n' +
-        'Use "options.replacer" or "options.ignoreUnknown"\n');
-    },
-    _domwindow: function() { return write('domwindow'); },
-    _bigint: function(number){
-      return write('bigint:' + number.toString());
-    },
-    /* Node.js standard native objects */
-    _process: function() { return write('process'); },
-    _timer: function() { return write('timer'); },
-    _pipe: function() { return write('pipe'); },
-    _tcp: function() { return write('tcp'); },
-    _udp: function() { return write('udp'); },
-    _tty: function() { return write('tty'); },
-    _statwatcher: function() { return write('statwatcher'); },
-    _securecontext: function() { return write('securecontext'); },
-    _connection: function() { return write('connection'); },
-    _zlib: function() { return write('zlib'); },
-    _context: function() { return write('context'); },
-    _nodescript: function() { return write('nodescript'); },
-    _httpparser: function() { return write('httpparser'); },
-    _dataview: function() { return write('dataview'); },
-    _signal: function() { return write('signal'); },
-    _fsevent: function() { return write('fsevent'); },
-    _tlswrap: function() { return write('tlswrap'); },
-  };
+function arrayBufferLength (value) {
+  const length = value.byteLength - value.byteOffset;
+  return digitCount(length) + 1 + length
 }
 
-// Mini-implementation of stream.PassThrough
-// We are far from having need for the full implementation, and we can
-// make assumptions like "many writes, then only one final read"
-// and we can ignore encoding specifics
-function PassThrough() {
-  return {
-    buf: '',
+function encodingLength (value) {
+  const length = 0;
 
-    write: function(b) {
-      this.buf += b;
-    },
+  if (value == null) return length
 
-    end: function(b) {
-      this.buf += b;
-    },
+  const type = getType(value);
 
-    read: function() {
-      return this.buf;
-    }
-  };
+  switch (type) {
+    case 'buffer': return digitCount(value.length) + 1 + value.length
+    case 'arraybufferview': return arrayBufferLength(value)
+    case 'string': return stringLength(value)
+    case 'array': case 'set': return listLength(value)
+    case 'number': return 1 + digitCount(Math.floor(value)) + 1
+    case 'bigint': return 1 + value.toString().length + 1
+    case 'object': return objectLength(value)
+    case 'map': return mapLength(value)
+    default:
+      throw new TypeError(`Unsupported value of type "${type}"`)
+  }
 }
-}(objectHash, objectHash.exports));
 
-var hash = objectHash.exports;
+var encodingLength_1 = encodingLength;
+
+(function (module) {
+const bencode = module.exports;
+
+bencode.encode = encode_1;
+bencode.decode = decode_1;
+
+/**
+ * Determines the amount of bytes
+ * needed to encode the given value
+ * @param  {Object|Array|Buffer|String|Number|Boolean} value
+ * @return {Number} byteCount
+ */
+bencode.byteLength = bencode.encodingLength = encodingLength_1;
+}(lib));
+
+var bencode = lib.exports;
 
 const _hoisted_1$d = { class: "" };
 var script$d = /*#__PURE__*/ vue.defineComponent({
@@ -5194,7 +5154,7 @@ var script$d = /*#__PURE__*/ vue.defineComponent({
          * объекта.
          * */
         const parsedConfig = vue.computed(() => props.config.map(elem => {
-            return Object.assign(Object.assign({}, elem), { hash: hash(elem).toString() });
+            return Object.assign(Object.assign({}, elem), { hash: bencode.encode(elem).toString() });
         }));
         vue.reactive({
             activeRow: null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eservices-core",
-  "version": "1.0.310",
+  "version": "1.0.311",
   "description": "----",
   "author": "",
   "scripts": {
@@ -16,9 +16,9 @@
   "main": "dist/index.js",
   "dependencies": {
     "@rollup/plugin-commonjs": "^21.0.1",
+    "bencode": "^2.0.3",
     "date-and-time": "^2.0.1",
     "jenesius-event-emitter": "^1.0.4",
-    "object-hash": "^3.0.0",
     "rollup-plugin-styles": "^4.0.0",
     "rollup-plugin-typescript2": "^0.31.1",
     "socket.io": "^4.4.1",
@@ -30,6 +30,7 @@
     "@babel/preset-typescript": "^7.16.5",
     "@rollup/plugin-node-resolve": "^13.1.3",
     "@rollup/plugin-typescript": "^8.3.0",
+    "@types/bencode": "^2.0.1",
     "@types/date-and-time": "^0.13.0",
     "@types/jest": "^24.9.1",
     "@types/object-hash": "^2.2.1",