one 1.1.390 → 1.1.391

package/dist/cjs/fork/getPathFromState-mods.native.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var getPathFromState_mods_exports = {};
+__export(getPathFromState_mods_exports, {
+  appendBaseUrl: () => appendBaseUrl,
+  getParamName: () => getParamName,
+  getPathWithConventionsCollapsed: () => getPathWithConventionsCollapsed
+});
+module.exports = __toCommonJS(getPathFromState_mods_exports);
+var import_matchers = require("../router/matchers");
+function getPathWithConventionsCollapsed(param) {
+  var { pattern, route, params, preserveGroups, preserveDynamicRoutes, shouldEncodeURISegment = !0, initialRouteName } = param, segments = pattern.split("/");
+  return segments.map(function(p, i) {
+    var name = getParamName(p);
+    if (p.startsWith("*"))
+      return preserveDynamicRoutes ? name === "not-found" ? "+not-found" : `[...${name}]` : params[name] ? Array.isArray(params[name]) ? params[name].join("/") : params[name] : route.name.startsWith("[") && route.name.endsWith("]") || p === "*not-found" ? "" : route.name;
+    if (p.startsWith(":")) {
+      if (preserveDynamicRoutes)
+        return `[${name}]`;
+      var value = params[name];
+      if (value === void 0 && p.endsWith("?"))
+        return;
+      var _ref;
+      return (_ref = shouldEncodeURISegment ? encodeURISegment(value) : value) !== null && _ref !== void 0 ? _ref : "undefined";
+    }
+    return !preserveGroups && (0, import_matchers.matchGroupName)(p) != null ? segments.length - 1 === i && initialRouteName ? segmentMatchesConvention(initialRouteName) ? "" : shouldEncodeURISegment ? encodeURISegment(initialRouteName, {
+      preserveBrackets: !0
+    }) : initialRouteName : "" : shouldEncodeURISegment ? encodeURISegment(p, {
+      preserveBrackets: !0
+    }) : p;
+  }).map(function(v) {
+    return v ?? "";
+  }).join("/");
+}
+var getParamName = function(pattern) {
+  return pattern.replace(/^[:*]/, "").replace(/\?$/, "");
+};
+function appendBaseUrl(path) {
+  var baseUrl = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : process.env.EXPO_BASE_URL;
+  return process.env.NODE_ENV !== "development" && baseUrl ? `/${baseUrl.replace(/^\/+/, "").replace(/\/$/, "")}${path}` : path;
+}
+function segmentMatchesConvention(segment) {
+  return segment === "index" || (0, import_matchers.matchDynamicName)(segment) != null || (0, import_matchers.matchGroupName)(segment) != null || (0, import_matchers.matchDeepDynamicRouteName)(segment) != null;
+}
+function encodeURISegment(str) {
+  var { preserveBrackets = !1 } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  return str = String(str).replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g, function(char) {
+    return encodeURIComponent(char);
+  }), preserveBrackets && (str = str.replace(/%5B/g, "[").replace(/%5D/g, "]")), str;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendBaseUrl,
+  getParamName,
+  getPathWithConventionsCollapsed
+});
+//# sourceMappingURL=getPathFromState-mods.js.map

