@webqit/webflo 0.11.39 → 0.11.41

package/src/runtime-pi/server/Runtime.js

@@ -6,44 +6,22 @@ import Fs from 'fs';
 import Path from 'path';
 import Http from 'http';
 import Https from 'https';
-import Formidable from 'formidable';
 import Sessions from 'client-sessions';
 import { Observer } from '@webqit/oohtml-ssr/apis.js';
 import { _each } from '@webqit/util/obj/index.js';
 import { _isEmpty } from '@webqit/util/js/index.js';
 import { _from as _arrFrom, _any } from '@webqit/util/arr/index.js';
 import { slice as _streamSlice } from 'stream-slice';
-import { urlPattern } from '../util.js';
-import * as whatwag from './whatwag.js';
-import xURL from '../xURL.js';
-import xFormData from "../xFormData.js";
-import xRequestHeaders from "../xRequestHeaders.js";
-import xResponseHeaders from "../xResponseHeaders.js";
+import { Readable as _ReadableStream } from 'stream';
+import { pattern } from '../util-url.js';
 import xRequest from "../xRequest.js";
 import xResponse from "../xResponse.js";
 import xfetch from '../xfetch.js';
-import xHttpEvent from '../xHttpEvent.js';
+import HttpEvent from '../HttpEvent.js';
 import _Runtime from '../Runtime.js';
 
-const URL = xURL(whatwag.URL);
-const FormData = xFormData(whatwag.FormData);
-const ReadableStream = whatwag.ReadableStream;
-const RequestHeaders = xRequestHeaders(whatwag.Headers);
-const ResponseHeaders = xResponseHeaders(whatwag.Headers);
-const Request = xRequest(whatwag.Request, RequestHeaders, FormData, whatwag.Blob);
-const Response = xResponse(whatwag.Response, ResponseHeaders, FormData, whatwag.Blob);
-const fetch = xfetch(whatwag.fetch);
-const HttpEvent = xHttpEvent(Request, Response, URL);
-
 export {
-    URL,
-    FormData,
-    ReadableStream,
-    RequestHeaders,
-    ResponseHeaders,
-    Request,
-    Response,
-    fetch,
+    //fetch,
     HttpEvent,
     Observer,
 }
