dinou 6.1.1 → 7.1.0

package/dinou/core/manifest-provider.js

@@ -0,0 +1,261 @@
+// dinou/core/manifest-provider.js
+// Universal provider for RSC Client Manifest and Server Functions Manifest.
+// Supports in-memory injection for Edge/Cloudflare Workers and disk fallback for Node.js.
+
+const path = require("path");
+const fs = require("fs");
+
+let cachedClientManifest = null;
+let cachedServerFunctionsManifest = null;
+
+function isDevMode() {
+  return (
+    process.env.DINOU_DEV === "true" ||
+    (typeof globalThis !== "undefined" && Boolean(globalThis.__DINOU_DEV__)) ||
+    process.env.NODE_ENV !== "production"
+  );
+}
+
+function getOutputFolder() {
+  return isDevMode() ? ".dinou/public" : ".dinou/dist3";
+}
+
+function getClientManifestPath() {
+  const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+  const outputFolder = getOutputFolder();
+  return path.resolve(
+    process.cwd(),
+    isWebpack
+      ? `${outputFolder}/react-client-manifest.json`
+      : `.dinou/react_client_manifest/react-client-manifest.json`
+  );
+}
+
+function getServerFunctionsManifestPath() {
+  const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+  const outputFolder = getOutputFolder();
+  return path.resolve(
+    process.cwd(),
+    isWebpack
+      ? `${outputFolder}/server-functions-manifest.json`
+      : `.dinou/server_functions_manifest/server-functions-manifest.json`
+  );
+}
+
+function isManifestReady() {
+  if (typeof globalThis !== "undefined" && globalThis.__DINOU_CLIENT_MANIFEST__) {
+    return true;
+  }
+  try {
+    const p = getClientManifestPath();
+    return fs.existsSync(p) && fs.readFileSync(p, "utf8").trim().length > 2;
+  } catch (e) {
+    return false;
+  }
+}
+
+function createDevClientManifestProxy(target) {
+  if (!target || typeof target !== "object") return target;
+  if (target.__isDinouDevProxy) return target;
+
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      if (prop === "__isDinouDevProxy") return true;
+      if (typeof prop !== "string") {
+        return Reflect.get(obj, prop, receiver);
+      }
+      if (prop in obj) {
+        return obj[prop];
+      }
+
+      // 1. Try drive-letter / url casing variations
+      let altProp = null;
+      if (prop.startsWith("file:///c:/")) {
+        altProp = "file:///C:/" + prop.slice(11);
+      } else if (prop.startsWith("file:///C:/")) {
+        altProp = "file:///c:/" + prop.slice(11);
+      }
+      if (altProp && altProp in obj) {
+        return obj[altProp];
+      }
+
+      // 2. Check in-memory base module entry
+      const hashIdx = prop.lastIndexOf("#");
+      const baseUri = hashIdx !== -1 ? prop.slice(0, hashIdx) : prop;
+      const expName = hashIdx !== -1 ? prop.slice(hashIdx + 1) : "default";
+
+      let altBaseUri = null;
+      if (baseUri.startsWith("file:///c:/")) {
+        altBaseUri = "file:///C:/" + baseUri.slice(11);
+      } else if (baseUri.startsWith("file:///C:/")) {
+        altBaseUri = "file:///c:/" + baseUri.slice(11);
+      }
+
+      if (hashIdx !== -1) {
+        const baseEntry = obj[baseUri] || (altBaseUri && obj[altBaseUri]);
+        if (baseEntry && baseEntry.id) {
+          const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+          const entry = {
+            ...baseEntry,
+            name: expName,
+            chunks: isWebpack ? (baseEntry.chunks || []) : expName,
+          };
+          obj[prop] = entry;
+          return entry;
+        }
+      }
+
+      // 3. Check if disk manifest has been updated
+      try {
+        const p = getClientManifestPath();
+        if (fs.existsSync(p)) {
+          const fresh = JSON.parse(fs.readFileSync(p, "utf8"));
+          if (fresh[prop]) {
+            const entry = { ...fresh[prop] };
+            if (hashIdx !== -1) {
+              const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+              entry.name = expName;
+              if (!isWebpack) entry.chunks = expName;
+            }
+            obj[prop] = entry;
+            return entry;
+          }
+          if (altProp && fresh[altProp]) {
+            const entry = { ...fresh[altProp] };
+            if (hashIdx !== -1) {
+              const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+              entry.name = expName;
+              if (!isWebpack) entry.chunks = expName;
+            }
+            obj[prop] = entry;
+            return entry;
+          }
+          if (hashIdx !== -1) {
+            const baseEntry = fresh[baseUri] || (altBaseUri && fresh[altBaseUri]);
+            if (baseEntry) {
+              const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+              const entry = {
+                ...baseEntry,
+                name: expName,
+                chunks: isWebpack ? (baseEntry.chunks || []) : expName,
+              };
+              obj[prop] = entry;
+              return entry;
+            }
+          }
+        }
+      } catch (e) {}
+
+      // 4. Fallback for client files in src/ during hot edits
+      if (baseUri.startsWith("file:///")) {
+        try {
+          const { fileURLToPath } = require("url");
+          const localPath = fileURLToPath(baseUri);
+          if (fs.existsSync(localPath)) {
+            const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+            const fallbackEntry = {
+              id: baseUri,
+              chunks: isWebpack ? [] : expName,
+              name: expName,
+            };
+            obj[prop] = fallbackEntry;
+            if (!obj[baseUri]) {
+              obj[baseUri] = { id: baseUri, chunks: isWebpack ? [] : "default", name: "*" };
+            }
+            return fallbackEntry;
+          }
+        } catch (e) {}
+      }
+
+      return Reflect.get(obj, prop, receiver);
+    },
+  });
+}
+
+function getClientManifest() {
+  if (typeof globalThis !== "undefined" && globalThis.__DINOU_CLIENT_MANIFEST__) {
+    const manifest = globalThis.__DINOU_CLIENT_MANIFEST__;
+    if (isDevMode() && !manifest.__isDinouDevProxy) {
+      globalThis.__DINOU_CLIENT_MANIFEST__ = createDevClientManifestProxy(manifest);
+      return globalThis.__DINOU_CLIENT_MANIFEST__;
+    }
+    return manifest;
+  }
+  const isDevelopment = isDevMode();
+  if (!isDevelopment && cachedClientManifest) {
+    return cachedClientManifest;
+  }
+  try {
+    const p = getClientManifestPath();
+    if (fs.existsSync(p)) {
+      const parsed = JSON.parse(fs.readFileSync(p, "utf8"));
+      if (!isDevelopment) cachedClientManifest = parsed;
+      return isDevelopment ? createDevClientManifestProxy(parsed) : parsed;
+    }
+  } catch (e) {}
+  return cachedClientManifest || (isDevelopment ? createDevClientManifestProxy({}) : {});
+}
+
+function setClientManifest(manifest) {
+  cachedClientManifest = manifest;
+  if (typeof globalThis !== "undefined") {
+    globalThis.__DINOU_CLIENT_MANIFEST__ = isDevMode()
+      ? createDevClientManifestProxy(manifest)
+      : manifest;
+  }
+}
+
+function getServerFunctionsManifest() {
+  if (typeof globalThis !== "undefined" && globalThis.__DINOU_SERVER_FUNCTIONS_MANIFEST__) {
+    const raw = globalThis.__DINOU_SERVER_FUNCTIONS_MANIFEST__;
+    if (raw instanceof Map) return raw;
+    const parsed = {};
+    for (const key in raw) {
+      parsed[key] = raw[key] instanceof Set ? raw[key] : new Set(raw[key]);
+    }
+    return parsed;
+  }
+
+  const isDevelopment = isDevMode();
+  const p = getServerFunctionsManifestPath();
+
+  if (isDevelopment) {
+    if (fs.existsSync(p)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+        const parsed = {};
+        for (const key in raw) {
+          parsed[key] = new Set(raw[key]);
+        }
+        return parsed;
+      } catch (e) {}
+    }
+    return null;
+  }
+
+  if (!cachedServerFunctionsManifest && fs.existsSync(p)) {
+    try {
+      const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+      cachedServerFunctionsManifest = {};
+      for (const key in raw) {
+        cachedServerFunctionsManifest[key] = new Set(raw[key]);
+      }
+    } catch (e) {}
+  }
+  return cachedServerFunctionsManifest;
+}
+
+function setServerFunctionsManifest(manifest) {
+  cachedServerFunctionsManifest = manifest;
+  if (typeof globalThis !== "undefined") {
+    globalThis.__DINOU_SERVER_FUNCTIONS_MANIFEST__ = manifest;
+  }
+}
+
+module.exports = {
+  isManifestReady,
+  getClientManifest,
+  setClientManifest,
+  getServerFunctionsManifest,
+  setServerFunctionsManifest,
+};

