@bitstillery/mithril 3.0.0-AA

package/api/router.ts

@@ -0,0 +1,670 @@
+import Vnode from '../render/vnode'
+import hyperscript from '../render/hyperscript'
+import decodeURIComponentSafe from '../util/decodeURIComponentSafe'
+import buildPathname from '../pathname/build'
+import parsePathname from '../pathname/parse'
+import compileTemplate from '../pathname/compileTemplate'
+import censor from '../util/censor'
+import {getPathname, getSearch, getHash} from '../util/uri'
+import {logger} from '../server/ssrLogger'
+
+import type {ComponentType, Vnode as VnodeType} from '../render/vnode'
+
+// RedirectObject will be defined after REDIRECT symbol is created
+// Using a type that references the symbol indirectly
+export type RedirectObject = {[key: symbol]: string}
+
+export interface RouteResolver<Attrs = Record<string, any>, State = any> {
+    onmatch?: (
+        args: Attrs,
+        requestedPath: string,
+        route: string,
+    ) => ComponentType<Attrs, State> | Promise<ComponentType<Attrs, State>> | RedirectObject | Promise<RedirectObject> | void
+    render?: (vnode: VnodeType<Attrs, State>) => VnodeType
+}
+
+export type SSRState = Record<string, any>
+export type SSRResult = string | {html: string; state: SSRState}
+
+export interface Route {
+    (path: string, params?: Record<string, any>, shouldReplaceHistory?: boolean): void
+    (path: string, component: ComponentType, shouldReplaceHistory?: boolean): void
+    set: (path: string, params?: Record<string, any>, data?: any) => void
+    get: () => string
+    prefix: string
+    link: (vnode: VnodeType) => string
+    param: (key?: string) => any
+    params: Record<string, any>
+    Link: ComponentType
+    SKIP: {}
+    REDIRECT: symbol
+    redirect: (path: string) => RedirectObject
+    resolve: (
+        pathname: string,
+        routes: Record<string, ComponentType | RouteResolver | {component: ComponentType | RouteResolver}>,
+        renderToString: (vnodes: any) => Promise<SSRResult>,
+        prefix?: string,
+    ) => Promise<SSRResult>
+}
+
+interface MountRedraw {
+    mount: (root: Element, component: ComponentType | null) => void
+    redraw: () => void
+}
+
+interface RouteOptions {
+    replace?: boolean
+    state?: any
+    title?: string | null
+}
+
+export default function router($window: any, mountRedraw: MountRedraw) {
+    let p = Promise.resolve()
+
+    let scheduled = false
+
+    let ready = false
+    let hasBeenResolved = false
+
+    let dom: Element | undefined
+    let compiled:
+        | Array<{route: string; component: any; check: (data: {path: string; params: Record<string, any>}) => boolean}>
+        | undefined
+    let fallbackRoute: string | undefined
+
+    let currentResolver: RouteResolver | null = null
+    let component: ComponentType | string = 'div'
+    let attrs: Record<string, any> = {}
+    let currentPath: string | undefined
+    let lastUpdate: ((comp: any) => void) | null = null
+
+    const RouterRoot: ComponentType = {
+        onremove: function () {
+            ready = hasBeenResolved = false
+            $window.removeEventListener('popstate', fireAsync, false)
+        },
+        view: function () {
+            // The route has already been resolved.
+            // Therefore, the following early return is not needed.
+            // if (!hasBeenResolved) return
+
+            // Pass currentPath in attrs so RouteResolver.render can use it for routePath.
+            // Use attrs.key (not currentPath) so that route param changes within the same
+            // route pattern update the component instead of causing a full remount.
+            const routeAttrs = {...attrs, routePath: currentPath || attrs.routePath}
+            const vnode = Vnode(component, attrs.key, routeAttrs, null, null, null)
+            if (currentResolver) return currentResolver.render!(vnode as any)
+            // Wrap in a fragment to preserve existing key semantics
+            return [vnode]
+        },
+    }
+
+    const SKIP = (route.SKIP = {})
+
+    // Redirect symbol for isomorphic redirect handling
+    const REDIRECT = (route.REDIRECT = Symbol('REDIRECT'))
+
+    // Helper function to create redirect objects
+    route.redirect = function (path: string) {
+        return {[REDIRECT]: path} as RedirectObject
+    }
+
+    // Type guard to check if value is a redirect object
+    // Note: We check for any Symbol key that might be a redirect, not just our specific REDIRECT symbol
+    // This allows redirect objects created by different router instances to be detected
+    function isRedirect(value: any): value is RedirectObject {
+        if (value == null || typeof value !== 'object') return false
+        // Check if this object has our REDIRECT symbol
+        if (REDIRECT in value) return true
+        // Also check for any Symbol keys that might be redirect objects from other router instances
+        // This handles the case where redirect objects are created by client-side m.route.redirect
+        // but checked by server-side router (or vice versa)
+        const symbolKeys = Object.getOwnPropertySymbols(value)
+        if (symbolKeys.length > 0) {
+            // Check if any symbol key's description suggests it's a redirect
+            // Or check if the object has a string property that looks like a path
+            for (const sym of symbolKeys) {
+                const desc = sym.description || ''
+                if (desc.includes('REDIRECT') || desc === 'REDIRECT') {
+                    const path = value[sym]
+                    if (typeof path === 'string' && path.startsWith('/')) {
+                        return true
+                    }
+                }
+            }
+        }
+        return false
+    }
+
+    // Helper to extract redirect path from redirect object (handles different REDIRECT symbols)
+    function getRedirectPath(redirectObj: RedirectObject): string {
+        // First try our REDIRECT symbol
+        if (REDIRECT in redirectObj) {
+            return redirectObj[REDIRECT]
+        }
+        // Otherwise, check all symbol keys
+        const symbolKeys = Object.getOwnPropertySymbols(redirectObj)
+        for (const sym of symbolKeys) {
+            const path = redirectObj[sym]
+            if (typeof path === 'string' && path.startsWith('/')) {
+                return path
+            }
+        }
+        throw new Error('Invalid redirect object: no redirect path found')
+    }
+
+    function resolveRoute() {
+        scheduled = false
+        // Consider the pathname holistically. The prefix might even be invalid,
+        // but that's not our problem.
+        // Use isomorphic URI API unconditionally - it handles environment detection internally
+        const hash = getHash()
+        let prefix = hash
+        if (route.prefix[0] !== '#') {
+            const search = getSearch()
+            prefix = search + prefix
+            if (route.prefix[0] !== '?') {
+                const pathname = getPathname()
+                prefix = pathname + prefix
+                if (prefix[0] !== '/') prefix = '/' + prefix
+            }
+        }
+        const path = decodeURIComponentSafe(prefix).slice(route.prefix.length)
+        const data = parsePathname(path)
+
+        Object.assign(data.params, $window.history.state || {})
+
+        function reject(e: any) {
+            console.error(e)
+            route.set(fallbackRoute!, null, {replace: true})
+        }
+
+        loop(0)
+        function loop(i: number) {
+            if (!compiled) return
+            for (; i < compiled.length; i++) {
+                if (compiled[i].check(data)) {
+                    let payload = compiled[i].component
+                    const matchedRoute = compiled[i].route
+                    const localComp = payload
+                    // Store the RouteResolver if payload has both onmatch and render
+                    // This allows us to preserve the resolver even after onmatch returns a component
+                    const resolverWithRender =
+                        payload &&
+                        typeof payload === 'object' &&
+                        payload.onmatch &&
+                        payload.render &&
+                        !payload.view &&
+                        typeof payload !== 'function'
+                            ? payload
+                            : null
+
+                    const update = (lastUpdate = function (comp: any) {
+                        if (update !== lastUpdate) return
+                        if (comp === SKIP) return loop(i + 1)
+                        // Handle redirect objects: explicit redirect signal
+                        if (isRedirect(comp)) {
+                            // Extract redirect target path
+                            const redirectPath = comp[REDIRECT]
+                            // Trigger navigation to redirect target
+                            route.set(redirectPath, null)
+                            // Skip rendering current route - new route resolution will handle redirect target
+                            return
+                        }
+                        // If we have a preserved resolver with render, use it
+                        if (resolverWithRender) {
+                            currentResolver = resolverWithRender
+                            component =
+                                comp != null && (typeof comp.view === 'function' || typeof comp === 'function') ? comp : 'div'
+                        }
+                        // If comp is a RouteResolver with render, set currentResolver instead of component
+                        else if (comp && typeof comp === 'object' && comp.render && !comp.view && typeof comp !== 'function') {
+                            currentResolver = comp
+                            component = 'div' // Placeholder, won't be used since currentResolver.render will be called
+                        } else {
+                            currentResolver = null
+                            component =
+                                comp != null && (typeof comp.view === 'function' || typeof comp === 'function') ? comp : 'div'
+                        }
+                        attrs = data.params
+                        currentPath = path
+                        lastUpdate = null
+                        if (hasBeenResolved) mountRedraw.redraw()
+                        else {
+                            hasBeenResolved = true
+                            mountRedraw.mount(dom!, RouterRoot)
+                        }
+                    })
+                    // There's no understating how much I *wish* I could
+                    // use `async`/`await` here...
+                    if (payload.view || typeof payload === 'function') {
+                        payload = {}
+                        update(localComp)
+                    } else if (payload.onmatch) {
+                        p.then(function () {
+                            return payload.onmatch!(data.params, path, matchedRoute)
+                        }).then(update, path === fallbackRoute ? null : reject)
+                    } else if (payload.render) {
+                        // RouteResolver with render method - update with resolver itself
+                        update(payload)
+                    } else update('div')
+                    return
+                }
+            }
+
+            if (path === fallbackRoute) {
+                throw new Error('Could not resolve default route ' + fallbackRoute + '.')
+            }
+            route.set(fallbackRoute!, null, {replace: true})
+        }
+    }
+
+    function fireAsync() {
+        if (!scheduled) {
+            scheduled = true
+            // TODO: just do `mountRedraw.redraw()` here and elide the timer
+            // dependency. Note that this will muck with tests a *lot*, so it's
+            // not as easy of a change as it sounds.
+            setTimeout(resolveRoute)
+        }
+    }
+
+    function route(root: Element, defaultRoute: string, routes: Record<string, ComponentType | RouteResolver>) {
+        if (!root) throw new TypeError('DOM element being rendered to does not exist.')
+
+        compiled = Object.keys(routes).map(function (routePath) {
+            if (routePath[0] !== '/') throw new SyntaxError("Routes must start with a '/'.")
+            if (/:([^/.-]+)(\.{3})?:/.test(routePath)) {
+                throw new SyntaxError("Route parameter names must be separated with either '/', '.', or '-'.")
+            }
+            return {
+                route: routePath,
+                component: routes[routePath],
+                check: compileTemplate(routePath),
+            }
+        })
+        fallbackRoute = defaultRoute
+        if (defaultRoute != null) {
+            const defaultData = parsePathname(defaultRoute)
+
+            if (
+                !compiled.some(function (i) {
+                    return i.check(defaultData)
+                })
+            ) {
+                throw new ReferenceError("Default route doesn't match any known routes.")
+            }
+        }
+        dom = root
+
+        $window.addEventListener('popstate', fireAsync, false)
+
+        ready = true
+
+        // The RouterRoot component is mounted when the route is first resolved.
+        resolveRoute()
+    }
+    route.set = function (path: string, data: Record<string, any> | null, options?: RouteOptions) {
+        if (lastUpdate != null) {
+            options = options || {}
+            options.replace = true
+        }
+        lastUpdate = null
+
+        path = buildPathname(path, data || {})
+        if (ready) {
+            // Router is initialized - use history API for navigation
+            const state = options ? options.state : null
+            const title = options ? options.title : null
+            if ($window?.history) {
+                if (options && options.replace) $window.history.replaceState(state, title, route.prefix + path)
+                else $window.history.pushState(state, title, route.prefix + path)
+            }
+            // Update URL before fireAsync so resolveRoute reads the new path
+            fireAsync()
+            // In SSR context (no $window), navigation is a no-op since we're just rendering HTML
+        } else {
+            // Router not yet initialized - use location.href for initial navigation
+            if ($window?.location) {
+                $window.location.href = route.prefix + path
+            }
+            // In SSR context (no $window), this is a no-op since we're just rendering HTML
+        }
+    }
+    route.get = function (): string {
+        // If currentPath is not set (e.g., during SSR before route.resolve is called),
+        // fall back to extracting pathname from __SSR_URL__ using the isomorphic URI API
+        if (currentPath === undefined) {
+            return getPathname()
+        }
+        return currentPath ?? ''
+    }
+    route.prefix = '#!'
+    route.link = function (vnode: VnodeType) {
+        return route.Link.view(vnode)
+    }
+    route.Link = {
+        view: function (vnode: VnodeType) {
+            // Omit the used parameters from the rendered element - they are
+            // internal. Also, censor the various lifecycle methods.
+            //
+            // We don't strip the other parameters because for convenience we
+            // let them be specified in the selector as well.
+            const child = hyperscript(
+                vnode.attrs?.selector || 'a',
+                censor(vnode.attrs || {}, ['options', 'params', 'selector', 'onclick']),
+                vnode.children,
+            )
+            let options: RouteOptions | undefined
+            let onclick: any
+            let href: string
+
+            // Let's provide a *right* way to disable a route link, rather than
+            // letting people screw up accessibility on accident.
+            //
+            // The attribute is coerced so users don't get surprised over
+            // `disabled: 0` resulting in a button that's somehow routable
+            // despite being visibly disabled.
+            if ((child.attrs!.disabled = Boolean(child.attrs!.disabled))) {
+                child.attrs!.href = null
+                child.attrs!['aria-disabled'] = 'true'
+                // If you *really* do want add `onclick` on a disabled link, use
+                // an `oncreate` hook to add it.
+            } else {
+                options = vnode.attrs?.options
+                onclick = vnode.attrs?.onclick
+                // Easier to build it now to keep it isomorphic.
+                href = buildPathname(child.attrs!.href || '', vnode.attrs?.params || {})
+                // Make Link isomorphic - use empty prefix on server for pathname routing
+                // On server ($window is null): always use empty prefix for clean URLs
+                // On client: use route.prefix (which may be '#!' for hash routing or '' for pathname routing)
+                // This ensures SSR generates clean pathname URLs while client can use hash routing if configured
+                const linkPrefix = $window == null ? '' : route.prefix
+                child.attrs!.href = linkPrefix + href
+                child.attrs!.onclick = function (e: any) {
+                    let result: any
+                    if (typeof onclick === 'function') {
+                        result = onclick.call(e.currentTarget, e)
+                    } else if (onclick == null || typeof onclick !== 'object') {
+                        // do nothing
+                    } else if (typeof onclick.handleEvent === 'function') {
+                        onclick.handleEvent(e)
+                    }
+
+                    // Adapted from React Router's implementation:
+                    // https://github.com/ReactTraining/react-router/blob/520a0acd48ae1b066eb0b07d6d4d1790a1d02482/packages/react-router-dom/modules/Link.js
+                    //
+                    // Try to be flexible and intuitive in how we handle links.
+                    // Fun fact: links aren't as obvious to get right as you
+                    // would expect. There's a lot more valid ways to click a
+                    // link than this, and one might want to not simply click a
+                    // link, but right click or command-click it to copy the
+                    // link target, etc. Nope, this isn't just for blind people.
+                    if (
+                        // Skip if `onclick` prevented default
+                        result !== false &&
+                        !e.defaultPrevented &&
+                        // Ignore everything but left clicks
+                        (e.button === 0 || e.which === 0 || e.which === 1) &&
+                        // Let the browser handle `target=_blank`, etc.
+                        (!e.currentTarget.target || e.currentTarget.target === '_self') &&
+                        // No modifier keys
+                        !e.ctrlKey &&
+                        !e.metaKey &&
+                        !e.shiftKey &&
+                        !e.altKey
+                    ) {
+                        // Safely call preventDefault - event might be wrapped by Mithril
+                        if (typeof e.preventDefault === 'function') {
+                            e.preventDefault()
+                        } else if (e.originalEvent && typeof e.originalEvent.preventDefault === 'function') {
+                            e.originalEvent.preventDefault()
+                        }
+                        ;(e as any).redraw = false
+                        route.set(href, null, options)
+                    }
+                }
+            }
+            return child
+        },
+    }
+    route.param = function (key?: string) {
+        return attrs && key != null ? attrs[key] : attrs
+    }
+    route.params = attrs
+
+    // Server-side route resolution (isomorphic)
+    route.resolve = async function (
+        pathname: string,
+        routes: Record<string, ComponentType | RouteResolver | {component: ComponentType | RouteResolver}>,
+        renderToString: (vnodes: any) => Promise<SSRResult>,
+        prefix: string = '',
+        redirectDepth: number = 0,
+    ): Promise<SSRResult> {
+        // Prevent infinite redirect loops
+        const MAX_REDIRECT_DEPTH = 5
+        if (redirectDepth > MAX_REDIRECT_DEPTH) {
+            throw new Error(`Maximum redirect depth (${MAX_REDIRECT_DEPTH}) exceeded. Possible redirect loop.`)
+        }
+        // Save current prefix and set to provided prefix for SSR
+        // This ensures Link components use the correct prefix during server-side rendering
+        const savedPrefix = route.prefix
+        route.prefix = prefix
+        // Save current path to restore after SSR
+        const savedCurrentPath = currentPath
+
+        // Set currentPath immediately so m.route.get() works during SSR
+        // Use pathname (full path) - this is what m.route.get() should return
+        currentPath = pathname || '/'
+
+        try {
+            // Compile routes (same logic as in route() function)
+            const compiled = Object.keys(routes).map(function (routePath) {
+                if (routePath[0] !== '/') throw new SyntaxError("Routes must start with a '/'.")
+                if (/:([^/.-]+)(\.{3})?:/.test(routePath)) {
+                    throw new SyntaxError("Route parameter names must be separated with either '/', '.', or '-'.")
+                }
+                // Handle both formats: direct component/resolver or {component: ...}
+                const routeValue = routes[routePath]
+                const component =
+                    routeValue && typeof routeValue === 'object' && 'component' in routeValue
+                        ? (routeValue as {component: ComponentType | RouteResolver}).component
+                        : (routeValue as ComponentType | RouteResolver)
+                return {
+                    route: routePath,
+                    component: component,
+                    check: compileTemplate(routePath),
+                }
+            })
+
+            // Parse pathname
+            const path = decodeURIComponentSafe(pathname || '/').slice(prefix.length)
+            const data = parsePathname(path)
+
+            // Update attrs for SSR so m.route.param() works during server-side rendering
+            attrs = data.params
+
+            // Find matching route
+            for (const {route: matchedRoute, component, check} of compiled) {
+                if (check(data)) {
+                    let payload = component
+
+                    // Handle RouteResolver
+                    if (payload && typeof payload === 'object' && ('onmatch' in payload || 'render' in payload)) {
+                        const resolver = payload as RouteResolver
+                        if (resolver.onmatch) {
+                            const result = resolver.onmatch(data.params, pathname, matchedRoute)
+                            if (result instanceof Promise) {
+                                payload = await result
+                            } else if (result !== undefined) {
+                                payload = result as any
+                            }
+                            // Note: If onmatch returns undefined, payload remains as the RouteResolver
+                        }
+
+                        // Check for redirect BEFORE processing as component
+                        // This prevents redirect objects from being treated as components
+                        if (isRedirect(payload)) {
+                            // Extract redirect target path (handles different REDIRECT symbols)
+                            const redirectPath = getRedirectPath(payload)
+                            logger.info(`redirecting to ${redirectPath}`, {
+                                pathname,
+                                route: matchedRoute,
+                                redirectPath,
+                            })
+                            // Update __SSR_URL__ to reflect redirect target for proper URL context
+                            // This ensures getCurrentUrl() and other URL-dependent code work correctly
+                            const originalSSRUrl = globalThis.__SSR_URL__
+                            try {
+                                // Construct full URL for redirect target if we have original URL context
+                                if (originalSSRUrl && typeof originalSSRUrl === 'string') {
+                                    try {
+                                        const originalUrl = new URL(originalSSRUrl)
+                                        // Build redirect target URL using same origin
+                                        const redirectUrl = new URL(redirectPath, originalUrl.origin)
+                                        globalThis.__SSR_URL__ = redirectUrl.href
+                                    } catch {
+                                        // If URL construction fails, just use redirect path as-is
+                                        globalThis.__SSR_URL__ = redirectPath
+                                    }
+                                } else {
+                                    globalThis.__SSR_URL__ = redirectPath
+                                }
+                                // Recursively resolve redirect target route
+                                // This will return SSRResult (string or {html, state})
+                                const redirectResult = await route.resolve(
+                                    redirectPath,
+                                    routes,
+                                    renderToString,
+                                    prefix,
+                                    redirectDepth + 1,
+                                )
+                                const redirectHtml = typeof redirectResult === 'string' ? redirectResult : redirectResult.html
+                                if (!redirectHtml || redirectHtml.length === 0) {
+                                    logger.warn('empty redirect result', {
+                                        pathname,
+                                        redirectPath,
+                                        route: matchedRoute,
+                                    })
+                                } else {
+                                    logger.debug('redirect resolved', {
+                                        pathname,
+                                        redirectPath,
+                                        htmlSize: redirectHtml.length,
+                                    })
+                                }
+                                return redirectResult
+                            } finally {
+                                // Restore original SSR URL after redirect resolution
+                                globalThis.__SSR_URL__ = originalSSRUrl
+                            }
+                        }
+
+                        // If resolver has render, use it
+                        if (resolver.render) {
+                            // Only render if payload is a valid component (onmatch returned a component)
+                            // If onmatch returned undefined, payload is still the RouteResolver, which is not a component
+                            const isComponentType =
+                                payload != null &&
+                                payload !== resolver &&
+                                (typeof payload === 'function' ||
+                                    (typeof payload === 'object' &&
+                                        'view' in payload &&
+                                        typeof (payload as any).view === 'function'))
+
+                            if (isComponentType) {
+                                try {
+                                    // Create component vnode using hyperscript
+                                    const componentVnode = hyperscript(payload as ComponentType, data.params)
+
+                                    // Call resolver.render to get the layout-wrapped vnode
+                                    // resolver.render does: m(layout, null, componentVnode)
+                                    const renderedVnode = resolver.render(componentVnode)
+                                    const result = await renderToString(renderedVnode)
+                                    const html = typeof result === 'string' ? result : result.html
+                                    if (html) {
+                                        logger.info(`rendered route component`, {
+                                            pathname,
+                                            route: matchedRoute,
+                                            htmlSize: html.length,
+                                        })
+                                    }
+                                    return result
+                                } catch (error) {
+                                    logger.error('route render failed', error, {
+                                        pathname,
+                                        route: matchedRoute,
+                                    })
+                                    throw error
+                                }
+                            }
+
+                            // If resolver has render but no onmatch (or onmatch returned undefined),
+                            // call render directly with a vnode that has routePath in attrs
+                            // This allows render-only resolvers to work
+                            if (!resolver.onmatch || payload === resolver) {
+                                try {
+                                    // Create a vnode with the resolver as tag and routePath in attrs
+                                    // Use Vnode() directly since resolver is not a component
+                                    const resolverVnode = Vnode(
+                                        resolver as any,
+                                        pathname,
+                                        {
+                                            ...data.params,
+                                            routePath: pathname,
+                                        },
+                                        null,
+                                        null,
+                                        null,
+                                    )
+                                    const renderedVnode = resolver.render(resolverVnode)
+                                    const result = await renderToString(renderedVnode)
+                                    return result
+                                } catch (error) {
+                                    logger.error('route render-only resolver failed', error, {
+                                        pathname,
+                                        route: matchedRoute,
+                                    })
+                                    throw error
+                                }
+                            }
+                            // If payload is not a valid component, skip rendering
+                            // This happens when onmatch returns undefined - render needs a component to work with
+                            // In this case, we should fall through to the component rendering logic below
+                            // which will handle the RouteResolver as a component if it has a view method
+                        }
+                    }
+
+                    // Render component
+                    // Check if payload is a ComponentType (not a RouteResolver)
+                    const isComponentType =
+                        payload != null &&
+                        (typeof payload === 'function' ||
+                            (typeof payload === 'object' && 'view' in payload && typeof (payload as any).view === 'function'))
+                    if (isComponentType) {
+                        const vnode = hyperscript(payload as ComponentType, data.params)
+                        const result = await renderToString(vnode)
+                        // Handle both string (backward compatibility) and {html, state} return types
+                        return typeof result === 'string' ? result : result
+                    }
+
+                    // Fallback to div
+                    const vnode = hyperscript('div', data.params)
+                    return await renderToString(vnode)
+                }
+            }
+
+            // No route found
+            throw new Error(`No route found for ${pathname}`)
+        } finally {
+            // Restore original prefix and currentPath
+            route.prefix = savedPrefix
+            currentPath = savedCurrentPath
+        }
+    }
+
+    return route as unknown as Route &
+        ((root: Element, defaultRoute: string, routes: Record<string, ComponentType | RouteResolver>) => void) & {
+            redirect: (path: string) => RedirectObject
+        }
+}

package/browser.ts

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import m from './index'
+
+if (typeof module !== 'undefined') {
+    ;(module as any)['exports'] = m
+} else {
+    ;(window as any).m = m
+}
+
+export default m