package/dist/cjs/fork/getPathFromState-mods.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/fork/Users/n8/one/packages/one/src/fork/getPathFromState-mods.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;;;AAQA,sBAA4E;AAarE,SAASA,gCAAgC,OAa/C;MAb+C,EAC9CC,SACAC,OACAC,QACAC,gBACAC,uBACAC,yBAAyB,IACzBC,iBAAgB,IAP8B,OAcxCC,WAAWP,QAAQQ,MAAM,GAAA;AAE/B,SAAOD,SACJE,IAAI,SAACC,GAAGC,GAAAA;AACP,QAAMC,OAAOC,aAAaH,CAAAA;AAI1B,QAAIA,EAAEI,WAAW,GAAA;AACf,aAAIV,wBACEQ,SAAS,cACJ,eAGF,OAAOA,IAAAA,MAGZV,OAAOU,IAAAA,IACLG,MAAMC,QAAQd,OAAOU,IAAAA,CAAK,IACrBV,OAAOU,IAAAA,EAAMK,KAAK,GAAA,IAEpBf,OAAOU,IAAAA,IAGZX,MAAMW,KAAKE,WAAW,GAAA,KAAQb,MAAMW,KAAKM,SAAS,GAAA,KAIlDR,MAAM,eACD,KAGFT,MAAMW;AAIf,QAAIF,EAAEI,WAAW,GAAA,GAAM;AACrB,UAAIV;AACF,eAAO,IAAIQ,IAAAA;AAGb,UAAMO,QAAQjB,OAAOU,IAAAA;AACrB,UAAIO,UAAUC,UAAaV,EAAEQ,SAAS,GAAA;AACpC;UAGMb;AAAR,cAAQA,OAAAA,yBAAyBgB,iBAAiBF,KAAAA,IAASA,WAAAA,QAAnDd,SAAAA,SAAAA,OAA6D;IACvE;AAEA,WAAI,CAACF,sBAAkBmB,gCAAeZ,CAAAA,KAAM,OAItCH,SAASgB,SAAS,MAAMZ,KACtBL,mBAEEkB,yBAAyBlB,gBAAAA,IACpB,KAEFD,yBACHgB,iBAAiBf,kBAAkB;MAAEmB,kBAAkB;IAAK,CAAA,IAC5DnB,mBAGD,KAGFD,yBAAyBgB,iBAAiBX,GAAG;MAAEe,kBAAkB;IAAK,CAAA,IAAKf;EACpF,CAAA,EACCD,IAAI,SAACiB,GAAAA;WAAMA,KAAK;KAChBT,KAAK,GAAA;AACV;AAEO,IAAMJ,eAAe,SAACb,SAAAA;SAAoBA,QAAQ2B,QAAQ,SAAS,EAAA,EAAIA,QAAQ,OAAO,EAAA;;AAEtF,SAASC,cACdC,MAAY;MACZC,UAAAA,UAAAA,SAAAA,KAAAA,UAAAA,CAAAA,MAAAA,SAAAA,UAAAA,CAAAA,IAA8BC,QAAQC,IAAIC;AAE1C,SAAIF,QAAQC,IAAIE,aAAa,iBACvBJ,UACK,IAAIA,QAAQH,QAAQ,QAAQ,EAAA,EAAIA,QAAQ,OAAO,EAAA,CAAA,GAAME,IAAAA,KAGzDA;AACT;AAEA,SAASL,yBAAyBW,SAAe;AAC/C,SACEA,YAAY,eACZC,kCAAiBD,OAAAA,KAAY,YAC7Bb,gCAAea,OAAAA,KAAY,YAC3BE,2CAA0BF,OAAAA,KAAY;AAE1C;AAEA,SAASd,iBAAiBiB,KAAW;MAAE,EAAEb,mBAAmB,GAAK,IAA1B,UAAA,SAAA,KAAA,UAAA,CAAA,MAAA,SAAA,UAAA,CAAA,IAA+B,CAAC;AAGrEa,eAAMC,OAAOD,GAAAA,EAAKX,QAAQ,mCAAmC,SAACa,MAAAA;WAASC,mBAAmBD,IAAAA;MAEtFf,qBAEFa,MAAMA,IAAIX,QAAQ,QAAQ,GAAA,EAAKA,QAAQ,QAAQ,GAAA,IAE1CW;AACT;",
+  "names": ["getPathWithConventionsCollapsed", "pattern", "route", "params", "preserveGroups", "preserveDynamicRoutes", "shouldEncodeURISegment", "initialRouteName", "segments", "split", "map", "p", "i", "name", "getParamName", "startsWith", "Array", "isArray", "join", "endsWith", "value", "undefined", "encodeURISegment", "matchGroupName", "length", "segmentMatchesConvention", "preserveBrackets", "v", "replace", "appendBaseUrl", "path", "baseUrl", "process", "env", "EXPO_BASE_URL", "NODE_ENV", "segment", "matchDynamicName", "matchDeepDynamicRouteName", "str", "String", "char", "encodeURIComponent"]
+}

