one 1.12.2 → 1.12.3

package/src/serve.ts

@@ -21,60 +21,146 @@ export async function serve(
 ) {
   // cluster mode: --cluster or --cluster=N
   if (args.cluster) {
-    const cluster = await import('node:cluster')
-    const { cpus } = await import('node:os')
+    const { cpus, platform } = await import('node:os')
+    const numWorkers = typeof args.cluster === 'number' ? args.cluster : cpus().length
+
+    // check if we can use SO_REUSEPORT (linux with node 22.12+)
+    const [major, minor] = process.versions.node.split('.').map(Number)
+    const canReusePort =
+      !['win32', 'darwin'].includes(platform()) &&
+      (major > 22 || (major === 22 && minor >= 12) || major >= 23)
+
+    if (canReusePort) {
+      // SO_REUSEPORT: spawn independent child processes, each binds to port directly
+      // kernel distributes connections - no IPC bottleneck
+      return await serveWithReusePort(args, numWorkers)
+    } else {
+      // fallback: node cluster module (IPC-based, works on macOS)
+      return await serveWithCluster(args, numWorkers)
+    }
+  }
+
+  // single-process mode
+  return await startWorker(args)
+}
+
+async function serveWithReusePort(args: Parameters<typeof serve>[0], numWorkers: number) {
+  const { fork } = await import('node:child_process')
+
+  console.info(`[one] cluster: starting ${numWorkers} workers (SO_REUSEPORT)`)
+
+  const workers: ReturnType<typeof fork>[] = []
+  let recentCrashes = 0
+  let lastCrashTime = 0
+
+  function spawnWorker() {
+    const child = fork(
+      process.argv[1]!,
+      process.argv.slice(2).filter((a) => !a.startsWith('--cluster')),
+      {
+        env: { ...process.env, ONE_CLUSTER_WORKER: '1' },
+        stdio: 'inherit',
+      }
+    )
+    workers.push(child)
 
-    if (cluster.default.isPrimary) {
-      const numWorkers = typeof args.cluster === 'number' ? args.cluster : cpus().length
+    child.on('exit', (code, signal) => {
+      const idx = workers.indexOf(child)
+      if (idx >= 0) workers.splice(idx, 1)
 
-      console.info(`[one] cluster: starting ${numWorkers} workers`)
+      if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT') return
 
-      for (let i = 0; i < numWorkers; i++) {
-        cluster.default.fork()
+      const now = Date.now()
+      if (now - lastCrashTime < 5000) {
+        recentCrashes++
+      } else {
+        recentCrashes = 1
       }
+      lastCrashTime = now
 
-      // restart crashed workers with backoff
-      let recentCrashes = 0
-      let lastCrashTime = 0
-
-      cluster.default.on('exit', (worker, code, signal) => {
-        if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT') return
-
-        const now = Date.now()
-        if (now - lastCrashTime < 5000) {
-          recentCrashes++
-        } else {
-          recentCrashes = 1
-        }
-        lastCrashTime = now
-
-        if (recentCrashes > numWorkers * 2) {
-          console.error(`[one] too many worker crashes, stopping`)
-          process.exit(1)
-        }
-
-        console.error(
-          `[one] worker ${worker.process.pid} died (code ${code}, signal ${signal}), restarting`
-        )
-        setTimeout(() => cluster.default.fork(), Math.min(recentCrashes * 500, 5000))
-      })
-
-      const shutdown = () => {
-        for (const id in cluster.default.workers) {
-          cluster.default.workers[id]?.process.kill('SIGTERM')
-        }
-        setTimeout(() => process.exit(0), 5000)
+      if (recentCrashes > numWorkers * 2) {
+        console.error(`[one] too many worker crashes, stopping`)
+        process.exit(1)
       }
-      process.on('SIGINT', shutdown)
-      process.on('SIGTERM', shutdown)
 
-      return
+      console.error(
+        `[one] worker ${child.pid} died (code ${code}, signal ${signal}), restarting`
+      )
+      setTimeout(spawnWorker, Math.min(recentCrashes * 500, 5000))
+    })
+  }
+
+  for (let i = 0; i < numWorkers; i++) {
+    spawnWorker()
+  }
+
+  const shutdown = () => {
+    for (const w of workers) {
+      w.kill('SIGTERM')
     }
+    setTimeout(() => process.exit(0), 5000)
   }
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+
+  // keep primary alive
+  await new Promise(() => {})
+}
+
+async function serveWithCluster(args: Parameters<typeof serve>[0], numWorkers: number) {
+  const cluster = await import('node:cluster')
+
+  if (cluster.default.isPrimary) {
+    console.info(`[one] cluster: starting ${numWorkers} workers (IPC)`)
+
+    for (let i = 0; i < numWorkers; i++) {
+      cluster.default.fork()
+    }
+
+    let recentCrashes = 0
+    let lastCrashTime = 0
+
+    cluster.default.on('exit', (worker, code, signal) => {
+      if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT') return
+
+      const now = Date.now()
+      if (now - lastCrashTime < 5000) {
+        recentCrashes++
+      } else {
+        recentCrashes = 1
+      }
+      lastCrashTime = now
+
+      if (recentCrashes > numWorkers * 2) {
+        console.error(`[one] too many worker crashes, stopping`)
+        process.exit(1)
+      }
+
+      console.error(
+        `[one] worker ${worker.process.pid} died (code ${code}, signal ${signal}), restarting`
+      )
+      setTimeout(() => cluster.default.fork(), Math.min(recentCrashes * 500, 5000))
+    })
+
+    const shutdown = () => {
+      for (const id in cluster.default.workers) {
+        cluster.default.workers[id]?.process.kill('SIGTERM')
+      }
+      setTimeout(() => process.exit(0), 5000)
+    }
+    process.on('SIGINT', shutdown)
+    process.on('SIGTERM', shutdown)
+
+    return
+  }
+
+  // cluster worker
+  return await startWorker(args)
+}
 
-  // worker (or single-process mode)
+async function startWorker(args: Parameters<typeof serve>[0]) {
   const outDir =
-    args.outDir || (FSExtra.existsSync('buildInfo.json') ? '.' : null) || 'dist'
+    args?.outDir || (FSExtra.existsSync('buildInfo.json') ? '.' : null) || 'dist'
   const buildInfo = (await FSExtra.readJSON(`${outDir}/buildInfo.json`)) as One.BuildInfo
   const { oneOptions } = buildInfo
 
@@ -89,18 +175,18 @@ export async function serve(
 
   labelProcess('serve')
 
-  if (args.loadEnv) {
+  if (args?.loadEnv) {
     await loadEnv('production')
   }
 
   return await vxrnServe({
     outDir: buildInfo.outDir || outDir,
-    app: args.app,
+    app: args?.app,
     ...oneOptions.server,
     ...removeUndefined({
-      port: args.port ? +args.port : undefined,
-      host: args.host,
-      compress: args.compress,
+      port: args?.port ? +args.port : undefined,
+      host: args?.host,
+      compress: args?.compress,
     }),
 
     async beforeRegisterRoutes(options, app) {

package/src/server/oneServe.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises'
-import { extname, join, resolve } from 'node:path'
+import { join, resolve } from 'node:path'
 import type { Hono, MiddlewareHandler } from 'hono'
 import type { BlankEnv } from 'hono/types'
 import {
@@ -9,6 +9,7 @@ import {
 } from '../constants'
 import {
   compileManifest,
+  getLoaderParams,
   getURLfromRequestURL,
   type RequestHandlers,
   runMiddlewares,
@@ -61,6 +62,7 @@ export async function oneServe(
     await import('../createHandleRequest')
   const { isResponse } = await import('../utils/isResponse')
   const { isStatusRedirect } = await import('../utils/isStatus')
+  const { withRequestContext } = await import('../vite/resolveResponse')
 
   const isAPIRequest = new WeakMap<any, boolean>()
 
@@ -117,6 +119,12 @@ export async function oneServe(
 
   const apiCJS = oneOptions.build?.api?.outputFormat === 'cjs'
 
+  // pre-computed constants to avoid per-request overhead
+  const useStreaming = !process.env.ONE_BUFFERED_SSR
+  const htmlHeaders = { 'content-type': 'text/html' }
+  // SSR responses get no-cache by default — include it in headers to avoid per-response mutation
+  const ssrHtmlHeaders = { 'content-type': 'text/html', 'cache-control': 'no-cache' }
+
   // cache resolved loader functions directly (not just modules)
   const loaderCache = new Map<string, Function | null>()
   const moduleImportCache = new Map<string, any>()
@@ -369,15 +377,31 @@ export async function oneServe(
         try {
           // collect layout loaders to run in parallel
           const layoutRoutes = route.layouts || []
-          const layoutLoaderPromises = layoutRoutes.map((layout: any) => {
+
+          // fast path: check which layouts actually have loaders (sync on cache hit)
+          // skip importAndRunLoader entirely for layouts with no loader
+          const layoutLoaderPromises: Array<ReturnType<typeof importAndRunLoader>> = []
+          const noLoaderResults: Array<{ loaderData: unknown; routeId: string }> = []
+
+          for (const layout of layoutRoutes) {
             const serverPath = layout.loaderServerPath || layout.contextKey
-            return importAndRunLoader(
-              layout.contextKey,
-              serverPath,
-              layout.contextKey,
-              loaderProps
-            )
-          })
+            const cacheKey = layout.contextKey || serverPath || ''
+            const cachedLoader = loaderCache.get(cacheKey)
+
+            if (cachedLoader === null) {
+              // loader already resolved to null - skip the async call entirely
+              noLoaderResults.push({ loaderData: undefined, routeId: layout.contextKey })
+            } else {
+              layoutLoaderPromises.push(
+                importAndRunLoader(
+                  layout.contextKey,
+                  serverPath,
+                  layout.contextKey,
+                  loaderProps
+                )
+              )
+            }
+          }
 
           // run page loader
           const pageLoaderPromise = importAndRunLoader(
@@ -396,10 +420,18 @@ export async function oneServe(
           let pageResult: { loaderData: unknown; routeId: string; isEnoent?: boolean }
 
           try {
-            ;[layoutResults, pageResult] = await Promise.all([
-              Promise.all(layoutLoaderPromises),
-              pageLoaderPromise,
-            ])
+            if (layoutLoaderPromises.length === 0) {
+              // fast path: all layout loaders are null or no layouts
+              layoutResults = noLoaderResults
+              pageResult = await pageLoaderPromise
+            } else {
+              const [asyncLayoutResults, pr] = await Promise.all([
+                Promise.all(layoutLoaderPromises),
+                pageLoaderPromise,
+              ])
+              layoutResults = [...noLoaderResults, ...asyncLayoutResults]
+              pageResult = pr
+            }
           } catch (err) {
             // Handle thrown responses (e.g., redirect) from any loader
             if (isResponse(err)) {
@@ -428,20 +460,24 @@ export async function oneServe(
           }
 
           // build matches array (layouts + page)
-          const matches: One.RouteMatch[] = [
-            ...layoutResults.map((result) => ({
+          const matchPathname = loaderProps?.path || '/'
+          const matchParams = loaderProps?.params || {}
+          const matches: One.RouteMatch[] = new Array(layoutResults.length + 1)
+          for (let i = 0; i < layoutResults.length; i++) {
+            const result = layoutResults[i]
+            matches[i] = {
               routeId: result.routeId,
-              pathname: loaderProps?.path || '/',
-              params: loaderProps?.params || {},
+              pathname: matchPathname,
+              params: matchParams,
               loaderData: result.loaderData,
-            })),
-            {
-              routeId: pageResult.routeId,
-              pathname: loaderProps?.path || '/',
-              params: loaderProps?.params || {},
-              loaderData: pageResult.loaderData,
-            },
-          ]
+            }
+          }
+          matches[layoutResults.length] = {
+            routeId: pageResult.routeId,
+            pathname: matchPathname,
+            params: matchParams,
+            loaderData: pageResult.loaderData,
+          }
 
           // for backwards compat, loaderData is still the page's loader data
           const loaderData = pageResult.loaderData
@@ -462,9 +498,6 @@ export async function oneServe(
             setSSRLoaderData(pageLoaderFn, pageResult.loaderData)
           }
 
-          const headers = new Headers()
-          headers.set('content-type', 'text/html')
-
           // prepare router for this SSR render (lightweight version bump)
           globalThis['__vxrnresetState']?.()
 
@@ -480,16 +513,20 @@ export async function oneServe(
             matches,
           }
 
-          // streaming SSR by default, fall back to buffered with ONE_BUFFERED_SSR=1
           const _rl = ensureRenderLoaded()
           if (_rl) await _rl
 
-          const streamFn = !process.env.ONE_BUFFERED_SSR ? renderStream : null
-          if (streamFn) {
-            const stream = await streamFn(renderProps)
+          const status = route.isNotFound ? 404 : 200
+          // use ssrHtmlHeaders (includes cache-control: no-cache) to avoid
+          // per-response header mutation in the Hono handler
+          const responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders
+
+          // streaming SSR by default, fall back to buffered with ONE_BUFFERED_SSR=1
+          if (useStreaming) {
+            const stream = await renderStream!(renderProps)
             return new Response(stream, {
-              headers,
-              status: route.isNotFound ? 404 : 200,
+              headers: responseHeaders,
+              status,
             })
           }
 
@@ -497,8 +534,8 @@ export async function oneServe(
           const rendered = await render!(renderProps)
 
           return new Response(rendered, {
-            headers,
-            status: route.isNotFound ? 404 : 200,
+            headers: responseHeaders,
+            status,
           })
         } catch (err) {
           // Handle thrown responses (e.g., redirect) that weren't caught above
@@ -545,9 +582,6 @@ url: ${url}`)
               loaderData: result.loaderData,
             }))
 
-            const headers = new Headers()
-            headers.set('content-type', 'text/html')
-
             globalThis['__vxrnresetState']?.()
 
             const _rl3 = ensureRenderLoaded()
@@ -567,7 +601,7 @@ url: ${url}`)
             })
 
             return new Response(rendered, {
-              headers,
+              headers: htmlHeaders,
               status: route.isNotFound ? 404 : 200,
             })
           } catch (err) {
@@ -649,14 +683,15 @@ url: ${url}`)
   function createHonoHandler(
     route: RouteInfoCompiled
   ): MiddlewareHandler<BlankEnv, never, {}> {
+    // pre-compute per-route checks (constant for the lifetime of the handler)
+    const isDynamicOrNotFound =
+      route.page.endsWith('/+not-found') || Object.keys(route.routeKeys).length > 0
+
     return async (context, next) => {
       try {
         const request = context.req.raw
 
-        if (
-          route.page.endsWith('/+not-found') ||
-          Reflect.ownKeys(route.routeKeys).length > 0
-        ) {
+        if (isDynamicOrNotFound) {
           // Static assets should have the highest priority - which is the behavior of the dev server.
           // But if we handle every matching static asset here, it seems to break some of the static routes.
           // So we only handle it if there's a matching not-found or dynamic route, to prevent One from taking over the static asset.
@@ -677,9 +712,80 @@ url: ${url}`)
           }
         }
 
-        // for js we want to serve our js files directly, as they can match a route on accident
-        // middleware my want to handle this eventually as well but for now this is a fine balance
-        if (extname(request.url) === '.js' || extname(request.url) === '.css') {
+        // for js/css we want to serve our files directly, as they can match a route on accident
+        // use the hono-parsed path to avoid parsing the full URL string
+        const reqPath = context.req.path
+        if (reqPath.endsWith('.js') || reqPath.endsWith('.css')) {
+          return next()
+        }
+
+        // fast path for SSR pages without middleware:
+        // skip URL parsing, resolvePageRoute, and resolveResponse entirely.
+        // use hono's pre-parsed path and compute params inline.
+        if (
+          route.type === 'ssr' &&
+          !route.middlewares?.length &&
+          !reqPath.endsWith(LOADER_JS_POSTFIX_UNCACHED)
+        ) {
+          if (debugRouter) {
+            console.info(`[one] ⚡ ${reqPath} → matched page route: ${route.page} (ssr)`)
+          }
+          const pathname = reqPath
+          // extract search from raw URL (after ?)
+          const rawUrl = request.url
+          const qIdx = rawUrl.indexOf('?')
+          const search = qIdx >= 0 ? rawUrl.slice(qIdx) : ''
+
+          // compute params from compiled regex using pathname
+          const params: Record<string, string> = {}
+          const match = route.compiledRegex.exec(pathname)
+          if (match?.groups) {
+            for (const [key, value] of Object.entries(match.groups)) {
+              const namedKey = route.routeKeys[key]
+              params[namedKey] = value as string
+            }
+          }
+
+          const loaderProps = {
+            path: pathname,
+            search,
+            request,
+            params,
+          }
+
+          // lazy-create URL only when needed (error paths, non-SSR branches)
+          const url = getURLfromRequestURL(request)
+
+          const response = await withRequestContext(async () => {
+            try {
+              return await requestHandlers.handlePage!({
+                request,
+                route,
+                url,
+                loaderProps,
+              })
+            } catch (err) {
+              if (isResponse(err)) {
+                return err as Response
+              }
+              throw err
+            }
+          })
+
+          if (response) {
+            if (isResponse(response)) {
+              if (isStatusRedirect(response.status)) {
+                const location = `${response.headers.get('location') || ''}`
+                response.headers.forEach((value, key) => {
+                  context.header(key, value)
+                })
+                return context.redirect(location, response.status)
+              }
+              // cache-control is already set in ssrHtmlHeaders for SSR responses
+              return response as Response
+            }
+            return next()
+          }
           return next()
         }
 

package/src/utils/evictOldest.ts

@@ -0,0 +1,13 @@
+/**
+ * evict the oldest entries from a map when it exceeds a size threshold.
+ * entries are iterated in insertion order, so the first entries are the oldest.
+ */
+export function evictOldest(map: Map<any, any>, threshold: number, count: number) {
+  if (map.size > threshold) {
+    const iter = map.keys()
+    for (let i = 0; i < count; i++) {
+      const key = iter.next().value
+      if (key) map.delete(key)
+    }
+  }
+}

package/src/utils/isResponse.ts

@@ -1,7 +1,7 @@
 // for some reason instanceof isnt working reliably
 export function isResponse(res: any): res is Response {
-  return (
-    res instanceof Response ||
-    (typeof res.status === 'number' && 'body' in res && typeof res.ok === 'boolean')
-  )
+  // fast path: most responses are instances
+  if (res instanceof Response) return true
+  // fallback: duck-type check for response-like objects
+  return res != null && typeof res.status === 'number' && typeof res.ok === 'boolean'
 }

package/src/vite/one-server-only.tsx

@@ -10,7 +10,16 @@ import { AsyncLocalStorage } from 'node:async_hooks'
 import { SERVER_CONTEXT_KEY } from '../constants'
 import type { One } from './types'
 
-type ALSInstance = AsyncLocalStorage<unknown>
+// symbol key for storing context directly on the ALS id object (faster than WeakMap)
+const _ctxKey = Symbol.for('__oneCtx')
+
+/** shape of the object stored as the ALS context id */
+export interface ALSId {
+  _id: number
+  [_ctxKey]?: One.ServerContext
+}
+
+type ALSInstance = AsyncLocalStorage<ALSId>
 
 const key = '__vxrnrequestAsyncLocalStore'
 const read = () => globalThis[key] as ALSInstance | undefined
@@ -18,7 +27,7 @@ const read = () => globalThis[key] as ALSInstance | undefined
 const ASYNC_LOCAL_STORE = {
   get current() {
     if (read()) return read()
-    const _ = new AsyncLocalStorage()
+    const _ = new AsyncLocalStorage<ALSId>()
     globalThis[key] = _
     return _
   },
@@ -35,9 +44,9 @@ export const asyncHeadersCache =
 globalThis['__vxrnasyncHeadersCache'] ||= asyncHeadersCache
 
 export async function runWithAsyncLocalContext<A>(
-  cb: (id: object) => Promise<A>
+  cb: (id: ALSId) => Promise<A>
 ): Promise<A> {
-  const id = { _id: Math.random() }
+  const id: ALSId = { _id: Math.random() }
   let out: A = null as any
   await ASYNC_LOCAL_STORE.current!.run(id, async () => {
     out = await cb(id)
@@ -92,7 +101,7 @@ export function ensureAsyncLocalID() {
     throw new Error(`Internal One error, no AsyncLocalStorage id!`)
   }
 
-  return id as object
+  return id as ALSId
 }
 
 export type MaybeServerContext = null | One.ServerContext
@@ -107,11 +116,14 @@ const serverContexts = globalThis[SERVER_CONTEXTS_KEY] as WeakMap<any, One.Serve
 export function setServerContext(data: One.ServerContext) {
   if (process.env.VITE_ENVIRONMENT === 'ssr') {
     const id = ensureAsyncLocalID()
-    if (!serverContexts.has(id)) {
-      serverContexts.set(id, {})
+    // fast path: store context directly on the id object to skip WeakMap ops
+    let context = id[_ctxKey]
+    if (!context) {
+      context = {}
+      id[_ctxKey] = context
+      // also set in WeakMap for backwards compatibility
+      serverContexts.set(id, context)
     }
-
-    const context = serverContexts.get(id)!
     Object.assign(context, data)
   } else {
     throw new Error(`Don't call setServerContext on client`)
@@ -122,7 +134,8 @@ export function getServerContext() {
   const out = (() => {
     if (process.env.VITE_ENVIRONMENT === 'ssr') {
       const id = ensureAsyncLocalID()
-      return serverContexts.get(id)
+      // fast path: read from id object directly
+      return id[_ctxKey] || serverContexts.get(id)
     }
     return globalThis[SERVER_CONTEXT_KEY] as MaybeServerContext
   })()
@@ -135,7 +148,8 @@ export function useServerContext() {
     try {
       const useContext = globalThis['__vxrnGetContextFromReactContext']
       if (useContext) {
-        return serverContexts.get(useContext())
+        const id = useContext() as ALSId | null
+        if (id) return id[_ctxKey] || serverContexts.get(id)
       }
     } catch {
       // ok, not in react tree

package/src/vite/resolveResponse.ts

@@ -1,16 +1,23 @@
 import { isResponse } from '../utils/isResponse'
 import {
+  type ALSId,
   asyncHeadersCache,
   mergeHeaders,
   requestAsyncLocalStore,
   runWithAsyncLocalContext,
 } from './one-server-only'
 
+// lightweight monotonic id - avoids Math.random() per request
+let _nextId = 1
+function createId(): ALSId {
+  return { _id: _nextId++ }
+}
+
 export async function resolveResponse(getResponse: () => Promise<Response>) {
   // inline ALS to reduce async nesting (each await = microtask = event loop pressure)
   const store = requestAsyncLocalStore
   if (store) {
-    const id = { _id: Math.random() }
+    const id = createId()
     let response: Response
     await store.run(id, async () => {
       try {
@@ -40,6 +47,18 @@ export async function resolveResponse(getResponse: () => Promise<Response>) {
   })
 }
 
+/**
+ * enter ALS context once for the entire request handler.
+ */
+export function withRequestContext<T>(fn: () => Promise<T>): Promise<T> {
+  const store = requestAsyncLocalStore
+  if (store) {
+    const id = createId()
+    return store.run(id, fn) as Promise<T>
+  }
+  return fn()
+}
+
 export function resolveAPIEndpoint(
   // this is the result of importing the file:
   runEndpoint: () => Promise<any>,

package/types/Root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Root.d.ts","sourceRoot":"","sources":["../src/Root.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,0BAA0B,CAAA;AAEjC,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,SAAS,EAMf,MAAM,OAAO,CAAA;AAYd,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAKlD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAEvC,KAAK,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG;IAC7C,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,mBAAmB,CAAA;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,GAAG,CAAC,YAAY,CAAA;IAC/B,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,CAAA;CAClB,CAAA;AAED,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,GAAG,CAAC,YAAY,CAAA;IACzB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,OAAO,CAAC,EAAE,iBAAiB,CAAC;QAAE,QAAQ,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACpD,wBAAwB,CAAC,EAAE,wBAAwB,GAAG;QACpD,KAAK,CAAC,EAAE;YACN,IAAI,EAAE,OAAO,CAAA;YACb,MAAM,EAAE;gBACN,OAAO,EAAE,MAAM,CAAA;gBACf,UAAU,EAAE,MAAM,CAAA;gBAClB,IAAI,EAAE,MAAM,CAAA;gBACZ,IAAI,EAAE,MAAM,CAAA;gBACZ,MAAM,EAAE,MAAM,CAAA;gBACd,YAAY,EAAE,MAAM,CAAA;aACrB,CAAA;SACF,CAAA;KACF,CAAA;CACF,CAAA;AAQD,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,kDAgIpC"}
+{"version":3,"file":"Root.d.ts","sourceRoot":"","sources":["../src/Root.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,0BAA0B,CAAA;AAEjC,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,SAAS,EAMf,MAAM,OAAO,CAAA;AAYd,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAMlD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAcvC,KAAK,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG;IAC7C,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,mBAAmB,CAAA;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,GAAG,CAAC,YAAY,CAAA;IAC/B,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,CAAA;CAClB,CAAA;AAED,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,GAAG,CAAC,YAAY,CAAA;IACzB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,OAAO,CAAC,EAAE,iBAAiB,CAAC;QAAE,QAAQ,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACpD,wBAAwB,CAAC,EAAE,wBAAwB,GAAG;QACpD,KAAK,CAAC,EAAE;YACN,IAAI,EAAE,OAAO,CAAA;YACb,MAAM,EAAE;gBACN,OAAO,EAAE,MAAM,CAAA;gBACf,UAAU,EAAE,MAAM,CAAA;gBAClB,IAAI,EAAE,MAAM,CAAA;gBACZ,IAAI,EAAE,MAAM,CAAA;gBACZ,MAAM,EAAE,MAAM,CAAA;gBACd,YAAY,EAAE,MAAM,CAAA;aACrB,CAAA;SACF,CAAA;KACF,CAAA;CACF,CAAA;AAQD,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,kDAgIpC"}