@graffy/common/cjs/coding/struct.js

Common libraries that used by various Graffy modules.

"use strict";

var _sliceInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/slice");

var _Array$from = require("@babel/runtime-corejs3/core-js-stable/array/from");

var _Symbol = require("@babel/runtime-corejs3/core-js-stable/symbol");

var _getIteratorMethod = require("@babel/runtime-corejs3/core-js/get-iterator-method");

var _Array$isArray2 = require("@babel/runtime-corejs3/core-js-stable/array/is-array");

var _getIterator = require("@babel/runtime-corejs3/core-js/get-iterator");

var _bindInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/bind");

var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");

exports.__esModule = true;
exports.encode = encode;
exports.decode = decode;
exports.OBJ = exports.ARR = void 0;

var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));

var _flatMap = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/flat-map"));

var _sort = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/sort"));

var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));

var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));

var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));

var _weakMap = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/weak-map"));

var _string = require("./string.js");

var _number = require("./number.js");

var _base = require("./base64.js");

function _createForOfIteratorHelperLoose(o, allowArrayLike) { var _context6; var it; if (typeof _Symbol === "undefined" || _getIteratorMethod(o) == null) { if (_Array$isArray2(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = _getIterator(o); return _bindInstanceProperty(_context6 = it.next).call(_context6, it); }

function _unsupportedIterableToArray(o, minLen) { var _context5; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty(_context5 = Object.prototype.toString.call(o)).call(_context5, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var END = 0;
var NULL = 1;
var FALSE = 2;
var TRUE = 3;
var NUM = 4;
var STR = 5;
var ARR = 6;
exports.ARR = ARR;
var OBJ = 7;
exports.OBJ = OBJ;

function encodeArray(array) {
  var _context;

  return (0, _concat.default)(_context = [ARR]).call(_context, (0, _flatMap.default)(array).call(array, function (value) {
    return encodeParts(value);
  }), [END]);
}

function encodeObject(object) {
  var _context2, _context3;

  var keys = (0, _sort.default)(_context2 = (0, _keys.default)(object)).call(_context2);
  return (0, _concat.default)(_context3 = [OBJ]).call(_context3, (0, _flatMap.default)(keys).call(keys, function (key) {
    var _context4;

    return (0, _concat.default)(_context4 = [STR, (0, _string.encode)(key), END]).call(_context4, encodeParts(object[key]));
  }), [END]);
}

function encodeParts(value) {
  if (value === null) return [NULL];
  if (value === false) return [FALSE];
  if (value === true) return [TRUE];
  if (typeof value === 'number') return [NUM, (0, _number.encode)(value)];
  if (typeof value === 'string') return [STR, (0, _string.encode)(value), END];
  if ((0, _isArray.default)(value)) return encodeArray(value);
  if (typeof value === 'object') return encodeObject(value);
  return [NULL];
}

function encode(value) {
  var parts = encodeParts(value);

  while (parts[parts.length - 1] === END) {
    parts.pop();
  }

  var length = (0, _reduce.default)(parts).call(parts, function (sum, part) {
    return sum + (typeof part === 'number' ? 1 : part.length);
  }, 0);
  var buffer = new Uint8Array(length);
  var i = 0;

  for (var _iterator = _createForOfIteratorHelperLoose(parts), _step; !(_step = _iterator()).done;) {
    var part = _step.value;

    if (typeof part === 'number') {
      buffer[i] = part;
      i++;
    } else {
      buffer.set(part, i);
      i += part.length;
    }
  }

  return (0, _base.encode)(buffer);
}

var nextKey = new _weakMap.default();

function decode(key) {
  var i = 0;
  var buffer = (0, _base.decode)(key, 0);
  /** @type {Array<{ [prop: string]: any }|Array>} */

  var stack = [[]];

  function readString() {
    var start = i;

    while (i < buffer.length && buffer[i] !== END) {
      i++;
    }

    var str = (0, _string.decode)(buffer.subarray(start, i));
    i++;
    return str;
  }

  function pushToken(type, value) {
    var current = stack[stack.length - 1];
    if (type === ARR || type === OBJ) stack.push(value);
    if (!current) return;

    if ((0, _isArray.default)(current)) {
      current.push(value);
    } else {
      if (nextKey.has(current)) {
        current[nextKey.get(current)] = value;
        nextKey.delete(current);
      } else {
        nextKey.set(current, value);
      }
    }
  }

  function popToken() {
    stack.pop();
  }

  while (i < buffer.length) {
    var type = buffer[i];
    var start = ++i;

    switch (type) {
      case END:
        popToken();
        break;

      case NULL:
        pushToken(type, null);
        break;

      case FALSE:
        pushToken(type, false);
        break;

      case TRUE:
        pushToken(type, true);
        break;

      case NUM:
        i += 8;
        pushToken(type, (0, _number.decode)(buffer.subarray(start, i)));
        break;

      case STR:
        pushToken(type, readString());
        break;

      case ARR:
        pushToken(type, []);
        break;

      case OBJ:
        pushToken(type, {});
        break;

      default:
        throw new Error('Invalid byte ' + type + ' at ' + start);
    }
  }

  return stack[0][0];
}