vike 0.4.180-commit-648cd01 → 0.4.181

package/dist/cjs/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.js

@@ -10,7 +10,7 @@ const globalObject = (0, utils_js_1.getGlobalObject)('assertNoInfiniteHttpRedire
     redirectGraph: {}
 });
 function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
-    if ((0, utils_js_1.isUriWithProtocol)(urlRedirectTarget)) {
+    if (!urlRedirectTarget.startsWith('/')) {
         // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
         //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
@@ -19,7 +19,6 @@ function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
         //    ```
         return;
     }
-    (0, utils_js_1.assert)(urlRedirectTarget.startsWith('/'));
     (0, utils_js_1.assert)(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
     graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());

package/dist/cjs/{shared/route → node/runtime/renderPage}/resolveRedirects.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRouteStringRedirect = exports.resolveRedirects = void 0;
-const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
-const utils_js_1 = require("../utils.js");
-const resolveUrlPathname_js_1 = require("./resolveUrlPathname.js");
-const resolveRouteString_js_1 = require("./resolveRouteString.js");
+const assertIsNotBrowser_js_1 = require("../../../utils/assertIsNotBrowser.js");
+const utils_js_1 = require("../../../shared/utils.js");
+const resolveUrlPathname_js_1 = require("../../../shared/route/resolveUrlPathname.js");
+const resolveRouteString_js_1 = require("../../../shared/route/resolveRouteString.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
-// TODO/v1-release: update
+// TODO/next-major-release: update
 const configSrc = '[vite.config.js > vike({ redirects })]';
 function resolveRedirects(redirects, urlPathname) {
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
@@ -23,10 +23,8 @@ function resolveRedirects(redirects, urlPathname) {
 exports.resolveRedirects = resolveRedirects;
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     (0, resolveRouteString_js_1.assertRouteString)(urlSource, `${configSrc} Invalid`);
-    (0, utils_js_1.assertUsage)(urlTarget.startsWith('/') ||
-        // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-        (0, utils_js_1.isUriWithProtocol)(urlTarget) ||
-        urlTarget === '*', `${configSrc} Invalid redirection target URL ${picocolors_1.default.cyan(urlTarget)}: the target URL should start with ${picocolors_1.default.cyan('/')}, a valid protocol (${picocolors_1.default.cyan('https:')}, ${picocolors_1.default.cyan('http:')}, ${picocolors_1.default.cyan('mailto:')}, ${picocolors_1.default.cyan('ipfs:')}, ${picocolors_1.default.cyan('magnet:')}, ...), or be ${picocolors_1.default.cyan('*')}`);
+    // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+    (0, utils_js_1.assertUsageUrlRedirectTarget)(urlTarget, `${configSrc} The URL redirection target`, true);
     assertParams(urlSource, urlTarget);
     const match = (0, resolveRouteString_js_1.resolveRouteString)(urlSource, urlPathname);
     if (!match)
@@ -34,7 +32,7 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     const urlResolved = (0, resolveUrlPathname_js_1.resolveUrlPathname)(urlTarget, match.routeParams);
     if (urlResolved === urlPathname)
         return null;
-    (0, utils_js_1.assert)(urlResolved.startsWith('/') || (0, utils_js_1.isUriWithProtocol)(urlResolved));
+    (0, utils_js_1.assert)((0, utils_js_1.isUrlRedirectTarget)(urlResolved));
     return urlResolved;
 }
 exports.resolveRouteStringRedirect = resolveRouteStringRedirect;
@@ -43,7 +41,7 @@ function assertParams(urlSource, urlTarget) {
     routeSegments.forEach((routeSegment) => {
         if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
             const segments = urlSource.split('/');
-            (0, utils_js_1.assertUsage)(segments.includes(routeSegment), `${configSrc} The redirection source URL ${picocolors_1.default.cyan(urlSource)} is missing the URL parameter ${picocolors_1.default.cyan(routeSegment)} used by the redirection target URL ${picocolors_1.default.cyan(urlTarget)}`);
+            (0, utils_js_1.assertUsage)(segments.includes(routeSegment), `${configSrc} The redirection source URL ${picocolors_1.default.string(urlSource)} is missing the URL parameter ${picocolors_1.default.string(routeSegment)} used by the redirection target URL ${picocolors_1.default.string(urlTarget)}`);
         }
     });
 }

package/dist/cjs/node/runtime/renderPage.js

@@ -21,7 +21,7 @@ const serializePageContextClientSide_js_1 = require("./html/serializePageContext
 const error_page_js_1 = require("../../shared/error-page.js");
 const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
 const loadUserFilesServerSide_js_1 = require("./renderPage/loadUserFilesServerSide.js");
-const resolveRedirects_js_1 = require("../../shared/route/resolveRedirects.js");
+const resolveRedirects_js_1 = require("./renderPage/resolveRedirects.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
     httpRequestsCount: 0,
     pendingRequestsCount: 0
@@ -332,12 +332,9 @@ function getRequestId() {
     return httpRequestId;
 }
 function isIgnoredUrl(urlOriginal) {
-    const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    (0, utils_js_1.assertWarning)(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
-    return (urlOriginal.endsWith('/__vite_ping') ||
-        urlOriginal.endsWith('/favicon.ico') ||
-        !(0, utils_js_1.isParsable)(urlOriginal) ||
-        isViteClientRequest);
+    const isViteRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
+    (0, utils_js_1.assertWarning)(!isViteRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
+    return (urlOriginal.endsWith('/__vite_ping') || urlOriginal.endsWith('/favicon.ico') || !(0, utils_js_1.isUrl)(urlOriginal) || isViteRequest);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
     const { trailingSlash, disableUrlNormalization, baseServer } = (0, globalContext_js_1.getGlobalContext)();
@@ -365,9 +362,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         const urlTarget = (0, resolveRedirects_js_1.resolveRedirects)(redirects, urlPathname);
         if (urlTarget === null)
             return null;
-        if (!(0, utils_js_1.isParsable)(urlTarget)) {
+        if (!(0, utils_js_1.isUrl)(urlTarget)) {
             // E.g. `urlTarget === 'mailto:some@example.com'`
-            (0, utils_js_1.assert)((0, utils_js_1.isUriWithProtocol)(urlTarget) && !urlTarget.startsWith('http'));
+            (0, utils_js_1.assert)((0, utils_js_1.isUri)(urlTarget));
             urlTargetExternal = urlTarget;
             return null;
         }

package/dist/cjs/shared/getPageContextUrlComputed.js

@@ -30,11 +30,6 @@ function getPageContextUrlComputed(pageContext) {
 }
 exports.getPageContextUrlComputed = getPageContextUrlComputed;
 function getUrlParsed(pageContext) {
-    // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
-    let urlHandler = pageContext._urlHandler;
-    if (!urlHandler) {
-        urlHandler = (url) => url;
-    }
     // Example of i18n app using `throw render()`:
     //  1. User goes to '/fr-FR/admin'.
     //  2. The first onBeforeRoute() call accesses pageContext.urlPathname (its value is '/fr-FR/admin': the pathname of pageContext.urlOriginal, since both pageContext.urlLogical and pageContext._urlRewrite are undefined) and sets pageContext.urlLogical to '/admin'.
@@ -43,23 +38,36 @@ function getUrlParsed(pageContext) {
     //  5. The second onBeforeRoute() call accesses pageContext.urlPathname (its value is '/fr-FR/login': the pathname of pageContext._urlRewrite, since pageContext.urlLogical is undefined) and sets pageContext.urlLogical to '/login'.
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
-    let urlResolved = 
-    // Set by onBeforeRoute()
-    pageContext.urlLogical ??
+    // Determine logical URL
+    let urlResolved;
+    let baseToBeRemoved;
+    if (pageContext.urlLogical) {
+        // Set by onBeforeRoute()
+        urlResolved = pageContext.urlLogical;
+        baseToBeRemoved = false;
+    }
+    else if (pageContext._urlRewrite) {
         // Set by `throw render()`
-        pageContext._urlRewrite ??
+        urlResolved = pageContext._urlRewrite;
+        baseToBeRemoved = false;
+    }
+    else {
         // Set by renderPage()
-        pageContext.urlOriginal;
-    urlResolved = urlHandler(urlResolved);
-    /*
-    console.log('pageContext.urlLogical', pageContext.urlLogical)
-    console.log('pageContext._urlRewrite', pageContext._urlRewrite)
-    console.log('pageContext.urlOriginal', pageContext.urlOriginal)
-    console.log()
-    //*/
-    const baseServer = pageContext._baseServer;
+        urlResolved = pageContext.urlOriginal;
+        baseToBeRemoved = true;
+    }
     (0, utils_js_1.assert)(urlResolved && typeof urlResolved === 'string');
-    (0, utils_js_1.assert)(baseServer.startsWith('/'));
+    // Remove .pageContext.json
+    let urlHandler = pageContext._urlHandler;
+    if (!urlHandler)
+        urlHandler = (url) => url;
+    urlResolved = urlHandler(urlResolved);
+    // Remove Base URL.
+    // - We assume there isn't any Base URL to the URLs set by the user at `throw render()` and onBeforeRoute()
+    //   - This makes sense because the Base URL is merely a setting: ideally the user should write code that doesn't know anything about it (so that the user can remove/add/change Base URL without having to modify any code).
+    // - pageContext.urlOriginal is the URL of the HTTP request and thus contains the Base URL.
+    const baseServer = !baseToBeRemoved ? '/' : pageContext._baseServer;
+    // Parse URL
     return (0, utils_js_1.parseUrl)(urlResolved, baseServer);
 }
 function urlPathnameGetter() {
@@ -74,47 +82,45 @@ function urlGetter() {
     return urlPathnameGetter.call(this);
 }
 function urlParsedGetter() {
-    const urlParsedOriginal = getUrlParsed(this);
-    const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
+    const { 
+    // remove hasBaseServer as it isn't part of UrlPublic
+    hasBaseServer: _, ...urlParsed } = getUrlParsed(this);
     const hashIsAvailable = (0, utils_js_1.isBrowser)();
     const warnHashNotAvailable = (prop) => {
         (0, utils_js_1.assertWarning)(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });
     };
-    const urlParsed = {
-        origin,
-        pathname,
-        pathnameOriginal,
-        search,
-        searchAll,
-        searchOriginal,
+    const urlParsedEnhanced = {
+        ...urlParsed,
         get hash() {
             warnHashNotAvailable('hash');
-            return hash;
+            return urlParsed.hash;
         },
         get hashOriginal() {
             warnHashNotAvailable('hashOriginal');
-            return hashOriginal;
+            return urlParsed.hashOriginal;
         },
+        // TODO/next-major-release: remove
         get hashString() {
             (0, utils_js_1.assertWarning)(false, 'pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal', {
                 onlyOnce: true,
                 showStackTrace: true
             });
             warnHashNotAvailable('hashString');
-            return hashOriginal;
+            return urlParsed.hashOriginal;
         },
+        // TODO/next-major-release: remove
         get searchString() {
             (0, utils_js_1.assertWarning)(false, 'pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal', { onlyOnce: true, showStackTrace: true });
-            return searchOriginal;
+            return urlParsed.searchOriginal;
         }
     };
-    (0, utils_js_1.changeEnumerable)(urlParsed, 'hashString', false);
-    (0, utils_js_1.changeEnumerable)(urlParsed, 'searchString', false);
+    (0, utils_js_1.changeEnumerable)(urlParsedEnhanced, 'hashString', false);
+    (0, utils_js_1.changeEnumerable)(urlParsedEnhanced, 'searchString', false);
     if (!hashIsAvailable) {
-        (0, utils_js_1.changeEnumerable)(urlParsed, 'hash', false);
-        (0, utils_js_1.changeEnumerable)(urlParsed, 'hashOriginal', false);
+        (0, utils_js_1.changeEnumerable)(urlParsedEnhanced, 'hash', false);
+        (0, utils_js_1.changeEnumerable)(urlParsedEnhanced, 'hashOriginal', false);
     }
-    return urlParsed;
+    return urlParsedEnhanced;
 }
 function assertPageContextUrl(pageContext) {
     (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');

package/dist/cjs/shared/modifyUrl.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyUrl = void 0;
+const utils_js_1 = require("./utils.js");
+/**
+ * Modify a URL.
+ *
+ * Example: changing the URL pathname for internationalization.
+ *
+ * https://vike.dev/modifyUrl
+ */
+function modifyUrl(url, modify) {
+    const urlParsed = (0, utils_js_1.parseUrl)(url, '/');
+    // Pathname
+    const pathname = modify.pathname ?? urlParsed.pathname;
+    // Origin
+    const originParts = [
+        modify.protocol ?? urlParsed.protocol ?? '',
+        modify.hostname ?? urlParsed.hostname ?? ''
+    ];
+    const port = modify.port ?? urlParsed.port;
+    if (port || port === 0) {
+        originParts.push(`:${port}`);
+    }
+    const origin = originParts.join('');
+    const urlModified = (0, utils_js_1.createUrlFromComponents)(origin, pathname, 
+    // Should we also support modifying search and hash?
+    urlParsed.searchOriginal, urlParsed.hashOriginal);
+    return urlModified;
+}
+exports.modifyUrl = modifyUrl;

package/dist/cjs/shared/route/abort.js

@@ -17,7 +17,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
  */
 function redirect(url, statusCode) {
     const abortCaller = 'throw redirect()';
-    assertUrl(url, abortCaller, true);
+    (0, utils_js_1.assertUsageUrlRedirectTarget)(url, getErrPrefix(abortCaller));
     const args = [JSON.stringify(url)];
     if (!statusCode) {
         statusCode = 302;
@@ -59,7 +59,7 @@ function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageConte
     }
     if (typeof urlOrStatusCode === 'string') {
         const url = urlOrStatusCode;
-        assertUrl(url, abortCaller);
+        (0, utils_js_1.assertUsageUrlPathnameAbsolute)(url, getErrPrefix(abortCaller));
         (0, utils_js_1.objectAssign)(pageContextAbort, {
             _urlRewrite: url
         });
@@ -174,12 +174,6 @@ function assertNoInfiniteAbortLoop(rewriteCount, redirectCount) {
     (0, utils_js_1.assertUsage)(rewriteCount + redirectCount <= 7, `Maximum chain length of 7 ${abortCalls} exceeded. Did you define an infinite loop of ${abortCalls}?`);
 }
 exports.assertNoInfiniteAbortLoop = assertNoInfiniteAbortLoop;
-function assertUrl(url, abortCaller, allowAbsoluteUrl) {
-    (0, utils_js_1.assertUsage)(url.startsWith('/') || (allowAbsoluteUrl && (0, utils_js_1.isUriWithProtocol)(url)), [
-        `Invalid URL ${picocolors_1.default.cyan(url)} passed to ${picocolors_1.default.cyan(abortCaller)}:`,
-        `the URL should start with ${picocolors_1.default.cyan('/')}`,
-        allowAbsoluteUrl && `or a valid protocol (${picocolors_1.default.cyan('https:')}, ${picocolors_1.default.cyan('ipfs:')}, ...)`
-    ]
-        .filter(Boolean)
-        .join(' '));
+function getErrPrefix(abortCaller) {
+    return `URL passed to ${picocolors_1.default.code(abortCaller)}`;
 }

package/dist/cjs/shared/route/executeOnBeforeRouteHook.js

@@ -71,7 +71,9 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
         delete hookReturn.pageContext.urlOriginal;
     }
     if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'urlLogical')) {
-        (0, utils_js_1.assertUsageUrl)(hookReturn.pageContext.urlLogical, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} but ${picocolors_1.default.cyan('urlLogical')}`);
+        (0, utils_js_1.assertUsageUrlPathnameAbsolute)(
+        // We type-cast to string instead of assertUsage() in order to save client-side KBs
+        hookReturn.pageContext.urlLogical, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} but ${picocolors_1.default.cyan('urlLogical')}`);
     }
     (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,

package/dist/cjs/utils/parseUrl.js

@@ -6,35 +6,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUriWithProtocol = exports.createUrlFromComponents = exports.assertUrlComponents = exports.isBaseServer = exports.assertUsageUrl = exports.isParsable = exports.parseUrl = void 0;
+exports.createUrlFromComponents = exports.assertUrlComponents = exports.isBaseServer = exports.isUrlExternal = exports.isUrlRedirectTarget = exports.isUri = exports.isUrl = exports.assertUsageUrlRedirectTarget = exports.assertUsageUrlPathnameAbsolute = exports.assertUsageUrlPathname = exports.parseUrl = void 0;
 const slice_js_1 = require("./slice.js");
 const assert_js_1 = require("./assert.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function isParsable(url) {
-    // `parseUrl()` works with these URLs
-    return (isUrlWithProtocol(url) ||
-        url.startsWith('/') ||
-        url.startsWith('.') ||
-        url.startsWith('?') ||
-        url.startsWith('#') ||
-        url === '');
-}
-exports.isParsable = isParsable;
-function assertUsageUrl(url, errPrefix) {
-    (0, assert_js_1.assert)(errPrefix.includes(' but '));
-    (0, assert_js_1.assertUsage)(typeof url === 'string', `${errPrefix} should be a string`);
-    if (isParsable(url))
-        return;
-    if (!url.startsWith('/') && !url.includes(':')) {
-        (0, assert_js_1.assertUsage)(false, `${errPrefix} is ${picocolors_1.default.cyan(url)} and it should be /${picocolors_1.default.cyan(url)} instead (URL pathnames should start with a leading slash)`);
-    }
-    else {
-        (0, assert_js_1.assertUsage)(false, `${errPrefix} isn't a valid URL`);
-    }
-}
-exports.assertUsageUrl = assertUsageUrl;
 function parseUrl(url, baseServer) {
-    (0, assert_js_1.assert)(isParsable(url));
+    (0, assert_js_1.assert)(isUrl(url), url);
     (0, assert_js_1.assert)(baseServer.startsWith('/'));
     // Hash
     const [urlWithoutHash, ...hashList] = url.split('#');
@@ -54,18 +31,24 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
-    (0, assert_js_1.assert)(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
-    (0, assert_js_1.assert)(pathnameResolved.startsWith('/'));
-    (0, assert_js_1.assert)(origin === null || url.startsWith(origin));
-    // `pathnameOriginal`
+    let { protocol, origin, pathnameAbsoluteWithBase } = getPathnameAbsoluteWithBase(urlWithoutHashNorSearch, baseServer);
     const pathnameOriginal = urlWithoutHashNorSearch.slice((origin || '').length);
     assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
     // Base URL
-    let { pathname, hasBaseServer } = analyzeBaseServer(pathnameResolved, baseServer);
+    let { pathname, hasBaseServer } = removeBaseServer(pathnameAbsoluteWithBase, baseServer);
+    // pageContext.urlParsed.href
+    const href = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+    // pageContext.urlParsed.{hostname, port}
+    const host = !origin ? null : origin.slice(protocol.length);
+    const { hostname, port } = parseHost(host, url);
+    // decode after setting href
     pathname = decodePathname(pathname);
     (0, assert_js_1.assert)(pathname.startsWith('/'));
     return {
+        href,
+        protocol,
+        hostname,
+        port,
         origin,
         pathname,
         pathnameOriginal: pathnameOriginal,
@@ -97,20 +80,20 @@ function decodePathname(urlPathname) {
         .join('/');
     return urlPathname;
 }
-function getPathname(url, baseServer) {
+function getPathnameAbsoluteWithBase(url, baseServer) {
     // Search and hash already extracted
     (0, assert_js_1.assert)(!url.includes('?') && !url.includes('#'));
     // url has origin
     {
-        const { origin, pathname } = parseOrigin(url);
+        const { protocol, origin, pathname } = parseOrigin(url);
         if (origin) {
-            return { origin, pathname };
+            return { protocol, origin, pathnameAbsoluteWithBase: pathname };
         }
         (0, assert_js_1.assert)(pathname === url);
     }
     // url doesn't have origin
     if (url.startsWith('/')) {
-        return { origin: null, pathname: url };
+        return { protocol: null, origin: null, pathnameAbsoluteWithBase: url };
     }
     else {
         // url is a relative path
@@ -125,21 +108,70 @@ function getPathname(url, baseServer) {
         else {
             base = baseServer;
         }
-        const pathname = resolveUrlPathnameRelative(url, base);
-        return { origin: null, pathname };
+        const pathnameAbsoluteWithBase = resolveUrlPathnameRelative(url, base);
+        return { protocol: null, origin: null, pathnameAbsoluteWithBase: pathnameAbsoluteWithBase };
     }
 }
 function parseOrigin(url) {
     if (!isUrlWithProtocol(url)) {
-        (0, assert_js_1.assert)(!isUriWithProtocol(url));
-        return { pathname: url, origin: null };
+        return { pathname: url, origin: null, protocol: null };
     }
     else {
-        const [originPart1, originPart2, originPart3, ...pathnameParts] = url.split('/');
-        const origin = [originPart1, originPart2, originPart3].join('/');
-        const pathname = ['', ...pathnameParts].join('/') || '/';
-        return { origin, pathname };
+        const { protocol, uriWithoutProtocol } = parseProtocol(url);
+        (0, assert_js_1.assert)(protocol);
+        const [host, ...rest] = uriWithoutProtocol.split('/');
+        const origin = protocol + host;
+        const pathname = '/' + rest.join('/');
+        return { pathname, origin, protocol };
+    }
+}
+function parseHost(host, url) {
+    const ret = { hostname: null, port: null };
+    if (!host)
+        return ret;
+    // hostname
+    const [hostname, ...rest] = host.split(':');
+    ret.hostname = hostname;
+    // port
+    if (rest.length > 0) {
+        (0, assert_js_1.assert)(rest.length === 1, url);
+        const portStr = rest[0];
+        const port = parseInt(portStr, 10);
+        (0, assert_js_1.assert)(port || port === 0, url);
+        ret.port = port;
     }
+    return ret;
+}
+function parseProtocol(uri) {
+    const SEP = ':';
+    const [before, ...after] = uri.split(SEP);
+    if (after.length === 0 ||
+        // https://github.com/vikejs/vike/commit/886a99ff21e86a8ca699a25cee7edc184aa058e4#r143308934
+        // https://en.wikipedia.org/wiki/List_of_URI_schemes
+        // https://www.rfc-editor.org/rfc/rfc7595
+        !/^[a-z][a-z0-9\+\-]*$/i.test(before)) {
+        return { protocol: null, uriWithoutProtocol: uri };
+    }
+    let protocol = before + SEP;
+    let uriWithoutProtocol = after.join(SEP);
+    const SEP2 = '//';
+    if (uriWithoutProtocol.startsWith(SEP2)) {
+        protocol = protocol + SEP2;
+        uriWithoutProtocol = uriWithoutProtocol.slice(SEP2.length);
+    }
+    return { protocol, uriWithoutProtocol };
+}
+function isUrlProtocol(protocol) {
+    // Is there an altenrative to having a blacklist?
+    // - If the blacklist becomes too big, maybe use a whitelist instead ['tauri://', 'file://', 'capacitor://', 'http://', 'https://']
+    const blacklist = [
+        // https://docs.ipfs.tech/how-to/address-ipfs-on-web
+        'ipfs://',
+        'ipns://'
+    ];
+    if (blacklist.includes(protocol))
+        return false;
+    return protocol.endsWith('://');
 }
 // Adapted from https://stackoverflow.com/questions/14780350/convert-relative-path-to-absolute-using-javascript/14780463#14780463
 function resolveUrlPathnameRelative(pathnameRelative, base) {
@@ -170,34 +202,15 @@ function resolveUrlPathnameRelative(pathnameRelative, base) {
         pathnameAbsolute = '/' + pathnameAbsolute;
     return pathnameAbsolute;
 }
-/* Not needed anymore?
-function assertUsageBaseServer(baseServer: string, usageErrorMessagePrefix: string = '') {
-  assertUsage(
-    !baseServer.startsWith('http'),
-    usageErrorMessagePrefix +
-      '`base` is not allowed to start with `http`. Consider using `baseAssets` instead, see https://vike.dev/base-url'
-  )
-  assertUsage(
-    baseServer.startsWith('/'),
-    usageErrorMessagePrefix + 'Wrong `base` value `' + baseServer + '`; `base` should start with `/`.'
-  )
-  assert(isBaseServer(baseServer))
-}
-*/
-function assertPathname(urlPathname) {
-    (0, assert_js_1.assert)(urlPathname.startsWith('/'));
-    (0, assert_js_1.assert)(!urlPathname.includes('?'));
-    (0, assert_js_1.assert)(!urlPathname.includes('#'));
-}
-function analyzeBaseServer(urlPathnameWithBase, baseServer) {
-    assertPathname(urlPathnameWithBase);
+function removeBaseServer(pathnameAbsoluteWithBase, baseServer) {
+    (0, assert_js_1.assert)(pathnameAbsoluteWithBase.startsWith('/'));
     (0, assert_js_1.assert)(isBaseServer(baseServer));
     // Mutable
-    let urlPathname = urlPathnameWithBase;
+    let urlPathname = pathnameAbsoluteWithBase;
     (0, assert_js_1.assert)(urlPathname.startsWith('/'));
     (0, assert_js_1.assert)(baseServer.startsWith('/'));
     if (baseServer === '/') {
-        const pathname = urlPathnameWithBase;
+        const pathname = pathnameAbsoluteWithBase;
         return { pathname, hasBaseServer: true };
     }
     // Support `url === '/some-base-url' && baseServer === '/some-base-url/'`
@@ -207,7 +220,7 @@ function analyzeBaseServer(urlPathnameWithBase, baseServer) {
         (0, assert_js_1.assert)(urlPathname === baseServerNormalized);
     }
     if (!urlPathname.startsWith(baseServerNormalized)) {
-        const pathname = urlPathnameWithBase;
+        const pathname = pathnameAbsoluteWithBase;
         return { pathname, hasBaseServer: false };
     }
     (0, assert_js_1.assert)(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
@@ -222,30 +235,98 @@ function isBaseServer(baseServer) {
     return baseServer.startsWith('/');
 }
 exports.isBaseServer = isBaseServer;
-function assertUrlComponents(url, origin, pathname, searchOriginal, hashOriginal) {
-    const urlRecreated = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+function assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal) {
+    const urlRecreated = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
     (0, assert_js_1.assert)(url === urlRecreated);
 }
 exports.assertUrlComponents = assertUrlComponents;
-function createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal) {
-    const urlRecreated = `${origin || ''}${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+function createUrlFromComponents(origin, pathname, search, hash) {
+    const urlRecreated = `${origin || ''}${pathname}${search || ''}${hash || ''}`;
     return urlRecreated;
 }
 exports.createUrlFromComponents = createUrlFromComponents;
-function isUriWithProtocol(str) {
-    // https://en.wikipedia.org/wiki/List_of_URI_schemes
-    // https://www.rfc-editor.org/rfc/rfc7595
-    // https://github.com/vikejs/vike/commit/886a99ff21e86a8ca699a25cee7edc184aa058e4#r143308934
-    // Examples:
-    //   http://
-    //   https://
-    //   tauri:// # [Tauri](https://tauri.app)
-    //   file:// # [Electron](https://github.com/vikejs/vike/issues/1557)
-    //   capacitor:// # [Capacitor](https://github.com/vikejs/vike/issues/1706)
-    return /^[a-z][a-z0-9\+\-]*:/i.test(str);
-}
-exports.isUriWithProtocol = isUriWithProtocol;
-// Same as isUriWithProtocol() but with trailing :// which is needed for parseOrigin()
-function isUrlWithProtocol(str) {
-    return /^[a-z][a-z0-9\+\-]*:\/\//i.test(str);
+function isUrl(url) {
+    // parseUrl() works with these URLs
+    return isUrlWithProtocol(url) || url.startsWith('/') || isUrlPathnameRelative(url);
+}
+exports.isUrl = isUrl;
+function isUrlRedirectTarget(url) {
+    return url.startsWith('/') || isUri(url) || isUrlWithProtocol(url);
+}
+exports.isUrlRedirectTarget = isUrlRedirectTarget;
+function isUrlPathnameRelative(url) {
+    return ['.', '?', '#'].some((c) => url.startsWith(c)) || url === '';
+}
+function isUrlExternal(url) {
+    return !url.startsWith('/') && !isUrlPathnameRelative(url);
+}
+exports.isUrlExternal = isUrlExternal;
+/*
+URL with protocol.
+
+  http://example.com
+  https://exmaple.com
+  tauri://localhost
+  file://example.com
+  capacitor://localhost/assets/chunks/chunk-DJBYDrsP.js
+
+[Tauri](https://github.com/vikejs/vike/issues/808)
+[Electron (`file://`)](https://github.com/vikejs/vike/issues/1557)
+[Capacitor](https://github.com/vikejs/vike/issues/1706)
+ */
+function isUrlWithProtocol(url) {
+    const { protocol } = parseProtocol(url);
+    return !!protocol && isUrlProtocol(protocol);
+}
+/*
+URIs that aren't URLs.
+
+  mailto:john@example.com
+
+  ipfs://bafybeiemxf5abjwjbikoz4mc3a3dla6ual3jsgpdr4cjr3oz3evfyavhwq/wiki/Vincent_van_Gogh.html
+
+  magnet:?xt=urn:btih:3a15e1ac49683d91b20c2ffc252ea612a6c01bd7&dn=The.Empire.Strikes.Back.1980.Remastered.1080p.BluRay.DDP.7.1.x265-EDGE2020.mkv&xl=3225443573&tr=udp://tracker.opentrackr.org:1337/announce&tr=udp://tracker.torrent.eu.org:451&tr=udp://open.stealth.si:80/announce&tr=udp://tracker.openbittorrent.com:6969&tr=udp://tracker.tiny-vps.com:6969/announce&tr=udp://open.demonii.com:1337
+
+We need to treat URIs differently than URLs.
+ - For example, we cannot parse URIs (their structure is unknown e.g. a `magnet:` URI is completely different than a `http://` URL).
+   - The protocols tauri:// file:// capacitor:// follow the same structure as http:// and https:// URLs.
+     - Thus we can parse them like http:// and https:// URLs.
+*/
+function isUri(uri) {
+    const { protocol } = parseProtocol(uri);
+    return !!protocol && !isUrlProtocol(uri);
+}
+exports.isUri = isUri;
+function assertUsageUrlPathname(url, errPrefix) {
+    assertUsageUrl(url, errPrefix, { allowRelative: true });
+}
+exports.assertUsageUrlPathname = assertUsageUrlPathname;
+function assertUsageUrlPathnameAbsolute(url, errPrefix) {
+    assertUsageUrl(url, errPrefix);
+}
+exports.assertUsageUrlPathnameAbsolute = assertUsageUrlPathnameAbsolute;
+function assertUsageUrlRedirectTarget(url, errPrefix, isUnresolved) {
+    assertUsageUrl(url, errPrefix, { isRedirectTarget: isUnresolved ? 'unresolved' : true });
+}
+exports.assertUsageUrlRedirectTarget = assertUsageUrlRedirectTarget;
+function assertUsageUrl(url, errPrefix, { allowRelative, isRedirectTarget } = {}) {
+    if (url.startsWith('/'))
+        return;
+    let errMsg = `${errPrefix} is ${picocolors_1.default.string(url)} but it should start with ${picocolors_1.default.string('/')}`;
+    if (isRedirectTarget) {
+        if (isUrlRedirectTarget(url))
+            return;
+        errMsg += ` or a protocol (${picocolors_1.default.string('http://')}, ${picocolors_1.default.string('mailto:')}, ...)`;
+        if (isRedirectTarget === 'unresolved') {
+            if (url === '*')
+                return;
+            errMsg += `, or be ${picocolors_1.default.string('*')}`;
+        }
+    }
+    if (allowRelative) {
+        if (isUrlPathnameRelative(url))
+            return;
+        errMsg += ', or be a relative URL';
+    }
+    (0, assert_js_1.assertUsage)(false, errMsg);
 }