package/dist/cjs/fork/getPathFromState.cjs

@@ -20,239 +20,90 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var getPathFromState_exports = {};
 __export(getPathFromState_exports, {
-  appendBaseUrl: () => appendBaseUrl,
-  deepEqual: () => deepEqual,
-  default: () => getPathFromState,
-  getPathDataFromState: () => getPathDataFromState
+  default: () => getPathFromState_default,
+  getPathDataFromState: () => getPathDataFromState,
+  getPathFromState: () => getPathFromState
 });
 module.exports = __toCommonJS(getPathFromState_exports);
-var import_core = require("@react-navigation/core"),
-  import_matchers = require("../router/matchers.cjs");
-const DEFAULT_SCREENS = {},
-  getActiveRoute = state => {
+var import_getPathFromState_mods = require("./getPathFromState-mods.cjs"),
+  import_validatePathConfig = require("./validatePathConfig.cjs");
+const getActiveRoute = state => {
     const route = typeof state.index == "number" ? state.routes[state.index] : state.routes[state.routes.length - 1];
-    return route.state ? getActiveRoute(route.state) : route && isInvalidParams(route.params) ? getActiveRoute(createFakeState(route.params)) : route;
-  };
-function createFakeState(params) {
-  return {
-    stale: !1,
-    type: "UNKNOWN",
-    key: "UNKNOWN",
-    index: 0,
-    routeNames: [],
-    routes: [{
-      key: "UNKNOWN",
-      name: params.screen,
-      params: params.params,
-      path: params.path
-    }]
+    return route.state ? getActiveRoute(route.state) : route;
+  },
+  cachedNormalizedConfigs = /* @__PURE__ */new WeakMap(),
+  getNormalizedConfigs = options => {
+    if (!options?.screens) return {};
+    const cached = cachedNormalizedConfigs.get(options?.screens);
+    if (cached) return cached;
+    const normalizedConfigs = createNormalizedConfigs(options.screens);
+    return cachedNormalizedConfigs.set(options.screens, normalizedConfigs), normalizedConfigs;
   };
+function getPathFromState(state, options) {
+  return getPathDataFromState(state, options).path;
 }
-function segmentMatchesConvention(segment) {
-  return segment === "index" || (0, import_matchers.matchDynamicName)(segment) != null || (0, import_matchers.matchGroupName)(segment) != null || (0, import_matchers.matchDeepDynamicRouteName)(segment) != null;
-}
-function encodeURIComponentPreservingBrackets(str) {
-  return encodeURIComponent(str).replace(/%5B/g, "[").replace(/%5D/g, "]");
-}
-function getPathFromState(state, _options) {
-  return getPathDataFromState(state, _options).path;
-}
-function getPathDataFromState(state, _options = {
-  screens: DEFAULT_SCREENS
-}) {
+function getPathDataFromState(state, options) {
   if (state == null) throw Error("Got 'undefined' for the navigation state. You must pass a valid state object.");
-  const {
-    preserveGroups,
-    preserveDynamicRoutes,
-    ...options
-  } = _options;
-  if ((0, import_core.validatePathConfig)(options), Object.is(options.screens, DEFAULT_SCREENS)) throw Error("You must pass a 'screens' object to 'getPathFromState' to generate a path.");
-  return getPathFromResolvedState(state,
-  // Create a normalized configs object which will be easier to use
-  createNormalizedConfigs(options.screens), {
-    preserveGroups,
-    preserveDynamicRoutes
-  });
-}
-function processParamsWithUserSettings(configItem, params) {
-  const stringify = configItem?.stringify;
-  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key,
-  // TODO: Strip nullish values here.
-  stringify?.[key] ? stringify[key](value) :
-  // Preserve rest params
-  Array.isArray(value) ? value : String(value)]));
-}
-function deepEqual(a, b) {
-  if (a === b) return !0;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return !1;
-    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return !1;
-    return !0;
-  }
-  if (typeof a == "object" && typeof b == "object") {
-    const keysA = Object.keys(a),
-      keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return !1;
-    for (const key of keysA) if (!deepEqual(a[key], b[key])) return !1;
-    return !0;
-  }
-  return !1;
-}
-function walkConfigItems(route, focusedRoute, configs, {
-  preserveDynamicRoutes
-}) {
-  !route.state && isInvalidParams(route.params);
-  let pattern = null,
-    focusedParams,
-    hash;
-  const collectedParams = {};
-  for (; route.name in configs;) {
-    const configItem = configs[route.name],
-      inputPattern = configItem.pattern;
-    if (inputPattern == null) throw new Error("Unexpected: No pattern found for route " + route.name);
-    if (pattern = inputPattern, route.params) {
-      route.params["#"] && (hash = route.params["#"], delete route.params["#"]);
-      const params = processParamsWithUserSettings(configItem, route.params);
-      pattern != null && Object.assign(collectedParams, params), deepEqual(focusedRoute, route) && (preserveDynamicRoutes ? focusedParams = params : focusedParams = getParamsWithConventionsCollapsed({
-        params,
-        pattern,
-        routeName: route.name
-      }));
-    }
-    if (!route.state && isInvalidParams(route.params), !configItem.screens || route.state === void 0) {
-      configItem.initialRouteName && configItem.screens && configItem.initialRouteName in configItem.screens && configItem.screens[configItem.initialRouteName]?.pattern && (pattern = configItem.screens[configItem.initialRouteName].pattern, focusedParams && (preserveDynamicRoutes || (focusedParams = getParamsWithConventionsCollapsed({
-        params: focusedParams,
-        pattern,
-        routeName: route.name
-      }))));
-      break;
-    }
-    const index = route.state.index ?? route.state.routes.length - 1,
-      nextRoute = route.state.routes[index],
-      nestedScreens = configItem.screens;
-    if (nestedScreens && nextRoute.name in nestedScreens) route = nextRoute, configs = nestedScreens;else break;
-  }
-  if (pattern == null) throw new Error(`No pattern found for route "${route.name}". Options are: ${Object.keys(configs).join(", ")}.`);
-  return pattern && !focusedParams && focusedRoute.params && (preserveDynamicRoutes ? focusedParams = focusedRoute.params : focusedParams = getParamsWithConventionsCollapsed({
-    params: focusedRoute.params,
-    pattern,
-    routeName: route.name
-  }), focusedParams = {
-    ...focusedParams,
-    ...collectedParams
-  }), {
-    pattern,
-    nextRoute: route,
-    focusedParams,
-    hash,
-    params: collectedParams
-  };
-}
-function getPathFromResolvedState(state, configs, {
-  preserveGroups,
-  preserveDynamicRoutes
-}) {
-  let path = "",
-    current = state,
-    hash;
+  options && (0, import_validatePathConfig.validatePathConfig)(options);
+  const configs = getNormalizedConfigs(options);
+  let path = "/",
+    current = state;
   const allParams = {};
   for (; current;) {
-    path += "/";
-    const route = current.routes[current.index ?? 0];
-    !route.state && isInvalidParams(route.params);
-    const {
+    let index = typeof current.index == "number" ? current.index : 0,
+      route = current.routes[index],
       pattern,
-      params: params2,
-      nextRoute,
-      focusedParams,
-      hash: $hash
-    } = walkConfigItems(route, getActiveRoute(current), {
-      ...configs
-    }, {
-      preserveDynamicRoutes
-    });
-    if ($hash && (hash = $hash), Object.assign(allParams, params2), path += getPathWithConventionsCollapsed({
+      focusedParams;
+    const focusedRoute = getActiveRoute(state);
+    let currentOptions = configs;
+    const nestedRouteNames = [];
+    let hasNext = !0;
+    for (; route.name in currentOptions && hasNext;) {
+      if (pattern = currentOptions[route.name].pattern, nestedRouteNames.push(route.name), route.params) {
+        const stringify = currentOptions[route.name]?.stringify,
+          currentParams = Object.fromEntries(Object.entries(route.params).flatMap(([key, value]) => key === "screen" || key === "params" ? [] : [[key, stringify?.[key] ? stringify[key](value) : Array.isArray(value) ? value.map(String) : String(value)]]));
+        Object.assign(allParams, currentParams), focusedRoute === route && (focusedParams = {
+          ...currentParams
+        }, pattern?.split("/").filter(p => p.startsWith(":")).forEach(p => {
+          const name = getParamName(p);
+          focusedParams && delete focusedParams[name];
+        }));
+      }
+      if (!currentOptions[route.name].screens || route.state === void 0) {
+        const screens = currentOptions[route.name].screens,
+          screen = route.params && "screen" in route.params ? route.params.screen?.toString() : screens ? Object.keys(screens)[0] : void 0;
+        screen && screens && currentOptions[route.name].screens?.[screen] ? (route = {
+          ...screens[screen],
+          name: screen,
+          key: screen
+        }, currentOptions = screens) : hasNext = !1;
+      } else {
+        index = typeof route.state.index == "number" ? route.state.index : route.state.routes.length - 1;
+        const nextRoute = route.state.routes[index],
+          nestedConfig = currentOptions[route.name].screens;
+        nestedConfig && nextRoute.name in nestedConfig ? (route = nextRoute, currentOptions = nestedConfig) : hasNext = !1;
+      }
+    }
+    if (currentOptions[route.name] !== void 0 ? (pattern === void 0 && (pattern = nestedRouteNames.join("/")), path += (0, import_getPathFromState_mods.getPathWithConventionsCollapsed)({
+      ...options,
       pattern,
-      routePath: nextRoute.path,
+      route,
       params: allParams,
-      initialRouteName: configs[nextRoute.name]?.initialRouteName,
-      preserveGroups,
-      preserveDynamicRoutes
-    }), nextRoute.state &&
-    // NOTE: The upstream implementation allows for sending in synthetic states (states that weren't generated by `getStateFromPath`)
-    // and any invalid routes will simply be ignored.
-    // Because of this, we need to check if the next route is valid before continuing, otherwise our more strict
-    // implementation will throw an error.
-    configs[nextRoute.state.routes?.[nextRoute.state?.index ?? 0]?.name]) current = nextRoute.state;else {
-      if (focusedParams &&
-      // note: using [...route] is returning an array which shouldn't go on search, this is just
-      // an initial hacky test to work around this as we dont want to pass that to search
-      !Array.isArray(focusedParams)) {
-        for (const param in focusedParams) focusedParams[param] === "undefined" && delete focusedParams[param];
-        const query = new URLSearchParams(focusedParams).toString();
-        query && (path += `?${query}`);
-      }
-      break;
+      initialRouteName: configs[route.name]?.initialRouteName
+    })) : route.name.startsWith("+") || (path += encodeURIComponent(route.name)), focusedParams || (focusedParams = focusedRoute.params), route.state) path += "/";else if (focusedParams) {
+      for (const param in focusedParams) focusedParams[param] === "undefined" && delete focusedParams[param];
+      delete focusedParams["#"];
+      const query = new URLSearchParams(focusedParams).toString();
+      query && (path += `?${query}`);
     }
+    current = route.state;
   }
-  hash && (allParams["#"] = hash, path += `#${hash}`);
-  const params = decodeParams(allParams);
-  return {
-    path: appendBaseUrl(basicSanitizePath(path)),
-    params
+  return path = path.replace(/\/+/g, "/"), path = path.length > 1 ? path.replace(/\/$/, "") : path, options?.path && (path = joinPaths(options.path, path)), path = (0, import_getPathFromState_mods.appendBaseUrl)(path), allParams["#"] && (path += `#${allParams["#"]}`), {
+    path,
+    params: allParams
   };
 }
-function decodeParams(params) {
-  const parsed = {};
-  for (const [key, value] of Object.entries(params)) try {
-    Array.isArray(value) ? parsed[key] = value.map(v => decodeURIComponent(v)) : parsed[key] = decodeURIComponent(value);
-  } catch {
-    parsed[key] = value;
-  }
-  return parsed;
-}
-function getPathWithConventionsCollapsed({
-  pattern,
-  routePath,
-  params,
-  preserveGroups,
-  preserveDynamicRoutes,
-  initialRouteName
-}) {
-  const segments = pattern.split("/");
-  return segments.map((p, i) => {
-    const name = getParamName(p);
-    return p.startsWith("*") ? preserveDynamicRoutes ? name === "not-found" ? "+not-found" : `[...${name}]` : params[name] ? Array.isArray(params[name]) ? params[name].join("/") : params[name] : i === 0 ? routePath : routePath?.split("/").slice(i + 1).join("/") : p.startsWith(":") ? preserveDynamicRoutes ? `[${name}]` : params[name] : !preserveGroups && (0, import_matchers.matchGroupName)(p) != null ? segments.length - 1 === i && initialRouteName ? segmentMatchesConvention(initialRouteName) ? "" : encodeURIComponentPreservingBrackets(initialRouteName) : "" : encodeURIComponentPreservingBrackets(p);
-  }).map(v => v ?? "").join("/");
-}
-function getParamsWithConventionsCollapsed({
-  pattern,
-  routeName,
-  params
-}) {
-  const processedParams = {
-      ...params
-    },
-    segments = pattern.split("/");
-  if (segments.filter(segment => segment.startsWith(":")).forEach(segment => {
-    const name = getParamName(segment);
-    delete processedParams[name];
-  }), segments.some(segment => segment.startsWith("*"))) {
-    const name = (0, import_matchers.testNotFound)(routeName) ? "not-found" : (0, import_matchers.matchDeepDynamicRouteName)(routeName) ?? routeName;
-    delete processedParams[name];
-  }
-  return processedParams;
-}
-function basicSanitizePath(path) {
-  const simplifiedPath = path.replace(/\/+/g, "/");
-  return simplifiedPath.length <= 1 ? simplifiedPath : simplifiedPath.replace(/\/$/, "");
-}
-function isInvalidParams(params) {
-  return params ? "params" in params && typeof params.params == "object" && params.params ? !0 : "initial" in params && typeof params.initial == "boolean" &&
-  // "path" in params &&
-  "screen" in params : !1;
-}
-const getParamName = pattern => pattern.replace(/^[:*]/, "").replace(/\?$/, ""),
+const getParamName = pattern => pattern.replace(/^:/, "").replace(/\?$/, ""),
   joinPaths = (...paths) => [].concat(...paths.map(p => p.split("/"))).filter(Boolean).join("/"),
   createConfigItem = (config, parentPattern) => {
     if (typeof config == "string") return {
@@ -265,11 +116,11 @@ const getParamName = pattern => pattern.replace(/^[:*]/, "").replace(/\?$/, ""),
       // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.
       pattern: pattern?.split("/").filter(Boolean).join("/"),
       stringify: config.stringify,
-      screens,
-      initialRouteName: config.initialRouteName
+      screens
     };
   },
-  createNormalizedConfigs = (options, pattern) => Object.fromEntries(Object.entries(options).map(([name, c]) => [name, createConfigItem(c, pattern)]));
-function appendBaseUrl(path, baseUrl = process.env.EXPO_BASE_URL) {
-  return process.env.NODE_ENV !== "development" && baseUrl ? `/${baseUrl.replace(/^\/+/, "").replace(/\/$/, "")}${path}` : path;
-}
+  createNormalizedConfigs = (options, pattern) => Object.fromEntries(Object.entries(options).map(([name, c]) => {
+    const result = createConfigItem(c, pattern);
+    return [name, result];
+  }));
+var getPathFromState_default = getPathFromState;