@@ -54,18 +32,18 @@ export default class Runtime extends _Runtime {
      * Runtime
      * 
      * @param Object        cx
-     * @param Function      clientCallback
+     * @param Function      applicationInstance
      * 
      * @return void
      */
-    constructor(cx, clientCallback) {
-        super(cx, clientCallback);
+    constructor(cx, applicationInstance) {
+        super(cx, applicationInstance);
         // ---------------
         this.ready = (async () => {
             // ---------------
             const resolveContextObj = async (cx, force = false) => {
-                if (_isEmpty(cx.server) || force) { cx.server = await (new cx.config.runtime.Server(cx)).read(); }
                 if (_isEmpty(cx.layout) || force) { cx.layout = await (new cx.config.deployment.Layout(cx)).read(); }
+                if (_isEmpty(cx.server) || force) { cx.server = await (new cx.config.runtime.Server(cx)).read(); }
                 if (_isEmpty(cx.env) || force) { cx.env = await (new cx.config.deployment.Env(cx)).read(); }
             };
             await resolveContextObj(this.cx);
@@ -80,14 +58,15 @@ export default class Runtime extends _Runtime {
             const parseDomains = domains => _arrFrom(domains).reduce((arr, str) => arr.concat(str.split(',')), []).map(str => str.trim()).filter(str => str);
             const selectDomains = (serverDefs, matchingPort = null) => serverDefs.reduce((doms, def) => doms.length ? doms : (((!matchingPort || def.port === matchingPort) && parseDomains(def.domains || def.hostnames)) || []), []);
             // ---------------
-            this.vhosts = new Map;
-            if (this.cx.config.deployment.Virtualization) {
-                const vhosts = await (new this.cx.config.deployment.Virtualization(this.cx)).read();
-                await Promise.all((vhosts.entries || []).map(async vhost => {
+            this.proxied = new Map;
+            if (this.cx.config.deployment.Proxy) {
+                const proxied = await (new this.cx.config.deployment.Proxy(this.cx)).read();
+                await Promise.all((proxied.entries || []).map(async vhost => {
                     let cx, hostnames = parseDomains(vhost.hostnames), port = vhost.port, proto = vhost.proto;
                     if (vhost.path) {
                         cx = this.cx.constructor.create(this.cx, Path.join(this.cx.CWD, vhost.path));
                         await resolveContextObj(cx, true);
+                        cx.dict.key = true;
                         // From the server that's most likely to be active
                         port || (port = cx.server.https.port || cx.server.port);
                         // The domain list that corresponds to the specified resolved port
@@ -98,7 +77,7 @@ export default class Runtime extends _Runtime {
                         proto || (proto = port === cx.server.https.port ? 'https' : 'http');
                     }
                     hostnames.length || (hostnames = ['*']);
-                    this.vhosts.set(hostnames.sort().join('|'), { cx, hostnames, port, proto });
+                    this.proxied.set(hostnames.sort().join('|'), { cx, hostnames, port, proto });
                 }));
             }
             // ---------------
@@ -139,12 +118,13 @@ export default class Runtime extends _Runtime {
                 });
                 // -------
                 addSSLContext(this.cx.server, domains);
-                for (const [ /*id*/, vhost ] of this.vhosts) {
+                for (const [ /*id*/, vhost ] of this.proxied) {
                     vhost.cx && addSSLContext(vhost.cx.server, vhost.hostnames);
                 }
             }
             // ---------------
             const handleRequest = async (proto, request, response) => {
+                request[Symbol.toStringTag] = 'ReadableStream';
                 const [ fullUrl, requestInit ] = await this.parseNodeRequest(proto, request);
                 let clientResponse = await this.go(fullUrl, requestInit, { request, response });
                 if (response.headersSent) return;
@@ -158,9 +138,12 @@ export default class Runtime extends _Runtime {
                 if (clientResponse.headers.location) {
                     return response.end();
                 }
-                if ((clientResponse.body instanceof ReadableStream)) {
+                if ((clientResponse.body instanceof _ReadableStream)) {
                     return clientResponse.body.pipe(response);
                 }
+                if ((clientResponse.body instanceof ReadableStream)) {
+                    return _ReadableStream.from(clientResponse.body).pipe(response);
+                }
                 let body = clientResponse.body;
                 if (clientResponse.headers.contentType === 'application/json') {
                     body += '';
@@ -187,20 +170,20 @@ export default class Runtime extends _Runtime {
                 } else {
                     this.cx.logger.info(`> Server not running! No port specified.`);
                 }
-                if (this.vhosts.size) {
+                if (this.proxied.size) {
                     this.cx.logger.info(`> Reverse proxy active.`);
-                    for (let [ id, def ] of this.vhosts) {
+                    for (let [ id, def ] of this.proxied) {
                         this.cx.logger.info(`> ${ id } >>> ${ def.port }`);
                     }
                 }
                 this.cx.logger.info(``);
             }
-			if (this.client && this.client.init) {
-                const request = this.generateRequest('/');
+			if (this.app && this.app.init) {
+                const request = this.generateRequest('http://localhost/');
                 const httpEvent = new HttpEvent(request, { srcType: 'initialization' }, (id = 'session', options = { duration: 60 * 60 * 24, activeDuration: 60 * 60 * 24 }, callback = null) => {
                     return this.getSession(this.cx, httpEvent, id, options, callback);
                 });
-                await this.client.init(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
+                await this.app.init(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
             }
 		})();
         // ---------------
@@ -220,55 +203,14 @@ export default class Runtime extends _Runtime {
      * @return Array
      */
     async parseNodeRequest(proto, request) {
-        let url = request.url;
         // Detected when using manual proxy setting in a browser
-        if (url.startsWith(`http://${ request.headers.host }`) || url.startsWith(`https://${ request.headers.host }`)) {
-            url = url.split(request.headers.host)[1];
+        if (request.url.startsWith(`http://${ request.headers.host }`) || request.url.startsWith(`https://${ request.headers.host }`)) {
+            request.url = request.url.split(request.headers.host)[1];
         }
-        const fullUrl = proto + '://' + request.headers.host + url;
+        const fullUrl = proto + '://' + request.headers.host + request.url;
         const requestInit = { method: request.method, headers: request.headers };
-        if (request.method !== 'GET' && request.method !== 'HEAD') {
-            requestInit.body = await new Promise((resolve, reject) => {
-                var formidable = new Formidable.IncomingForm({ multiples: true, allowEmptyFiles: true, keepExtensions: true });
-                formidable.parse(request, (error, fields, files) => {
-                    if (error) { return reject(error); }
-                    if (request.headers['content-type'] === 'application/json') {
-                        return resolve(fields);
-                    }
-                    const formData = new FormData;
-                    Object.keys(fields).forEach(name => {
-                        if (Array.isArray(fields[name])) {
-                            const values = Array.isArray(fields[name][0]) 
-                                ? fields[name][0]/* bugly a nested array when there are actually more than entry */ 
-                                : fields[name];
-                            values.forEach(value => {
-                                formData.append(!name.endsWith(']') ? name + '[]' : name, value);
-                            });
-                        } else {
-                            formData.append(name, fields[name]);
-                        }
-                    });
-                    Object.keys(files).forEach(name => {
-                        const fileCompat = file => {
-                            // IMPORTANT
-                            // Path up the "formidable" file in a way that "formdata-node"
-                            // to can translate it into its own file instance
-                            file[Symbol.toStringTag] = 'File';
-                            file.stream = () => Fs.createReadStream(file.path);
-                            // Done pathcing
-                            return file;
-                        }
-                        if (Array.isArray(files[name])) {
-                            files[name].forEach(value => {
-                                formData.append(name, fileCompat(value));
-                            });
-                        } else {
-                            formData.append(name, fileCompat(files[name]));
-                        }
-                    });
-                    resolve(formData);
-                });
-            });
+        if (!['GET', 'HEAD'].includes(request.method)) {
+            requestInit.body = request;
         }
         return [ fullUrl, requestInit ];
     }
@@ -286,13 +228,13 @@ export default class Runtime extends _Runtime {
         await this.ready;
 
         // ------------
-        url = typeof url === 'string' ? new whatwag.URL(url) : url;
+        url = typeof url === 'string' ? new URL(url) : url;
         init = { referrer: this.location.href, ...init };
         // ------------
         const hosts = [];
         this.servers.forEach(server => hosts.push(...server.domains));
         // ------------
-        for (const [ /*id*/, vhost ] of this.vhosts) {
+        for (const [ /*id*/, vhost ] of this.proxied) {
             if (vhost.hostnames.includes(url.hostname) || (vhost.hostnames.includes('*') && !hosts.includes('*'))) {
                 return this.proxyGo(vhost, url, init);
             }
@@ -309,10 +251,10 @@ export default class Runtime extends _Runtime {
             exit = { status: 302, headers: { Location: ( url.hostname = `www.${ url.hostname }`, url.href ) } };
         } else if (this.cx.config.runtime.server.Redirects) {
             exit = ((await (new this.cx.config.runtime.server.Redirects(this.cx)).read()).entries || []).reduce((_rdr, entry) => {
-                return _rdr || ((_rdr = urlPattern(entry.from, url.origin).exec(url.href)) && { status: entry.code || 302, headers: { Location: _rdr.render(entry.to) } });
+                return _rdr || ((_rdr = pattern(entry.from, url.origin).exec(url.href)) && { status: entry.code || 302, headers: { Location: _rdr.render(entry.to) } });
             }, null);
         }
-        if (exit) { return new Response(null, exit); }
+        if (exit) { return new xResponse(null, exit); }
         // ------------
 
         // ------------
@@ -323,7 +265,7 @@ export default class Runtime extends _Runtime {
         // ------------
         // Automatically-added headers
         const autoHeaders = this.cx.config.runtime.server.Headers 
-            ? ((await (new this.cx.config.runtime.server.Headers(this.cx)).read()).entries || []).filter(entry => urlPattern(entry.url, url.origin).exec(url.href))
+            ? ((await (new this.cx.config.runtime.server.Headers(this.cx)).read()).entries || []).filter(entry => pattern(entry.url, url.origin).exec(url.href))
             : [];
         // The request object
         const request = this.generateRequest(url.href, init, autoHeaders.filter(header => header.type === 'request'));
@@ -334,10 +276,10 @@ export default class Runtime extends _Runtime {
         // Response
         let response, finalResponse;
         try {
-            response = await this.client.handle(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
+            response = await this.app.handle(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
             finalResponse = await this.handleResponse(this.cx, httpEvent, response, autoHeaders.filter(header => header.type === 'response'));
         } catch(e) {
-            finalResponse = new Response(null, { status: 500, statusText: e.message });
+            finalResponse = new xResponse(null, { status: 500, statusText: e.message });
             console.error(e);
         }
         // Logging
@@ -353,19 +295,20 @@ export default class Runtime extends _Runtime {
     // Fetch from proxied host
     async proxyGo(vhost, url, init) {
         // ---------
-        const url2 = new whatwag.URL(url);
+        const url2 = new URL(url);
         url2.port = vhost.port;
         if (vhost.proto) { url2.protocol = vhost.proto; }
         // ---------
-        const init2 = { ...init, compress: false };
+        const init2 = { ...init, decompress: false/* honoured in xfetch() */ };
         if (!init2.headers) init2.headers = {};
         init2.headers.host = url2.host;
+        delete init2.headers.connection;
         // ---------
         let response;
         try {
             response = await this.remoteFetch(url2, init2);
         } catch(e) {
-            response = new Response(null, { status: 500, statusText: e.message });
+            response = new xResponse(null, { status: 500, statusText: e.message });
             console.error(e);
         }
         if (this.cx.logger) {
@@ -378,7 +321,7 @@ export default class Runtime extends _Runtime {
 
     // Generates request object
     generateRequest(href, init = {}, autoHeaders = []) {
-        const request = new Request(href, init);
+        const request = new xRequest(href, init);
         this._autoHeaders(request.headers, autoHeaders);
         return request;
     }
@@ -422,24 +365,24 @@ export default class Runtime extends _Runtime {
         let href = request;
 		if (request instanceof Request) {
 			href = request.url;
-		} else if (request instanceof whatwag.URL) {
+		} else if (request instanceof URL) {
 			href = request.href;
 		}
         Observer.set(this.network, 'remote', href);
-        const _response = fetch(request, ...args);
+        const _response = xfetch(request, ...args);
         // This catch() is NOT intended to handle failure of the fetch
         _response.catch(e => Observer.set(this.network, 'error', e.message));
         // Save a reference to this
         return _response.then(async response => {
             // Stop loading status
             Observer.set(this.network, 'remote', false);
-            return new Response(response);
+            return new xResponse(response);
         });
     }
 
     // Handles response object
     async handleResponse(cx, e, response, autoHeaders = []) {
-        if (!(response instanceof Response)) { response = new Response(response); }
+        if (!(response instanceof xResponse)) { response = new xResponse(response); }
         Observer.set(this.network, 'remote', false);
         Observer.set(this.network, 'error', null);
 
@@ -461,7 +404,7 @@ export default class Runtime extends _Runtime {
         if (response.headers.location) {
             const xRedirectPolicy = e.request.headers.get('X-Redirect-Policy');
             const xRedirectCode = e.request.headers.get('X-Redirect-Code') || 300;
-            const destinationUrl = new whatwag.URL(response.headers.location, e.url.origin);
+            const destinationUrl = new URL(response.headers.location, e.url.origin);
             const isSameOriginRedirect = destinationUrl.origin === e.url.origin;
             let isSameSpaRedirect, sparootsFile = Path.join(cx.CWD, cx.layout.PUBLIC_DIR, 'sparoots.json');
             if (isSameOriginRedirect && xRedirectPolicy === 'manual-when-cross-spa' && Fs.existsSync(sparootsFile)) {
@@ -483,7 +426,7 @@ export default class Runtime extends _Runtime {
 
         // ----------------
         // 404
-        if (response.bodyAttrs.input === undefined || response.bodyAttrs.input === null) {
+        if (response.meta.body === undefined || response.meta.body === null) {
             response.attrs.status = response.status !== 200 ? response.status : 404;
             response.attrs.statusText  = `${e.request.url} not found!`;
             return response;
@@ -507,7 +450,7 @@ export default class Runtime extends _Runtime {
         // Body
         let rangeRequest, body = response.body;
         if ((rangeRequest = e.request.headers.range) && !response.headers.get('Content-Range')
-        && ((body instanceof ReadableStream) || (ArrayBuffer.isView(body) && (body = ReadableStream.from(body))))) {
+        && ((body instanceof ReadableStream) || (ArrayBuffer.isView(body) && (body = _ReadableStream.from(body))))) {
             // ...in partials
             const totalLength = response.headers.contentLength || 0;
             const ranges = await rangeRequest.reduce(async (_ranges, range) => {
@@ -540,7 +483,7 @@ export default class Runtime extends _Runtime {
                 });
             } else {
                 // TODO: of ranges.parts is more than one, return multipart/byteranges
-                response = new Response(ranges.parts[0].body, {
+                response = new xResponse(ranges.parts[0].body, {
                     status: 206,
                     statusText: response.statusText,
                     headers: response.headers,

package/src/runtime-pi/server/index.js

@@ -3,16 +3,16 @@
  * @imports
  */
 import Context from './Context.js';
-import RuntimeClient from './RuntimeClient.js';
+import Application from './Application.js';
 import Runtime from './Runtime.js';
 
 /**
  * @start
  */
-export async function start(clientCallback = null) {
+export async function start(applicationInstance = null) {
     const cx = this || {};
-    const defaultClientCallback = _cx => new RuntimeClient(_cx);
-    return new Runtime(Context.create(cx), clientCallback || defaultClientCallback);
+    const defaultApplicationInstance = _cx => new Application(_cx);
+    return new Runtime(Context.create(cx), applicationInstance || defaultApplicationInstance);
 }
 
 /**

package/src/runtime-pi/util-http.js

@@ -0,0 +1,70 @@
+
+/**
+ * @imports
+ */
+import { _isString, _isNumeric, _isObject, _isPlainObject, _isArray, _isPlainArray, _isTypeObject, _isNumber } from '@webqit/util/js/index.js';
+import { _before } from '@webqit/util/str/index.js';
+import { params } from './util-url.js';
+
+export function formatMessage(body) {
+    let type = dataType(body);
+    let headers = {};
+    if ([ 'Blob', 'File' ].includes(type)) {
+        headers = { 'Content-Type': body.type,  'Content-Length': body.size, };
+    } else if ([ 'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer' ].includes(type)) {
+        headers = {  'Content-Length': body.byteLength, };
+    } else if (type === 'json' && _isTypeObject(body)) {
+        const [ _body, isJsonfiable ] = formData(body);
+        if (isJsonfiable) {
+            body = JSON.stringify(body, (k, v) => v instanceof Error ? { ...v, message: v.message } : v);
+            headers = { 'Content-Type': 'application/json', 'Content-Length': (new Blob([ body ])).size, };
+        } else {
+            body = _body;
+            type = 'FormData';
+        }
+    } else if (type === 'json') {
+        headers = { 'Content-Length': (body + '').length, };
+    }
+    return [ body, headers, type ];
+}
+
+export function formData(data = {}) {
+    const formData = this instanceof FormData ? this : new FormData;
+    let isJsonfiable = true;
+    if (arguments.length) {
+        params.reduceValue(data, '', (value, contextPath, suggestedKeys = undefined) => {
+            if (suggestedKeys) {
+                const isJson = dataType(value) === 'json';
+                isJsonfiable = isJsonfiable && isJson;
+                return isJson && suggestedKeys;
+            }
+            formData.append(contextPath, value);
+        });
+        return [ formData, isJsonfiable ];
+    }
+    let json;
+    for (let [ name, value ] of formData.entries()) {
+        if (!json) { json = _isNumeric(_before(name, '[')) ? [] : {}; }
+        const isJson = dataType(value) === 'json';
+        isJsonfiable = isJsonfiable && isJson;
+        if (value === 'false') { value = false; }
+        if (value === 'true') { value = true; }
+        if (value === 'null') { value = null; }
+        if (value === 'undefined') { value = undefined; }
+        params.set(json, name, value);
+    }
+    return [ json, isJsonfiable ];
+}
+
+export function dataType(value) {
+    if (_isString(value) || _isNumber(value) || value === null) return 'json';
+    if (!_isTypeObject(value)) return;
+    const toStringTag = value[Symbol.toStringTag];
+    const type = [
+        'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer', 'Blob', 'File', 'FormData', 'Stream', 'ReadableStream'
+    ].reduce((_toStringTag, type) => _toStringTag || (toStringTag === type ? type : null), null);
+    if (type) return type;
+    if ((_isObject(value) && _isPlainObject(value)) || (_isArray(value) && _isPlainArray(value)) || 'toString' in value) {
+        return 'json';
+    }
+}

package/src/runtime-pi/util-url.js

@@ -0,0 +1,147 @@
+
+/**
+ * @imports
+ */
+import { _isString, _isNumeric, _isArray, _isTypeObject } from '@webqit/util/js/index.js';
+if (typeof URLPattern === 'undefined') {
+    await import('urlpattern-polyfill');
+}
+
+export const params = {
+    // Parse a search params string into an object
+    parse(str, delim = '&') {
+        str = str || '';
+        const target = {};
+        (str.startsWith('?') ? str.substr(1) : str)
+            .split(delim).filter(q => q).map(q => q.split('=').map(q => q.trim()))
+            .forEach(q => this.set(target, q[0], decodeURIComponent(q[1])));
+        return target;
+    },
+    // Stringify an object into a search params string
+    stringify(targetObject, delim = '&') {
+        const q = [];
+        Object.keys(targetObject).forEach(key => {
+            this.reduceValue(targetObject[key], key, (_value, _pathNotation, suggestedKeys = undefined) => {
+                if (suggestedKeys) return suggestedKeys;
+                q.push(`${_pathNotation}=${encodeURIComponent(_value)}`);
+            });
+        });
+        return q.join(delim);
+    },
+
+    // Get value by path notation
+    get(targetObject, pathNotation) {
+        return this.reducePath(pathNotation, targetObject, (key, _targetObject) => {
+            if (!_targetObject && _targetObject !== 0) return;
+            return _targetObject[key];
+        });
+    },
+    // Set value by path notation
+    set(targetObject, pathNotation, value) {
+        this.reducePath(pathNotation, targetObject, function(_key, _targetObject, suggestedBranch = undefined) {
+            let _value = value;
+            if (suggestedBranch) { _value = suggestedBranch; }
+            if (_key === '' && _isArray(_targetObject)) {
+                _targetObject.push(_value);
+            } else {
+                _targetObject[_key] = _value;
+            }
+            return _value;
+        });
+    },
+    
+    // Resolve a value to its leaf nodes
+    reduceValue(value, contextPath, callback) {
+        if (_isTypeObject(value)) {
+            let suggestedKeys = Object.keys(value);
+            let keys = callback(value, contextPath, suggestedKeys);
+            if (_isArray(keys)) {
+                return keys.forEach(key => {
+                    this.reduceValue(value[key], contextPath ? `${contextPath}[${key}]` : key, callback);
+                });
+            }
+        }
+        callback(value, contextPath);
+    },
+    // Resolve a path to its leaf index
+    reducePath(pathNotation, contextObject, callback) {
+        if (_isString(pathNotation) && pathNotation.endsWith(']') && _isTypeObject(contextObject)) {
+            let [ key, ...rest ] = pathNotation.split('[');
+            if (_isNumeric(key)) { key = parseInt(key); }
+            rest = rest.join('[').replace(']', '');
+            let branch;
+            if (key in contextObject) {
+                branch = contextObject[key];
+            } else {
+                let suggestedBranch = rest === '' || _isNumeric(rest.split('[')[0]) ? [] : {};
+                branch = callback(key, contextObject, suggestedBranch);
+            }
+            return this.reducePath(rest, branch, callback);
+        }
+        if (_isNumeric(pathNotation)) { pathNotation = parseInt(pathNotation); }
+        return callback(pathNotation, contextObject);
+    },    
+};
+
+export const path = {
+    join(/* path segments */) {
+        // Split the inputs into a list of path commands.
+        var parts = [], backsteps = 0;
+        for (var i = 0, l = arguments.length; i < l; i++) {
+            parts = parts.concat(arguments[i].split("/"));
+        }
+        // Interpret the path commands to get the new resolved path.
+        var newParts = [];
+        for (i = 0, l = parts.length; i < l; i++) {
+            var part = parts[i];
+            // Remove leading and trailing slashes
+            // Also remove "." segments
+            if (!part || part === ".") continue;
+            // Interpret ".." to pop the last segment
+            if (part === "..") {
+                if (!newParts.length) backsteps ++;
+                else newParts.pop();
+            }
+            // Push new path segments.
+            else newParts.push(part);
+        }
+        // Preserve the initial slash if there was one.
+        if (parts[0] === "") newParts.unshift("");
+        // Turn back into a single string path.
+        return '../'.repeat(backsteps) + newParts.join("/") || (newParts.length ? "/" : ".");
+    },
+    // A simple function to get the dirname of a path
+    // Trailing slashes are ignored. Leading slash is preserved.
+    dirname(path) {
+        return this.join(path, "..");
+    }
+};
+
+export const pattern = (pattern, baseUrl = null) => ({
+    pattern: new URLPattern(pattern, baseUrl),
+    isPattern() {
+        return Object.keys(this.pattern.keys || {}).some(compName => this.pattern.keys[compName].length);
+    },
+    test(...args) { return this.pattern.test(...args) }, 
+    exec(...args) {
+        let components = this.pattern.exec(...args);
+        if (!components) return;
+        components.vars = Object.keys(this.pattern.keys).reduce(({ named, unnamed }, compName) => {
+            this.pattern.keys[compName].forEach(key => {
+                let value = components[compName].groups[key.name];
+                if (typeof key.name === 'number') {
+                    unnamed.push(value);
+                } else {
+                    named[key.name] = value;
+                }
+            });
+            return { named, unnamed };
+        }, { named: {}, unnamed: [] });
+        components.render = str => {
+            return str.replace(/\$(\$|[0-9A-Z]+)/gi, (a, b) => {
+                return b === '$' ? '$' : (_isNumeric(b) ? components.vars.unnamed[b - 1] : components.vars.named[b]) || '';
+            });
+        }
+        return components;
+    }
+});