@jeffusion/bungee-core 4.0.0 → 4.2.0

package/dist/master.js

@@ -16047,7 +16047,7 @@ var init_migrations = __esm(() => {
 });
 
 // src/config-migrations/types.ts
-var LATEST_CONFIG_VERSION = 2;
+var LATEST_CONFIG_VERSION = 4;
 
 // src/config-migrations/utils.ts
 function isPlainObject(value) {
@@ -16110,7 +16110,7 @@ function detectConfigVersion(rawConfig) {
   if (!isPlainObject(rawConfig)) {
     return 1;
   }
-  const version = rawConfig.configVersion;
+  const version = rawConfig.configVersion ?? rawConfig.config_version;
   return typeof version === "number" && Number.isInteger(version) && version > 0 ? version : 1;
 }
 function isPlainRecord(value) {
@@ -16151,7 +16151,7 @@ var init_v1_to_v2 = __esm(() => {
   ];
   v1ToV2Migration = {
     fromVersion: 1,
-    toVersion: LATEST_CONFIG_VERSION,
+    toVersion: 2,
     description: "Migrate legacy failover route fields to config model v2",
     migrate(input) {
       const config = cloneJson(input);
@@ -16184,7 +16184,259 @@ var init_v1_to_v2 = __esm(() => {
         }
         return cleanupEmptyObjects(migratedRoute);
       });
-      config.configVersion = LATEST_CONFIG_VERSION;
+      config.configVersion = 2;
+      return {
+        config: cleanupEmptyObjects(config),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/versions/v2-to-v3.ts
+function renameKeysRecursive(obj, mappings, changes) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => renameKeysRecursive(item, mappings, changes));
+  }
+  if (!isPlainRecord(obj)) {
+    return obj;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const mapping = mappings.find(([from]) => from === key);
+    const newKey = mapping ? mapping[1] : key;
+    if (mapping) {
+      changes.push({
+        type: "rename",
+        path: key,
+        from: key,
+        to: newKey,
+        message: `Renamed ${key} to ${newKey}`
+      });
+    }
+    result[newKey] = renameKeysRecursive(value, mappings, changes);
+  }
+  return result;
+}
+function migrateRoutesToServiceRef(config, changes, warnings) {
+  if (!Array.isArray(config.routes))
+    return;
+  const upstreamSignatureMap = new Map;
+  const services = [];
+  for (const route of config.routes) {
+    if (!isPlainRecord(route))
+      continue;
+    const endpoints = route.endpoints;
+    if (!Array.isArray(endpoints) || endpoints.length === 0) {
+      warnings.push({
+        path: `route "${route.path || "unknown"}"`,
+        message: "Route has no endpoints; skipping service extraction"
+      });
+      continue;
+    }
+    const signature = JSON.stringify(endpoints.map((u) => ({
+      target: u.target,
+      weight: u.weight,
+      priority: u.priority
+    })));
+    let serviceName = upstreamSignatureMap.get(signature);
+    if (!serviceName) {
+      serviceName = `service-${services.length + 1}`;
+      upstreamSignatureMap.set(signature, serviceName);
+      const service = {
+        name: serviceName,
+        endpoints
+      };
+      if (isPlainRecord(route.health_check)) {
+        service.health_check = route.health_check;
+      }
+      services.push(service);
+      changes.push({
+        type: "move",
+        path: `route "${route.path}".endpoints`,
+        from: "route.endpoints",
+        to: `services.${serviceName}.endpoints`,
+        message: `Extracted endpoints to service "${serviceName}"`
+      });
+    }
+    route.service = serviceName;
+    delete route.endpoints;
+  }
+  config.services = services;
+}
+var CAMEL_TO_SNAKE_MAPPINGS, v2ToV3Migration;
+var init_v2_to_v3 = __esm(() => {
+  CAMEL_TO_SNAKE_MAPPINGS = [
+    ["configVersion", "config_version"],
+    ["logLevel", "log_level"],
+    ["bodyParserLimit", "body_parser_limit"],
+    ["pathRewrite", "path_rewrite"],
+    ["stickySession", "sticky_session"],
+    ["keyExpression", "key_expression"],
+    ["connectMs", "connect_ms"],
+    ["requestMs", "request_ms"],
+    ["retryOn", "retry_on"],
+    ["passiveHealth", "passive_health"],
+    ["consecutiveFailures", "consecutive_failures"],
+    ["healthySuccesses", "healthy_successes"],
+    ["autoDisableThreshold", "auto_disable_threshold"],
+    ["autoEnableOnActiveHealthCheck", "auto_enable_on_active_health_check"],
+    ["probeIntervalMs", "probe_interval_ms"],
+    ["probeTimeoutMs", "probe_timeout_ms"],
+    ["slowStart", "slow_start"],
+    ["durationMs", "duration_ms"],
+    ["initialWeightFactor", "initial_weight_factor"],
+    ["healthCheck", "health_check"],
+    ["intervalMs", "interval_ms"],
+    ["timeoutMs", "timeout_ms"],
+    ["expectedStatus", "expected_status"],
+    ["unhealthyThreshold", "unhealthy_threshold"],
+    ["healthyThreshold", "healthy_threshold"],
+    ["contentType", "content_type"],
+    ["maxSize", "max_size"],
+    ["retentionDays", "retention_days"],
+    ["upstreams", "endpoints"]
+  ];
+  v2ToV3Migration = {
+    fromVersion: 2,
+    toVersion: 3,
+    description: "Migrate camelCase to snake_case and extract upstreams into services",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      const changes = [];
+      const warnings = [];
+      const renamedConfig = renameKeysRecursive(config, CAMEL_TO_SNAKE_MAPPINGS, changes);
+      migrateRoutesToServiceRef(renamedConfig, changes, warnings);
+      renamedConfig.config_version = 3;
+      return {
+        config: cleanupEmptyObjects(renamedConfig),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/versions/v3-to-v4.ts
+function serviceNameFromPath(path6) {
+  const base = path6.replace(/^\/+/, "").replace(/\/+$/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return `${base || "root"}-service`;
+}
+function uniqueServiceName(preferredName, existingNames) {
+  if (!existingNames.has(preferredName)) {
+    existingNames.add(preferredName);
+    return preferredName;
+  }
+  let suffix = 2;
+  while (existingNames.has(`${preferredName}-${suffix}`)) {
+    suffix++;
+  }
+  const name = `${preferredName}-${suffix}`;
+  existingNames.add(name);
+  return name;
+}
+function moveRouteConfigToService(route, service, routeIndex, changes) {
+  if (route.failover && !service.failover) {
+    service.failover = route.failover;
+    changes.push({
+      type: "move",
+      path: `routes.${routeIndex}.failover`,
+      from: `routes.${routeIndex}.failover`,
+      to: `services.${service.name}.failover`,
+      message: `Moved route failover to service "${service.name}"`
+    });
+  }
+  if (route.sticky_session && !service.sticky_session) {
+    service.sticky_session = route.sticky_session;
+    changes.push({
+      type: "move",
+      path: `routes.${routeIndex}.sticky_session`,
+      from: `routes.${routeIndex}.sticky_session`,
+      to: `services.${service.name}.sticky_session`,
+      message: `Moved route sticky_session to service "${service.name}"`
+    });
+  }
+  if (route.failover) {
+    delete route.failover;
+  }
+  if (route.sticky_session) {
+    delete route.sticky_session;
+  }
+}
+var v3ToV4Migration;
+var init_v3_to_v4 = __esm(() => {
+  v3ToV4Migration = {
+    fromVersion: 3,
+    toVersion: 4,
+    description: "Move failover and sticky_session from routes to services",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      const changes = [];
+      const warnings = [];
+      const routes = Array.isArray(config.routes) ? config.routes : [];
+      const services = Array.isArray(config.services) ? config.services : [];
+      const serviceNames = new Set(services.map((service) => service.name));
+      for (let routeIndex = 0;routeIndex < routes.length; routeIndex++) {
+        const route = routes[routeIndex];
+        if (!isPlainRecord(route)) {
+          continue;
+        }
+        const hasRouteFailover = route.failover !== undefined;
+        const hasRouteStickySession = route.sticky_session !== undefined;
+        if (!hasRouteFailover && !hasRouteStickySession) {
+          continue;
+        }
+        if (route.service) {
+          let service2 = services.find((candidate) => candidate.name === route.service);
+          if (!service2) {
+            const routeEndpoints2 = route.endpoints ?? [];
+            service2 = {
+              name: route.service,
+              endpoints: routeEndpoints2
+            };
+            services.push(service2);
+            serviceNames.add(service2.name);
+            changes.push({
+              type: "move",
+              path: `routes.${routeIndex}.service`,
+              to: `services.${service2.name}`,
+              message: `Created missing service "${service2.name}" for route "${route.path}"`
+            });
+          }
+          moveRouteConfigToService(route, service2, routeIndex, changes);
+          continue;
+        }
+        const serviceName = uniqueServiceName(serviceNameFromPath(route.path), serviceNames);
+        const routeEndpoints = route.endpoints ?? [];
+        const service = {
+          name: serviceName,
+          endpoints: routeEndpoints,
+          ...route.failover && { failover: route.failover },
+          ...route.sticky_session && { sticky_session: route.sticky_session }
+        };
+        services.push(service);
+        route.service = serviceName;
+        delete route.endpoints;
+        changes.push({
+          type: "move",
+          path: `routes.${routeIndex}`,
+          from: `routes.${routeIndex}.endpoints/failover/sticky_session`,
+          to: `services.${serviceName}`,
+          message: `Created service "${serviceName}" from route "${route.path}"`
+        });
+        moveRouteConfigToService(route, service, routeIndex, changes);
+      }
+      if (services.length > 0) {
+        config.services = services;
+      }
+      config.config_version = 4;
       return {
         config: cleanupEmptyObjects(config),
         changes,
@@ -16198,47 +16450,3324 @@ var init_v1_to_v2 = __esm(() => {
 var CONFIG_MIGRATIONS;
 var init_config_migrations = __esm(() => {
   init_v1_to_v2();
+  init_v2_to_v3();
+  init_v3_to_v4();
   CONFIG_MIGRATIONS = [
-    v1ToV2Migration
+    v1ToV2Migration,
+    v2ToV3Migration,
+    v3ToV4Migration
   ];
 });
 
-// src/config-migrations/migrate-config.ts
-function buildMigrationMap(migrations2) {
-  return new Map(migrations2.map((migration4) => [migration4.fromVersion, migration4]));
+// src/config-migrations/migrate-config.ts
+function buildMigrationMap(migrations2) {
+  return new Map(migrations2.map((migration4) => [migration4.fromVersion, migration4]));
+}
+function migrateConfigToLatest(rawConfig) {
+  const migrationMap = buildMigrationMap(CONFIG_MIGRATIONS);
+  const originalVersion = detectConfigVersion(rawConfig);
+  let currentVersion = originalVersion;
+  let workingConfig = cloneJson(rawConfig);
+  const changes = [];
+  const warnings = [];
+  while (currentVersion < LATEST_CONFIG_VERSION) {
+    const migration4 = migrationMap.get(currentVersion);
+    if (!migration4) {
+      throw new Error(`No config migration registered from version ${currentVersion}`);
+    }
+    const result = migration4.migrate(workingConfig);
+    workingConfig = result.config;
+    changes.push(...result.changes);
+    warnings.push(...result.warnings);
+    currentVersion = migration4.toVersion;
+  }
+  if (!isPlainRecord(workingConfig)) {
+    throw new Error("Migrated config must be an object");
+  }
+  workingConfig.config_version = LATEST_CONFIG_VERSION;
+  return {
+    config: workingConfig,
+    originalVersion,
+    finalVersion: LATEST_CONFIG_VERSION,
+    changes,
+    warnings
+  };
+}
+var init_migrate_config = __esm(() => {
+  init_config_migrations();
+});
+
+// src/compat/legacy-plugin-adapter.ts
+class LegacyCompatAdapter {
+  static adaptConfig(config) {
+    if (!config.services)
+      return config;
+    return {
+      ...config,
+      services: config.services.map((service) => ({
+        ...service,
+        plugins: service.plugins ?? []
+      }))
+    };
+  }
+  static adaptInterceptResult(result) {
+    if (result === undefined)
+      return;
+    if (result instanceof Response) {
+      return { action: "respond", response: result };
+    }
+    return result;
+  }
+}
+
+// ../../node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear_default;
+var init__listCacheClear = __esm(() => {
+  _listCacheClear_default = listCacheClear;
+});
+
+// ../../node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default;
+var init_eq = __esm(() => {
+  eq_default = eq;
+});
+
+// ../../node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf_default;
+var init__assocIndexOf = __esm(() => {
+  init_eq();
+  _assocIndexOf_default = assocIndexOf;
+});
+
+// ../../node_modules/lodash-es/_listCacheDelete.js
+function listCacheDelete(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var arrayProto, splice, _listCacheDelete_default;
+var init__listCacheDelete = __esm(() => {
+  init__assocIndexOf();
+  arrayProto = Array.prototype;
+  splice = arrayProto.splice;
+  _listCacheDelete_default = listCacheDelete;
+});
+
+// ../../node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  return index < 0 ? undefined : data[index][1];
+}
+var _listCacheGet_default;
+var init__listCacheGet = __esm(() => {
+  init__assocIndexOf();
+  _listCacheGet_default = listCacheGet;
+});
+
+// ../../node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return _assocIndexOf_default(this.__data__, key) > -1;
+}
+var _listCacheHas_default;
+var init__listCacheHas = __esm(() => {
+  init__assocIndexOf();
+  _listCacheHas_default = listCacheHas;
+});
+
+// ../../node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet_default;
+var init__listCacheSet = __esm(() => {
+  init__assocIndexOf();
+  _listCacheSet_default = listCacheSet;
+});
+
+// ../../node_modules/lodash-es/_ListCache.js
+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]);
+  }
+}
+var _ListCache_default;
+var init__ListCache = __esm(() => {
+  init__listCacheClear();
+  init__listCacheDelete();
+  init__listCacheGet();
+  init__listCacheHas();
+  init__listCacheSet();
+  ListCache.prototype.clear = _listCacheClear_default;
+  ListCache.prototype["delete"] = _listCacheDelete_default;
+  ListCache.prototype.get = _listCacheGet_default;
+  ListCache.prototype.has = _listCacheHas_default;
+  ListCache.prototype.set = _listCacheSet_default;
+  _ListCache_default = ListCache;
+});
+
+// ../../node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new _ListCache_default;
+  this.size = 0;
+}
+var _stackClear_default;
+var init__stackClear = __esm(() => {
+  init__ListCache();
+  _stackClear_default = stackClear;
+});
+
+// ../../node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete_default;
+var init__stackDelete = __esm(() => {
+  _stackDelete_default = stackDelete;
+});
+
+// ../../node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var _stackGet_default;
+var init__stackGet = __esm(() => {
+  _stackGet_default = stackGet;
+});
+
+// ../../node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var _stackHas_default;
+var init__stackHas = __esm(() => {
+  _stackHas_default = stackHas;
+});
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal, _freeGlobal_default;
+var init__freeGlobal = __esm(() => {
+  freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+  _freeGlobal_default = freeGlobal;
+});
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf, root, _root_default;
+var init__root = __esm(() => {
+  init__freeGlobal();
+  freeSelf = typeof self == "object" && self && self.Object === Object && self;
+  root = _freeGlobal_default || freeSelf || Function("return this")();
+  _root_default = root;
+});
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2, _Symbol_default;
+var init__Symbol = __esm(() => {
+  init__root();
+  Symbol2 = _root_default.Symbol;
+  _Symbol_default = Symbol2;
+});
+
+// ../../node_modules/lodash-es/_getRawTag.js
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var objectProto, hasOwnProperty, nativeObjectToString, symToStringTag, _getRawTag_default;
+var init__getRawTag = __esm(() => {
+  init__Symbol();
+  objectProto = Object.prototype;
+  hasOwnProperty = objectProto.hasOwnProperty;
+  nativeObjectToString = objectProto.toString;
+  symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+  _getRawTag_default = getRawTag;
+});
+
+// ../../node_modules/lodash-es/_objectToString.js
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectProto2, nativeObjectToString2, _objectToString_default;
+var init__objectToString = __esm(() => {
+  objectProto2 = Object.prototype;
+  nativeObjectToString2 = objectProto2.toString;
+  _objectToString_default = objectToString;
+});
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]", symToStringTag2, _baseGetTag_default;
+var init__baseGetTag = __esm(() => {
+  init__Symbol();
+  init__getRawTag();
+  init__objectToString();
+  symToStringTag2 = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+  _baseGetTag_default = baseGetTag;
+});
+
+// ../../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default;
+var init_isObject = __esm(() => {
+  isObject_default = isObject;
+});
+
+// ../../node_modules/lodash-es/isFunction.js
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = _baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]", isFunction_default;
+var init_isFunction = __esm(() => {
+  init__baseGetTag();
+  init_isObject();
+  isFunction_default = isFunction;
+});
+
+// ../../node_modules/lodash-es/_coreJsData.js
+var coreJsData, _coreJsData_default;
+var init__coreJsData = __esm(() => {
+  init__root();
+  coreJsData = _root_default["__core-js_shared__"];
+  _coreJsData_default = coreJsData;
+});
+
+// ../../node_modules/lodash-es/_isMasked.js
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var maskSrcKey, _isMasked_default;
+var init__isMasked = __esm(() => {
+  init__coreJsData();
+  maskSrcKey = function() {
+    var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
+    return uid ? "Symbol(src)_1." + uid : "";
+  }();
+  _isMasked_default = isMasked;
+});
+
+// ../../node_modules/lodash-es/_toSource.js
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return func + "";
+    } catch (e) {}
+  }
+  return "";
+}
+var funcProto, funcToString, _toSource_default;
+var init__toSource = __esm(() => {
+  funcProto = Function.prototype;
+  funcToString = funcProto.toString;
+  _toSource_default = toSource;
+});
+
+// ../../node_modules/lodash-es/_baseIsNative.js
+function baseIsNative(value) {
+  if (!isObject_default(value) || _isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(_toSource_default(value));
+}
+var reRegExpChar, reIsHostCtor, funcProto2, objectProto3, funcToString2, hasOwnProperty2, reIsNative, _baseIsNative_default;
+var init__baseIsNative = __esm(() => {
+  init_isFunction();
+  init__isMasked();
+  init_isObject();
+  init__toSource();
+  reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+  reIsHostCtor = /^\[object .+?Constructor\]$/;
+  funcProto2 = Function.prototype;
+  objectProto3 = Object.prototype;
+  funcToString2 = funcProto2.toString;
+  hasOwnProperty2 = objectProto3.hasOwnProperty;
+  reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+  _baseIsNative_default = baseIsNative;
+});
+
+// ../../node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+var _getValue_default;
+var init__getValue = __esm(() => {
+  _getValue_default = getValue;
+});
+
+// ../../node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = _getValue_default(object, key);
+  return _baseIsNative_default(value) ? value : undefined;
+}
+var _getNative_default;
+var init__getNative = __esm(() => {
+  init__baseIsNative();
+  init__getValue();
+  _getNative_default = getNative;
+});
+
+// ../../node_modules/lodash-es/_Map.js
+var Map2, _Map_default;
+var init__Map = __esm(() => {
+  init__getNative();
+  init__root();
+  Map2 = _getNative_default(_root_default, "Map");
+  _Map_default = Map2;
+});
+
+// ../../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate, _nativeCreate_default;
+var init__nativeCreate = __esm(() => {
+  init__getNative();
+  nativeCreate = _getNative_default(Object, "create");
+  _nativeCreate_default = nativeCreate;
+});
+
+// ../../node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var _hashClear_default;
+var init__hashClear = __esm(() => {
+  init__nativeCreate();
+  _hashClear_default = hashClear;
+});
+
+// ../../node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete_default;
+var init__hashDelete = __esm(() => {
+  _hashDelete_default = hashDelete;
+});
+
+// ../../node_modules/lodash-es/_hashGet.js
+function hashGet(key) {
+  var data = this.__data__;
+  if (_nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty3.call(data, key) ? data[key] : undefined;
+}
+var HASH_UNDEFINED = "__lodash_hash_undefined__", objectProto4, hasOwnProperty3, _hashGet_default;
+var init__hashGet = __esm(() => {
+  init__nativeCreate();
+  objectProto4 = Object.prototype;
+  hasOwnProperty3 = objectProto4.hasOwnProperty;
+  _hashGet_default = hashGet;
+});
+
+// ../../node_modules/lodash-es/_hashHas.js
+function hashHas(key) {
+  var data = this.__data__;
+  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty4.call(data, key);
+}
+var objectProto5, hasOwnProperty4, _hashHas_default;
+var init__hashHas = __esm(() => {
+  init__nativeCreate();
+  objectProto5 = Object.prototype;
+  hasOwnProperty4 = objectProto5.hasOwnProperty;
+  _hashHas_default = hashHas;
+});
+
+// ../../node_modules/lodash-es/_hashSet.js
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = _nativeCreate_default && value === undefined ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__", _hashSet_default;
+var init__hashSet = __esm(() => {
+  init__nativeCreate();
+  _hashSet_default = hashSet;
+});
+
+// ../../node_modules/lodash-es/_Hash.js
+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]);
+  }
+}
+var _Hash_default;
+var init__Hash = __esm(() => {
+  init__hashClear();
+  init__hashDelete();
+  init__hashGet();
+  init__hashHas();
+  init__hashSet();
+  Hash.prototype.clear = _hashClear_default;
+  Hash.prototype["delete"] = _hashDelete_default;
+  Hash.prototype.get = _hashGet_default;
+  Hash.prototype.has = _hashHas_default;
+  Hash.prototype.set = _hashSet_default;
+  _Hash_default = Hash;
+});
+
+// ../../node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    hash: new _Hash_default,
+    map: new (_Map_default || _ListCache_default),
+    string: new _Hash_default
+  };
+}
+var _mapCacheClear_default;
+var init__mapCacheClear = __esm(() => {
+  init__Hash();
+  init__ListCache();
+  init__Map();
+  _mapCacheClear_default = mapCacheClear;
+});
+
+// ../../node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable_default;
+var init__isKeyable = __esm(() => {
+  _isKeyable_default = isKeyable;
+});
+
+// ../../node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData_default;
+var init__getMapData = __esm(() => {
+  init__isKeyable();
+  _getMapData_default = getMapData;
+});
+
+// ../../node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = _getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete_default;
+var init__mapCacheDelete = __esm(() => {
+  init__getMapData();
+  _mapCacheDelete_default = mapCacheDelete;
+});
+
+// ../../node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return _getMapData_default(this, key).get(key);
+}
+var _mapCacheGet_default;
+var init__mapCacheGet = __esm(() => {
+  init__getMapData();
+  _mapCacheGet_default = mapCacheGet;
+});
+
+// ../../node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return _getMapData_default(this, key).has(key);
+}
+var _mapCacheHas_default;
+var init__mapCacheHas = __esm(() => {
+  init__getMapData();
+  _mapCacheHas_default = mapCacheHas;
+});
+
+// ../../node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = _getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet_default;
+var init__mapCacheSet = __esm(() => {
+  init__getMapData();
+  _mapCacheSet_default = mapCacheSet;
+});
+
+// ../../node_modules/lodash-es/_MapCache.js
+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]);
+  }
+}
+var _MapCache_default;
+var init__MapCache = __esm(() => {
+  init__mapCacheClear();
+  init__mapCacheDelete();
+  init__mapCacheGet();
+  init__mapCacheHas();
+  init__mapCacheSet();
+  MapCache.prototype.clear = _mapCacheClear_default;
+  MapCache.prototype["delete"] = _mapCacheDelete_default;
+  MapCache.prototype.get = _mapCacheGet_default;
+  MapCache.prototype.has = _mapCacheHas_default;
+  MapCache.prototype.set = _mapCacheSet_default;
+  _MapCache_default = MapCache;
+});
+
+// ../../node_modules/lodash-es/_stackSet.js
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof _ListCache_default) {
+    var pairs = data.__data__;
+    if (!_Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new _MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var LARGE_ARRAY_SIZE = 200, _stackSet_default;
+var init__stackSet = __esm(() => {
+  init__ListCache();
+  init__Map();
+  init__MapCache();
+  _stackSet_default = stackSet;
+});
+
+// ../../node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new _ListCache_default(entries);
+  this.size = data.size;
+}
+var _Stack_default;
+var init__Stack = __esm(() => {
+  init__ListCache();
+  init__stackClear();
+  init__stackDelete();
+  init__stackGet();
+  init__stackHas();
+  init__stackSet();
+  Stack.prototype.clear = _stackClear_default;
+  Stack.prototype["delete"] = _stackDelete_default;
+  Stack.prototype.get = _stackGet_default;
+  Stack.prototype.has = _stackHas_default;
+  Stack.prototype.set = _stackSet_default;
+  _Stack_default = Stack;
+});
+
+// ../../node_modules/lodash-es/_setCacheAdd.js
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED3);
+  return this;
+}
+var HASH_UNDEFINED3 = "__lodash_hash_undefined__", _setCacheAdd_default;
+var init__setCacheAdd = __esm(() => {
+  _setCacheAdd_default = setCacheAdd;
+});
+
+// ../../node_modules/lodash-es/_setCacheHas.js
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas_default;
+var init__setCacheHas = __esm(() => {
+  _setCacheHas_default = setCacheHas;
+});
+
+// ../../node_modules/lodash-es/_SetCache.js
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new _MapCache_default;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+var _SetCache_default;
+var init__SetCache = __esm(() => {
+  init__MapCache();
+  init__setCacheAdd();
+  init__setCacheHas();
+  SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd_default;
+  SetCache.prototype.has = _setCacheHas_default;
+  _SetCache_default = SetCache;
+});
+
+// ../../node_modules/lodash-es/_arraySome.js
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arraySome_default;
+var init__arraySome = __esm(() => {
+  _arraySome_default = arraySome;
+});
+
+// ../../node_modules/lodash-es/_cacheHas.js
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var _cacheHas_default;
+var init__cacheHas = __esm(() => {
+  _cacheHas_default = cacheHas;
+});
+
+// ../../node_modules/lodash-es/_equalArrays.js
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new _SetCache_default : undefined;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!_arraySome_default(other, function(othValue2, othIndex) {
+        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2, _equalArrays_default;
+var init__equalArrays = __esm(() => {
+  init__SetCache();
+  init__arraySome();
+  init__cacheHas();
+  _equalArrays_default = equalArrays;
+});
+
+// ../../node_modules/lodash-es/_Uint8Array.js
+var Uint8Array2, _Uint8Array_default;
+var init__Uint8Array = __esm(() => {
+  init__root();
+  Uint8Array2 = _root_default.Uint8Array;
+  _Uint8Array_default = Uint8Array2;
+});
+
+// ../../node_modules/lodash-es/_mapToArray.js
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray_default;
+var init__mapToArray = __esm(() => {
+  _mapToArray_default = mapToArray;
+});
+
+// ../../node_modules/lodash-es/_setToArray.js
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray_default;
+var init__setToArray = __esm(() => {
+  _setToArray_default = setToArray;
+});
+
+// ../../node_modules/lodash-es/_equalByTag.js
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new _Uint8Array_default(object), new _Uint8Array_default(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq_default(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag:
+      return object == other + "";
+    case mapTag:
+      var convert = _mapToArray_default;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
+      convert || (convert = _setToArray_default);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG2;
+      stack.set(object, other);
+      var result = _equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var COMPARE_PARTIAL_FLAG2 = 1, COMPARE_UNORDERED_FLAG2 = 2, boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", symbolProto, symbolValueOf, _equalByTag_default;
+var init__equalByTag = __esm(() => {
+  init__Symbol();
+  init__Uint8Array();
+  init_eq();
+  init__equalArrays();
+  init__mapToArray();
+  init__setToArray();
+  symbolProto = _Symbol_default ? _Symbol_default.prototype : undefined;
+  symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+  _equalByTag_default = equalByTag;
+});
+
+// ../../node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush_default;
+var init__arrayPush = __esm(() => {
+  _arrayPush_default = arrayPush;
+});
+
+// ../../node_modules/lodash-es/isArray.js
+var isArray, isArray_default;
+var init_isArray = __esm(() => {
+  isArray = Array.isArray;
+  isArray_default = isArray;
+});
+
+// ../../node_modules/lodash-es/_baseGetAllKeys.js
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray_default(object) ? result : _arrayPush_default(result, symbolsFunc(object));
+}
+var _baseGetAllKeys_default;
+var init__baseGetAllKeys = __esm(() => {
+  init__arrayPush();
+  init_isArray();
+  _baseGetAllKeys_default = baseGetAllKeys;
+});
+
+// ../../node_modules/lodash-es/_arrayFilter.js
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var _arrayFilter_default;
+var init__arrayFilter = __esm(() => {
+  _arrayFilter_default = arrayFilter;
+});
+
+// ../../node_modules/lodash-es/stubArray.js
+function stubArray() {
+  return [];
+}
+var stubArray_default;
+var init_stubArray = __esm(() => {
+  stubArray_default = stubArray;
+});
+
+// ../../node_modules/lodash-es/_getSymbols.js
+var objectProto6, propertyIsEnumerable, nativeGetSymbols, getSymbols, _getSymbols_default;
+var init__getSymbols = __esm(() => {
+  init__arrayFilter();
+  init_stubArray();
+  objectProto6 = Object.prototype;
+  propertyIsEnumerable = objectProto6.propertyIsEnumerable;
+  nativeGetSymbols = Object.getOwnPropertySymbols;
+  getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return _arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
+    });
+  };
+  _getSymbols_default = getSymbols;
+});
+
+// ../../node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var _baseTimes_default;
+var init__baseTimes = __esm(() => {
+  _baseTimes_default = baseTimes;
+});
+
+// ../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default;
+var init_isObjectLike = __esm(() => {
+  isObjectLike_default = isObjectLike;
+});
+
+// ../../node_modules/lodash-es/_baseIsArguments.js
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && _baseGetTag_default(value) == argsTag;
+}
+var argsTag = "[object Arguments]", _baseIsArguments_default;
+var init__baseIsArguments = __esm(() => {
+  init__baseGetTag();
+  init_isObjectLike();
+  _baseIsArguments_default = baseIsArguments;
+});
+
+// ../../node_modules/lodash-es/isArguments.js
+var objectProto7, hasOwnProperty5, propertyIsEnumerable2, isArguments, isArguments_default;
+var init_isArguments = __esm(() => {
+  init__baseIsArguments();
+  init_isObjectLike();
+  objectProto7 = Object.prototype;
+  hasOwnProperty5 = objectProto7.hasOwnProperty;
+  propertyIsEnumerable2 = objectProto7.propertyIsEnumerable;
+  isArguments = _baseIsArguments_default(function() {
+    return arguments;
+  }()) ? _baseIsArguments_default : function(value) {
+    return isObjectLike_default(value) && hasOwnProperty5.call(value, "callee") && !propertyIsEnumerable2.call(value, "callee");
+  };
+  isArguments_default = isArguments;
+});
+
+// ../../node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default;
+var init_stubFalse = __esm(() => {
+  stubFalse_default = stubFalse;
+});
+
+// ../../node_modules/lodash-es/isBuffer.js
+var exports_isBuffer = {};
+__export(exports_isBuffer, {
+  default: () => isBuffer_default
+});
+var freeExports, freeModule, moduleExports, Buffer2, nativeIsBuffer, isBuffer, isBuffer_default;
+var init_isBuffer = __esm(() => {
+  init__root();
+  init_stubFalse();
+  freeExports = typeof exports_isBuffer == "object" && exports_isBuffer && !exports_isBuffer.nodeType && exports_isBuffer;
+  freeModule = freeExports && typeof module_isBuffer == "object" && module_isBuffer && !module_isBuffer.nodeType && module_isBuffer;
+  moduleExports = freeModule && freeModule.exports === freeExports;
+  Buffer2 = moduleExports ? _root_default.Buffer : undefined;
+  nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined;
+  isBuffer = nativeIsBuffer || stubFalse_default;
+  isBuffer_default = isBuffer;
+});
+
+// ../../node_modules/lodash-es/_isIndex.js
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var MAX_SAFE_INTEGER = 9007199254740991, reIsUint, _isIndex_default;
+var init__isIndex = __esm(() => {
+  reIsUint = /^(?:0|[1-9]\d*)$/;
+  _isIndex_default = isIndex;
+});
+
+// ../../node_modules/lodash-es/isLength.js
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var MAX_SAFE_INTEGER2 = 9007199254740991, isLength_default;
+var init_isLength = __esm(() => {
+  isLength_default = isLength;
+});
+
+// ../../node_modules/lodash-es/_baseIsTypedArray.js
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[_baseGetTag_default(value)];
+}
+var argsTag2 = "[object Arguments]", arrayTag = "[object Array]", boolTag2 = "[object Boolean]", dateTag2 = "[object Date]", errorTag2 = "[object Error]", funcTag2 = "[object Function]", mapTag2 = "[object Map]", numberTag2 = "[object Number]", objectTag = "[object Object]", regexpTag2 = "[object RegExp]", setTag2 = "[object Set]", stringTag2 = "[object String]", weakMapTag = "[object WeakMap]", arrayBufferTag2 = "[object ArrayBuffer]", dataViewTag2 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]", typedArrayTags, _baseIsTypedArray_default;
+var init__baseIsTypedArray = __esm(() => {
+  init__baseGetTag();
+  init_isLength();
+  init_isObjectLike();
+  typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag2] = typedArrayTags[boolTag2] = typedArrayTags[dataViewTag2] = typedArrayTags[dateTag2] = typedArrayTags[errorTag2] = typedArrayTags[funcTag2] = typedArrayTags[mapTag2] = typedArrayTags[numberTag2] = typedArrayTags[objectTag] = typedArrayTags[regexpTag2] = typedArrayTags[setTag2] = typedArrayTags[stringTag2] = typedArrayTags[weakMapTag] = false;
+  _baseIsTypedArray_default = baseIsTypedArray;
+});
+
+// ../../node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var _baseUnary_default;
+var init__baseUnary = __esm(() => {
+  _baseUnary_default = baseUnary;
+});
+
+// ../../node_modules/lodash-es/_nodeUtil.js
+var exports__nodeUtil = {};
+__export(exports__nodeUtil, {
+  default: () => _nodeUtil_default
+});
+var freeExports2, freeModule2, moduleExports2, freeProcess, nodeUtil, _nodeUtil_default;
+var init__nodeUtil = __esm(() => {
+  init__freeGlobal();
+  freeExports2 = typeof exports__nodeUtil == "object" && exports__nodeUtil && !exports__nodeUtil.nodeType && exports__nodeUtil;
+  freeModule2 = freeExports2 && typeof module__nodeUtil == "object" && module__nodeUtil && !module__nodeUtil.nodeType && module__nodeUtil;
+  moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+  freeProcess = moduleExports2 && _freeGlobal_default.process;
+  nodeUtil = function() {
+    try {
+      var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+      if (types) {
+        return types;
+      }
+      return freeProcess && freeProcess.binding && freeProcess.binding("util");
+    } catch (e) {}
+  }();
+  _nodeUtil_default = nodeUtil;
+});
+
+// ../../node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray, isTypedArray, isTypedArray_default;
+var init_isTypedArray = __esm(() => {
+  init__baseIsTypedArray();
+  init__baseUnary();
+  init__nodeUtil();
+  nodeIsTypedArray = _nodeUtil_default && _nodeUtil_default.isTypedArray;
+  isTypedArray = nodeIsTypedArray ? _baseUnary_default(nodeIsTypedArray) : _baseIsTypedArray_default;
+  isTypedArray_default = isTypedArray;
+});
+
+// ../../node_modules/lodash-es/_arrayLikeKeys.js
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? _baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty6.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || _isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto8, hasOwnProperty6, _arrayLikeKeys_default;
+var init__arrayLikeKeys = __esm(() => {
+  init__baseTimes();
+  init_isArguments();
+  init_isArray();
+  init_isBuffer();
+  init__isIndex();
+  init_isTypedArray();
+  objectProto8 = Object.prototype;
+  hasOwnProperty6 = objectProto8.hasOwnProperty;
+  _arrayLikeKeys_default = arrayLikeKeys;
+});
+
+// ../../node_modules/lodash-es/_isPrototype.js
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto9;
+  return value === proto;
+}
+var objectProto9, _isPrototype_default;
+var init__isPrototype = __esm(() => {
+  objectProto9 = Object.prototype;
+  _isPrototype_default = isPrototype;
+});
+
+// ../../node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg_default;
+var init__overArg = __esm(() => {
+  _overArg_default = overArg;
+});
+
+// ../../node_modules/lodash-es/_nativeKeys.js
+var nativeKeys, _nativeKeys_default;
+var init__nativeKeys = __esm(() => {
+  init__overArg();
+  nativeKeys = _overArg_default(Object.keys, Object);
+  _nativeKeys_default = nativeKeys;
+});
+
+// ../../node_modules/lodash-es/_baseKeys.js
+function baseKeys(object) {
+  if (!_isPrototype_default(object)) {
+    return _nativeKeys_default(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty7.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto10, hasOwnProperty7, _baseKeys_default;
+var init__baseKeys = __esm(() => {
+  init__isPrototype();
+  init__nativeKeys();
+  objectProto10 = Object.prototype;
+  hasOwnProperty7 = objectProto10.hasOwnProperty;
+  _baseKeys_default = baseKeys;
+});
+
+// ../../node_modules/lodash-es/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default;
+var init_isArrayLike = __esm(() => {
+  init_isFunction();
+  init_isLength();
+  isArrayLike_default = isArrayLike;
+});
+
+// ../../node_modules/lodash-es/keys.js
+function keys(object) {
+  return isArrayLike_default(object) ? _arrayLikeKeys_default(object) : _baseKeys_default(object);
+}
+var keys_default;
+var init_keys = __esm(() => {
+  init__arrayLikeKeys();
+  init__baseKeys();
+  init_isArrayLike();
+  keys_default = keys;
+});
+
+// ../../node_modules/lodash-es/_getAllKeys.js
+function getAllKeys(object) {
+  return _baseGetAllKeys_default(object, keys_default, _getSymbols_default);
+}
+var _getAllKeys_default;
+var init__getAllKeys = __esm(() => {
+  init__baseGetAllKeys();
+  init__getSymbols();
+  init_keys();
+  _getAllKeys_default = getAllKeys;
+});
+
+// ../../node_modules/lodash-es/_equalObjects.js
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = _getAllKeys_default(object), objLength = objProps.length, othProps = _getAllKeys_default(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty8.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && (("constructor" in object) && ("constructor" in other)) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var COMPARE_PARTIAL_FLAG3 = 1, objectProto11, hasOwnProperty8, _equalObjects_default;
+var init__equalObjects = __esm(() => {
+  init__getAllKeys();
+  objectProto11 = Object.prototype;
+  hasOwnProperty8 = objectProto11.hasOwnProperty;
+  _equalObjects_default = equalObjects;
+});
+
+// ../../node_modules/lodash-es/_DataView.js
+var DataView, _DataView_default;
+var init__DataView = __esm(() => {
+  init__getNative();
+  init__root();
+  DataView = _getNative_default(_root_default, "DataView");
+  _DataView_default = DataView;
+});
+
+// ../../node_modules/lodash-es/_Promise.js
+var Promise2, _Promise_default;
+var init__Promise = __esm(() => {
+  init__getNative();
+  init__root();
+  Promise2 = _getNative_default(_root_default, "Promise");
+  _Promise_default = Promise2;
+});
+
+// ../../node_modules/lodash-es/_Set.js
+var Set2, _Set_default;
+var init__Set = __esm(() => {
+  init__getNative();
+  init__root();
+  Set2 = _getNative_default(_root_default, "Set");
+  _Set_default = Set2;
+});
+
+// ../../node_modules/lodash-es/_WeakMap.js
+var WeakMap2, _WeakMap_default;
+var init__WeakMap = __esm(() => {
+  init__getNative();
+  init__root();
+  WeakMap2 = _getNative_default(_root_default, "WeakMap");
+  _WeakMap_default = WeakMap2;
+});
+
+// ../../node_modules/lodash-es/_getTag.js
+var mapTag3 = "[object Map]", objectTag2 = "[object Object]", promiseTag = "[object Promise]", setTag3 = "[object Set]", weakMapTag2 = "[object WeakMap]", dataViewTag3 = "[object DataView]", dataViewCtorString, mapCtorString, promiseCtorString, setCtorString, weakMapCtorString, getTag, _getTag_default;
+var init__getTag = __esm(() => {
+  init__DataView();
+  init__Map();
+  init__Promise();
+  init__Set();
+  init__WeakMap();
+  init__baseGetTag();
+  init__toSource();
+  dataViewCtorString = _toSource_default(_DataView_default);
+  mapCtorString = _toSource_default(_Map_default);
+  promiseCtorString = _toSource_default(_Promise_default);
+  setCtorString = _toSource_default(_Set_default);
+  weakMapCtorString = _toSource_default(_WeakMap_default);
+  getTag = _baseGetTag_default;
+  if (_DataView_default && getTag(new _DataView_default(new ArrayBuffer(1))) != dataViewTag3 || _Map_default && getTag(new _Map_default) != mapTag3 || _Promise_default && getTag(_Promise_default.resolve()) != promiseTag || _Set_default && getTag(new _Set_default) != setTag3 || _WeakMap_default && getTag(new _WeakMap_default) != weakMapTag2) {
+    getTag = function(value) {
+      var result = _baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : undefined, ctorString = Ctor ? _toSource_default(Ctor) : "";
+      if (ctorString) {
+        switch (ctorString) {
+          case dataViewCtorString:
+            return dataViewTag3;
+          case mapCtorString:
+            return mapTag3;
+          case promiseCtorString:
+            return promiseTag;
+          case setCtorString:
+            return setTag3;
+          case weakMapCtorString:
+            return weakMapTag2;
+        }
+      }
+      return result;
+    };
+  }
+  _getTag_default = getTag;
+});
+
+// ../../node_modules/lodash-es/_baseIsEqualDeep.js
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag2 : _getTag_default(object), othTag = othIsArr ? arrayTag2 : _getTag_default(other);
+  objTag = objTag == argsTag3 ? objectTag3 : objTag;
+  othTag = othTag == argsTag3 ? objectTag3 : othTag;
+  var objIsObj = objTag == objectTag3, othIsObj = othTag == objectTag3, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer_default(object)) {
+    if (!isBuffer_default(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new _Stack_default);
+    return objIsArr || isTypedArray_default(object) ? _equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
+    var objIsWrapped = objIsObj && hasOwnProperty9.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new _Stack_default);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new _Stack_default);
+  return _equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
+}
+var COMPARE_PARTIAL_FLAG4 = 1, argsTag3 = "[object Arguments]", arrayTag2 = "[object Array]", objectTag3 = "[object Object]", objectProto12, hasOwnProperty9, _baseIsEqualDeep_default;
+var init__baseIsEqualDeep = __esm(() => {
+  init__Stack();
+  init__equalArrays();
+  init__equalByTag();
+  init__equalObjects();
+  init__getTag();
+  init_isArray();
+  init_isBuffer();
+  init_isTypedArray();
+  objectProto12 = Object.prototype;
+  hasOwnProperty9 = objectProto12.hasOwnProperty;
+  _baseIsEqualDeep_default = baseIsEqualDeep;
+});
+
+// ../../node_modules/lodash-es/_baseIsEqual.js
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
+    return value !== value && other !== other;
+  }
+  return _baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var _baseIsEqual_default;
+var init__baseIsEqual = __esm(() => {
+  init__baseIsEqualDeep();
+  init_isObjectLike();
+  _baseIsEqual_default = baseIsEqual;
+});
+
+// ../../node_modules/lodash-es/_baseIsMatch.js
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index, noCustomizer = !customizer;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new _Stack_default;
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined ? _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var COMPARE_PARTIAL_FLAG5 = 1, COMPARE_UNORDERED_FLAG3 = 2, _baseIsMatch_default;
+var init__baseIsMatch = __esm(() => {
+  init__Stack();
+  init__baseIsEqual();
+  _baseIsMatch_default = baseIsMatch;
+});
+
+// ../../node_modules/lodash-es/_isStrictComparable.js
+function isStrictComparable(value) {
+  return value === value && !isObject_default(value);
+}
+var _isStrictComparable_default;
+var init__isStrictComparable = __esm(() => {
+  init_isObject();
+  _isStrictComparable_default = isStrictComparable;
+});
+
+// ../../node_modules/lodash-es/_getMatchData.js
+function getMatchData(object) {
+  var result = keys_default(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, _isStrictComparable_default(value)];
+  }
+  return result;
+}
+var _getMatchData_default;
+var init__getMatchData = __esm(() => {
+  init__isStrictComparable();
+  init_keys();
+  _getMatchData_default = getMatchData;
+});
+
+// ../../node_modules/lodash-es/_matchesStrictComparable.js
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== undefined || (key in Object(object)));
+  };
+}
+var _matchesStrictComparable_default;
+var init__matchesStrictComparable = __esm(() => {
+  _matchesStrictComparable_default = matchesStrictComparable;
+});
+
+// ../../node_modules/lodash-es/_baseMatches.js
+function baseMatches(source) {
+  var matchData = _getMatchData_default(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return _matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || _baseIsMatch_default(object, source, matchData);
+  };
+}
+var _baseMatches_default;
+var init__baseMatches = __esm(() => {
+  init__baseIsMatch();
+  init__getMatchData();
+  init__matchesStrictComparable();
+  _baseMatches_default = baseMatches;
+});
+
+// ../../node_modules/lodash-es/isSymbol.js
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && _baseGetTag_default(value) == symbolTag2;
+}
+var symbolTag2 = "[object Symbol]", isSymbol_default;
+var init_isSymbol = __esm(() => {
+  init__baseGetTag();
+  init_isObjectLike();
+  isSymbol_default = isSymbol;
+});
+
+// ../../node_modules/lodash-es/_isKey.js
+function isKey(value, object) {
+  if (isArray_default(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var reIsDeepProp, reIsPlainProp, _isKey_default;
+var init__isKey = __esm(() => {
+  init_isArray();
+  init_isSymbol();
+  reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+  reIsPlainProp = /^\w*$/;
+  _isKey_default = isKey;
+});
+
+// ../../node_modules/lodash-es/memoize.js
+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_default);
+  return memoized;
+}
+var FUNC_ERROR_TEXT = "Expected a function", memoize_default;
+var init_memoize = __esm(() => {
+  init__MapCache();
+  memoize.Cache = _MapCache_default;
+  memoize_default = memoize;
+});
+
+// ../../node_modules/lodash-es/_memoizeCapped.js
+function memoizeCapped(func) {
+  var result = memoize_default(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var MAX_MEMOIZE_SIZE = 500, _memoizeCapped_default;
+var init__memoizeCapped = __esm(() => {
+  init_memoize();
+  _memoizeCapped_default = memoizeCapped;
+});
+
+// ../../node_modules/lodash-es/_stringToPath.js
+var rePropName, reEscapeChar, stringToPath, _stringToPath_default;
+var init__stringToPath = __esm(() => {
+  init__memoizeCapped();
+  rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+  reEscapeChar = /\\(\\)?/g;
+  stringToPath = _memoizeCapped_default(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;
+  });
+  _stringToPath_default = stringToPath;
+});
+
+// ../../node_modules/lodash-es/_arrayMap.js
+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;
+}
+var _arrayMap_default;
+var init__arrayMap = __esm(() => {
+  _arrayMap_default = arrayMap;
+});
+
+// ../../node_modules/lodash-es/_baseToString.js
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray_default(value)) {
+    return _arrayMap_default(value, baseToString) + "";
+  }
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var INFINITY, symbolProto2, symbolToString, _baseToString_default;
+var init__baseToString = __esm(() => {
+  init__Symbol();
+  init__arrayMap();
+  init_isArray();
+  init_isSymbol();
+  INFINITY = 1 / 0;
+  symbolProto2 = _Symbol_default ? _Symbol_default.prototype : undefined;
+  symbolToString = symbolProto2 ? symbolProto2.toString : undefined;
+  _baseToString_default = baseToString;
+});
+
+// ../../node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : _baseToString_default(value);
+}
+var toString_default;
+var init_toString = __esm(() => {
+  init__baseToString();
+  toString_default = toString;
+});
+
+// ../../node_modules/lodash-es/_castPath.js
+function castPath(value, object) {
+  if (isArray_default(value)) {
+    return value;
+  }
+  return _isKey_default(value, object) ? [value] : _stringToPath_default(toString_default(value));
+}
+var _castPath_default;
+var init__castPath = __esm(() => {
+  init_isArray();
+  init__isKey();
+  init__stringToPath();
+  init_toString();
+  _castPath_default = castPath;
+});
+
+// ../../node_modules/lodash-es/_toKey.js
+function toKey(value) {
+  if (typeof value == "string" || isSymbol_default(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
+}
+var INFINITY2, _toKey_default;
+var init__toKey = __esm(() => {
+  init_isSymbol();
+  INFINITY2 = 1 / 0;
+  _toKey_default = toKey;
+});
+
+// ../../node_modules/lodash-es/_baseGet.js
+function baseGet(object, path6) {
+  path6 = _castPath_default(path6, object);
+  var index = 0, length = path6.length;
+  while (object != null && index < length) {
+    object = object[_toKey_default(path6[index++])];
+  }
+  return index && index == length ? object : undefined;
+}
+var _baseGet_default;
+var init__baseGet = __esm(() => {
+  init__castPath();
+  init__toKey();
+  _baseGet_default = baseGet;
+});
+
+// ../../node_modules/lodash-es/get.js
+function get(object, path6, defaultValue) {
+  var result = object == null ? undefined : _baseGet_default(object, path6);
+  return result === undefined ? defaultValue : result;
+}
+var get_default;
+var init_get = __esm(() => {
+  init__baseGet();
+  get_default = get;
+});
+
+// ../../node_modules/lodash-es/_baseHasIn.js
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+var _baseHasIn_default;
+var init__baseHasIn = __esm(() => {
+  _baseHasIn_default = baseHasIn;
+});
+
+// ../../node_modules/lodash-es/_hasPath.js
+function hasPath(object, path6, hasFunc) {
+  path6 = _castPath_default(path6, object);
+  var index = -1, length = path6.length, result = false;
+  while (++index < length) {
+    var key = _toKey_default(path6[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength_default(length) && _isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
+}
+var _hasPath_default;
+var init__hasPath = __esm(() => {
+  init__castPath();
+  init_isArguments();
+  init_isArray();
+  init__isIndex();
+  init_isLength();
+  init__toKey();
+  _hasPath_default = hasPath;
+});
+
+// ../../node_modules/lodash-es/hasIn.js
+function hasIn(object, path6) {
+  return object != null && _hasPath_default(object, path6, _baseHasIn_default);
+}
+var hasIn_default;
+var init_hasIn = __esm(() => {
+  init__baseHasIn();
+  init__hasPath();
+  hasIn_default = hasIn;
+});
+
+// ../../node_modules/lodash-es/_baseMatchesProperty.js
+function baseMatchesProperty(path6, srcValue) {
+  if (_isKey_default(path6) && _isStrictComparable_default(srcValue)) {
+    return _matchesStrictComparable_default(_toKey_default(path6), srcValue);
+  }
+  return function(object) {
+    var objValue = get_default(object, path6);
+    return objValue === undefined && objValue === srcValue ? hasIn_default(object, path6) : _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+  };
+}
+var COMPARE_PARTIAL_FLAG6 = 1, COMPARE_UNORDERED_FLAG4 = 2, _baseMatchesProperty_default;
+var init__baseMatchesProperty = __esm(() => {
+  init__baseIsEqual();
+  init_get();
+  init_hasIn();
+  init__isKey();
+  init__isStrictComparable();
+  init__matchesStrictComparable();
+  init__toKey();
+  _baseMatchesProperty_default = baseMatchesProperty;
+});
+
+// ../../node_modules/lodash-es/identity.js
+function identity(value) {
+  return value;
+}
+var identity_default;
+var init_identity = __esm(() => {
+  identity_default = identity;
+});
+
+// ../../node_modules/lodash-es/_baseProperty.js
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+var _baseProperty_default;
+var init__baseProperty = __esm(() => {
+  _baseProperty_default = baseProperty;
+});
+
+// ../../node_modules/lodash-es/_basePropertyDeep.js
+function basePropertyDeep(path6) {
+  return function(object) {
+    return _baseGet_default(object, path6);
+  };
+}
+var _basePropertyDeep_default;
+var init__basePropertyDeep = __esm(() => {
+  init__baseGet();
+  _basePropertyDeep_default = basePropertyDeep;
+});
+
+// ../../node_modules/lodash-es/property.js
+function property(path6) {
+  return _isKey_default(path6) ? _baseProperty_default(_toKey_default(path6)) : _basePropertyDeep_default(path6);
+}
+var property_default;
+var init_property = __esm(() => {
+  init__baseProperty();
+  init__basePropertyDeep();
+  init__isKey();
+  init__toKey();
+  property_default = property;
+});
+
+// ../../node_modules/lodash-es/_baseIteratee.js
+function baseIteratee(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity_default;
+  }
+  if (typeof value == "object") {
+    return isArray_default(value) ? _baseMatchesProperty_default(value[0], value[1]) : _baseMatches_default(value);
+  }
+  return property_default(value);
+}
+var _baseIteratee_default;
+var init__baseIteratee = __esm(() => {
+  init__baseMatches();
+  init__baseMatchesProperty();
+  init_identity();
+  init_isArray();
+  init_property();
+  _baseIteratee_default = baseIteratee;
+});
+
+// ../../node_modules/lodash-es/_createFind.js
+function createFind(findIndexFunc) {
+  return function(collection, predicate, fromIndex) {
+    var iterable = Object(collection);
+    if (!isArrayLike_default(collection)) {
+      var iteratee = _baseIteratee_default(predicate, 3);
+      collection = keys_default(collection);
+      predicate = function(key) {
+        return iteratee(iterable[key], key, iterable);
+      };
+    }
+    var index = findIndexFunc(collection, predicate, fromIndex);
+    return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
+  };
+}
+var _createFind_default;
+var init__createFind = __esm(() => {
+  init__baseIteratee();
+  init_isArrayLike();
+  init_keys();
+  _createFind_default = createFind;
+});
+
+// ../../node_modules/lodash-es/_baseFindIndex.js
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+  while (fromRight ? index-- : ++index < length) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _baseFindIndex_default;
+var init__baseFindIndex = __esm(() => {
+  _baseFindIndex_default = baseFindIndex;
+});
+
+// ../../node_modules/lodash-es/_trimmedEndIndex.js
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+var reWhitespace, _trimmedEndIndex_default;
+var init__trimmedEndIndex = __esm(() => {
+  reWhitespace = /\s/;
+  _trimmedEndIndex_default = trimmedEndIndex;
+});
+
+// ../../node_modules/lodash-es/_baseTrim.js
+function baseTrim(string) {
+  return string ? string.slice(0, _trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
+}
+var reTrimStart, _baseTrim_default;
+var init__baseTrim = __esm(() => {
+  init__trimmedEndIndex();
+  reTrimStart = /^\s+/;
+  _baseTrim_default = baseTrim;
+});
+
+// ../../node_modules/lodash-es/toNumber.js
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol_default(value)) {
+    return NAN;
+  }
+  if (isObject_default(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject_default(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = _baseTrim_default(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var NAN, reIsBadHex, reIsBinary, reIsOctal, freeParseInt, toNumber_default;
+var init_toNumber = __esm(() => {
+  init__baseTrim();
+  init_isObject();
+  init_isSymbol();
+  NAN = 0 / 0;
+  reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+  reIsBinary = /^0b[01]+$/i;
+  reIsOctal = /^0o[0-7]+$/i;
+  freeParseInt = parseInt;
+  toNumber_default = toNumber;
+});
+
+// ../../node_modules/lodash-es/toFinite.js
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber_default(value);
+  if (value === INFINITY3 || value === -INFINITY3) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+var INFINITY3, MAX_INTEGER = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, toFinite_default;
+var init_toFinite = __esm(() => {
+  init_toNumber();
+  INFINITY3 = 1 / 0;
+  toFinite_default = toFinite;
+});
+
+// ../../node_modules/lodash-es/toInteger.js
+function toInteger(value) {
+  var result = toFinite_default(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var toInteger_default;
+var init_toInteger = __esm(() => {
+  init_toFinite();
+  toInteger_default = toInteger;
+});
+
+// ../../node_modules/lodash-es/findIndex.js
+function findIndex(array, predicate, fromIndex) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return -1;
+  }
+  var index = fromIndex == null ? 0 : toInteger_default(fromIndex);
+  if (index < 0) {
+    index = nativeMax(length + index, 0);
+  }
+  return _baseFindIndex_default(array, _baseIteratee_default(predicate, 3), index);
+}
+var nativeMax, findIndex_default;
+var init_findIndex = __esm(() => {
+  init__baseFindIndex();
+  init__baseIteratee();
+  init_toInteger();
+  nativeMax = Math.max;
+  findIndex_default = findIndex;
+});
+
+// ../../node_modules/lodash-es/find.js
+var find, find_default;
+var init_find = __esm(() => {
+  init__createFind();
+  init_findIndex();
+  find = _createFind_default(findIndex_default);
+  find_default = find;
+});
+
+// ../../node_modules/lodash-es/_arrayEach.js
+function arrayEach(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+var _arrayEach_default;
+var init__arrayEach = __esm(() => {
+  _arrayEach_default = arrayEach;
+});
+
+// ../../node_modules/lodash-es/_createBaseFor.js
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var _createBaseFor_default;
+var init__createBaseFor = __esm(() => {
+  _createBaseFor_default = createBaseFor;
+});
+
+// ../../node_modules/lodash-es/_baseFor.js
+var baseFor, _baseFor_default;
+var init__baseFor = __esm(() => {
+  init__createBaseFor();
+  baseFor = _createBaseFor_default();
+  _baseFor_default = baseFor;
+});
+
+// ../../node_modules/lodash-es/_baseForOwn.js
+function baseForOwn(object, iteratee) {
+  return object && _baseFor_default(object, iteratee, keys_default);
+}
+var _baseForOwn_default;
+var init__baseForOwn = __esm(() => {
+  init__baseFor();
+  init_keys();
+  _baseForOwn_default = baseForOwn;
+});
+
+// ../../node_modules/lodash-es/_createBaseEach.js
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike_default(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+    while (fromRight ? index-- : ++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+var _createBaseEach_default;
+var init__createBaseEach = __esm(() => {
+  init_isArrayLike();
+  _createBaseEach_default = createBaseEach;
+});
+
+// ../../node_modules/lodash-es/_baseEach.js
+var baseEach, _baseEach_default;
+var init__baseEach = __esm(() => {
+  init__baseForOwn();
+  init__createBaseEach();
+  baseEach = _createBaseEach_default(_baseForOwn_default);
+  _baseEach_default = baseEach;
+});
+
+// ../../node_modules/lodash-es/_castFunction.js
+function castFunction(value) {
+  return typeof value == "function" ? value : identity_default;
+}
+var _castFunction_default;
+var init__castFunction = __esm(() => {
+  init_identity();
+  _castFunction_default = castFunction;
+});
+
+// ../../node_modules/lodash-es/forEach.js
+function forEach(collection, iteratee) {
+  var func = isArray_default(collection) ? _arrayEach_default : _baseEach_default;
+  return func(collection, _castFunction_default(iteratee));
+}
+var forEach_default;
+var init_forEach = __esm(() => {
+  init__arrayEach();
+  init__baseEach();
+  init__castFunction();
+  init_isArray();
+  forEach_default = forEach;
+});
+
+// ../../node_modules/lodash-es/isEmpty.js
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (isArrayLike_default(value) && (isArray_default(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer_default(value) || isTypedArray_default(value) || isArguments_default(value))) {
+    return !value.length;
+  }
+  var tag = _getTag_default(value);
+  if (tag == mapTag4 || tag == setTag4) {
+    return !value.size;
+  }
+  if (_isPrototype_default(value)) {
+    return !_baseKeys_default(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty10.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+var mapTag4 = "[object Map]", setTag4 = "[object Set]", objectProto13, hasOwnProperty10, isEmpty_default;
+var init_isEmpty = __esm(() => {
+  init__baseKeys();
+  init__getTag();
+  init_isArguments();
+  init_isArray();
+  init_isArrayLike();
+  init_isBuffer();
+  init__isPrototype();
+  init_isTypedArray();
+  objectProto13 = Object.prototype;
+  hasOwnProperty10 = objectProto13.hasOwnProperty;
+  isEmpty_default = isEmpty;
+});
+
+// ../../node_modules/lodash-es/_baseMap.js
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike_default(collection) ? Array(collection.length) : [];
+  _baseEach_default(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+var _baseMap_default;
+var init__baseMap = __esm(() => {
+  init__baseEach();
+  init_isArrayLike();
+  _baseMap_default = baseMap;
+});
+
+// ../../node_modules/lodash-es/map.js
+function map(collection, iteratee) {
+  var func = isArray_default(collection) ? _arrayMap_default : _baseMap_default;
+  return func(collection, _baseIteratee_default(iteratee, 3));
+}
+var map_default;
+var init_map = __esm(() => {
+  init__arrayMap();
+  init__baseIteratee();
+  init__baseMap();
+  init_isArray();
+  map_default = map;
+});
+
+// ../../node_modules/lodash-es/_defineProperty.js
+var defineProperty, _defineProperty_default;
+var init__defineProperty = __esm(() => {
+  init__getNative();
+  defineProperty = function() {
+    try {
+      var func = _getNative_default(Object, "defineProperty");
+      func({}, "", {});
+      return func;
+    } catch (e) {}
+  }();
+  _defineProperty_default = defineProperty;
+});
+
+// ../../node_modules/lodash-es/_baseAssignValue.js
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && _defineProperty_default) {
+    _defineProperty_default(object, key, {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var _baseAssignValue_default;
+var init__baseAssignValue = __esm(() => {
+  init__defineProperty();
+  _baseAssignValue_default = baseAssignValue;
+});
+
+// ../../node_modules/lodash-es/_assignMergeValue.js
+function assignMergeValue(object, key, value) {
+  if (value !== undefined && !eq_default(object[key], value) || value === undefined && !(key in object)) {
+    _baseAssignValue_default(object, key, value);
+  }
+}
+var _assignMergeValue_default;
+var init__assignMergeValue = __esm(() => {
+  init__baseAssignValue();
+  init_eq();
+  _assignMergeValue_default = assignMergeValue;
+});
+
+// ../../node_modules/lodash-es/_cloneBuffer.js
+var exports__cloneBuffer = {};
+__export(exports__cloneBuffer, {
+  default: () => _cloneBuffer_default
+});
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+var freeExports3, freeModule3, moduleExports3, Buffer3, allocUnsafe, _cloneBuffer_default;
+var init__cloneBuffer = __esm(() => {
+  init__root();
+  freeExports3 = typeof exports__cloneBuffer == "object" && exports__cloneBuffer && !exports__cloneBuffer.nodeType && exports__cloneBuffer;
+  freeModule3 = freeExports3 && typeof module__cloneBuffer == "object" && module__cloneBuffer && !module__cloneBuffer.nodeType && module__cloneBuffer;
+  moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
+  Buffer3 = moduleExports3 ? _root_default.Buffer : undefined;
+  allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : undefined;
+  _cloneBuffer_default = cloneBuffer;
+});
+
+// ../../node_modules/lodash-es/_cloneArrayBuffer.js
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new _Uint8Array_default(result).set(new _Uint8Array_default(arrayBuffer));
+  return result;
+}
+var _cloneArrayBuffer_default;
+var init__cloneArrayBuffer = __esm(() => {
+  init__Uint8Array();
+  _cloneArrayBuffer_default = cloneArrayBuffer;
+});
+
+// ../../node_modules/lodash-es/_cloneTypedArray.js
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? _cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var _cloneTypedArray_default;
+var init__cloneTypedArray = __esm(() => {
+  init__cloneArrayBuffer();
+  _cloneTypedArray_default = cloneTypedArray;
+});
+
+// ../../node_modules/lodash-es/_copyArray.js
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+var _copyArray_default;
+var init__copyArray = __esm(() => {
+  _copyArray_default = copyArray;
+});
+
+// ../../node_modules/lodash-es/_baseCreate.js
+var objectCreate, baseCreate, _baseCreate_default;
+var init__baseCreate = __esm(() => {
+  init_isObject();
+  objectCreate = Object.create;
+  baseCreate = function() {
+    function object() {}
+    return function(proto) {
+      if (!isObject_default(proto)) {
+        return {};
+      }
+      if (objectCreate) {
+        return objectCreate(proto);
+      }
+      object.prototype = proto;
+      var result = new object;
+      object.prototype = undefined;
+      return result;
+    };
+  }();
+  _baseCreate_default = baseCreate;
+});
+
+// ../../node_modules/lodash-es/_getPrototype.js
+var getPrototype, _getPrototype_default;
+var init__getPrototype = __esm(() => {
+  init__overArg();
+  getPrototype = _overArg_default(Object.getPrototypeOf, Object);
+  _getPrototype_default = getPrototype;
+});
+
+// ../../node_modules/lodash-es/_initCloneObject.js
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !_isPrototype_default(object) ? _baseCreate_default(_getPrototype_default(object)) : {};
+}
+var _initCloneObject_default;
+var init__initCloneObject = __esm(() => {
+  init__baseCreate();
+  init__getPrototype();
+  init__isPrototype();
+  _initCloneObject_default = initCloneObject;
+});
+
+// ../../node_modules/lodash-es/isArrayLikeObject.js
+function isArrayLikeObject(value) {
+  return isObjectLike_default(value) && isArrayLike_default(value);
+}
+var isArrayLikeObject_default;
+var init_isArrayLikeObject = __esm(() => {
+  init_isArrayLike();
+  init_isObjectLike();
+  isArrayLikeObject_default = isArrayLikeObject;
+});
+
+// ../../node_modules/lodash-es/isPlainObject.js
+function isPlainObject2(value) {
+  if (!isObjectLike_default(value) || _baseGetTag_default(value) != objectTag4) {
+    return false;
+  }
+  var proto = _getPrototype_default(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty11.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
+}
+var objectTag4 = "[object Object]", funcProto3, objectProto14, funcToString3, hasOwnProperty11, objectCtorString, isPlainObject_default;
+var init_isPlainObject = __esm(() => {
+  init__baseGetTag();
+  init__getPrototype();
+  init_isObjectLike();
+  funcProto3 = Function.prototype;
+  objectProto14 = Object.prototype;
+  funcToString3 = funcProto3.toString;
+  hasOwnProperty11 = objectProto14.hasOwnProperty;
+  objectCtorString = funcToString3.call(Object);
+  isPlainObject_default = isPlainObject2;
+});
+
+// ../../node_modules/lodash-es/_safeGet.js
+function safeGet(object, key) {
+  if (key === "constructor" && typeof object[key] === "function") {
+    return;
+  }
+  if (key == "__proto__") {
+    return;
+  }
+  return object[key];
+}
+var _safeGet_default;
+var init__safeGet = __esm(() => {
+  _safeGet_default = safeGet;
+});
+
+// ../../node_modules/lodash-es/_assignValue.js
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty12.call(object, key) && eq_default(objValue, value)) || value === undefined && !(key in object)) {
+    _baseAssignValue_default(object, key, value);
+  }
+}
+var objectProto15, hasOwnProperty12, _assignValue_default;
+var init__assignValue = __esm(() => {
+  init__baseAssignValue();
+  init_eq();
+  objectProto15 = Object.prototype;
+  hasOwnProperty12 = objectProto15.hasOwnProperty;
+  _assignValue_default = assignValue;
+});
+
+// ../../node_modules/lodash-es/_copyObject.js
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;
+    if (newValue === undefined) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      _baseAssignValue_default(object, key, newValue);
+    } else {
+      _assignValue_default(object, key, newValue);
+    }
+  }
+  return object;
+}
+var _copyObject_default;
+var init__copyObject = __esm(() => {
+  init__assignValue();
+  init__baseAssignValue();
+  _copyObject_default = copyObject;
+});
+
+// ../../node_modules/lodash-es/_nativeKeysIn.js
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _nativeKeysIn_default;
+var init__nativeKeysIn = __esm(() => {
+  _nativeKeysIn_default = nativeKeysIn;
+});
+
+// ../../node_modules/lodash-es/_baseKeysIn.js
+function baseKeysIn(object) {
+  if (!isObject_default(object)) {
+    return _nativeKeysIn_default(object);
+  }
+  var isProto = _isPrototype_default(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty13.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto16, hasOwnProperty13, _baseKeysIn_default;
+var init__baseKeysIn = __esm(() => {
+  init_isObject();
+  init__isPrototype();
+  init__nativeKeysIn();
+  objectProto16 = Object.prototype;
+  hasOwnProperty13 = objectProto16.hasOwnProperty;
+  _baseKeysIn_default = baseKeysIn;
+});
+
+// ../../node_modules/lodash-es/keysIn.js
+function keysIn(object) {
+  return isArrayLike_default(object) ? _arrayLikeKeys_default(object, true) : _baseKeysIn_default(object);
+}
+var keysIn_default;
+var init_keysIn = __esm(() => {
+  init__arrayLikeKeys();
+  init__baseKeysIn();
+  init_isArrayLike();
+  keysIn_default = keysIn;
+});
+
+// ../../node_modules/lodash-es/toPlainObject.js
+function toPlainObject(value) {
+  return _copyObject_default(value, keysIn_default(value));
+}
+var toPlainObject_default;
+var init_toPlainObject = __esm(() => {
+  init__copyObject();
+  init_keysIn();
+  toPlainObject_default = toPlainObject;
+});
+
+// ../../node_modules/lodash-es/_baseMergeDeep.js
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = _safeGet_default(object, key), srcValue = _safeGet_default(source, key), stacked = stack.get(srcValue);
+  if (stacked) {
+    _assignMergeValue_default(object, key, stacked);
+    return;
+  }
+  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : undefined;
+  var isCommon = newValue === undefined;
+  if (isCommon) {
+    var isArr = isArray_default(srcValue), isBuff = !isArr && isBuffer_default(srcValue), isTyped = !isArr && !isBuff && isTypedArray_default(srcValue);
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray_default(objValue)) {
+        newValue = objValue;
+      } else if (isArrayLikeObject_default(objValue)) {
+        newValue = _copyArray_default(objValue);
+      } else if (isBuff) {
+        isCommon = false;
+        newValue = _cloneBuffer_default(srcValue, true);
+      } else if (isTyped) {
+        isCommon = false;
+        newValue = _cloneTypedArray_default(srcValue, true);
+      } else {
+        newValue = [];
+      }
+    } else if (isPlainObject_default(srcValue) || isArguments_default(srcValue)) {
+      newValue = objValue;
+      if (isArguments_default(objValue)) {
+        newValue = toPlainObject_default(objValue);
+      } else if (!isObject_default(objValue) || isFunction_default(objValue)) {
+        newValue = _initCloneObject_default(srcValue);
+      }
+    } else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack["delete"](srcValue);
+  }
+  _assignMergeValue_default(object, key, newValue);
+}
+var _baseMergeDeep_default;
+var init__baseMergeDeep = __esm(() => {
+  init__assignMergeValue();
+  init__cloneBuffer();
+  init__cloneTypedArray();
+  init__copyArray();
+  init__initCloneObject();
+  init_isArguments();
+  init_isArray();
+  init_isArrayLikeObject();
+  init_isBuffer();
+  init_isFunction();
+  init_isObject();
+  init_isPlainObject();
+  init_isTypedArray();
+  init__safeGet();
+  init_toPlainObject();
+  _baseMergeDeep_default = baseMergeDeep;
+});
+
+// ../../node_modules/lodash-es/_baseMerge.js
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  _baseFor_default(source, function(srcValue, key) {
+    stack || (stack = new _Stack_default);
+    if (isObject_default(srcValue)) {
+      _baseMergeDeep_default(object, source, key, srcIndex, baseMerge, customizer, stack);
+    } else {
+      var newValue = customizer ? customizer(_safeGet_default(object, key), srcValue, key + "", object, source, stack) : undefined;
+      if (newValue === undefined) {
+        newValue = srcValue;
+      }
+      _assignMergeValue_default(object, key, newValue);
+    }
+  }, keysIn_default);
+}
+var _baseMerge_default;
+var init__baseMerge = __esm(() => {
+  init__Stack();
+  init__assignMergeValue();
+  init__baseFor();
+  init__baseMergeDeep();
+  init_isObject();
+  init_keysIn();
+  init__safeGet();
+  _baseMerge_default = baseMerge;
+});
+
+// ../../node_modules/lodash-es/_apply.js
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+var _apply_default;
+var init__apply = __esm(() => {
+  _apply_default = apply;
+});
+
+// ../../node_modules/lodash-es/_overRest.js
+function overRest(func, start, transform) {
+  start = nativeMax2(start === undefined ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index = -1, length = nativeMax2(args.length - start, 0), array = Array(length);
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return _apply_default(func, this, otherArgs);
+  };
+}
+var nativeMax2, _overRest_default;
+var init__overRest = __esm(() => {
+  init__apply();
+  nativeMax2 = Math.max;
+  _overRest_default = overRest;
+});
+
+// ../../node_modules/lodash-es/constant.js
+function constant(value) {
+  return function() {
+    return value;
+  };
 }
-function migrateConfigToLatest(rawConfig) {
-  const migrationMap = buildMigrationMap(CONFIG_MIGRATIONS);
-  const originalVersion = detectConfigVersion(rawConfig);
-  let currentVersion = originalVersion;
-  let workingConfig = cloneJson(rawConfig);
-  const changes = [];
-  const warnings = [];
-  while (currentVersion < LATEST_CONFIG_VERSION) {
-    const migration4 = migrationMap.get(currentVersion);
-    if (!migration4) {
-      throw new Error(`No config migration registered from version ${currentVersion}`);
+var constant_default;
+var init_constant = __esm(() => {
+  constant_default = constant;
+});
+
+// ../../node_modules/lodash-es/_baseSetToString.js
+var baseSetToString, _baseSetToString_default;
+var init__baseSetToString = __esm(() => {
+  init_constant();
+  init__defineProperty();
+  init_identity();
+  baseSetToString = !_defineProperty_default ? identity_default : function(func, string) {
+    return _defineProperty_default(func, "toString", {
+      configurable: true,
+      enumerable: false,
+      value: constant_default(string),
+      writable: true
+    });
+  };
+  _baseSetToString_default = baseSetToString;
+});
+
+// ../../node_modules/lodash-es/_shortOut.js
+function shortOut(func) {
+  var count = 0, lastCalled = 0;
+  return function() {
+    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
     }
-    const result = migration4.migrate(workingConfig);
-    workingConfig = result.config;
-    changes.push(...result.changes);
-    warnings.push(...result.warnings);
-    currentVersion = migration4.toVersion;
+    return func.apply(undefined, arguments);
+  };
+}
+var HOT_COUNT = 800, HOT_SPAN = 16, nativeNow, _shortOut_default;
+var init__shortOut = __esm(() => {
+  nativeNow = Date.now;
+  _shortOut_default = shortOut;
+});
+
+// ../../node_modules/lodash-es/_setToString.js
+var setToString, _setToString_default;
+var init__setToString = __esm(() => {
+  init__baseSetToString();
+  init__shortOut();
+  setToString = _shortOut_default(_baseSetToString_default);
+  _setToString_default = setToString;
+});
+
+// ../../node_modules/lodash-es/_baseRest.js
+function baseRest(func, start) {
+  return _setToString_default(_overRest_default(func, start, identity_default), func + "");
+}
+var _baseRest_default;
+var init__baseRest = __esm(() => {
+  init_identity();
+  init__overRest();
+  init__setToString();
+  _baseRest_default = baseRest;
+});
+
+// ../../node_modules/lodash-es/_isIterateeCall.js
+function isIterateeCall(value, index, object) {
+  if (!isObject_default(object)) {
+    return false;
   }
-  if (!isPlainRecord(workingConfig)) {
-    throw new Error("Migrated config must be an object");
+  var type = typeof index;
+  if (type == "number" ? isArrayLike_default(object) && _isIndex_default(index, object.length) : type == "string" && (index in object)) {
+    return eq_default(object[index], value);
   }
-  workingConfig.configVersion = LATEST_CONFIG_VERSION;
-  return {
-    config: workingConfig,
-    originalVersion,
-    finalVersion: LATEST_CONFIG_VERSION,
-    changes,
-    warnings
+  return false;
+}
+var _isIterateeCall_default;
+var init__isIterateeCall = __esm(() => {
+  init_eq();
+  init_isArrayLike();
+  init__isIndex();
+  init_isObject();
+  _isIterateeCall_default = isIterateeCall;
+});
+
+// ../../node_modules/lodash-es/_createAssigner.js
+function createAssigner(assigner) {
+  return _baseRest_default(function(object, sources) {
+    var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined, guard = length > 2 ? sources[2] : undefined;
+    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined;
+    if (guard && _isIterateeCall_default(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? undefined : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+var _createAssigner_default;
+var init__createAssigner = __esm(() => {
+  init__baseRest();
+  init__isIterateeCall();
+  _createAssigner_default = createAssigner;
+});
+
+// ../../node_modules/lodash-es/mergeWith.js
+var mergeWith, mergeWith_default;
+var init_mergeWith = __esm(() => {
+  init__baseMerge();
+  init__createAssigner();
+  mergeWith = _createAssigner_default(function(object, source, srcIndex, customizer) {
+    _baseMerge_default(object, source, srcIndex, customizer);
+  });
+  mergeWith_default = mergeWith;
+});
+
+// ../../node_modules/lodash-es/_isFlattenable.js
+function isFlattenable(value) {
+  return isArray_default(value) || isArguments_default(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+var spreadableSymbol, _isFlattenable_default;
+var init__isFlattenable = __esm(() => {
+  init__Symbol();
+  init_isArguments();
+  init_isArray();
+  spreadableSymbol = _Symbol_default ? _Symbol_default.isConcatSpreadable : undefined;
+  _isFlattenable_default = isFlattenable;
+});
+
+// ../../node_modules/lodash-es/_baseFlatten.js
+function baseFlatten(array, depth, predicate, isStrict, result) {
+  var index = -1, length = array.length;
+  predicate || (predicate = _isFlattenable_default);
+  result || (result = []);
+  while (++index < length) {
+    var value = array[index];
+    if (depth > 0 && predicate(value)) {
+      if (depth > 1) {
+        baseFlatten(value, depth - 1, predicate, isStrict, result);
+      } else {
+        _arrayPush_default(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+var _baseFlatten_default;
+var init__baseFlatten = __esm(() => {
+  init__arrayPush();
+  init__isFlattenable();
+  _baseFlatten_default = baseFlatten;
+});
+
+// ../../node_modules/lodash-es/_baseSortBy.js
+function baseSortBy(array, comparer) {
+  var length = array.length;
+  array.sort(comparer);
+  while (length--) {
+    array[length] = array[length].value;
+  }
+  return array;
+}
+var _baseSortBy_default;
+var init__baseSortBy = __esm(() => {
+  _baseSortBy_default = baseSortBy;
+});
+
+// ../../node_modules/lodash-es/_compareAscending.js
+function compareAscending(value, other) {
+  if (value !== other) {
+    var valIsDefined = value !== undefined, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol_default(value);
+    var othIsDefined = other !== undefined, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol_default(other);
+    if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
+      return 1;
+    }
+    if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
+      return -1;
+    }
+  }
+  return 0;
+}
+var _compareAscending_default;
+var init__compareAscending = __esm(() => {
+  init_isSymbol();
+  _compareAscending_default = compareAscending;
+});
+
+// ../../node_modules/lodash-es/_compareMultiple.js
+function compareMultiple(object, other, orders) {
+  var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+  while (++index < length) {
+    var result = _compareAscending_default(objCriteria[index], othCriteria[index]);
+    if (result) {
+      if (index >= ordersLength) {
+        return result;
+      }
+      var order = orders[index];
+      return result * (order == "desc" ? -1 : 1);
+    }
+  }
+  return object.index - other.index;
+}
+var _compareMultiple_default;
+var init__compareMultiple = __esm(() => {
+  init__compareAscending();
+  _compareMultiple_default = compareMultiple;
+});
+
+// ../../node_modules/lodash-es/_baseOrderBy.js
+function baseOrderBy(collection, iteratees, orders) {
+  if (iteratees.length) {
+    iteratees = _arrayMap_default(iteratees, function(iteratee) {
+      if (isArray_default(iteratee)) {
+        return function(value) {
+          return _baseGet_default(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+        };
+      }
+      return iteratee;
+    });
+  } else {
+    iteratees = [identity_default];
+  }
+  var index = -1;
+  iteratees = _arrayMap_default(iteratees, _baseUnary_default(_baseIteratee_default));
+  var result = _baseMap_default(collection, function(value, key, collection2) {
+    var criteria = _arrayMap_default(iteratees, function(iteratee) {
+      return iteratee(value);
+    });
+    return { criteria, index: ++index, value };
+  });
+  return _baseSortBy_default(result, function(object, other) {
+    return _compareMultiple_default(object, other, orders);
+  });
+}
+var _baseOrderBy_default;
+var init__baseOrderBy = __esm(() => {
+  init__arrayMap();
+  init__baseGet();
+  init__baseIteratee();
+  init__baseMap();
+  init__baseSortBy();
+  init__baseUnary();
+  init__compareMultiple();
+  init_identity();
+  init_isArray();
+  _baseOrderBy_default = baseOrderBy;
+});
+
+// ../../node_modules/lodash-es/sortBy.js
+var sortBy, sortBy_default;
+var init_sortBy = __esm(() => {
+  init__baseFlatten();
+  init__baseOrderBy();
+  init__baseRest();
+  init__isIterateeCall();
+  sortBy = _baseRest_default(function(collection, iteratees) {
+    if (collection == null) {
+      return [];
+    }
+    var length = iteratees.length;
+    if (length > 1 && _isIterateeCall_default(collection, iteratees[0], iteratees[1])) {
+      iteratees = [];
+    } else if (length > 2 && _isIterateeCall_default(iteratees[0], iteratees[1], iteratees[2])) {
+      iteratees = [iteratees[0]];
+    }
+    return _baseOrderBy_default(collection, _baseFlatten_default(iteratees, 1), []);
+  });
+  sortBy_default = sortBy;
+});
+
+// ../../node_modules/lodash-es/_baseSum.js
+function baseSum(array, iteratee) {
+  var result, index = -1, length = array.length;
+  while (++index < length) {
+    var current = iteratee(array[index]);
+    if (current !== undefined) {
+      result = result === undefined ? current : result + current;
+    }
+  }
+  return result;
+}
+var _baseSum_default;
+var init__baseSum = __esm(() => {
+  _baseSum_default = baseSum;
+});
+
+// ../../node_modules/lodash-es/sumBy.js
+function sumBy(array, iteratee) {
+  return array && array.length ? _baseSum_default(array, _baseIteratee_default(iteratee, 2)) : 0;
+}
+var sumBy_default;
+var init_sumBy = __esm(() => {
+  init__baseIteratee();
+  init__baseSum();
+  sumBy_default = sumBy;
+});
+
+// ../../node_modules/lodash-es/lodash.js
+var init_lodash = __esm(() => {
+  init_find();
+  init_forEach();
+  init_get();
+  init_isArray();
+  init_isEmpty();
+  init_map();
+  init_mergeWith();
+  init_sortBy();
+  init_sumBy();
+});
+
+// src/expression-engine.ts
+import { createHash, randomUUID } from "crypto";
+
+class SafeEvaluator {
+  context;
+  functions;
+  constructor(context) {
+    this.context = context;
+    this.functions = {
+      ...builtinFunctions,
+      Math,
+      Date,
+      JSON,
+      parseInt,
+      parseFloat,
+      isNaN,
+      isFinite,
+      encodeURIComponent,
+      decodeURIComponent
+    };
+  }
+  evaluate(expression) {
+    try {
+      const safeContext = {
+        headers: this.context.headers,
+        body: this.context.body,
+        url: this.context.url,
+        method: this.context.method,
+        env: this.context.env,
+        stream: this.context.stream,
+        ...this.functions
+      };
+      if (expression.includes("process.exit") || expression.includes("require(") || expression.includes("eval(") || expression.includes("Function(")) {
+        throw new Error("Dangerous function call detected");
+      }
+      const func = new Function(...Object.keys(safeContext), `"use strict"; return (${expression});`);
+      return func(...Object.values(safeContext));
+    } catch (error) {
+      throw new Error(`Expression evaluation failed: ${error.message}`);
+    }
+  }
+}
+function evaluateExpression(expression, context) {
+  try {
+    const evaluator = new SafeEvaluator(context);
+    const result = evaluator.evaluate(expression);
+    return result;
+  } catch (error) {
+    if (!isTestEnvironment) {
+      logger.error({ expression, error }, "Failed to evaluate expression");
+    }
+    throw error;
+  }
+}
+function processDynamicValue(value, context) {
+  const _recursiveProcess = (currentValue) => {
+    if (typeof currentValue === "string") {
+      const expressionRegex = /\{\{(.+?)\}\}/g;
+      const matches = Array.from(currentValue.matchAll(expressionRegex));
+      if (matches.length === 0) {
+        return currentValue;
+      }
+      if (matches.length === 1 && matches[0][0] === currentValue) {
+        return evaluateExpression(matches[0][1], context);
+      }
+      let result = currentValue;
+      for (const match of matches) {
+        const [fullMatch, expression] = match;
+        try {
+          const evaluated = evaluateExpression(expression, context);
+          result = result.replace(fullMatch, String(evaluated));
+        } catch (error) {
+          if (!isTestEnvironment) {
+            logger.warn({ expression, error }, "Expression evaluation failed in template string");
+          }
+        }
+      }
+      return result;
+    } else if (Array.isArray(currentValue)) {
+      return currentValue.map((item) => _recursiveProcess(item));
+    } else if (typeof currentValue === "object" && currentValue !== null) {
+      const newObj = {};
+      for (const key in currentValue) {
+        if (Object.prototype.hasOwnProperty.call(currentValue, key)) {
+          newObj[key] = _recursiveProcess(currentValue[key]);
+        }
+      }
+      return newObj;
+    }
+    return currentValue;
   };
+  return _recursiveProcess(value);
 }
-var init_migrate_config = __esm(() => {
-  init_config_migrations();
+var isTestEnvironment, builtinFunctions, expressionCache;
+var init_expression_engine = __esm(() => {
+  init_logger();
+  isTestEnvironment = typeof globalThis.describe !== "undefined";
+  builtinFunctions = {
+    uuid: () => randomUUID(),
+    now: () => Date.now(),
+    randomInt: (min, max) => Math.floor(Math.random() * (max - min + 1)) + min,
+    base64encode: (str) => Buffer.from(str).toString("base64"),
+    base64decode: (str) => Buffer.from(str, "base64").toString(),
+    md5: (str) => createHash("md5").update(str).digest("hex"),
+    sha256: (str) => createHash("sha256").update(str).digest("hex"),
+    parseJWT: (token) => {
+      try {
+        if (!token || typeof token !== "string") {
+          throw new Error("Invalid token type");
+        }
+        const payload = token.split(".")[1];
+        if (!payload)
+          throw new Error("Invalid JWT format");
+        return JSON.parse(Buffer.from(payload, "base64").toString());
+      } catch (error) {
+        const tokenPreview = typeof token === "string" ? token.substring(0, 20) + "..." : "invalid";
+        if (!isTestEnvironment) {
+          logger.warn({ token: tokenPreview, error }, "Failed to parse JWT");
+        }
+        return {};
+      }
+    },
+    jsonParse: (str) => JSON.parse(str),
+    jsonStringify: (obj) => JSON.stringify(obj),
+    encrypt: (str, method = "base64") => {
+      if (method === "base64")
+        return Buffer.from(str).toString("base64");
+      return str;
+    },
+    first: (arr) => arr?.[0],
+    last: (arr) => arr?.[arr.length - 1],
+    length: (obj) => obj?.length || Object.keys(obj || {}).length,
+    keys: (obj) => Object.keys(obj || {}),
+    values: (obj) => Object.values(obj || {}),
+    trim: (str) => str?.trim(),
+    toLowerCase: (str) => str?.toLowerCase(),
+    toUpperCase: (str) => str?.toUpperCase(),
+    split: (str, delimiter) => str?.split(delimiter) || [],
+    replace: (str, search, replacement) => str?.replace(search, replacement),
+    isString: (val) => typeof val === "string",
+    isNumber: (val) => typeof val === "number",
+    isObject: (val) => typeof val === "object" && val !== null,
+    isArray: (val) => Array.isArray(val),
+    deepClean: (obj, fieldsToRemove = ["$schema", "additionalProperties", "title"]) => {
+      if (!obj || typeof obj !== "object")
+        return obj;
+      const clean = (current) => {
+        if (Array.isArray(current)) {
+          return current.map(clean);
+        }
+        if (current && typeof current === "object") {
+          const cleaned = {};
+          for (const [key, value] of Object.entries(current)) {
+            if (fieldsToRemove.includes(key)) {
+              continue;
+            }
+            cleaned[key] = clean(value);
+          }
+          return cleaned;
+        }
+        return current;
+      };
+      return clean(obj);
+    }
+  };
+  expressionCache = new Map;
+});
+
+// src/worker/rules/modifier.ts
+function deepMergeRules(base, override) {
+  const customizer = (objValue, srcValue) => {
+    if (isArray_default(objValue)) {
+      return [...new Set([...objValue, ...srcValue])];
+    }
+  };
+  return mergeWith_default({}, base, override, customizer);
+}
+async function applyBodyRules(body, rules, context, requestLog) {
+  let modifiedBody = structuredClone(body);
+  logger.debug({ request: requestLog, phase: "before", body: modifiedBody }, "Body before applying rules");
+  if (rules) {
+    const processAndSet = (key, value, action) => {
+      try {
+        const processedValue = processDynamicValue(value, context);
+        if (processedValue !== undefined) {
+          modifiedBody[key] = processedValue;
+          logger.debug({ request: requestLog, body: { key, value: processedValue } }, `Applied body '${action}' rule`);
+        } else {
+          logger.debug({ request: requestLog, body: { key } }, `Skipped body '${action}' rule (undefined result)`);
+        }
+      } catch (err) {
+        logger.error({ request: requestLog, body: { key }, err }, `Failed to process body '${action}' rule`);
+      }
+    };
+    if (rules.add) {
+      forEach_default(rules.add, (value, key) => {
+        processAndSet(key, value, "add");
+      });
+    }
+    if (rules.replace) {
+      forEach_default(rules.replace, (value, key) => {
+        if (key in modifiedBody || rules.add && key in rules.add) {
+          processAndSet(key, value, "replace");
+        }
+      });
+    }
+    if (rules.default) {
+      forEach_default(rules.default, (value, key) => {
+        if (modifiedBody[key] === undefined) {
+          processAndSet(key, value, "default");
+        }
+      });
+    }
+    if (rules.remove) {
+      for (const key of rules.remove) {
+        const wasAdded = rules.add && key in rules.add;
+        const wasReplaced = rules.replace && key in rules.replace;
+        if (!wasAdded && !wasReplaced) {
+          delete modifiedBody[key];
+          logger.debug({ request: requestLog, body: { key } }, "Removed body field");
+        }
+      }
+    }
+  }
+  if (modifiedBody.__multi_events && Array.isArray(modifiedBody.__multi_events)) {
+    logger.debug({ request: requestLog, eventCount: modifiedBody.__multi_events.length }, "Returning multiple events");
+    return modifiedBody.__multi_events;
+  }
+  logger.debug({ request: requestLog, phase: "after", body: modifiedBody }, "Body after applying rules");
+  return modifiedBody;
+}
+function applyQueryRules(searchParams, rules, context, requestLog) {
+  const modified = new URLSearchParams(searchParams);
+  if (rules) {
+    if (rules.add) {
+      forEach_default(rules.add, (value, key) => {
+        const processed = processDynamicValue(value, context);
+        if (processed !== undefined) {
+          modified.set(key, String(processed));
+          logger.debug({ request: requestLog, query: { key, value: processed } }, "Applied query 'add' rule");
+        }
+      });
+    }
+    if (rules.replace) {
+      forEach_default(rules.replace, (value, key) => {
+        if (modified.has(key) || rules.add && key in rules.add) {
+          const processed = processDynamicValue(value, context);
+          if (processed !== undefined) {
+            modified.set(key, String(processed));
+            logger.debug({ request: requestLog, query: { key, value: processed } }, "Applied query 'replace' rule");
+          }
+        }
+      });
+    }
+    if (rules.default) {
+      forEach_default(rules.default, (value, key) => {
+        if (!modified.has(key)) {
+          const processed = processDynamicValue(value, context);
+          if (processed !== undefined) {
+            modified.set(key, String(processed));
+            logger.debug({ request: requestLog, query: { key, value: processed } }, "Applied query 'default' rule");
+          }
+        }
+      });
+    }
+    if (rules.remove) {
+      for (const key of rules.remove) {
+        const wasAdded = rules.add && key in rules.add;
+        const wasReplaced = rules.replace && key in rules.replace;
+        if (!wasAdded && !wasReplaced) {
+          modified.delete(key);
+          logger.debug({ request: requestLog, query: { key } }, "Removed query parameter");
+        }
+      }
+    }
+  }
+  return modified;
+}
+var init_modifier = __esm(() => {
+  init_lodash();
+  init_logger();
+  init_expression_engine();
+});
+
+// src/utils/endpoint-resolver.ts
+function pluginName(plugin) {
+  return typeof plugin === "string" ? plugin : plugin.name;
+}
+function mergePluginArrays(basePlugins, overridePlugins) {
+  if (basePlugins === undefined && overridePlugins === undefined) {
+    return;
+  }
+  const merged = [...basePlugins ?? []];
+  const indexByName = new Map;
+  for (const [index, plugin] of merged.entries()) {
+    indexByName.set(pluginName(plugin), index);
+  }
+  for (const plugin of overridePlugins ?? []) {
+    const name = pluginName(plugin);
+    const existingIndex = indexByName.get(name);
+    if (existingIndex === undefined) {
+      indexByName.set(name, merged.length);
+      merged.push(plugin);
+    } else {
+      merged[existingIndex] = plugin;
+    }
+  }
+  return merged;
+}
+function extractModificationRules(endpoint) {
+  const rules = {};
+  if (endpoint.headers !== undefined) {
+    rules.headers = endpoint.headers;
+  }
+  if (endpoint.body !== undefined) {
+    rules.body = endpoint.body;
+  }
+  if (endpoint.query !== undefined) {
+    rules.query = endpoint.query;
+  }
+  return rules;
+}
+function applyModificationRules(endpoint, rules) {
+  const merged = { ...endpoint };
+  if (rules.headers !== undefined) {
+    merged.headers = rules.headers;
+  } else {
+    delete merged.headers;
+  }
+  if (rules.body !== undefined) {
+    merged.body = rules.body;
+  } else {
+    delete merged.body;
+  }
+  if (rules.query !== undefined) {
+    merged.query = rules.query;
+  } else {
+    delete merged.query;
+  }
+  return merged;
+}
+function deepMergeEndpoint(base, override) {
+  const plugins = mergePluginArrays(base.plugins, override.plugins);
+  const rules = deepMergeRules(extractModificationRules(base), extractModificationRules(override));
+  const merged = applyModificationRules({ ...base, ...override }, rules);
+  if (plugins !== undefined) {
+    merged.plugins = plugins;
+  } else {
+    delete merged.plugins;
+  }
+  return merged;
+}
+function resolveEffectiveRouteEndpoints(route, services) {
+  const service = route.service ? services?.find((candidate) => candidate.name === route.service) : undefined;
+  if (!service) {
+    return route.endpoints ?? [];
+  }
+  const merged = [...service.endpoints];
+  for (const endpoint of route.endpoints ?? []) {
+    const existingIndex = merged.findIndex((candidate) => candidate.target === endpoint.target);
+    if (existingIndex >= 0) {
+      merged[existingIndex] = deepMergeEndpoint(merged[existingIndex], endpoint);
+    } else {
+      merged.push(endpoint);
+    }
+  }
+  return merged;
+}
+function resolveRouteService(config, route) {
+  return route.service ? config.services?.find((service) => service.name === route.service) : undefined;
+}
+var init_endpoint_resolver = __esm(() => {
+  init_modifier();
 });
 
 // src/config.ts
@@ -16251,105 +19780,100 @@ function ensurePositiveNumber(value, field, context) {
   }
   return value;
 }
-function normalizeRouteConfig(route) {
+function normalizeRouteConfig(route, services) {
   route.timeouts ??= {};
-  route.failover ??= undefined;
-  for (const upstream of route.upstreams) {
-    if (upstream.weight === undefined) {
-      upstream.weight = 100;
+  const endpoints = resolveEffectiveRouteEndpoints(route, services);
+  route.endpoints = endpoints;
+  for (const endpoint of endpoints) {
+    if (endpoint.weight === undefined) {
+      endpoint.weight = 100;
     }
-    if (upstream.priority === undefined) {
-      upstream.priority = 1;
+    if (endpoint.priority === undefined) {
+      endpoint.priority = 1;
     }
   }
   return route;
 }
-function validateStickySession(route) {
-  if (route.stickySession === undefined) {
+function validateStickySession(service) {
+  if (service.sticky_session === undefined) {
     return;
   }
-  if (typeof route.stickySession !== "object" || route.stickySession === null || Array.isArray(route.stickySession)) {
-    logger.error(`Invalid stickySession config in route "${route.path}". stickySession must be an object.`);
+  if (typeof service.sticky_session !== "object" || service.sticky_session === null || Array.isArray(service.sticky_session)) {
+    logger.error(`Invalid sticky_session config in service "${service.name}". sticky_session must be an object.`);
     process.exit(1);
   }
-  if (route.stickySession.enabled !== undefined && typeof route.stickySession.enabled !== "boolean") {
-    logger.error(`Invalid stickySession.enabled in route "${route.path}". stickySession.enabled must be a boolean.`);
+  if (service.sticky_session.enabled !== undefined && typeof service.sticky_session.enabled !== "boolean") {
+    logger.error(`Invalid sticky_session.enabled in service "${service.name}". sticky_session.enabled must be a boolean.`);
     process.exit(1);
   }
-  if (route.stickySession.keyExpression !== undefined && typeof route.stickySession.keyExpression !== "string") {
-    logger.error(`Invalid stickySession.keyExpression in route "${route.path}". stickySession.keyExpression must be a string.`);
+  if (service.sticky_session.key_expression !== undefined && typeof service.sticky_session.key_expression !== "string") {
+    logger.error(`Invalid sticky_session.key_expression in service "${service.name}". sticky_session.key_expression must be a string.`);
     process.exit(1);
   }
 }
-function validateFailoverConfig(route) {
-  const failover = route.failover;
+function validateFailoverConfig(service) {
+  const failover = service.failover;
   if (!failover) {
     return;
   }
   if (typeof failover.enabled !== "boolean") {
-    logger.error(`Invalid failover.enabled in route "${route.path}". failover.enabled must be a boolean.`);
+    logger.error(`Invalid failover.enabled in service "${service.name}". failover.enabled must be a boolean.`);
     process.exit(1);
   }
-  if (route.upstreams.length < 2 && failover.enabled) {
-    logger.warn(`Route for path "${route.path}" has failover enabled but less than 2 upstreams. Failover will not be active.`);
-  }
-  if (route.timeouts?.connectMs !== undefined) {
-    ensurePositiveNumber(route.timeouts.connectMs, "timeouts.connectMs", `route "${route.path}"`);
-  }
-  if (route.timeouts?.requestMs !== undefined) {
-    ensurePositiveNumber(route.timeouts.requestMs, "timeouts.requestMs", `route "${route.path}"`);
+  if (service.endpoints.length < 2 && failover.enabled) {
+    logger.warn(`Service "${service.name}" has failover enabled but less than 2 endpoints. Failover will not be active.`);
   }
-  if (failover.recovery?.probeIntervalMs !== undefined) {
-    ensurePositiveNumber(failover.recovery.probeIntervalMs, "failover.recovery.probeIntervalMs", `route "${route.path}"`);
+  if (failover.recovery?.probe_interval_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.probe_interval_ms, "failover.recovery.probe_interval_ms", `service "${service.name}"`);
   }
-  if (failover.recovery?.probeTimeoutMs !== undefined) {
-    ensurePositiveNumber(failover.recovery.probeTimeoutMs, "failover.recovery.probeTimeoutMs", `route "${route.path}"`);
+  if (failover.recovery?.probe_timeout_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.probe_timeout_ms, "failover.recovery.probe_timeout_ms", `service "${service.name}"`);
   }
-  if (failover.passiveHealth?.consecutiveFailures !== undefined) {
-    ensurePositiveNumber(failover.passiveHealth.consecutiveFailures, "failover.passiveHealth.consecutiveFailures", `route "${route.path}"`);
+  if (failover.passive_health?.consecutive_failures !== undefined) {
+    ensurePositiveNumber(failover.passive_health.consecutive_failures, "failover.passive_health.consecutive_failures", `service "${service.name}"`);
   }
-  if (failover.passiveHealth?.healthySuccesses !== undefined) {
-    ensurePositiveNumber(failover.passiveHealth.healthySuccesses, "failover.passiveHealth.healthySuccesses", `route "${route.path}"`);
+  if (failover.passive_health?.healthy_successes !== undefined) {
+    ensurePositiveNumber(failover.passive_health.healthy_successes, "failover.passive_health.healthy_successes", `service "${service.name}"`);
   }
-  if (failover.passiveHealth?.autoDisableThreshold !== undefined) {
-    ensurePositiveNumber(failover.passiveHealth.autoDisableThreshold, "failover.passiveHealth.autoDisableThreshold", `route "${route.path}"`);
+  if (failover.passive_health?.auto_disable_threshold !== undefined) {
+    ensurePositiveNumber(failover.passive_health.auto_disable_threshold, "failover.passive_health.auto_disable_threshold", `service "${service.name}"`);
   }
-  if (failover.passiveHealth?.autoEnableOnActiveHealthCheck !== undefined && typeof failover.passiveHealth.autoEnableOnActiveHealthCheck !== "boolean") {
-    logger.error(`Invalid failover.passiveHealth.autoEnableOnActiveHealthCheck in route "${route.path}". It must be a boolean.`);
+  if (failover.passive_health?.auto_enable_on_active_health_check !== undefined && typeof failover.passive_health.auto_enable_on_active_health_check !== "boolean") {
+    logger.error(`Invalid failover.passive_health.auto_enable_on_active_health_check in service "${service.name}". It must be a boolean.`);
     process.exit(1);
   }
-  if (failover.slowStart) {
-    if (typeof failover.slowStart.enabled !== "boolean") {
-      logger.error(`Invalid failover.slowStart.enabled in route "${route.path}". It must be a boolean.`);
+  if (failover.slow_start) {
+    if (typeof failover.slow_start.enabled !== "boolean") {
+      logger.error(`Invalid failover.slow_start.enabled in service "${service.name}". It must be a boolean.`);
       process.exit(1);
     }
-    if (failover.slowStart.durationMs !== undefined) {
-      ensurePositiveNumber(failover.slowStart.durationMs, "failover.slowStart.durationMs", `route "${route.path}"`);
+    if (failover.slow_start.duration_ms !== undefined) {
+      ensurePositiveNumber(failover.slow_start.duration_ms, "failover.slow_start.duration_ms", `service "${service.name}"`);
     }
-    if (failover.slowStart.initialWeightFactor !== undefined) {
-      const factor = failover.slowStart.initialWeightFactor;
+    if (failover.slow_start.initial_weight_factor !== undefined) {
+      const factor = failover.slow_start.initial_weight_factor;
       if (typeof factor !== "number" || Number.isNaN(factor) || factor <= 0 || factor > 1) {
-        logger.error(`failover.slowStart.initialWeightFactor in route "${route.path}" must be between 0 and 1.`);
+        logger.error(`failover.slow_start.initial_weight_factor in service "${service.name}" must be between 0 and 1.`);
         process.exit(1);
       }
     }
   }
-  if (failover.healthCheck) {
-    if (typeof failover.healthCheck.enabled !== "boolean") {
-      logger.error(`Invalid failover.healthCheck.enabled in route "${route.path}". It must be a boolean.`);
+  if (failover.health_check) {
+    if (typeof failover.health_check.enabled !== "boolean") {
+      logger.error(`Invalid failover.health_check.enabled in service "${service.name}". It must be a boolean.`);
       process.exit(1);
     }
-    if (failover.healthCheck.intervalMs !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.intervalMs, "failover.healthCheck.intervalMs", `route "${route.path}"`);
+    if (failover.health_check.interval_ms !== undefined) {
+      ensurePositiveNumber(failover.health_check.interval_ms, "failover.health_check.interval_ms", `service "${service.name}"`);
     }
-    if (failover.healthCheck.timeoutMs !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.timeoutMs, "failover.healthCheck.timeoutMs", `route "${route.path}"`);
+    if (failover.health_check.timeout_ms !== undefined) {
+      ensurePositiveNumber(failover.health_check.timeout_ms, "failover.health_check.timeout_ms", `service "${service.name}"`);
     }
-    if (failover.healthCheck.unhealthyThreshold !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.unhealthyThreshold, "failover.healthCheck.unhealthyThreshold", `route "${route.path}"`);
+    if (failover.health_check.unhealthy_threshold !== undefined) {
+      ensurePositiveNumber(failover.health_check.unhealthy_threshold, "failover.health_check.unhealthy_threshold", `service "${service.name}"`);
     }
-    if (failover.healthCheck.healthyThreshold !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.healthyThreshold, "failover.healthCheck.healthyThreshold", `route "${route.path}"`);
+    if (failover.health_check.healthy_threshold !== undefined) {
+      ensurePositiveNumber(failover.health_check.healthy_threshold, "failover.health_check.healthy_threshold", `service "${service.name}"`);
     }
   }
 }
@@ -16377,44 +19901,92 @@ function validateAuthConfig(authConfig, context) {
   }
   logger.debug(`Auth config validated successfully for ${context}`);
 }
+function validateServices(services) {
+  const names = new Set;
+  for (const service of services) {
+    if (!service.name || typeof service.name !== "string") {
+      logger.error('Each service must have a non-empty "name" string.');
+      process.exit(1);
+    }
+    if (names.has(service.name)) {
+      logger.error(`Duplicate service name: "${service.name}". Service names must be unique.`);
+      process.exit(1);
+    }
+    names.add(service.name);
+    if (!service.endpoints || !Array.isArray(service.endpoints) || service.endpoints.length === 0) {
+      logger.error(`Service "${service.name}" must have a non-empty "endpoints" array.`);
+      process.exit(1);
+    }
+    for (const endpoint of service.endpoints) {
+      if (typeof endpoint.target !== "string") {
+        logger.error(`Invalid endpoint in service "${service.name}". Each endpoint must have a string "target".`);
+        process.exit(1);
+      }
+    }
+    validateStickySession(service);
+    validateFailoverConfig(service);
+  }
+}
 function validateAndNormalizeConfig(config) {
   if (!config.routes || !Array.isArray(config.routes)) {
     logger.error('Error: "routes" is not defined or not an array in config.json.');
     process.exit(1);
   }
+  if (config.services && Array.isArray(config.services)) {
+    validateServices(config.services);
+  }
   if (config.auth) {
     validateAuthConfig(config.auth, "global");
   }
   for (const route of config.routes) {
-    if (!route.upstreams || route.upstreams.length === 0) {
-      logger.error(`Route for path "${route.path}" must have a non-empty "upstreams" array.`);
+    const hasEndpoints = route.endpoints && route.endpoints.length > 0;
+    const hasServiceRef = !!route.service;
+    const hasDirectResponse = !!route.direct_response?.enabled;
+    const hasRedirect = !!route.redirect?.enabled;
+    const hasResponseRules = !!route.response_rules?.some((rule) => rule.enabled);
+    if (!hasEndpoints && !hasServiceRef && !hasDirectResponse && !hasRedirect && !hasResponseRules) {
+      logger.error(`Route for path "${route.path}" must have "endpoints", "service", "response_rules", "direct_response", or "redirect" defined.`);
       process.exit(1);
     }
+    if (hasServiceRef) {
+      const svc = config.services?.find((s) => s.name === route.service);
+      if (!svc) {
+        logger.error(`Route "${route.path}" references unknown service "${route.service}".`);
+        process.exit(1);
+      }
+    }
     if (route.auth) {
       validateAuthConfig(route.auth, `route "${route.path}"`);
     }
-    validateStickySession(route);
-    validateFailoverConfig(route);
-    normalizeRouteConfig(route);
-    let totalWeight = 0;
-    for (const upstream of route.upstreams) {
-      if (typeof upstream.target !== "string") {
-        logger.error(`Invalid upstream in route for path "${route.path}". Each upstream must have a string "target".`);
-        process.exit(1);
-      }
-      if (typeof upstream.weight !== "number" || upstream.weight <= 0) {
-        logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
-        process.exit(1);
+    normalizeRouteConfig(route, config.services);
+    if (route.timeouts?.connect_ms !== undefined) {
+      ensurePositiveNumber(route.timeouts.connect_ms, "timeouts.connect_ms", `route "${route.path}"`);
+    }
+    if (route.timeouts?.request_ms !== undefined) {
+      ensurePositiveNumber(route.timeouts.request_ms, "timeouts.request_ms", `route "${route.path}"`);
+    }
+    const endpoints = resolveEffectiveRouteEndpoints(route, config.services);
+    if (endpoints.length > 0) {
+      let total_weight = 0;
+      for (const endpoint of endpoints) {
+        if (typeof endpoint.target !== "string") {
+          logger.error(`Invalid endpoint in route for path "${route.path}". Each endpoint must have a string "target".`);
+          process.exit(1);
+        }
+        if (typeof endpoint.weight !== "number" || endpoint.weight <= 0) {
+          logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
+          process.exit(1);
+        }
+        if (typeof endpoint.priority !== "number" || endpoint.priority <= 0) {
+          logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
+          process.exit(1);
+        }
+        total_weight += endpoint.weight;
       }
-      if (typeof upstream.priority !== "number" || upstream.priority <= 0) {
-        logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
+      if (total_weight === 0) {
+        logger.error(`Total weight for endpoints in route "${route.path}" cannot be zero.`);
         process.exit(1);
       }
-      totalWeight += upstream.weight;
-    }
-    if (totalWeight === 0) {
-      logger.error(`Total weight for upstreams in route "${route.path}" cannot be zero.`);
-      process.exit(1);
     }
   }
   return config;
@@ -16431,7 +20003,7 @@ function preloadGlobalConfig() {
     const config = migrateConfigToLatest(rawConfig).config;
     const configMapping = [
       {
-        jsonKey: "logLevel",
+        jsonKey: "log_level",
         envKey: "LOG_LEVEL",
         default: "info",
         validate: (value) => ["trace", "debug", "info", "warn", "error", "fatal"].includes(value.toLowerCase())
@@ -16455,7 +20027,7 @@ function preloadGlobalConfig() {
         }
       },
       {
-        jsonKey: "bodyParserLimit",
+        jsonKey: "body_parser_limit",
         envKey: "BODY_PARSER_LIMIT",
         default: "50mb"
       }
@@ -16486,7 +20058,7 @@ async function loadConfig(configPath) {
     if (!fs6.existsSync(configFilePath)) {
       logger.info(`Config file not found at ${configFilePath}, creating empty configuration`);
       const minimalConfig = {
-        configVersion: 2,
+        config_version: 4,
         routes: []
       };
       fs6.writeFileSync(configFilePath, JSON.stringify(minimalConfig, null, 2), "utf-8");
@@ -16503,7 +20075,8 @@ async function loadConfig(configPath) {
         changeCount: migrated.changes.length
       }, "Config migrated to latest version in memory");
     }
-    return validateAndNormalizeConfig(migrated.config);
+    const adapted = LegacyCompatAdapter.adaptConfig(migrated.config);
+    return validateAndNormalizeConfig(adapted);
   } catch (error) {
     logger.fatal({ error }, "Failed to load or parse config.json. Please ensure it exists and is valid JSON.");
     process.exit(1);
@@ -16512,6 +20085,7 @@ async function loadConfig(configPath) {
 var init_config = __esm(() => {
   init_logger();
   init_migrate_config();
+  init_endpoint_resolver();
 });
 
 // src/plugin-storage-cleanup.ts
@@ -16680,7 +20254,7 @@ var init_plugin_storage_cleanup = __esm(() => {
 // src/plugin-permissions.ts
 class PluginPermissionManager {
   permissions = new Map;
-  registerPlugin(pluginName, metadata) {
+  registerPlugin(pluginName2, metadata) {
     const permissions = new Set;
     permissions.add("storage" /* STORAGE */);
     if (metadata.permissions && Array.isArray(metadata.permissions)) {
@@ -16728,25 +20302,25 @@ class PluginPermissionManager {
       permissions.add("ui:forms" /* UI_FORMS */);
       permissions.add("ui:modals" /* UI_MODALS */);
     }
-    this.permissions.set(pluginName, permissions);
-    logger.debug({ pluginName, permissions: Array.from(permissions) }, "Registered plugin permissions");
+    this.permissions.set(pluginName2, permissions);
+    logger.debug({ pluginName: pluginName2, permissions: Array.from(permissions) }, "Registered plugin permissions");
   }
-  hasPermission(pluginName, permission) {
-    const perms = this.permissions.get(pluginName);
+  hasPermission(pluginName2, permission) {
+    const perms = this.permissions.get(pluginName2);
     if (!perms) {
-      logger.warn({ pluginName, permission }, "Plugin not registered in permission manager");
+      logger.warn({ pluginName: pluginName2, permission }, "Plugin not registered in permission manager");
       return false;
     }
     return perms.has(permission);
   }
-  hasPermissions(pluginName, requiredPermissions) {
-    return requiredPermissions.every((perm) => this.hasPermission(pluginName, perm));
+  hasPermissions(pluginName2, requiredPermissions) {
+    return requiredPermissions.every((perm) => this.hasPermission(pluginName2, perm));
   }
-  getPermissions(pluginName) {
-    return this.permissions.get(pluginName) || new Set;
+  getPermissions(pluginName2) {
+    return this.permissions.get(pluginName2) || new Set;
   }
-  getSandboxAttributes(pluginName) {
-    const perms = this.permissions.get(pluginName);
+  getSandboxAttributes(pluginName2) {
+    const perms = this.permissions.get(pluginName2);
     if (!perms) {
       return "allow-scripts";
     }
@@ -16762,8 +20336,8 @@ class PluginPermissionManager {
     }
     return Array.from(sandboxAttrs).join(" ");
   }
-  getCSP(pluginName) {
-    const perms = this.permissions.get(pluginName);
+  getCSP(pluginName2) {
+    const perms = this.permissions.get(pluginName2);
     if (!perms) {
       return "default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'";
     }
@@ -16783,7 +20357,7 @@ class PluginPermissionManager {
     cspDirectives.push("base-uri 'self'");
     return cspDirectives.join("; ");
   }
-  canAccessAPI(pluginName, apiPath) {
+  canAccessAPI(pluginName2, apiPath) {
     const apiPermissionMap = {
       "/api/plugins": "api:plugins" /* API_PLUGINS */,
       "/api/routes": "api:routes" /* API_ROUTES */,
@@ -16791,14 +20365,14 @@ class PluginPermissionManager {
     };
     for (const [prefix, permission] of Object.entries(apiPermissionMap)) {
       if (apiPath.startsWith(prefix)) {
-        return this.hasPermission(pluginName, permission);
+        return this.hasPermission(pluginName2, permission);
       }
     }
     return true;
   }
-  unregisterPlugin(pluginName) {
-    this.permissions.delete(pluginName);
-    logger.debug({ pluginName }, "Unregistered plugin permissions");
+  unregisterPlugin(pluginName2) {
+    this.permissions.delete(pluginName2);
+    logger.debug({ pluginName: pluginName2 }, "Unregistered plugin permissions");
   }
   clear() {
     this.permissions.clear();