evolit 0.1.0-alpha.12 → 0.1.0-alpha.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolit",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.13",
   "description": "A convention-driven application framework for LitSX and web components.",
   "type": "module",
   "packageManager": "yarn@4.10.3",

package/src/client-assets.js

@@ -229,9 +229,12 @@ function createSharedEntrySource(specifier) {
   ].join("\n");
 }
 
-export async function collectSharedVendorSpecifiers(additionalEntrySpecifiers = []) {
+export async function collectSharedVendorSpecifiers(
+  additionalEntrySpecifiers = [],
+  options = {},
+) {
   return [...new Set([
-    ...SHARED_VENDOR_SPECIFIERS,
+    ...(options.includeBase === false ? [] : SHARED_VENDOR_SPECIFIERS),
     ...additionalEntrySpecifiers.filter((specifier) => isBareSpecifier(specifier)),
   ])].sort();
 }
@@ -426,20 +429,52 @@ export async function buildSharedVendorRuntime(
       ? options.additionalEntrySpecifiers.filter((specifier) => isBareSpecifier(specifier))
       : [],
   )].sort();
-  const cacheKey = `${projectRoot}::${mode}::${additionalEntrySpecifiers.join("|")}`;
+  if (mode === "development" && !options.vendorGroup) {
+    const baseRuntime = await buildSharedVendorRuntime(projectRoot, mode, {
+      ...options,
+      additionalEntrySpecifiers: [],
+      vendorGroup: "base",
+      includeBase: true,
+    });
+    const additionalRuntimes = await Promise.all(
+      additionalEntrySpecifiers
+        .filter((specifier) => !SHARED_VENDOR_SPECIFIERS.includes(specifier))
+        .map((specifier) => buildSharedVendorRuntime(projectRoot, mode, {
+          ...options,
+          additionalEntrySpecifiers: [specifier],
+          vendorGroup: `vendor-${crypto.createHash("sha1").update(specifier).digest("hex").slice(0, 10)}`,
+          includeBase: false,
+        })),
+    );
+    return {
+      imports: Object.assign(
+        {},
+        baseRuntime.imports,
+        ...additionalRuntimes.map((runtime) => runtime.imports),
+      ),
+      outputRoot: getSharedOutputRoot(projectRoot, mode),
+    };
+  }
+
+  const vendorGroup = options.vendorGroup ?? null;
+  const cacheKey = `${projectRoot}::${mode}::${vendorGroup ?? "all"}::${additionalEntrySpecifiers.join("|")}`;
   if (sharedRuntimeBuildCache.has(cacheKey)) {
     return sharedRuntimeBuildCache.get(cacheKey);
   }
 
   const pendingBuild = (async () => {
-    const sharedRoot = getSharedOutputRoot(projectRoot, mode);
+    const sharedRootBase = getSharedOutputRoot(projectRoot, mode);
+    const sharedRoot = vendorGroup ? path.join(sharedRootBase, vendorGroup) : sharedRootBase;
     const entriesRoot = path.join(
       projectRoot,
       INTERNAL_DIRECTORY,
       mode === "development" ? DEV_DIRECTORY : BUILD_DIRECTORY,
       "__shared_entries__",
+      ...(vendorGroup ? [vendorGroup] : []),
     );
-    const specifiers = await collectSharedVendorSpecifiers(additionalEntrySpecifiers);
+    const specifiers = await collectSharedVendorSpecifiers(additionalEntrySpecifiers, {
+      includeBase: options.includeBase !== false,
+    });
     const inputEntries = await writeSharedRuntimeEntrySources(entriesRoot, specifiers);
 
     await fs.rm(sharedRoot, { recursive: true, force: true });
@@ -494,7 +529,7 @@ export async function buildSharedVendorRuntime(
           continue;
         }
 
-        imports[specifier] = `/_evolit/shared/${chunk.fileName}`;
+        imports[specifier] = `/_evolit/shared/${vendorGroup ? `${vendorGroup}/` : ""}${chunk.fileName}`;
       }
 
       return {
@@ -1134,7 +1169,32 @@ function rewriteStaticAssetPlaceholdersWithMap(source, publicPathByRelativePath)
 }
 
 function rewriteRelativeCssAssetUrls(source, fileRelativePath, publicPathByRelativePath) {
-  return source.replaceAll(
+  const rewrittenImports = source.replaceAll(
+    /@import(\s+)(url\(\s*)?(?:(["'])([^"']+)\3|([^\s;)]+))(\s*\))?/g,
+    (match, whitespace, urlPrefix = "", quote = "", quotedSpecifier, unquotedSpecifier, closing = "") => {
+      const specifier = quotedSpecifier ?? unquotedSpecifier;
+      if (!isRelativeSpecifier(specifier)) {
+        return match;
+      }
+
+      const resolvedRelativePath = resolveRelativeClientImportPath(fileRelativePath, specifier);
+      const rewrittenTarget = publicPathByRelativePath.get(resolvedRelativePath);
+      if (!rewrittenTarget) {
+        return match;
+      }
+
+      const cleanSpecifier = stripImportSearchAndHash(specifier);
+      const rewrittenSpecifier = `${normalizeRelativeImportPath(
+        path.relative(
+          path.dirname(publicPathByRelativePath.get(fileRelativePath)),
+          rewrittenTarget,
+        ),
+      )}${specifier.slice(cleanSpecifier.length)}`;
+      return `@import${whitespace}${urlPrefix}${quote}${rewrittenSpecifier}${quote}${closing}`;
+    },
+  );
+
+  return rewrittenImports.replaceAll(
     /url\(\s*(['"]?)([^"'()]+)\1\s*\)/g,
     (match, quote = "", rawSpecifier) => {
       const specifier = String(rawSpecifier).trim();
@@ -1460,7 +1520,9 @@ async function bundleClientAssets(projectRoot, options = {}) {
     publicPathByRelativePath.set(entry.relativePath, hashedRelativePath);
   }
 
-  await fs.rm(staticRoot, { recursive: true, force: true });
+  if (mode !== "development") {
+    await fs.rm(staticRoot, { recursive: true, force: true });
+  }
   await ensureDirectory(staticRoot);
 
   const nonScriptAssets = [];
@@ -1670,30 +1732,43 @@ async function bundleClientAssets(projectRoot, options = {}) {
   }
 
   const mapAssets = [];
-  const staticFiles = await walkFiles(staticRoot);
-  for (const filePath of staticFiles) {
-    if (!filePath.endsWith(".map")) {
-      continue;
+  for (const asset of scriptAssetRecords) {
+    const mapPath = `${asset.outputPath}.map`;
+    try {
+      const stat = await fs.stat(mapPath);
+      const relativePath = path.relative(staticRoot, mapPath).split(path.sep).join("/");
+      const publicUrl = toStaticPublicUrl(relativePath);
+      byPublicPath[publicUrl] = mapPath;
+      mapAssets.push({
+        clientModule: relativePath,
+        type: "asset",
+        kind: "asset",
+        publicUrl,
+        outputPath: mapPath,
+        hash: null,
+        size: stat.size,
+        imports: [],
+        importUrls: [],
+        styleImports: [],
+        styleUrls: [],
+        assetImports: [],
+        assetUrls: [],
+      });
+    } catch {
+      // Source maps are optional in non-development builds.
     }
+  }
 
-    const relativePath = path.relative(staticRoot, filePath).split(path.sep).join("/");
-    const publicUrl = toStaticPublicUrl(relativePath);
-    byPublicPath[publicUrl] = filePath;
-    mapAssets.push({
-      clientModule: relativePath,
-      type: "asset",
-      kind: "asset",
-      publicUrl,
-      outputPath: filePath,
-      hash: null,
-      size: (await fs.stat(filePath)).size,
-      imports: [],
-      importUrls: [],
-      styleImports: [],
-      styleUrls: [],
-      assetImports: [],
-      assetUrls: [],
-    });
+  if (mode === "development") {
+    const retainedOutputPaths = new Set(
+      [...scriptAssetRecords, ...nonScriptAssets, ...mapAssets]
+        .map((asset) => asset.outputPath),
+    );
+    for (const filePath of await walkFiles(staticRoot)) {
+      if (!retainedOutputPaths.has(filePath)) {
+        await fs.rm(filePath, { force: true });
+      }
+    }
   }
 
   const assets = [...scriptAssetRecords, ...nonScriptAssets, ...mapAssets]

package/src/compiler.js

@@ -21,6 +21,10 @@ const RESOLVABLE_IMPORT_EXTENSIONS = [
   ...MODULE_EXTENSIONS,
   ...STATIC_ASSET_EXTENSIONS,
 ];
+const developmentGraphCache = new Map();
+const developmentGraphDependencies = new Map();
+const developmentModuleNamespaceCache = new Map();
+const developmentGraphVersions = new Map();
 
 function isRelativeSpecifier(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
@@ -272,7 +276,46 @@ async function rewriteRelativeSpecifiers({
   };
 }
 
-export async function compileModuleGraph(entryPath, options = {}) {
+function getDevelopmentGraphCacheKey(entryPath, options) {
+  return [
+    options.projectRoot,
+    entryPath,
+    options.target ?? "server",
+    options.ssr === true ? "ssr" : "client",
+    options.sourceMaps === false ? "without-maps" : "with-maps",
+  ].join("::");
+}
+
+export function invalidateDevelopmentCompilationCache(projectRoot, changedPaths = null) {
+  const prefix = `${path.resolve(projectRoot)}::`;
+  const normalizedChangedPaths = Array.isArray(changedPaths) && changedPaths.length > 0
+    ? new Set(changedPaths.map((changedPath) => path.resolve(changedPath)))
+    : null;
+  let invalidated = false;
+
+  for (const key of developmentGraphCache.keys()) {
+    if (!key.startsWith(prefix)) {
+      continue;
+    }
+
+    const dependencies = developmentGraphDependencies.get(key);
+    const shouldInvalidate =
+      normalizedChangedPaths == null ||
+      !dependencies ||
+      [...dependencies].some((dependency) => normalizedChangedPaths.has(dependency));
+    if (shouldInvalidate) {
+      developmentGraphCache.delete(key);
+      developmentGraphDependencies.delete(key);
+      developmentModuleNamespaceCache.delete(key);
+      developmentGraphVersions.set(key, (developmentGraphVersions.get(key) ?? 0) + 1);
+      invalidated = true;
+    }
+  }
+
+  return invalidated;
+}
+
+async function compileModuleGraphUncached(entryPath, options = {}) {
   const {
     projectRoot,
     mode = "development",
@@ -346,16 +389,77 @@ export async function compileModuleGraph(entryPath, options = {}) {
   return {
     entrypoint: await compileModule(entryPath),
     outputRoot,
+    sourceFiles: [...visited.keys()],
+  };
+}
+
+export async function compileModuleGraph(entryPath, options = {}) {
+  const mode = options.mode ?? "development";
+  if (mode !== "development") {
+    return compileModuleGraphUncached(entryPath, options);
+  }
+
+  const normalizedOptions = {
+    ...options,
+    projectRoot: path.resolve(options.projectRoot ?? process.cwd()),
   };
+  const cacheKey = getDevelopmentGraphCacheKey(
+    path.resolve(entryPath),
+    normalizedOptions,
+  );
+  let pendingCompile = developmentGraphCache.get(cacheKey);
+  if (!pendingCompile) {
+    pendingCompile = compileModuleGraphUncached(entryPath, normalizedOptions);
+    developmentGraphCache.set(cacheKey, pendingCompile);
+    pendingCompile.then((result) => {
+      if (developmentGraphCache.get(cacheKey) === pendingCompile) {
+        developmentGraphDependencies.set(cacheKey, new Set(result.sourceFiles));
+      }
+    }, () => {});
+  }
+
+  try {
+    return await pendingCompile;
+  } catch (error) {
+    if (developmentGraphCache.get(cacheKey) === pendingCompile) {
+      developmentGraphCache.delete(cacheKey);
+      developmentGraphDependencies.delete(cacheKey);
+    }
+    throw error;
+  }
 }
 
 export async function importCompiledModule(entryPath, options = {}) {
-  const { entrypoint } = await compileModuleGraph(entryPath, options);
+  const mode = options.mode ?? "development";
+  const normalizedOptions = mode === "development"
+    ? { ...options, projectRoot: path.resolve(options.projectRoot ?? process.cwd()) }
+    : options;
+  const cacheKey = mode === "development"
+    ? getDevelopmentGraphCacheKey(path.resolve(entryPath), normalizedOptions)
+    : null;
+  const cachedModule = cacheKey ? developmentModuleNamespaceCache.get(cacheKey) : null;
+  if (cachedModule) {
+    return cachedModule;
+  }
+
+  const { entrypoint } = await compileModuleGraph(entryPath, normalizedOptions);
   const moduleUrl = new URL(pathToFileURL(entrypoint).href);
 
-  if (options.mode === "development") {
-    moduleUrl.searchParams.set("t", String(Date.now()));
+  if (mode === "development") {
+    moduleUrl.searchParams.set("t", String(developmentGraphVersions.get(cacheKey) ?? 0));
   }
 
-  return import(moduleUrl.href);
+  const pendingModule = import(moduleUrl.href);
+  if (cacheKey) {
+    developmentModuleNamespaceCache.set(cacheKey, pendingModule);
+  }
+
+  try {
+    return await pendingModule;
+  } catch (error) {
+    if (developmentModuleNamespaceCache.get(cacheKey) === pendingModule) {
+      developmentModuleNamespaceCache.delete(cacheKey);
+    }
+    throw error;
+  }
 }

package/src/deployment-runtime.js

@@ -1,6 +1,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { compileModuleGraph } from "./compiler.js";
+import {
+  compileModuleGraph,
+  invalidateDevelopmentCompilationCache,
+} from "./compiler.js";
 import {
   collectTransitiveAssetPreloads,
   collectTransitiveStyleUrls,
@@ -220,8 +223,27 @@ export async function createRequestRenderer({ projectRoot, mode, assetManifest,
     "@litsx/ssr/hydration",
   );
   const devBundledEntries = new Set();
+  const devPreparedClientModules = new Set();
+  const devClientModuleDependencies = new Map();
   let devRollupCache = null;
+  let devClientAssetWork = Promise.resolve();
+  const developmentMetrics = {
+    clientArtifactBuilds: 0,
+    clientArtifactCacheHits: 0,
+    invalidations: 0,
+    selectivelyInvalidatedClientEntries: 0,
+  };
   const usesFrameworkRouteResolver = !routeResolver;
+
+  function enqueueDevClientAssetWork(work) {
+    const nextWork = devClientAssetWork.then(work, work);
+    devClientAssetWork = nextWork.catch(() => {});
+    return nextWork;
+  }
+
+  function getDevClientModuleKey(clientModule) {
+    return path.resolve(projectRoot, clientModule);
+  }
   async function createFrameworkRouteResolver() {
     return createRouteResolver(projectRoot, mode, {
       getStaticAssetPublicUrls() {
@@ -282,21 +304,44 @@ export async function createRequestRenderer({ projectRoot, mode, assetManifest,
       return effectiveRouteResolver;
     },
     responseCacheController,
-    async invalidateDevelopmentState() {
+    async invalidateDevelopmentState(changedPaths = null) {
       if (mode !== "development") {
         return;
       }
 
-      currentAssetManifest = null;
-      currentAssetResolver = createAssetResolver(projectRoot, {
-        assetManifest: currentAssetManifest,
-      });
-      devBundledEntries.clear();
-      devRollupCache = null;
+      return enqueueDevClientAssetWork(async () => {
+        developmentMetrics.invalidations += 1;
+        const normalizedChangedPaths = Array.isArray(changedPaths) && changedPaths.length > 0
+          ? new Set(changedPaths.map((changedPath) => path.resolve(changedPath)))
+          : null;
+        invalidateDevelopmentCompilationCache(projectRoot, changedPaths);
+        const affectedClientModules = normalizedChangedPaths == null
+          ? new Set(devPreparedClientModules)
+          : new Set(
+            [...devClientModuleDependencies]
+              .filter(([, dependencies]) =>
+                [...dependencies].some((dependency) => normalizedChangedPaths.has(dependency))
+              )
+              .map(([clientModule]) => clientModule),
+          );
+
+        if (affectedClientModules.size > 0 || normalizedChangedPaths == null) {
+          developmentMetrics.selectivelyInvalidatedClientEntries += affectedClientModules.size;
+          currentAssetManifest = null;
+          currentAssetResolver = createAssetResolver(projectRoot, {
+            assetManifest: currentAssetManifest,
+          });
+          devRollupCache = null;
+          for (const clientModule of affectedClientModules) {
+            devPreparedClientModules.delete(clientModule);
+            devClientModuleDependencies.delete(clientModule);
+          }
+        }
 
-      if (usesFrameworkRouteResolver) {
-        effectiveRouteResolver = await createFrameworkRouteResolver();
-      }
+        if (usesFrameworkRouteResolver) {
+          effectiveRouteResolver = await createFrameworkRouteResolver();
+        }
+      });
     },
     async prepareRouteClientArtifacts(routeResult) {
       if (routeResult.type !== "route" && !routeResult.boundaryModule) {
@@ -308,19 +353,49 @@ export async function createRequestRenderer({ projectRoot, mode, assetManifest,
         ...(routeResult.boundaryModule ? [routeResult.boundaryModule] : []),
       ];
 
-      for (const clientModule of new Set(clientModules)) {
-        const clientBuild = await compileModuleGraph(clientModule, {
-          projectRoot,
-          mode,
-          sourceMaps: mode === "development",
-          target: "client",
-        });
-        devBundledEntries.add(
-          path.relative(clientBuild.outputRoot, clientBuild.entrypoint).split(path.sep).join("/"),
-        );
+      if (mode !== "development") {
+        for (const clientModule of new Set(clientModules)) {
+          await compileModuleGraph(clientModule, {
+            projectRoot,
+            mode,
+            sourceMaps: false,
+            target: "client",
+          });
+        }
+        return;
       }
 
-      if (mode === "development") {
+      return enqueueDevClientAssetWork(async () => {
+        let discoveredClientEntry = false;
+        for (const clientModule of new Set(clientModules)) {
+          const clientModuleKey = getDevClientModuleKey(clientModule);
+          if (devPreparedClientModules.has(clientModuleKey)) {
+            continue;
+          }
+
+          const clientBuild = await compileModuleGraph(clientModule, {
+            projectRoot,
+            mode,
+            sourceMaps: true,
+            target: "client",
+          });
+          devPreparedClientModules.add(clientModuleKey);
+          devClientModuleDependencies.set(
+            clientModuleKey,
+            new Set(clientBuild.sourceFiles ?? [clientModuleKey]),
+          );
+          devBundledEntries.add(
+            path.relative(clientBuild.outputRoot, clientBuild.entrypoint).split(path.sep).join("/"),
+          );
+          discoveredClientEntry = true;
+        }
+
+        if (!discoveredClientEntry && currentAssetManifest) {
+          developmentMetrics.clientArtifactCacheHits += 1;
+          return;
+        }
+
+        developmentMetrics.clientArtifactBuilds += 1;
         const bundledClientAssets = await emitBundledClientAssetsWithState(projectRoot, {
           mode: "development",
           entryClientModules: devBundledEntries,
@@ -340,19 +415,20 @@ export async function createRequestRenderer({ projectRoot, mode, assetManifest,
           },
         ) ?? currentHydrationModuleUrl;
         devRollupCache = bundledClientAssets.rollupCache;
-      }
+      });
     },
     async resolveRoutePolicy(request) {
       return effectiveRouteResolver.resolveRoutePolicy(request);
     },
     async renderRoute(request, routePolicyResult = null) {
       const shouldPrepareBeforeResolve = mode === "development" && !currentAssetManifest;
+      let resolvedRoutePolicyResult = routePolicyResult;
       if (shouldPrepareBeforeResolve) {
-        const resolvedRoutePolicyResult = routePolicyResult ?? await effectiveRouteResolver.resolveRoutePolicy(request);
+        resolvedRoutePolicyResult ??= await effectiveRouteResolver.resolveRoutePolicy(request);
         await this.prepareRouteClientArtifacts(resolvedRoutePolicyResult);
       }
 
-      const routeResult = await effectiveRouteResolver.resolveRequest(request);
+      const routeResult = await effectiveRouteResolver.resolveRequest(request, resolvedRoutePolicyResult);
       if (!shouldPrepareBeforeResolve || routeResult.boundaryModule) {
         await this.prepareRouteClientArtifacts(routeResult);
       }
@@ -365,6 +441,9 @@ export async function createRequestRenderer({ projectRoot, mode, assetManifest,
     get assetManifest() {
       return currentAssetManifest;
     },
+    get developmentMetrics() {
+      return mode === "development" ? { ...developmentMetrics } : null;
+    },
   };
 }
 
@@ -403,12 +482,12 @@ export async function createDeploymentRuntime({
     assets,
     cache: renderer.responseCacheController,
     renderer,
-    async invalidateDevelopmentState() {
+    async invalidateDevelopmentState(changedPaths = null) {
       if (mode !== "development") {
         return;
       }
 
-      await renderer.invalidateDevelopmentState();
+      await renderer.invalidateDevelopmentState(changedPaths);
       if (typeof effectiveResponseCacheRuntime.store.clear === "function") {
         await effectiveResponseCacheRuntime.store.clear();
       }

package/src/render.js

@@ -384,7 +384,10 @@ export async function createRouteResolver(projectRoot, mode = "development", res
       return renderNotFound(request);
     }
 
-    const { pageModule, layoutModules } = await loadRouteModules(
+    const preloadedModules = options.routePolicyResult?.route === match.route
+      ? options.routePolicyResult.__evolitLoadedModules
+      : null;
+    const { pageModule, layoutModules } = preloadedModules ?? await loadRouteModules(
       match.route,
       projectRoot,
       mode,
@@ -394,7 +397,7 @@ export async function createRouteResolver(projectRoot, mode = "development", res
     const cachePolicy = normalizeRouteCachePolicy(routeConfig);
 
     if (options.renderTree === false) {
-      return {
+      const routePolicyResult = {
         type: "route",
         status: 200,
         route: match.route,
@@ -404,6 +407,10 @@ export async function createRouteResolver(projectRoot, mode = "development", res
         cachePolicy,
         cacheKey: createRequestCacheKey(url),
       };
+      Object.defineProperty(routePolicyResult, "__evolitLoadedModules", {
+        value: { pageModule, layoutModules },
+      });
+      return routePolicyResult;
     }
 
     const pageComponent = assertServerComponent(
@@ -509,8 +516,8 @@ export async function createRouteResolver(projectRoot, mode = "development", res
     async resolveRoutePolicy(request) {
       return resolveMatchedRequest(request, { renderTree: false });
     },
-    async resolveRequest(request) {
-      return resolveMatchedRequest(request, { renderTree: true });
+    async resolveRequest(request, routePolicyResult = null) {
+      return resolveMatchedRequest(request, { renderTree: true, routePolicyResult });
     },
   };
 }

package/src/server.js

@@ -78,7 +78,7 @@ async function createRecursiveDirectoryWatcher(rootDirectory, onChange) {
     let watcher;
     try {
       watcher = watch(directory, (eventType, fileName) => {
-        onChange();
+        onChange(fileName ? path.join(directory, String(fileName)) : null);
 
         if (eventType === "rename" && fileName) {
           void watchNewDirectory(path.join(directory, fileName));
@@ -165,8 +165,12 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
   let pendingInvalidation = null;
   let resolvePendingInvalidation = null;
   let invalidationPromise = Promise.resolve();
+  const pendingChangedPaths = new Set();
 
-  function scheduleDevelopmentInvalidation() {
+  function scheduleDevelopmentInvalidation(changedPath = null) {
+    if (changedPath) {
+      pendingChangedPaths.add(path.resolve(changedPath));
+    }
     if (invalidationTimer) {
       clearTimeout(invalidationTimer);
     }
@@ -180,11 +184,15 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
     invalidationTimer = setTimeout(() => {
       invalidationTimer = null;
       const resolve = resolvePendingInvalidation;
+      const changedPaths = pendingChangedPaths.size > 0
+        ? [...pendingChangedPaths]
+        : null;
+      pendingChangedPaths.clear();
       pendingInvalidation = null;
       resolvePendingInvalidation = null;
       invalidationPromise = invalidationPromise
         .catch(() => {})
-        .then(() => deploymentRuntime.invalidateDevelopmentState());
+        .then(() => deploymentRuntime.invalidateDevelopmentState(changedPaths));
       invalidationPromise.then(
         () => {
           for (const socket of liveReloadSockets) {