swagger-client 3.28.3 → 3.29.0

package/dist/swagger-client.browser.js

@@ -3414,10 +3414,9 @@ __webpack_require__.r(__webpack_exports__);
 class JSONParser extends _swagger_api_apidom_reference_configuration_empty__WEBPACK_IMPORTED_MODULE_0__["default"] {
   constructor(options = {}) {
     super({
-      ...options,
       name: 'json-swagger-client',
-      fileExtensions: ['.json'],
-      mediaTypes: ['application/json']
+      mediaTypes: ['application/json'],
+      ...options
     });
   }
   async canParse(file) {
@@ -3483,10 +3482,9 @@ class OpenAPIJSON3_1Parser extends _swagger_api_apidom_reference_configuration_e
   detectionRegExp = /"openapi"\s*:\s*"(?<version_json>3\.1\.(?:[1-9]\d*|0))"/;
   constructor(options = {}) {
     super({
-      ...options,
       name: 'openapi-json-3-1-swagger-client',
-      fileExtensions: ['.json'],
-      mediaTypes: new _swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_1__.OpenAPIMediaTypes(..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_1__["default"].filterByFormat('generic'), ..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_1__["default"].filterByFormat('json'))
+      mediaTypes: new _swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_1__.OpenAPIMediaTypes(..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_1__["default"].filterByFormat('generic'), ..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_1__["default"].filterByFormat('json')),
+      ...options
     });
   }
   async canParse(file) {
@@ -3558,9 +3556,8 @@ class OpenAPIYAML31Parser extends _swagger_api_apidom_reference_configuration_em
   constructor(options = {}) {
     super({
       name: 'openapi-yaml-3-1-swagger-client',
-      ...options,
-      fileExtensions: ['.yaml', '.yml'],
-      mediaTypes: new _swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_2__.OpenAPIMediaTypes(..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_2__["default"].filterByFormat('generic'), ..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_2__["default"].filterByFormat('yaml'))
+      mediaTypes: new _swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_2__.OpenAPIMediaTypes(..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_2__["default"].filterByFormat('generic'), ..._swagger_api_apidom_ns_openapi_3_1__WEBPACK_IMPORTED_MODULE_2__["default"].filterByFormat('yaml')),
+      ...options
     });
   }
   async canParse(file) {
@@ -3627,10 +3624,9 @@ __webpack_require__.r(__webpack_exports__);
 class YAMLParser extends _swagger_api_apidom_reference_configuration_empty__WEBPACK_IMPORTED_MODULE_1__["default"] {
   constructor(options = {}) {
     super({
-      ...options,
       name: 'yaml-1-2-swagger-client',
-      fileExtensions: ['.yaml', '.yml'],
-      mediaTypes: ['text/yaml', 'application/yaml']
+      mediaTypes: ['text/yaml', 'application/yaml'],
+      ...options
     });
   }
   async canParse(file) {
@@ -3824,8 +3820,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   generateAbsoluteRefPatches: () => (/* binding */ generateAbsoluteRefPatches),
 /* harmony export */   isFreelyNamed: () => (/* binding */ isFreelyNamed)
 /* harmony export */ });
-/* harmony import */ var traverse__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36623);
-/* harmony import */ var traverse__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(traverse__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var neotraverse_legacy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(70909);
 /* harmony import */ var _swagger_api_apidom_reference_configuration_empty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(83748);
 /* harmony import */ var _constants_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3832);
 
@@ -3869,7 +3864,7 @@ function generateAbsoluteRefPatches(obj, basePath, {
   targetKeys = ['$ref', '$$ref']
 } = {}) {
   const patches = [];
-  traverse__WEBPACK_IMPORTED_MODULE_0___default()(obj).forEach(function callback() {
+  (0,neotraverse_legacy__WEBPACK_IMPORTED_MODULE_0__["default"])(obj).forEach(function callback() {
     if (targetKeys.includes(this.key) && typeof this.node === 'string') {
       const nodePath = this.path; // this node's path, relative to `obj`
       const fullPath = basePath.concat(this.path);
@@ -15528,344 +15523,6 @@ module.exports = function getSideChannel() {
 };
 
 
-/***/ }),
-
-/***/ 36623:
-/***/ ((module) => {
-
-"use strict";
-
-
-// TODO: use call-bind, is-date, is-regex, is-string, is-boolean-object, is-number-object
-function toS(obj) { return Object.prototype.toString.call(obj); }
-function isDate(obj) { return toS(obj) === '[object Date]'; }
-function isRegExp(obj) { return toS(obj) === '[object RegExp]'; }
-function isError(obj) { return toS(obj) === '[object Error]'; }
-function isBoolean(obj) { return toS(obj) === '[object Boolean]'; }
-function isNumber(obj) { return toS(obj) === '[object Number]'; }
-function isString(obj) { return toS(obj) === '[object String]'; }
-
-// TODO: use isarray
-var isArray = Array.isArray || function isArray(xs) {
-	return Object.prototype.toString.call(xs) === '[object Array]';
-};
-
-// TODO: use for-each?
-function forEach(xs, fn) {
-	if (xs.forEach) { return xs.forEach(fn); }
-	for (var i = 0; i < xs.length; i++) {
-		fn(xs[i], i, xs);
-	}
-	return void undefined;
-}
-
-// TODO: use object-keys
-var objectKeys = Object.keys || function keys(obj) {
-	var res = [];
-	for (var key in obj) { res.push(key); } // eslint-disable-line no-restricted-syntax
-	return res;
-};
-
-var propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
-var getOwnPropertySymbols = Object.getOwnPropertySymbols; // eslint-disable-line id-length
-
-// TODO: use reflect.ownkeys and filter out non-enumerables
-function ownEnumerableKeys(obj) {
-	var res = objectKeys(obj);
-
-	// Include enumerable symbol properties.
-	if (getOwnPropertySymbols) {
-		var symbols = getOwnPropertySymbols(obj);
-		for (var i = 0; i < symbols.length; i++) {
-			if (propertyIsEnumerable.call(obj, symbols[i])) {
-				res.push(symbols[i]);
-			}
-		}
-	}
-	return res;
-}
-
-// TODO: use object.hasown
-var hasOwnProperty = Object.prototype.hasOwnProperty || function (obj, key) {
-	return key in obj;
-};
-
-function copy(src) {
-	if (typeof src === 'object' && src !== null) {
-		var dst;
-
-		if (isArray(src)) {
-			dst = [];
-		} else if (isDate(src)) {
-			dst = new Date(src.getTime ? src.getTime() : src);
-		} else if (isRegExp(src)) {
-			dst = new RegExp(src);
-		} else if (isError(src)) {
-			dst = { message: src.message };
-		} else if (isBoolean(src) || isNumber(src) || isString(src)) {
-			dst = Object(src);
-		} else if (Object.create && Object.getPrototypeOf) {
-			dst = Object.create(Object.getPrototypeOf(src));
-		} else if (src.constructor === Object) {
-			dst = {};
-		} else {
-			var proto = (src.constructor && src.constructor.prototype)
-				|| src.__proto__
-				|| {};
-			var T = function T() {}; // eslint-disable-line func-style, func-name-matching
-			T.prototype = proto;
-			dst = new T();
-		}
-
-		forEach(ownEnumerableKeys(src), function (key) {
-			dst[key] = src[key];
-		});
-		return dst;
-	}
-	return src;
-}
-
-function walk(root, cb, immutable) {
-	var path = [];
-	var parents = [];
-	var alive = true;
-
-	return (function walker(node_) {
-		var node = immutable ? copy(node_) : node_;
-		var modifiers = {};
-
-		var keepGoing = true;
-
-		var state = {
-			node: node,
-			node_: node_,
-			path: [].concat(path),
-			parent: parents[parents.length - 1],
-			parents: parents,
-			key: path[path.length - 1],
-			isRoot: path.length === 0,
-			level: path.length,
-			circular: null,
-			update: function (x, stopHere) {
-				if (!state.isRoot) {
-					state.parent.node[state.key] = x;
-				}
-				state.node = x;
-				if (stopHere) { keepGoing = false; }
-			},
-			delete: function (stopHere) {
-				delete state.parent.node[state.key];
-				if (stopHere) { keepGoing = false; }
-			},
-			remove: function (stopHere) {
-				if (isArray(state.parent.node)) {
-					state.parent.node.splice(state.key, 1);
-				} else {
-					delete state.parent.node[state.key];
-				}
-				if (stopHere) { keepGoing = false; }
-			},
-			keys: null,
-			before: function (f) { modifiers.before = f; },
-			after: function (f) { modifiers.after = f; },
-			pre: function (f) { modifiers.pre = f; },
-			post: function (f) { modifiers.post = f; },
-			stop: function () { alive = false; },
-			block: function () { keepGoing = false; },
-		};
-
-		if (!alive) { return state; }
-
-		function updateState() {
-			if (typeof state.node === 'object' && state.node !== null) {
-				if (!state.keys || state.node_ !== state.node) {
-					state.keys = ownEnumerableKeys(state.node);
-				}
-
-				state.isLeaf = state.keys.length === 0;
-
-				for (var i = 0; i < parents.length; i++) {
-					if (parents[i].node_ === node_) {
-						state.circular = parents[i];
-						break; // eslint-disable-line no-restricted-syntax
-					}
-				}
-			} else {
-				state.isLeaf = true;
-				state.keys = null;
-			}
-
-			state.notLeaf = !state.isLeaf;
-			state.notRoot = !state.isRoot;
-		}
-
-		updateState();
-
-		// use return values to update if defined
-		var ret = cb.call(state, state.node);
-		if (ret !== undefined && state.update) { state.update(ret); }
-
-		if (modifiers.before) { modifiers.before.call(state, state.node); }
-
-		if (!keepGoing) { return state; }
-
-		if (
-			typeof state.node === 'object'
-			&& state.node !== null
-			&& !state.circular
-		) {
-			parents.push(state);
-
-			updateState();
-
-			forEach(state.keys, function (key, i) {
-				path.push(key);
-
-				if (modifiers.pre) { modifiers.pre.call(state, state.node[key], key); }
-
-				var child = walker(state.node[key]);
-				if (immutable && hasOwnProperty.call(state.node, key)) {
-					state.node[key] = child.node;
-				}
-
-				child.isLast = i === state.keys.length - 1;
-				child.isFirst = i === 0;
-
-				if (modifiers.post) { modifiers.post.call(state, child); }
-
-				path.pop();
-			});
-			parents.pop();
-		}
-
-		if (modifiers.after) { modifiers.after.call(state, state.node); }
-
-		return state;
-	}(root)).node;
-}
-
-function Traverse(obj) {
-	this.value = obj;
-}
-
-Traverse.prototype.get = function (ps) {
-	var node = this.value;
-	for (var i = 0; i < ps.length; i++) {
-		var key = ps[i];
-		if (!node || !hasOwnProperty.call(node, key)) {
-			return void undefined;
-		}
-		node = node[key];
-	}
-	return node;
-};
-
-Traverse.prototype.has = function (ps) {
-	var node = this.value;
-	for (var i = 0; i < ps.length; i++) {
-		var key = ps[i];
-		if (!node || !hasOwnProperty.call(node, key)) {
-			return false;
-		}
-		node = node[key];
-	}
-	return true;
-};
-
-Traverse.prototype.set = function (ps, value) {
-	var node = this.value;
-	for (var i = 0; i < ps.length - 1; i++) {
-		var key = ps[i];
-		if (!hasOwnProperty.call(node, key)) { node[key] = {}; }
-		node = node[key];
-	}
-	node[ps[i]] = value;
-	return value;
-};
-
-Traverse.prototype.map = function (cb) {
-	return walk(this.value, cb, true);
-};
-
-Traverse.prototype.forEach = function (cb) {
-	this.value = walk(this.value, cb, false);
-	return this.value;
-};
-
-Traverse.prototype.reduce = function (cb, init) {
-	var skip = arguments.length === 1;
-	var acc = skip ? this.value : init;
-	this.forEach(function (x) {
-		if (!this.isRoot || !skip) {
-			acc = cb.call(this, acc, x);
-		}
-	});
-	return acc;
-};
-
-Traverse.prototype.paths = function () {
-	var acc = [];
-	this.forEach(function () {
-		acc.push(this.path);
-	});
-	return acc;
-};
-
-Traverse.prototype.nodes = function () {
-	var acc = [];
-	this.forEach(function () {
-		acc.push(this.node);
-	});
-	return acc;
-};
-
-Traverse.prototype.clone = function () {
-	var parents = [];
-	var nodes = [];
-
-	return (function clone(src) {
-		for (var i = 0; i < parents.length; i++) {
-			if (parents[i] === src) {
-				return nodes[i];
-			}
-		}
-
-		if (typeof src === 'object' && src !== null) {
-			var dst = copy(src);
-
-			parents.push(src);
-			nodes.push(dst);
-
-			forEach(ownEnumerableKeys(src), function (key) {
-				dst[key] = clone(src[key]);
-			});
-
-			parents.pop();
-			nodes.pop();
-			return dst;
-		}
-
-		return src;
-
-	}(this.value));
-};
-
-function traverse(obj) {
-	return new Traverse(obj);
-}
-
-// TODO: replace with object.assign?
-forEach(ownEnumerableKeys(Traverse.prototype), function (key) {
-	traverse[key] = function (obj) {
-		var args = [].slice.call(arguments, 1);
-		var t = new Traverse(obj);
-		return t[key].apply(t, args);
-	};
-});
-
-module.exports = traverse;
-
-
 /***/ }),
 
 /***/ 6993:
@@ -45037,6 +44694,567 @@ var jsYaml = {
 
 
 
+/***/ }),
+
+/***/ 70909:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* binding */ src_default)
+/* harmony export */ });
+function _array_like_to_array(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;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    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 _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var __typeError = function(msg) {
+    throw TypeError(msg);
+};
+var __accessCheck = function(obj, member, msg) {
+    return member.has(obj) || __typeError("Cannot " + msg);
+};
+var __privateGet = function(obj, member, getter) {
+    return __accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = function(obj, member, value) {
+    return member.has(obj) ? __typeError("Cannot add the same private member more than once") : _instanceof(member, WeakSet) ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = function(obj, member, value, setter) {
+    return __accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value;
+};
+// src/index.ts
+var to_string = function(obj) {
+    return Object.prototype.toString.call(obj);
+};
+var is_typed_array = function(value) {
+    return ArrayBuffer.isView(value) && !_instanceof(value, DataView);
+};
+var is_date = function(obj) {
+    return to_string(obj) === "[object Date]";
+};
+var is_regexp = function(obj) {
+    return to_string(obj) === "[object RegExp]";
+};
+var is_error = function(obj) {
+    return to_string(obj) === "[object Error]";
+};
+var is_boolean = function(obj) {
+    return to_string(obj) === "[object Boolean]";
+};
+var is_number = function(obj) {
+    return to_string(obj) === "[object Number]";
+};
+var is_string = function(obj) {
+    return to_string(obj) === "[object String]";
+};
+var is_array = Array.isArray;
+var gopd = Object.getOwnPropertyDescriptor;
+var is_property_enumerable = Object.prototype.propertyIsEnumerable;
+var get_own_property_symbols = Object.getOwnPropertySymbols;
+var has_own_property = Object.prototype.hasOwnProperty;
+function own_enumerable_keys(obj) {
+    var res = Object.keys(obj);
+    var symbols = get_own_property_symbols(obj);
+    for(var i = 0; i < symbols.length; i++){
+        if (is_property_enumerable.call(obj, symbols[i])) {
+            res.push(symbols[i]);
+        }
+    }
+    return res;
+}
+function is_writable(object, key) {
+    var _gopd;
+    return !((_gopd = gopd(object, key)) === null || _gopd === void 0 ? void 0 : _gopd.writable);
+}
+function copy(src, options) {
+    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+        var dst;
+        if (is_array(src)) {
+            dst = [];
+        } else if (is_date(src)) {
+            dst = new Date(src.getTime ? src.getTime() : src);
+        } else if (is_regexp(src)) {
+            dst = new RegExp(src);
+        } else if (is_error(src)) {
+            dst = {
+                message: src.message
+            };
+        } else if (is_boolean(src) || is_number(src) || is_string(src)) {
+            dst = Object(src);
+        } else if (is_typed_array(src)) {
+            return src.slice();
+        } else {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = iterator_function(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                dst[key] = src[key];
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return dst;
+    }
+    return src;
+}
+var empty_null = {
+    includeSymbols: false,
+    immutable: false
+};
+function walk(root, cb) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : empty_null;
+    var path = [];
+    var parents = [];
+    var alive = true;
+    var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+    var immutable = !!options.immutable;
+    return function walker(node_) {
+        var node = immutable ? copy(node_, options) : node_;
+        var modifiers = {};
+        var keep_going = true;
+        var state = {
+            node: node,
+            node_: node_,
+            path: [].concat(path),
+            parent: parents[parents.length - 1],
+            parents: parents,
+            key: path[path.length - 1],
+            isRoot: path.length === 0,
+            level: path.length,
+            circular: void 0,
+            isLeaf: false,
+            notLeaf: true,
+            notRoot: true,
+            isFirst: false,
+            isLast: false,
+            update: function update(x) {
+                var stopHere = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            delete: function _delete(stopHere) {
+                delete state.parent.node[state.key];
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            remove: function remove(stopHere) {
+                if (is_array(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                } else {
+                    delete state.parent.node[state.key];
+                }
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            keys: null,
+            before: function before(f) {
+                modifiers.before = f;
+            },
+            after: function after(f) {
+                modifiers.after = f;
+            },
+            pre: function pre(f) {
+                modifiers.pre = f;
+            },
+            post: function post(f) {
+                modifiers.post = f;
+            },
+            stop: function stop() {
+                alive = false;
+            },
+            block: function block() {
+                keep_going = false;
+            }
+        };
+        if (!alive) {
+            return state;
+        }
+        function update_state() {
+            if (_type_of(state.node) === "object" && state.node !== null) {
+                if (!state.keys || state.node_ !== state.node) {
+                    state.keys = iterator_function(state.node);
+                }
+                state.isLeaf = state.keys.length === 0;
+                for(var i = 0; i < parents.length; i++){
+                    if (parents[i].node_ === node_) {
+                        state.circular = parents[i];
+                        break;
+                    }
+                }
+            } else {
+                state.isLeaf = true;
+                state.keys = null;
+            }
+            state.notLeaf = !state.isLeaf;
+            state.notRoot = !state.isRoot;
+        }
+        update_state();
+        var ret = cb.call(state, state.node);
+        if (ret !== void 0 && state.update) {
+            state.update(ret);
+        }
+        if (modifiers.before) {
+            modifiers.before.call(state, state.node);
+        }
+        if (!keep_going) {
+            return state;
+        }
+        if (_type_of(state.node) === "object" && state.node !== null && !state.circular) {
+            parents.push(state);
+            update_state();
+            var _state_keys;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.entries((_state_keys = state.keys) !== null && _state_keys !== void 0 ? _state_keys : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), index = _step_value[0], key = _step_value[1];
+                    var _state_keys1;
+                    path.push(key);
+                    if (modifiers.pre) {
+                        modifiers.pre.call(state, state.node[key], key);
+                    }
+                    var child = walker(state.node[key]);
+                    if (immutable && has_own_property.call(state.node, key) && !is_writable(state.node, key)) {
+                        state.node[key] = child.node;
+                    }
+                    child.isLast = ((_state_keys1 = state.keys) === null || _state_keys1 === void 0 ? void 0 : _state_keys1.length) ? +index === state.keys.length - 1 : false;
+                    child.isFirst = +index === 0;
+                    if (modifiers.post) {
+                        modifiers.post.call(state, child);
+                    }
+                    path.pop();
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            parents.pop();
+        }
+        if (modifiers.after) {
+            modifiers.after.call(state, state.node);
+        }
+        return state;
+    }(root).node;
+}
+var _value, _options;
+var Traverse = /*#__PURE__*/ function() {
+    "use strict";
+    function Traverse(obj) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : empty_null;
+        _class_call_check(this, Traverse);
+        // ! Have to keep these public as legacy mode requires them
+        __privateAdd(this, _value);
+        __privateAdd(this, _options);
+        __privateSet(this, _value, obj);
+        __privateSet(this, _options, options);
+    }
+    _create_class(Traverse, [
+        {
+            /**
+   * Get the element at the array `path`.
+   */ key: "get",
+            value: function get(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return void 0;
+                    }
+                    node = node[key];
+                }
+                return node;
+            }
+        },
+        {
+            /**
+   * Return whether the element at the array `path` exists.
+   */ key: "has",
+            value: function has(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return false;
+                    }
+                    node = node[key];
+                }
+                return true;
+            }
+        },
+        {
+            /**
+   * Set the element at the array `path` to `value`.
+   */ key: "set",
+            value: function set(path, value) {
+                var node = __privateGet(this, _value);
+                var i = 0;
+                for(i = 0; i < path.length - 1; i++){
+                    var key = path[i];
+                    if (!has_own_property.call(node, key)) {
+                        node[key] = {};
+                    }
+                    node = node[key];
+                }
+                node[path[i]] = value;
+                return value;
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+   */ key: "map",
+            value: function map(cb) {
+                return walk(__privateGet(this, _value), cb, {
+                    immutable: true,
+                    includeSymbols: !!__privateGet(this, _options).includeSymbols
+                });
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+   */ key: "forEach",
+            value: function forEach(cb) {
+                __privateSet(this, _value, walk(__privateGet(this, _value), cb, __privateGet(this, _options)));
+                return __privateGet(this, _value);
+            }
+        },
+        {
+            /**
+   * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+   *
+   * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+   */ key: "reduce",
+            value: function reduce(cb, init) {
+                var skip = arguments.length === 1;
+                var acc = skip ? __privateGet(this, _value) : init;
+                this.forEach(function(x) {
+                    if (!this.isRoot || !skip) {
+                        acc = cb.call(this, acc, x);
+                    }
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every possible non-cyclic path in the object.
+   * Paths are `Array`s of string keys.
+   */ key: "paths",
+            value: function paths() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.path);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every node in the object.
+   */ key: "nodes",
+            value: function nodes() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.node);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Create a deep clone of the object.
+   */ key: "clone",
+            value: function clone() {
+                var parents = [];
+                var nodes = [];
+                var options = __privateGet(this, _options);
+                if (is_typed_array(__privateGet(this, _value))) {
+                    return __privateGet(this, _value).slice();
+                }
+                return function clone(src) {
+                    for(var i = 0; i < parents.length; i++){
+                        if (parents[i] === src) {
+                            return nodes[i];
+                        }
+                    }
+                    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+                        var dst = copy(src, options);
+                        parents.push(src);
+                        nodes.push(dst);
+                        var iteratorFunction = options.includeSymbols ? own_enumerable_keys : Object.keys;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = iteratorFunction(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var key = _step.value;
+                                dst[key] = clone(src[key]);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        parents.pop();
+                        nodes.pop();
+                        return dst;
+                    }
+                    return src;
+                }(__privateGet(this, _value));
+            }
+        }
+    ]);
+    return Traverse;
+}();
+_value = new WeakMap();
+_options = new WeakMap();
+var traverse = function(obj, options) {
+    return new Traverse(obj, options);
+};
+traverse.get = function(obj, paths, options) {
+    return new Traverse(obj, options).get(paths);
+};
+traverse.set = function(obj, path, value, options) {
+    return new Traverse(obj, options).set(path, value);
+};
+traverse.has = function(obj, paths, options) {
+    return new Traverse(obj, options).has(paths);
+};
+traverse.map = function(obj, cb, options) {
+    return new Traverse(obj, options).map(cb);
+};
+traverse.forEach = function(obj, cb, options) {
+    return new Traverse(obj, options).forEach(cb);
+};
+traverse.reduce = function(obj, cb, init, options) {
+    return new Traverse(obj, options).reduce(cb, init);
+};
+traverse.paths = function(obj, options) {
+    return new Traverse(obj, options).paths();
+};
+traverse.nodes = function(obj, options) {
+    return new Traverse(obj, options).nodes();
+};
+traverse.clone = function(obj, options) {
+    return new Traverse(obj, options).clone();
+};
+var src_default = traverse;
+// src/legacy.cts
+
+
+
+
 /***/ }),
 
 /***/ 61546: