swagger-client 3.10.13 → 3.12.1

package/es/specmap/helpers.js

@@ -1,7 +1,13 @@
-import _slicedToArray from "@babel/runtime-corejs2/helpers/slicedToArray";
-import _toConsumableArray from "@babel/runtime-corejs2/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
+import _toConsumableArray from "@babel/runtime-corejs3/helpers/toConsumableArray";
+import _someInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/some";
+import _indexOfInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/index-of";
 import traverse from 'traverse';
-import URL from 'url'; // This will match if the direct parent's key exactly matches an item.
+import URL from 'url';
+import isString from 'lodash/isString'; // This will match if the direct parent's key exactly matches an item.
 
 var freelyNamedKeyParents = ['properties']; // This will match if the grandparent's key exactly matches an item.
 // NOTE that this is for finding non-free paths!
@@ -24,39 +30,48 @@ export function isFreelyNamed(parentPath) {
   var grandparentKey = parentPath[parentPath.length - 2];
   var parentStr = parentPath.join('/');
   return (// eslint-disable-next-line max-len
-    freelyNamedKeyParents.indexOf(parentKey) > -1 && nonFreelyNamedKeyGrandparents.indexOf(grandparentKey) === -1 || freelyNamedPaths.indexOf(parentStr) > -1 || freelyNamedAncestors.some(function (el) {
-      return parentStr.indexOf(el) > -1;
+    _indexOfInstanceProperty(freelyNamedKeyParents).call(freelyNamedKeyParents, parentKey) > -1 && _indexOfInstanceProperty(nonFreelyNamedKeyGrandparents).call(nonFreelyNamedKeyGrandparents, grandparentKey) === -1 || _indexOfInstanceProperty(freelyNamedPaths).call(freelyNamedPaths, parentStr) > -1 || _someInstanceProperty(freelyNamedAncestors).call(freelyNamedAncestors, function (el) {
+      return _indexOfInstanceProperty(parentStr).call(parentStr, el) > -1;
     })
   );
 }
 export function generateAbsoluteRefPatches(obj, basePath) {
+  var _context2;
+
   var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
       specmap = _ref.specmap,
       _ref$getBaseUrlForNod = _ref.getBaseUrlForNodePath,
       getBaseUrlForNodePath = _ref$getBaseUrlForNod === void 0 ? function (path) {
-    return specmap.getContext([].concat(_toConsumableArray(basePath), _toConsumableArray(path))).baseDoc;
+    var _context;
+
+    return specmap.getContext(_concatInstanceProperty(_context = []).call(_context, _toConsumableArray(basePath), _toConsumableArray(path))).baseDoc;
   } : _ref$getBaseUrlForNod,
       _ref$targetKeys = _ref.targetKeys,
       targetKeys = _ref$targetKeys === void 0 ? ['$ref', '$$ref'] : _ref$targetKeys;
 
   var patches = [];
-  traverse(obj).forEach(function callback() {
-    if (targetKeys.indexOf(this.key) > -1) {
+
+  _forEachInstanceProperty(_context2 = traverse(obj)).call(_context2, function callback() {
+    if (_includesInstanceProperty(targetKeys).call(targetKeys, this.key) && isString(this.node)) {
       var nodePath = this.path; // this node's path, relative to `obj`
 
-      var fullPath = basePath.concat(this.path);
+      var fullPath = _concatInstanceProperty(basePath).call(basePath, this.path);
+
       var absolutifiedRefValue = absolutifyPointer(this.node, getBaseUrlForNodePath(nodePath));
       patches.push(specmap.replace(fullPath, absolutifiedRefValue));
     }
   });
+
   return patches;
 }
 export function absolutifyPointer(pointer, baseUrl) {
+  var _context3;
+
   var _pointer$split = pointer.split('#'),
       _pointer$split2 = _slicedToArray(_pointer$split, 2),
       urlPart = _pointer$split2[0],
       fragmentPart = _pointer$split2[1];
 
   var newRefUrlPart = URL.resolve(urlPart || '', baseUrl || '');
-  return fragmentPart ? "".concat(newRefUrlPart, "#").concat(fragmentPart) : newRefUrlPart;
+  return fragmentPart ? _concatInstanceProperty(_context3 = "".concat(newRefUrlPart, "#")).call(_context3, fragmentPart) : newRefUrlPart;
 }

package/es/specmap/index.js

@@ -1,14 +1,23 @@
-import _objectSpread from "@babel/runtime-corejs2/helpers/objectSpread2";
-import _typeof from "@babel/runtime-corejs2/helpers/typeof";
-import _Promise from "@babel/runtime-corejs2/core-js/promise";
-import _regeneratorRuntime from "@babel/runtime-corejs2/regenerator";
-import _Object$keys2 from "@babel/runtime-corejs2/core-js/object/keys";
-import _createForOfIteratorHelper from "@babel/runtime-corejs2/helpers/createForOfIteratorHelper";
-import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
-import _Object$create from "@babel/runtime-corejs2/core-js/object/create";
-import _Object$assign from "@babel/runtime-corejs2/core-js/object/assign";
-import _classCallCheck from "@babel/runtime-corejs2/helpers/classCallCheck";
-import _createClass from "@babel/runtime-corejs2/helpers/createClass";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/slice";
+import _spliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/splice";
+import _objectSpread from "@babel/runtime-corejs3/helpers/objectSpread2";
+import _typeof from "@babel/runtime-corejs3/helpers/typeof";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
+import _Promise from "@babel/runtime-corejs3/core-js-stable/promise";
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import _Object$keys2 from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _indexOfInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/index-of";
+import _createForOfIteratorHelper from "@babel/runtime-corejs3/helpers/createForOfIteratorHelper";
+import _everyInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/every";
+import _Array$isArray from "@babel/runtime-corejs3/core-js-stable/array/is-array";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
+import _bindInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/bind";
+import _Object$create from "@babel/runtime-corejs3/core-js-stable/object/create";
+import _Object$assign from "@babel/runtime-corejs3/core-js-stable/object/assign";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
+import _classCallCheck from "@babel/runtime-corejs3/helpers/classCallCheck";
+import _createClass from "@babel/runtime-corejs3/helpers/createClass";
 import find from 'lodash/find';
 import noop from 'lodash/noop';
 import lib from './lib';
@@ -28,12 +37,18 @@ var SpecMap = /*#__PURE__*/function () {
   }, {
     key: "getPatchesOfType",
     value: function getPatchesOfType(patches, fn) {
-      return patches.filter(fn);
+      return _filterInstanceProperty(patches).call(patches, fn);
     }
   }]);
 
   function SpecMap(opts) {
-    var _this = this;
+    var _this = this,
+        _context,
+        _context2,
+        _context3,
+        _context4,
+        _context5,
+        _context6;
 
     _classCallCheck(this, SpecMap);
 
@@ -62,13 +77,13 @@ var SpecMap = /*#__PURE__*/function () {
     }, opts); // Lib methods bound
 
 
-    this.get = this._get.bind(this); // eslint-disable-line no-underscore-dangle
+    this.get = _bindInstanceProperty(_context = this._get).call(_context, this); // eslint-disable-line no-underscore-dangle
 
-    this.getContext = this._getContext.bind(this); // eslint-disable-line no-underscore-dangle
+    this.getContext = _bindInstanceProperty(_context2 = this._getContext).call(_context2, this); // eslint-disable-line no-underscore-dangle
 
-    this.hasRun = this._hasRun.bind(this); // eslint-disable-line no-underscore-dangle
+    this.hasRun = _bindInstanceProperty(_context3 = this._hasRun).call(_context3, this); // eslint-disable-line no-underscore-dangle
 
-    this.wrappedPlugins = this.plugins.map(this.wrapPlugin.bind(this)).filter(lib.isFunction); // Initial patch(s)
+    this.wrappedPlugins = _filterInstanceProperty(_context4 = _mapInstanceProperty(_context5 = this.plugins).call(_context5, _bindInstanceProperty(_context6 = this.wrapPlugin).call(_context6, this))).call(_context4, lib.isFunction); // Initial patch(s)
 
     this.patches.push(lib.add([], this.spec));
     this.patches.push(lib.context([], this.context));
@@ -93,13 +108,13 @@ var SpecMap = /*#__PURE__*/function () {
     key: "verbose",
     value: function verbose(header) {
       if (this.debugLevel === 'verbose') {
-        var _console2;
+        var _console2, _context7;
 
         for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
           args[_key2 - 1] = arguments[_key2];
         }
 
-        (_console2 = console).log.apply(_console2, ["[".concat(header, "]   ")].concat(args)); // eslint-disable-line no-console
+        (_console2 = console).log.apply(_console2, _concatInstanceProperty(_context7 = ["[".concat(header, "]   ")]).call(_context7, args)); // eslint-disable-line no-console
 
       }
     }
@@ -119,7 +134,7 @@ var SpecMap = /*#__PURE__*/function () {
         fn = createKeyBasedPlugin(plugin);
       }
 
-      return _Object$assign(fn.bind(ctx), {
+      return _Object$assign(_bindInstanceProperty(fn).call(fn, ctx), {
         pluginName: plugin.name || name,
         isGenerator: lib.isGenerator(fn)
       }); // Expected plugin interface: {key: string, plugin: fn*}
@@ -133,7 +148,7 @@ var SpecMap = /*#__PURE__*/function () {
             return true;
           }
 
-          return path.every(function (val, i) {
+          return _everyInstanceProperty(path).call(path, function (val, i) {
             return val === tested[i];
           });
         };
@@ -141,38 +156,38 @@ var SpecMap = /*#__PURE__*/function () {
         return /*#__PURE__*/_regeneratorRuntime.mark(function generator(patches, specmap) {
           var _marked, refCache, _iterator, _step, patch, traverse;
 
-          return _regeneratorRuntime.wrap(function generator$(_context2) {
+          return _regeneratorRuntime.wrap(function generator$(_context9) {
             while (1) {
-              switch (_context2.prev = _context2.next) {
+              switch (_context9.prev = _context9.next) {
                 case 0:
                   traverse = function _traverse(obj, path, patch) {
                     var parentIndex, parent, indexOfFirstProperties, isRootProperties, traversed, _i, _Object$keys, key, val, updatedPath, isObj, objRef, isWithinPathDiscriminator;
 
-                    return _regeneratorRuntime.wrap(function traverse$(_context) {
+                    return _regeneratorRuntime.wrap(function traverse$(_context8) {
                       while (1) {
-                        switch (_context.prev = _context.next) {
+                        switch (_context8.prev = _context8.next) {
                           case 0:
                             if (lib.isObject(obj)) {
-                              _context.next = 6;
+                              _context8.next = 6;
                               break;
                             }
 
                             if (!(pluginObj.key === path[path.length - 1])) {
-                              _context.next = 4;
+                              _context8.next = 4;
                               break;
                             }
 
-                            _context.next = 4;
+                            _context8.next = 4;
                             return pluginObj.plugin(obj, pluginObj.key, path, specmap);
 
                           case 4:
-                            _context.next = 30;
+                            _context8.next = 30;
                             break;
 
                           case 6:
                             parentIndex = path.length - 1;
                             parent = path[parentIndex];
-                            indexOfFirstProperties = path.indexOf('properties');
+                            indexOfFirstProperties = _indexOfInstanceProperty(path).call(path, 'properties');
                             isRootProperties = parent === 'properties' && parentIndex === indexOfFirstProperties;
                             traversed = specmap.allowMetaPatches && refCache[obj.$$ref]; // eslint-disable-next-line no-restricted-syntax
 
@@ -180,23 +195,23 @@ var SpecMap = /*#__PURE__*/function () {
 
                           case 12:
                             if (!(_i < _Object$keys.length)) {
-                              _context.next = 30;
+                              _context8.next = 30;
                               break;
                             }
 
                             key = _Object$keys[_i];
                             val = obj[key];
-                            updatedPath = path.concat(key);
+                            updatedPath = _concatInstanceProperty(path).call(path, key);
                             isObj = lib.isObject(val);
                             objRef = obj.$$ref;
 
                             if (traversed) {
-                              _context.next = 22;
+                              _context8.next = 22;
                               break;
                             }
 
                             if (!isObj) {
-                              _context.next = 22;
+                              _context8.next = 22;
                               break;
                             }
 
@@ -205,32 +220,32 @@ var SpecMap = /*#__PURE__*/function () {
                               refCache[objRef] = true;
                             }
 
-                            return _context.delegateYield(traverse(val, updatedPath, patch), "t0", 22);
+                            return _context8.delegateYield(traverse(val, updatedPath, patch), "t0", 22);
 
                           case 22:
                             if (!(!isRootProperties && key === pluginObj.key)) {
-                              _context.next = 27;
+                              _context8.next = 27;
                               break;
                             }
 
                             isWithinPathDiscriminator = isSubPath(pathDiscriminator, path);
 
                             if (!(!pathDiscriminator || isWithinPathDiscriminator)) {
-                              _context.next = 27;
+                              _context8.next = 27;
                               break;
                             }
 
-                            _context.next = 27;
+                            _context8.next = 27;
                             return pluginObj.plugin(val, key, updatedPath, specmap, patch);
 
                           case 27:
                             _i++;
-                            _context.next = 12;
+                            _context8.next = 12;
                             break;
 
                           case 30:
                           case "end":
-                            return _context.stop();
+                            return _context8.stop();
                         }
                       }
                     }, _marked);
@@ -239,44 +254,44 @@ var SpecMap = /*#__PURE__*/function () {
                   _marked = /*#__PURE__*/_regeneratorRuntime.mark(traverse);
                   refCache = {}; // eslint-disable-next-line no-restricted-syntax
 
-                  _iterator = _createForOfIteratorHelper(patches.filter(lib.isAdditiveMutation));
-                  _context2.prev = 4;
+                  _iterator = _createForOfIteratorHelper(_filterInstanceProperty(patches).call(patches, lib.isAdditiveMutation));
+                  _context9.prev = 4;
 
                   _iterator.s();
 
                 case 6:
                   if ((_step = _iterator.n()).done) {
-                    _context2.next = 11;
+                    _context9.next = 11;
                     break;
                   }
 
                   patch = _step.value;
-                  return _context2.delegateYield(traverse(patch.value, patch.path, patch), "t0", 9);
+                  return _context9.delegateYield(traverse(patch.value, patch.path, patch), "t0", 9);
 
                 case 9:
-                  _context2.next = 6;
+                  _context9.next = 6;
                   break;
 
                 case 11:
-                  _context2.next = 16;
+                  _context9.next = 16;
                   break;
 
                 case 13:
-                  _context2.prev = 13;
-                  _context2.t1 = _context2["catch"](4);
+                  _context9.prev = 13;
+                  _context9.t1 = _context9["catch"](4);
 
-                  _iterator.e(_context2.t1);
+                  _iterator.e(_context9.t1);
 
                 case 16:
-                  _context2.prev = 16;
+                  _context9.prev = 16;
 
                   _iterator.f();
 
-                  return _context2.finish(16);
+                  return _context9.finish(16);
 
                 case 19:
                 case "end":
-                  return _context2.stop();
+                  return _context9.stop();
               }
             }
           }, generator, null, [[4, 13, 16, 19]]);
@@ -299,7 +314,9 @@ var SpecMap = /*#__PURE__*/function () {
     key: "nextPromisedPatch",
     value: function nextPromisedPatch() {
       if (this.promisedPatches.length > 0) {
-        return _Promise.race(this.promisedPatches.map(function (patch) {
+        var _context10;
+
+        return _Promise.race(_mapInstanceProperty(_context10 = this.promisedPatches).call(_context10, function (patch) {
           return patch.value;
         }));
       }
@@ -340,9 +357,10 @@ var SpecMap = /*#__PURE__*/function () {
   }, {
     key: "updatePatches",
     value: function updatePatches(patches) {
-      var _this3 = this;
+      var _context11,
+          _this3 = this;
 
-      lib.normalizeArray(patches).forEach(function (patch) {
+      _forEachInstanceProperty(_context11 = lib.normalizeArray(patches)).call(_context11, function (patch) {
         if (patch instanceof Error) {
           _this3.errors.push(patch);
 
@@ -405,14 +423,16 @@ var SpecMap = /*#__PURE__*/function () {
   }, {
     key: "removePromisedPatch",
     value: function removePromisedPatch(patch) {
-      var index = this.promisedPatches.indexOf(patch);
+      var _context12, _context13;
+
+      var index = _indexOfInstanceProperty(_context12 = this.promisedPatches).call(_context12, patch);
 
       if (index < 0) {
         this.debug("Tried to remove a promisedPatch that isn't there!");
         return;
       }
 
-      this.promisedPatches.splice(index, 1);
+      _spliceInstanceProperty(_context13 = this.promisedPatches).call(_context13, index, 1);
     }
   }, {
     key: "promisedPatchThen",
@@ -437,13 +457,15 @@ var SpecMap = /*#__PURE__*/function () {
   }, {
     key: "getMutations",
     value: function getMutations(from, to) {
+      var _context14;
+
       from = from || 0;
 
       if (typeof to !== 'number') {
         to = this.mutations.length;
       }
 
-      return this.mutations.slice(from, to);
+      return _sliceInstanceProperty(_context14 = this.mutations).call(_context14, from, to);
     }
   }, {
     key: "getCurrentMutations",
@@ -527,19 +549,24 @@ var SpecMap = /*#__PURE__*/function () {
       that.pluginCount[plugin] = (that.pluginCount[plugin] || 0) + 1;
 
       if (that.pluginCount[plugin] > HARD_LIMIT) {
+        var _context15;
+
         return _Promise.resolve({
           spec: that.state,
-          errors: that.errors.concat(new Error("We've reached a hard limit of ".concat(HARD_LIMIT, " plugin runs")))
+          errors: _concatInstanceProperty(_context15 = that.errors).call(_context15, new Error("We've reached a hard limit of ".concat(HARD_LIMIT, " plugin runs")))
         });
       } // A different plugin runs, wait for all promises to resolve, then retry
 
 
       if (plugin !== this.currentPlugin && this.promisedPatches.length) {
-        var promises = this.promisedPatches.map(function (p) {
+        var _context16;
+
+        var promises = _mapInstanceProperty(_context16 = this.promisedPatches).call(_context16, function (p) {
           return p.value;
         }); // Waits for all to settle instead of Promise.all which stops on rejection
 
-        return _Promise.all(promises.map(function (promise) {
+
+        return _Promise.all(_mapInstanceProperty(promises).call(promises, function (promise) {
           return promise.then(noop, noop);
         })).then(function () {
           return _this5.dispatch();

package/es/specmap/lib/all-of.js

@@ -1,6 +1,10 @@
-import _toConsumableArray from "@babel/runtime-corejs2/helpers/toConsumableArray";
-import _objectSpread from "@babel/runtime-corejs2/helpers/objectSpread2";
-import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
+import _toConsumableArray from "@babel/runtime-corejs3/helpers/toConsumableArray";
+import _objectSpread from "@babel/runtime-corejs3/helpers/objectSpread2";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
+import _Array$isArray from "@babel/runtime-corejs3/core-js-stable/array/is-array";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/slice";
+import isEmpty from 'lodash/isEmpty';
 import { isFreelyNamed, generateAbsoluteRefPatches } from '../helpers';
 export default {
   key: 'allOf',
@@ -12,7 +16,7 @@ export default {
       return undefined;
     }
 
-    var parent = fullPath.slice(0, -1);
+    var parent = _sliceInstanceProperty(fullPath).call(fullPath, 0, -1);
 
     if (isFreelyNamed(parent)) {
       return undefined;
@@ -29,17 +33,25 @@ export default {
     // Remove the `allOf` property so it doesn't get added to the result of the `allOf` plugin
 
     var originalDefinitionObj = patch.value;
-    parent.forEach(function (part) {
+
+    _forEachInstanceProperty(parent).call(parent, function (part) {
       if (!originalDefinitionObj) return; // bail out if we've lost sight of our target
 
       originalDefinitionObj = originalDefinitionObj[part];
     });
-    originalDefinitionObj = _objectSpread({}, originalDefinitionObj);
+
+    originalDefinitionObj = _objectSpread({}, originalDefinitionObj); // when we've lost sight, interrupt prematurely
+
+    if (isEmpty(originalDefinitionObj)) {
+      return undefined;
+    }
+
     delete originalDefinitionObj.allOf;
     var patches = []; // remove existing content
 
     patches.push(specmap.replace(parent, {}));
-    val.forEach(function (toMerge, i) {
+
+    _forEachInstanceProperty(val).call(val, function (toMerge, i) {
       if (!specmap.isObject(toMerge)) {
         if (alreadyAddError) {
           return null;
@@ -58,10 +70,13 @@ export default {
       patches.push(specmap.mergeDeep(parent, toMerge)); // Generate patches that migrate $ref values based on ContextTree information
       // remove ["allOf"], which will not be present when these patches are applied
 
-      var collapsedFullPath = fullPath.slice(0, -1);
+      var collapsedFullPath = _sliceInstanceProperty(fullPath).call(fullPath, 0, -1);
+
       var absoluteRefPatches = generateAbsoluteRefPatches(toMerge, collapsedFullPath, {
         getBaseUrlForNodePath: function getBaseUrlForNodePath(nodePath) {
-          return specmap.getContext([].concat(_toConsumableArray(fullPath), [i], _toConsumableArray(nodePath))).baseDoc;
+          var _context;
+
+          return specmap.getContext(_concatInstanceProperty(_context = []).call(_context, _toConsumableArray(fullPath), [i], _toConsumableArray(nodePath))).baseDoc;
         },
         specmap: specmap
       });
@@ -69,11 +84,14 @@ export default {
       return undefined;
     }); // Merge back the values from the original definition
 
+
     patches.push(specmap.mergeDeep(parent, originalDefinitionObj)); // If there was not an original $$ref value, make sure to remove
     // any $$ref value that may exist from the result of `allOf` merges
 
     if (!originalDefinitionObj.$$ref) {
-      patches.push(specmap.remove([].concat(parent, '$$ref')));
+      var _context2;
+
+      patches.push(specmap.remove(_concatInstanceProperty(_context2 = []).call(_context2, parent, '$$ref')));
     }
 
     return patches;

package/es/specmap/lib/context-tree.js

@@ -1,7 +1,10 @@
-import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
-import _objectSpread from "@babel/runtime-corejs2/helpers/objectSpread2";
-import _classCallCheck from "@babel/runtime-corejs2/helpers/classCallCheck";
-import _createClass from "@babel/runtime-corejs2/helpers/createClass";
+import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
+import _objectSpread from "@babel/runtime-corejs3/helpers/objectSpread2";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/slice";
+import _reduceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reduce";
+import _classCallCheck from "@babel/runtime-corejs3/helpers/classCallCheck";
+import _createClass from "@babel/runtime-corejs3/helpers/createClass";
 
 var ContextTree = /*#__PURE__*/function () {
   function ContextTree(value) {
@@ -60,6 +63,8 @@ var ContextTree = /*#__PURE__*/function () {
   }, {
     key: "getParent",
     value: function getParent(path, ensureExists) {
+      var _context;
+
       if (!path || path.length < 1) {
         return null;
       }
@@ -68,7 +73,7 @@ var ContextTree = /*#__PURE__*/function () {
         return this.root;
       }
 
-      return path.slice(0, -1).reduce(function (branch, token) {
+      return _reduceInstanceProperty(_context = _sliceInstanceProperty(path).call(path, 0, -1)).call(_context, function (branch, token) {
         if (!branch) {
           return branch;
         }
@@ -99,10 +104,12 @@ function createNode(value, parent) {
 }
 
 function updateNode(node, value, parent) {
+  var _context2;
+
   node.value = value || {};
   node.protoValue = parent ? _objectSpread(_objectSpread({}, parent.protoValue), node.value) : node.value;
 
-  _Object$keys(node.children).forEach(function (prop) {
+  _forEachInstanceProperty(_context2 = _Object$keys(node.children)).call(_context2, function (prop) {
     var child = node.children[prop];
     node.children[prop] = updateNode(child, child.value, node);
   });