text: function _arrayLikeToArray(arr, len) {
      (null == len || len > arr.length) && (len = arr.length);
      for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
      return arr2;
  }
  function _arrayWithHoles(arr) {
      if (Array.isArray(arr)) return arr;
  }
  function _extends() {
      return (_extends = Object.assign || function(target) {
          for(var i = 1; i < arguments.length; i++){
              var source = arguments[i];
              for(var key in source)Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
          }
          return target;
      }).apply(this, arguments);
  }
  function _nonIterableRest() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  function _slicedToArray(arr, i) {
      return _arrayWithHoles(arr) || (function(arr, i) {
          var _s, _e, _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
          if (null != _i) {
              var _arr = [], _n = !0, _d = !1;
              try {
                  for(_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !i || _arr.length !== i); _n = !0);
              } catch (err) {
                  _d = !0, _e = err;
              } finally{
                  try {
                      _n || null == _i.return || _i.return();
                  } finally{
                      if (_d) throw _e;
                  }
              }
              return _arr;
          }
      })(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
  }
  function _toArray(arr) {
      return _arrayWithHoles(arr) || (function(iter) {
          if ("undefined" != typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) return Array.from(iter);
      })(arr) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
  }
  function _unsupportedIterableToArray(o, minLen) {
      if (o) {
          if ("string" == typeof o) return _arrayLikeToArray(o, minLen);
          var n = Object.prototype.toString.call(o).slice(8, -1);
          if ("Object" === n && o.constructor && (n = o.constructor.name), "Map" === n || "Set" === n) return Array.from(n);
          if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
      }
  }
  _slicedToArray(strArray, 1)[0].toString(), _toArray(strArray).slice(0).push(void 0), _toArray(strArray).slice(2).push(void 0), strMap.t1.toString(), _extends({}, strMap).z.toString();
  var ref, x = numMapPoint.x, y = numMapPoint.y, z = numMapPoint.z;
  x.toFixed(), y.toFixed(), z.toFixed();
  var x1 = numMapPoint.x, q = function(source, excluded) {
      if (null == source) return {};
      var key, i, target = function(source, excluded) {
          if (null == source) return {};
          var key, i, target = {}, sourceKeys = Object.keys(source);
          for(i = 0; i < sourceKeys.length; i++)key = sourceKeys[i], excluded.indexOf(key) >= 0 || (target[key] = source[key]);
          return target;
      }(source, excluded);
      if (Object.getOwnPropertySymbols) {
          var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
          for(i = 0; i < sourceSymbolKeys.length; i++)key = sourceSymbolKeys[i], excluded.indexOf(key) >= 0 || Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
      }
      return target;
  }(numMapPoint, [
      "x"
  ]);
  x1.toFixed(), q.y.toFixed(), q.z.toFixed(), target_string = _slicedToArray(strArray, 1)[0], target_string_undef = _slicedToArray(strArray, 1)[0], target_string_arr = _toArray(strArray).slice(3), (ref = numMapPoint).x, ref.y, ref.z, numMapPoint.q;
  