@cmflow/atlas 3.4.0-beta.2 → 3.4.0-beta.21

package/dist/index.mjs

@@ -0,0 +1,1297 @@
+import { fileURLToPath as __atlasFileURLToPath } from "node:url";
+const __filename = __atlasFileURLToPath(import.meta.url);
+import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-CGR6nZuH.mjs";
+import { u as getUserConfig } from "./taskProgressService-CAC_RIoa.mjs";
+import { a as httpClient, i as loadOpenApiDocument, t as extractOpenApiBackendProperties } from "./propertyExtractionService-8BjqpPFa.mjs";
+import { t as defineExpressionRule } from "./defineExpressionRule-GhkeHHT8.mjs";
+
+//#region src/fn/defineConfig.ts
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+//#region src/fn/defineBackendSource.ts
+function defineBackendSource(source) {
+	return source;
+}
+
+//#endregion
+//#region ../../node_modules/lodash/isArray.js
+var require_isArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is classified as an `Array` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	* @example
+	*
+	* _.isArray([1, 2, 3]);
+	* // => true
+	*
+	* _.isArray(document.body.children);
+	* // => false
+	*
+	* _.isArray('abc');
+	* // => false
+	*
+	* _.isArray(_.noop);
+	* // => false
+	*/
+	var isArray = Array.isArray;
+	module.exports = isArray;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_freeGlobal.js
+var require__freeGlobal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	module.exports = freeGlobal;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_root.js
+var require__root = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var freeGlobal = require__freeGlobal();
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function("return this")();
+	module.exports = root;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_Symbol.js
+var require__Symbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Built-in value references. */
+	var Symbol = require__root().Symbol;
+	module.exports = Symbol;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_getRawTag.js
+var require__getRawTag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Symbol = require__Symbol();
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var nativeObjectToString = objectProto.toString;
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+	/**
+	* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @returns {string} Returns the raw `toStringTag`.
+	*/
+	function getRawTag(value) {
+		var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+		try {
+			value[symToStringTag] = void 0;
+			var unmasked = true;
+		} catch (e) {}
+		var result = nativeObjectToString.call(value);
+		if (unmasked) {
+			if (isOwn) value[symToStringTag] = tag;
+			else delete value[symToStringTag];
+		}
+		return result;
+	}
+	module.exports = getRawTag;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_objectToString.js
+var require__objectToString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var nativeObjectToString = Object.prototype.toString;
+	/**
+	* Converts `value` to a string using `Object.prototype.toString`.
+	*
+	* @private
+	* @param {*} value The value to convert.
+	* @returns {string} Returns the converted string.
+	*/
+	function objectToString(value) {
+		return nativeObjectToString.call(value);
+	}
+	module.exports = objectToString;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_baseGetTag.js
+var require__baseGetTag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Symbol = require__Symbol();
+	var getRawTag = require__getRawTag();
+	var objectToString = require__objectToString();
+	/** `Object#toString` result references. */
+	var nullTag = "[object Null]";
+	var undefinedTag = "[object Undefined]";
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+	/**
+	* The base implementation of `getTag` without fallbacks for buggy environments.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @returns {string} Returns the `toStringTag`.
+	*/
+	function baseGetTag(value) {
+		if (value == null) return value === void 0 ? undefinedTag : nullTag;
+		return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+	}
+	module.exports = baseGetTag;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/isObjectLike.js
+var require_isObjectLike = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return value != null && typeof value == "object";
+	}
+	module.exports = isObjectLike;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/isSymbol.js
+var require_isSymbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag();
+	var isObjectLike = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+	}
+	module.exports = isSymbol;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_isKey.js
+var require__isKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isArray();
+	var isSymbol = require_isSymbol();
+	/** Used to match property names within property paths. */
+	var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+	var reIsPlainProp = /^\w*$/;
+	/**
+	* Checks if `value` is a property name and not a property path.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @param {Object} [object] The object to query keys on.
+	* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+	*/
+	function isKey(value, object) {
+		if (isArray(value)) return false;
+		var type = typeof value;
+		if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) return true;
+		return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+	}
+	module.exports = isKey;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/isObject.js
+var require_isObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is the
+	* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	* @example
+	*
+	* _.isObject({});
+	* // => true
+	*
+	* _.isObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isObject(_.noop);
+	* // => true
+	*
+	* _.isObject(null);
+	* // => false
+	*/
+	function isObject(value) {
+		var type = typeof value;
+		return value != null && (type == "object" || type == "function");
+	}
+	module.exports = isObject;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/isFunction.js
+var require_isFunction = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag();
+	var isObject = require_isObject();
+	/** `Object#toString` result references. */
+	var asyncTag = "[object AsyncFunction]";
+	var funcTag = "[object Function]";
+	var genTag = "[object GeneratorFunction]";
+	var proxyTag = "[object Proxy]";
+	/**
+	* Checks if `value` is classified as a `Function` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	* @example
+	*
+	* _.isFunction(_);
+	* // => true
+	*
+	* _.isFunction(/abc/);
+	* // => false
+	*/
+	function isFunction(value) {
+		if (!isObject(value)) return false;
+		var tag = baseGetTag(value);
+		return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+	}
+	module.exports = isFunction;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_coreJsData.js
+var require__coreJsData = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = require__root()["__core-js_shared__"];
+	module.exports = coreJsData;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_isMasked.js
+var require__isMasked = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var coreJsData = require__coreJsData();
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = function() {
+		var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+		return uid ? "Symbol(src)_1." + uid : "";
+	}();
+	/**
+	* Checks if `func` has its source masked.
+	*
+	* @private
+	* @param {Function} func The function to check.
+	* @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	*/
+	function isMasked(func) {
+		return !!maskSrcKey && maskSrcKey in func;
+	}
+	module.exports = isMasked;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_toSource.js
+var require__toSource = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = Function.prototype.toString;
+	/**
+	* Converts `func` to its source code.
+	*
+	* @private
+	* @param {Function} func The function to convert.
+	* @returns {string} Returns the source code.
+	*/
+	function toSource(func) {
+		if (func != null) {
+			try {
+				return funcToString.call(func);
+			} catch (e) {}
+			try {
+				return func + "";
+			} catch (e) {}
+		}
+		return "";
+	}
+	module.exports = toSource;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_baseIsNative.js
+var require__baseIsNative = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isFunction = require_isFunction();
+	var isMasked = require__isMasked();
+	var isObject = require_isObject();
+	var toSource = require__toSource();
+	/**
+	* Used to match `RegExp`
+	* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	*/
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+	/** Used for built-in method references. */
+	var funcProto = Function.prototype;
+	var objectProto = Object.prototype;
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+	/**
+	* The base implementation of `_.isNative` without bad shim checks.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a native function,
+	*  else `false`.
+	*/
+	function baseIsNative(value) {
+		if (!isObject(value) || isMasked(value)) return false;
+		return (isFunction(value) ? reIsNative : reIsHostCtor).test(toSource(value));
+	}
+	module.exports = baseIsNative;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_getValue.js
+var require__getValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Gets the value at `key` of `object`.
+	*
+	* @private
+	* @param {Object} [object] The object to query.
+	* @param {string} key The key of the property to get.
+	* @returns {*} Returns the property value.
+	*/
+	function getValue(object, key) {
+		return object == null ? void 0 : object[key];
+	}
+	module.exports = getValue;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_getNative.js
+var require__getNative = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsNative = require__baseIsNative();
+	var getValue = require__getValue();
+	/**
+	* Gets the native function at `key` of `object`.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {string} key The key of the method to get.
+	* @returns {*} Returns the function if it's native, else `undefined`.
+	*/
+	function getNative(object, key) {
+		var value = getValue(object, key);
+		return baseIsNative(value) ? value : void 0;
+	}
+	module.exports = getNative;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_nativeCreate.js
+var require__nativeCreate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__getNative()(Object, "create");
+	module.exports = nativeCreate;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_hashClear.js
+var require__hashClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/**
+	* Removes all key-value entries from the hash.
+	*
+	* @private
+	* @name clear
+	* @memberOf Hash
+	*/
+	function hashClear() {
+		this.__data__ = nativeCreate ? nativeCreate(null) : {};
+		this.size = 0;
+	}
+	module.exports = hashClear;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_hashDelete.js
+var require__hashDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Removes `key` and its value from the hash.
+	*
+	* @private
+	* @name delete
+	* @memberOf Hash
+	* @param {Object} hash The hash to modify.
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function hashDelete(key) {
+		var result = this.has(key) && delete this.__data__[key];
+		this.size -= result ? 1 : 0;
+		return result;
+	}
+	module.exports = hashDelete;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_hashGet.js
+var require__hashGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* Gets the hash value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf Hash
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function hashGet(key) {
+		var data = this.__data__;
+		if (nativeCreate) {
+			var result = data[key];
+			return result === HASH_UNDEFINED ? void 0 : result;
+		}
+		return hasOwnProperty.call(data, key) ? data[key] : void 0;
+	}
+	module.exports = hashGet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_hashHas.js
+var require__hashHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* Checks if a hash value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf Hash
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function hashHas(key) {
+		var data = this.__data__;
+		return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+	}
+	module.exports = hashHas;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_hashSet.js
+var require__hashSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	/**
+	* Sets the hash `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf Hash
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the hash instance.
+	*/
+	function hashSet(key, value) {
+		var data = this.__data__;
+		this.size += this.has(key) ? 0 : 1;
+		data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+		return this;
+	}
+	module.exports = hashSet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_Hash.js
+var require__Hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hashClear = require__hashClear();
+	var hashDelete = require__hashDelete();
+	var hashGet = require__hashGet();
+	var hashHas = require__hashHas();
+	var hashSet = require__hashSet();
+	/**
+	* Creates a hash object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function Hash(entries) {
+		var index = -1, length = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	Hash.prototype.clear = hashClear;
+	Hash.prototype["delete"] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+	module.exports = Hash;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheClear.js
+var require__listCacheClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Removes all key-value entries from the list cache.
+	*
+	* @private
+	* @name clear
+	* @memberOf ListCache
+	*/
+	function listCacheClear() {
+		this.__data__ = [];
+		this.size = 0;
+	}
+	module.exports = listCacheClear;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/eq.js
+var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Performs a
+	* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* comparison between two values to determine if they are equivalent.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to compare.
+	* @param {*} other The other value to compare.
+	* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	* var other = { 'a': 1 };
+	*
+	* _.eq(object, object);
+	* // => true
+	*
+	* _.eq(object, other);
+	* // => false
+	*
+	* _.eq('a', 'a');
+	* // => true
+	*
+	* _.eq('a', Object('a'));
+	* // => false
+	*
+	* _.eq(NaN, NaN);
+	* // => true
+	*/
+	function eq(value, other) {
+		return value === other || value !== value && other !== other;
+	}
+	module.exports = eq;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_assocIndexOf.js
+var require__assocIndexOf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var eq = require_eq();
+	/**
+	* Gets the index at which the `key` is found in `array` of key-value pairs.
+	*
+	* @private
+	* @param {Array} array The array to inspect.
+	* @param {*} key The key to search for.
+	* @returns {number} Returns the index of the matched value, else `-1`.
+	*/
+	function assocIndexOf(array, key) {
+		var length = array.length;
+		while (length--) if (eq(array[length][0], key)) return length;
+		return -1;
+	}
+	module.exports = assocIndexOf;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheDelete.js
+var require__listCacheDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/** Built-in value references. */
+	var splice = Array.prototype.splice;
+	/**
+	* Removes `key` and its value from the list cache.
+	*
+	* @private
+	* @name delete
+	* @memberOf ListCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function listCacheDelete(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) return false;
+		if (index == data.length - 1) data.pop();
+		else splice.call(data, index, 1);
+		--this.size;
+		return true;
+	}
+	module.exports = listCacheDelete;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheGet.js
+var require__listCacheGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Gets the list cache value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf ListCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function listCacheGet(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		return index < 0 ? void 0 : data[index][1];
+	}
+	module.exports = listCacheGet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheHas.js
+var require__listCacheHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Checks if a list cache value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf ListCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function listCacheHas(key) {
+		return assocIndexOf(this.__data__, key) > -1;
+	}
+	module.exports = listCacheHas;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheSet.js
+var require__listCacheSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Sets the list cache `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf ListCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the list cache instance.
+	*/
+	function listCacheSet(key, value) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) {
+			++this.size;
+			data.push([key, value]);
+		} else data[index][1] = value;
+		return this;
+	}
+	module.exports = listCacheSet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_ListCache.js
+var require__ListCache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var listCacheClear = require__listCacheClear();
+	var listCacheDelete = require__listCacheDelete();
+	var listCacheGet = require__listCacheGet();
+	var listCacheHas = require__listCacheHas();
+	var listCacheSet = require__listCacheSet();
+	/**
+	* Creates an list cache object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function ListCache(entries) {
+		var index = -1, length = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype["delete"] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+	module.exports = ListCache;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_Map.js
+var require__Map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Map = require__getNative()(require__root(), "Map");
+	module.exports = Map;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheClear.js
+var require__mapCacheClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Hash = require__Hash();
+	var ListCache = require__ListCache();
+	var Map = require__Map();
+	/**
+	* Removes all key-value entries from the map.
+	*
+	* @private
+	* @name clear
+	* @memberOf MapCache
+	*/
+	function mapCacheClear() {
+		this.size = 0;
+		this.__data__ = {
+			"hash": new Hash(),
+			"map": new (Map || ListCache)(),
+			"string": new Hash()
+		};
+	}
+	module.exports = mapCacheClear;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_isKeyable.js
+var require__isKeyable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is suitable for use as unique object key.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	*/
+	function isKeyable(value) {
+		var type = typeof value;
+		return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+	}
+	module.exports = isKeyable;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_getMapData.js
+var require__getMapData = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isKeyable = require__isKeyable();
+	/**
+	* Gets the data for `map`.
+	*
+	* @private
+	* @param {Object} map The map to query.
+	* @param {string} key The reference key.
+	* @returns {*} Returns the map data.
+	*/
+	function getMapData(map, key) {
+		var data = map.__data__;
+		return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+	}
+	module.exports = getMapData;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheDelete.js
+var require__mapCacheDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Removes `key` and its value from the map.
+	*
+	* @private
+	* @name delete
+	* @memberOf MapCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function mapCacheDelete(key) {
+		var result = getMapData(this, key)["delete"](key);
+		this.size -= result ? 1 : 0;
+		return result;
+	}
+	module.exports = mapCacheDelete;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheGet.js
+var require__mapCacheGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Gets the map value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf MapCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function mapCacheGet(key) {
+		return getMapData(this, key).get(key);
+	}
+	module.exports = mapCacheGet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheHas.js
+var require__mapCacheHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Checks if a map value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf MapCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function mapCacheHas(key) {
+		return getMapData(this, key).has(key);
+	}
+	module.exports = mapCacheHas;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheSet.js
+var require__mapCacheSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Sets the map `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf MapCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the map cache instance.
+	*/
+	function mapCacheSet(key, value) {
+		var data = getMapData(this, key), size = data.size;
+		data.set(key, value);
+		this.size += data.size == size ? 0 : 1;
+		return this;
+	}
+	module.exports = mapCacheSet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_MapCache.js
+var require__MapCache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var mapCacheClear = require__mapCacheClear();
+	var mapCacheDelete = require__mapCacheDelete();
+	var mapCacheGet = require__mapCacheGet();
+	var mapCacheHas = require__mapCacheHas();
+	var mapCacheSet = require__mapCacheSet();
+	/**
+	* Creates a map cache object to store key-value pairs.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function MapCache(entries) {
+		var index = -1, length = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype["delete"] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+	module.exports = MapCache;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/memoize.js
+var require_memoize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MapCache = require__MapCache();
+	/** Error message constants. */
+	var FUNC_ERROR_TEXT = "Expected a function";
+	/**
+	* Creates a function that memoizes the result of `func`. If `resolver` is
+	* provided, it determines the cache key for storing the result based on the
+	* arguments provided to the memoized function. By default, the first argument
+	* provided to the memoized function is used as the map cache key. The `func`
+	* is invoked with the `this` binding of the memoized function.
+	*
+	* **Note:** The cache is exposed as the `cache` property on the memoized
+	* function. Its creation may be customized by replacing the `_.memoize.Cache`
+	* constructor with one whose instances implement the
+	* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+	* method interface of `clear`, `delete`, `get`, `has`, and `set`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Function
+	* @param {Function} func The function to have its output memoized.
+	* @param {Function} [resolver] The function to resolve the cache key.
+	* @returns {Function} Returns the new memoized function.
+	* @example
+	*
+	* var object = { 'a': 1, 'b': 2 };
+	* var other = { 'c': 3, 'd': 4 };
+	*
+	* var values = _.memoize(_.values);
+	* values(object);
+	* // => [1, 2]
+	*
+	* values(other);
+	* // => [3, 4]
+	*
+	* object.a = 2;
+	* values(object);
+	* // => [1, 2]
+	*
+	* // Modify the result cache.
+	* values.cache.set(object, ['a', 'b']);
+	* values(object);
+	* // => ['a', 'b']
+	*
+	* // Replace `_.memoize.Cache`.
+	* _.memoize.Cache = WeakMap;
+	*/
+	function memoize(func, resolver) {
+		if (typeof func != "function" || resolver != null && typeof resolver != "function") throw new TypeError(FUNC_ERROR_TEXT);
+		var memoized = function() {
+			var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+			if (cache.has(key)) return cache.get(key);
+			var result = func.apply(this, args);
+			memoized.cache = cache.set(key, result) || cache;
+			return result;
+		};
+		memoized.cache = new (memoize.Cache || MapCache)();
+		return memoized;
+	}
+	memoize.Cache = MapCache;
+	module.exports = memoize;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_memoizeCapped.js
+var require__memoizeCapped = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var memoize = require_memoize();
+	/** Used as the maximum memoize cache size. */
+	var MAX_MEMOIZE_SIZE = 500;
+	/**
+	* A specialized version of `_.memoize` which clears the memoized function's
+	* cache when it exceeds `MAX_MEMOIZE_SIZE`.
+	*
+	* @private
+	* @param {Function} func The function to have its output memoized.
+	* @returns {Function} Returns the new memoized function.
+	*/
+	function memoizeCapped(func) {
+		var result = memoize(func, function(key) {
+			if (cache.size === MAX_MEMOIZE_SIZE) cache.clear();
+			return key;
+		});
+		var cache = result.cache;
+		return result;
+	}
+	module.exports = memoizeCapped;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_stringToPath.js
+var require__stringToPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var memoizeCapped = require__memoizeCapped();
+	/** Used to match property names within property paths. */
+	var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+	/** Used to match backslashes in property paths. */
+	var reEscapeChar = /\\(\\)?/g;
+	/**
+	* Converts `string` to a property path array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the property path array.
+	*/
+	var stringToPath = memoizeCapped(function(string) {
+		var result = [];
+		if (string.charCodeAt(0) === 46) result.push("");
+		string.replace(rePropName, function(match, number, quote, subString) {
+			result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+		});
+		return result;
+	});
+	module.exports = stringToPath;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_arrayMap.js
+var require__arrayMap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* A specialized version of `_.map` for arrays without support for iteratee
+	* shorthands.
+	*
+	* @private
+	* @param {Array} [array] The array to iterate over.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @returns {Array} Returns the new mapped array.
+	*/
+	function arrayMap(array, iteratee) {
+		var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+		while (++index < length) result[index] = iteratee(array[index], index, array);
+		return result;
+	}
+	module.exports = arrayMap;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_baseToString.js
+var require__baseToString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Symbol = require__Symbol();
+	var arrayMap = require__arrayMap();
+	var isArray = require_isArray();
+	var isSymbol = require_isSymbol();
+	/** Used as references for various `Number` constants. */
+	var INFINITY = 1 / 0;
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : void 0;
+	var symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isArray(value)) return arrayMap(value, baseToString) + "";
+		if (isSymbol(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	module.exports = baseToString;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/toString.js
+var require_toString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseToString = require__baseToString();
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to convert.
+	* @returns {string} Returns the converted string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	module.exports = toString;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_castPath.js
+var require__castPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isArray();
+	var isKey = require__isKey();
+	var stringToPath = require__stringToPath();
+	var toString = require_toString();
+	/**
+	* Casts `value` to a path array if it's not one.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @param {Object} [object] The object to query keys on.
+	* @returns {Array} Returns the cast property path array.
+	*/
+	function castPath(value, object) {
+		if (isArray(value)) return value;
+		return isKey(value, object) ? [value] : stringToPath(toString(value));
+	}
+	module.exports = castPath;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_toKey.js
+var require__toKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isSymbol = require_isSymbol();
+	/** Used as references for various `Number` constants. */
+	var INFINITY = 1 / 0;
+	/**
+	* Converts `value` to a string key if it's not a string or symbol.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @returns {string|symbol} Returns the key.
+	*/
+	function toKey(value) {
+		if (typeof value == "string" || isSymbol(value)) return value;
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	module.exports = toKey;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/_baseGet.js
+var require__baseGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var castPath = require__castPath();
+	var toKey = require__toKey();
+	/**
+	* The base implementation of `_.get` without support for default values.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path of the property to get.
+	* @returns {*} Returns the resolved value.
+	*/
+	function baseGet(object, path) {
+		path = castPath(path, object);
+		var index = 0, length = path.length;
+		while (object != null && index < length) object = object[toKey(path[index++])];
+		return index && index == length ? object : void 0;
+	}
+	module.exports = baseGet;
+}));
+
+//#endregion
+//#region ../../node_modules/lodash/get.js
+var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGet = require__baseGet();
+	/**
+	* Gets the value at `path` of `object`. If the resolved value is
+	* `undefined`, the `defaultValue` is returned in its place.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.7.0
+	* @category Object
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path of the property to get.
+	* @param {*} [defaultValue] The value returned for `undefined` resolved values.
+	* @returns {*} Returns the resolved value.
+	* @example
+	*
+	* var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	*
+	* _.get(object, 'a[0].b.c');
+	* // => 3
+	*
+	* _.get(object, ['a', '0', 'b', 'c']);
+	* // => 3
+	*
+	* _.get(object, 'a.b.c', 'default');
+	* // => 'default'
+	*/
+	function get(object, path, defaultValue) {
+		var result = object == null ? void 0 : baseGet(object, path);
+		return result === void 0 ? defaultValue : result;
+	}
+	module.exports = get;
+}));
+
+//#endregion
+//#region src/fn/constant.ts
+var import_get = /* @__PURE__ */ __toESM(require_get(), 1);
+function constant(name, defaultValue) {
+	return (0, import_get.default)(getUserConfig().envs, name, defaultValue);
+}
+
+//#endregion
+//#region src/services/openapi/openapiSource.ts
+async function openapiSource(params) {
+	const document = await loadOpenApiDocument(params.url, params.timeoutMs);
+	return extractOpenApiBackendProperties(document);
+}
+
+//#endregion
+export { constant, defineBackendSource, defineConfig, defineExpressionRule, httpClient, openapiSource };
+//# sourceMappingURL=index.mjs.map