package/dinou/core/navigation-utils.js

@@ -26,6 +26,10 @@ export function isExternalUrl(href) {
 }
 
 export function resolveUrl(href, currentPathname) {
+  if (!href) {
+    return "";
+  }
+
   if (isExternalUrl(href)) {
     return href;
   }

package/dinou/core/navigation.js

@@ -62,7 +62,7 @@ export function useRouter() {
       replace: () => { },
       back: () => { },
       forward: () => { },
-      refresh: () => { },
+      refresh: (options) => { },
     };
   }
 
@@ -86,29 +86,42 @@ export function useRouter() {
      * Refresh the current route.
      * Makes a new request to the server for the current URL, clearing the cache,
      * and re-renders the server component without a full browser reload.
+     * Pass `{ layout: true }` to also invalidate and re-render the layout.
      */
-    refresh: () => context.refresh(),
+    refresh: (options) => context.refresh(options),
+
+    /**
+     * Refresh a specific DinouCacheSlot without re-rendering the rest of the page.
+     * @param {string} slotId The ID or tag of the slot to refresh.
+     * @param {object} [options] Optional configuration ({ fresh?: boolean }).
+     */
+    refreshSlot: (slotId, options) => refreshSlot(slotId, options),
   };
 }
 
+export function refreshSlot(slotId, options) {
+  if (typeof window !== "undefined") {
+    if (typeof window.__DINOU_REFRESH_SLOT__ === "function") {
+      window.__DINOU_REFRESH_SLOT__(slotId, options);
+    } else {
+      window.dispatchEvent(
+        new CustomEvent("dinou:refresh-slot", { detail: { id: slotId, options } })
+      );
+    }
+  }
+}
+
+const DINOU_CONTEXT_KEY = Symbol.for("dinou.request.context.storage");
+
 export function usePathname() {
   // 🟢 1. SERVER LOGIC (SSR)
   if (typeof window === "undefined") {
     try {
-      const dynamicRequire =
-        typeof __dinou_require__ !== "undefined"
-          ? __dinou_require__
-          : typeof module !== "undefined" && typeof module.require === "function"
-            ? module.require.bind(module)
-            : null;
-      if (dynamicRequire) {
-        const { getContext } = dynamicRequire(
-          /* webpackIgnore: true */ "./request-context.js"
-        );
-        const ctx = getContext();
-        if (ctx && ctx.req) {
-          return normalizePath(ctx.req.path);
-        }
+      const storage = globalThis[DINOU_CONTEXT_KEY];
+      const ctx = (storage && typeof storage.getStore === "function" ? storage.getStore() : null)
+        || globalThis[Symbol.for("dinou.request.context.current")];
+      if (ctx && ctx.req) {
+        return normalizePath(ctx.req.path);
       }
     } catch (e) {
       console.log("error getContext usePathname", e);
@@ -134,37 +147,35 @@ export function useSearchParams() {
   // 🟢 1. SERVER LOGIC
   if (typeof window === "undefined") {
     try {
-      const dynamicRequire =
-        typeof __dinou_require__ !== "undefined"
-          ? __dinou_require__
-          : typeof module !== "undefined" && typeof module.require === "function"
-            ? module.require.bind(module)
-            : null;
-      if (dynamicRequire) {
-        const { getContext } = dynamicRequire(
-          /* webpackIgnore: true */ "./request-context.js"
-        );
-        const ctx = getContext();
-        if (ctx && ctx.req && ctx.req.query) {
-          const params = new URLSearchParams();
-          Object.entries(ctx.req.query).forEach(([key, val]) => {
-            if (Array.isArray(val)) val.forEach((v) => params.append(key, v));
-            else if (val) params.append(key, val);
-          });
-          return params;
-        }
+      const storage = globalThis[DINOU_CONTEXT_KEY];
+      const ctx = storage && typeof storage.getStore === "function" ? storage.getStore() : null;
+      if (ctx && ctx.req && ctx.req.query) {
+        const params = new URLSearchParams();
+        Object.entries(ctx.req.query).forEach(([key, val]) => {
+          if (Array.isArray(val)) val.forEach((v) => params.append(key, v));
+          else if (val) params.append(key, val);
+        });
+        return params;
       }
     } catch (e) { }
+    return new URLSearchParams();
   }
 
   // 🔵 2. CLIENT LOGIC
   const context = useContext(RouterContext);
 
   // ⚠️ CRITICAL CHANGE: We extract .url
-  const fullRoute = typeof context === "string" ? context : context.url;
+  const fullRoute = typeof context === "string" ? context : context?.url;
+
+  if (typeof fullRoute === "string" && fullRoute.includes("?")) {
+    const searchPart = (fullRoute.split("?")[1] || "").split("#")[0];
+    return new URLSearchParams(searchPart);
+  }
 
-  if (typeof fullRoute !== "string") return new URLSearchParams();
+  if (typeof window !== "undefined" && window.location && window.location.search) {
+    return new URLSearchParams(window.location.search);
+  }
 
-  const searchPart = (fullRoute.split("?")[1] || "").split("#")[0];
-  return new URLSearchParams(searchPart);
+  return new URLSearchParams();
 }
+

package/dinou/core/parse-exports.js

@@ -1,15 +1,21 @@
+let swc = null;
+try {
+  swc = require("@swc/core");
+} catch (e) {}
+
 const parser = require("@babel/parser");
 const traverse = require("@babel/traverse");
 
-function parseExports(code) {
+function parseExportsWithBabel(code) {
   const ast = parser.parse(code, {
     sourceType: "module",
     plugins: ["jsx", "typescript"],
   });
 
   const exports = new Set();
+  const traverseFn = typeof traverse === "function" ? traverse : (traverse.default || traverse);
 
-  traverse.default(ast, {
+  traverseFn(ast, {
     ExportDefaultDeclaration() {
       exports.add("default");
     },
@@ -40,4 +46,248 @@ function parseExports(code) {
   return [...exports];
 }
 
+function parseExports(code) {
+  if (swc && typeof swc.parseSync === "function") {
+    try {
+      const ast = swc.parseSync(code, { syntax: "typescript", tsx: true });
+      const exports = new Set();
+      for (const item of ast.body) {
+        if (item.type === "ExportDefaultDeclaration" || item.type === "ExportDefaultExpression") {
+          exports.add("default");
+        } else if (item.type === "ExportDeclaration") {
+          const d = item.declaration;
+          if (!d) continue;
+          if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+            if (d.identifier?.value) exports.add(d.identifier.value);
+          } else if (d.type === "VariableDeclaration") {
+            for (const v of d.declarations) {
+              if (v.id.type === "Identifier") exports.add(v.id.value);
+            }
+          }
+        } else if (item.type === "ExportNamedDeclaration") {
+          const d = item.declaration;
+          if (d) {
+            if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+              if (d.identifier?.value) exports.add(d.identifier.value);
+            } else if (d.type === "VariableDeclaration") {
+              for (const v of d.declarations) {
+                if (v.id.type === "Identifier") exports.add(v.id.value);
+              }
+            }
+          }
+          if (item.specifiers) {
+            for (const s of item.specifiers) {
+              const name = s.exported?.value || s.orig?.value;
+              if (name) exports.add(name);
+            }
+          }
+        }
+      }
+      return [...exports];
+    } catch (e) {
+      // Fallback to Babel
+    }
+  }
+
+  return parseExportsWithBabel(code);
+}
+
+function parsePprConfigWithBabel(code) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+    });
+
+    let pprValue = null;
+    const traverseFn = typeof traverse === "function" ? traverse : (traverse.default || traverse);
+
+    traverseFn(ast, {
+      ExportNamedDeclaration(p) {
+        const decl = p.node.declaration;
+        if (!decl) return;
+
+        if (decl.type === "FunctionDeclaration") {
+          if (decl.id && decl.id.name === "ppr") {
+            for (const s of decl.body?.body || []) {
+              if (s.type === "ReturnStatement" && s.argument) {
+                if (s.argument.type === "BooleanLiteral") pprValue = s.argument.value;
+                else if (s.argument.type === "StringLiteral") pprValue = s.argument.value !== "false";
+                else if (s.argument.type === "Identifier") pprValue = s.argument.name === "true";
+              }
+            }
+            if (pprValue === null) pprValue = true;
+          }
+        } else if (decl.type === "VariableDeclaration") {
+          for (const d of decl.declarations) {
+            if (d.id && d.id.type === "Identifier") {
+              if (d.id.name === "ppr") {
+                if (d.init) {
+                  if (d.init.type === "BooleanLiteral") {
+                    pprValue = d.init.value;
+                  } else if (d.init.type === "StringLiteral") {
+                    pprValue = d.init.value !== "false";
+                  } else if (d.init.type === "Identifier") {
+                    pprValue = d.init.name === "true";
+                  } else if (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression") {
+                    if (d.init.body.type === "BooleanLiteral") {
+                      pprValue = d.init.body.value;
+                    } else if (d.init.body.type === "BlockStatement") {
+                      for (const s of d.init.body.body || []) {
+                        if (s.type === "ReturnStatement" && s.argument) {
+                          if (s.argument.type === "BooleanLiteral") pprValue = s.argument.value;
+                          else if (s.argument.type === "StringLiteral") pprValue = s.argument.value !== "false";
+                          else if (s.argument.type === "Identifier") pprValue = s.argument.name === "true";
+                        }
+                      }
+                    }
+                    if (pprValue === null) pprValue = true;
+                  } else {
+                    pprValue = true;
+                  }
+                } else {
+                  pprValue = true;
+                }
+              }
+            }
+          }
+        }
+      },
+      ExportDefaultDeclaration(p) {
+        function checkObject(objNode) {
+          if (!objNode || objNode.type !== "ObjectExpression") return;
+          for (const prop of objNode.properties || []) {
+            const key = prop.key?.name || prop.key?.value;
+            if (key === "ppr") {
+              const val = prop.value;
+              if (val?.type === "BooleanLiteral") pprValue = val.value;
+              else if (val?.type === "StringLiteral") pprValue = val.value !== "false";
+              else if (val?.type === "Identifier") pprValue = val.name === "true";
+              else if (val?.type === "ArrowFunctionExpression" || val?.type === "FunctionExpression") {
+                if (val.body?.type === "BooleanLiteral") pprValue = val.body.value;
+                else if (val.body?.type === "BlockStatement") {
+                  for (const s of val.body.body || []) {
+                    if (s.type === "ReturnStatement" && s.argument) {
+                      if (s.argument.type === "BooleanLiteral") pprValue = s.argument.value;
+                      else if (s.argument.type === "StringLiteral") pprValue = s.argument.value !== "false";
+                      else if (s.argument.type === "Identifier") pprValue = s.argument.name === "true";
+                    }
+                  }
+                }
+                if (pprValue === null) pprValue = true;
+              } else {
+                pprValue = true;
+              }
+            }
+          }
+        }
+
+        const decl = p.node.declaration;
+        if (!decl) return;
+        if (decl.type === "ObjectExpression") {
+          checkObject(decl);
+        } else if (decl.type === "Identifier") {
+          const binding = p.scope?.getBinding(decl.name);
+          if (binding && binding.path?.node?.init?.type === "ObjectExpression") {
+            checkObject(binding.path.node.init);
+          }
+        }
+      },
+    });
+
+    return pprValue;
+  } catch (e) {
+    // Regex fallback
+    const matchConst = code.match(/(?:export\s+const|export\s+let|export\s+var)\s+ppr\s*=\s*(true|false|"[^"]*"|'[^']*')/);
+    if (matchConst) {
+      const val = matchConst[1].trim();
+      return val !== "false" && val !== '"false"' && val !== "'false'";
+    }
+    const matchFunc = code.match(/(?:export\s+(?:async\s+)?function\s+ppr\s*\([^)]*\)\s*\{[\s\S]*?return\s+(true|false))/);
+    if (matchFunc) {
+      return matchFunc[1] === "true";
+    }
+    const matchArrow = code.match(/(?:export\s+const|export\s+let|export\s+var)\s+ppr\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>\s*(?:\{[\s\S]*?return\s+(true|false)|(true|false))/);
+    if (matchArrow) {
+      const val = matchArrow[1] || matchArrow[2];
+      return val === "true";
+    }
+    const matchProp = code.match(/\bppr\s*:\s*(true|false|"[^"]*"|'[^']*')/);
+    if (matchProp) {
+      const val = matchProp[1].trim();
+      return val !== "false" && val !== '"false"' && val !== "'false'";
+    }
+    return null;
+  }
+}
+
+function parsePprConfig(code) {
+  if (!code || typeof code !== "string") return null;
+  if (!code.includes("ppr")) return null;
+
+  if (swc && typeof swc.parseSync === "function") {
+    try {
+      const ast = swc.parseSync(code, { syntax: "typescript", tsx: true });
+      for (const item of ast.body) {
+        if (item.type === "ExportDeclaration" || item.type === "ExportNamedDeclaration") {
+          const d = item.declaration;
+          if (!d) continue;
+
+          if (d.type === "FunctionDeclaration") {
+            const name = d.identifier?.value || d.identifier?.name;
+            if (name === "ppr") {
+              for (const stmt of d.body?.stmts || []) {
+                if (stmt.type === "ReturnStatement" && stmt.argument) {
+                  if (stmt.argument.type === "BooleanLiteral") return Boolean(stmt.argument.value);
+                  if (stmt.argument.type === "StringLiteral") return stmt.argument.value !== "false";
+                  if (stmt.argument.type === "Identifier") return stmt.argument.value === "true";
+                }
+              }
+              return true;
+            }
+          } else if (d.type === "VariableDeclaration") {
+            for (const v of d.declarations) {
+              const name = v.id?.value || v.id?.name;
+              if (name === "ppr") {
+                if (v.init) {
+                  if (v.init.type === "BooleanLiteral") return Boolean(v.init.value);
+                  if (v.init.type === "StringLiteral") return v.init.value !== "false";
+                  if (v.init.type === "Identifier") return v.init.value === "true";
+                  if (v.init.type === "ArrowFunctionExpression" || v.init.type === "FunctionExpression") {
+                    if (v.init.body.type === "BooleanLiteral") return Boolean(v.init.body.value);
+                    if (v.init.body.type === "BlockStatement") {
+                      for (const s of v.init.body.stmts || []) {
+                        if (s.type === "ReturnStatement" && s.argument) {
+                          if (s.argument.type === "BooleanLiteral") return Boolean(s.argument.value);
+                          if (s.argument.type === "StringLiteral") return s.argument.value !== "false";
+                          if (s.argument.type === "Identifier") return s.argument.value === "true";
+                        }
+                      }
+                    }
+                    return true;
+                  }
+                  return true;
+                }
+                return true;
+              }
+            }
+          }
+        }
+      }
+      // If SWC didn't find named ppr, fall through to Babel for default export & scope analysis
+    } catch (e) {
+      // Fallback to Babel
+    }
+  }
+
+  return parsePprConfigWithBabel(code);
+}
+
+const { resolveModulePpr } = require("./resolve-module-ppr");
+
+parseExports.parsePprConfig = parsePprConfig;
+parseExports.hasPpr = (code) => parsePprConfig(code) === true;
+parseExports.resolveModulePpr = resolveModulePpr;
+
 module.exports = parseExports;
+