@webqit/webflo 0.10.5 → 0.11.2

package/src/runtime-pi/client/generate.js

@@ -42,28 +42,29 @@ export async function generate() {
     const dirSelf = Path.dirname(Url.fileURLToPath(import.meta.url)).replace(/\\/g, '/');
     // -----------
     // Scan Subdocuments
-    const scanSubscopes = scope => {
-        let dir = Path.join(dirPublic, scope), passes = 0;
-        return [ Fs.readdirSync(dir).reduce((scopes, f) => {
+    const scanSubroots = (sparoot, rootFileName) => {
+        let dir = Path.join(dirPublic, sparoot), passes = 0;
+        return [ Fs.readdirSync(dir).reduce((sparoots, f) => {
             let resource = Path.join(dir, f);
             if (Fs.statSync(resource).isDirectory()) {
-                let subscope = Path.join(scope, f);
-                if (Fs.existsSync(Path.join(resource, 'index.html'))) {
-                    return scopes.concat(subscope);
+                let subsparoot = Path.join(sparoot, f);
+                if (Fs.existsSync(Path.join(resource, rootFileName))) {
+                    return sparoots.concat(subsparoot);
                 }
                 passes ++;
-                return scopes.concat(scanSubscopes(subscope)[ 0 ]);
+                return sparoots.concat(scanSubroots(subsparoot, rootFileName)[ 0 ]);
             }
-            return scopes;
+            return sparoots;
         }, []), passes ];
     };
     // -----------
     // Generate client build
-    const generateClient = async function(scope) {
-        let [ subscopes, passes ] = scanSubscopes(scope);
-        let routing = { scope, subscopes, passes };
-        let codeSplitting = !!(scope !== '/' || subscopes.length);
-        let outfileMain = Path.join(scope, clientConfig.bundle_filename),
+    const generateClient = async function(sparoot, spaGraphCallback = null) {
+        let [ subsparoots, targets ] = (sparoot && scanSubroots(sparoot, 'index.html')) || [ [], false ];
+        if (!sparoot) sparoot = '/';
+        let spaRouting = { root: sparoot, subroots: subsparoots, targets };
+        let codeSplitting = !!(sparoot !== '/' || subsparoots.length);
+        let outfileMain = Path.join(sparoot, clientConfig.bundle_filename),
             outfileWebflo = _beforeLast(clientConfig.bundle_filename, '.js') + '.webflo.js';
         let gen = { imports: {}, code: [], };
         // ------------------
@@ -88,7 +89,7 @@ export async function generate() {
         // ------------------
         if (!codeSplitting) {
             initWebflo(gen);
-        } else if (scope === '/') {
+        } else if (sparoot === '/') {
             if (cx.logger) {
                 cx.logger.log(cx.logger.style.keyword(`-----------------`));
                 cx.logger.log(`Base Build`);
@@ -100,22 +101,22 @@ export async function generate() {
         // ------------------
         if (cx.logger) {
             cx.logger.log(cx.logger.style.keyword(`-----------------`));
-            cx.logger.log(`Client Build ` + cx.logger.style.comment(`(scope:${scope}; is-split:${codeSplitting})`));
+            cx.logger.log(`Client Build ` + cx.logger.style.comment(`(sparoot:${sparoot}; is-split:${codeSplitting})`));
             cx.logger.log(cx.logger.style.keyword(`-----------------`));
         }
         gen.code.push(`const { start } = WebQit.Webflo`);
         // ------------------
         // Bundle
-        declareStart.call(cx, gen, dirClient, dirPublic, clientConfig, routing);
+        declareStart.call(cx, gen, dirClient, dirPublic, clientConfig, spaRouting);
         await bundle.call(cx, gen, Path.join(dirPublic, outfileMain), true/* asModule */);
         // ------------------
         // Embed/unembed
-        let targetDocumentFile = Path.join(dirPublic, scope, 'index.html'),
+        let targetDocumentFile = Path.join(dirPublic, sparoot, 'index.html'),
             outfileWebfloPublic = Path.join(clientConfig.public_base_url, outfileWebflo),
             outfileMainPublic = Path.join(clientConfig.public_base_url, outfileMain),
             embedList = [],
             unembedList = [];
-        if (cx.flags['auto-embeds']) {
+        if (cx.flags['auto-embed']) {
             if (codeSplitting) {
                 embedList.push(outfileWebfloPublic);
             } else {
@@ -128,21 +129,23 @@ export async function generate() {
         handleEmbeds(targetDocumentFile, embedList, unembedList);
         // ------------------
         // Recurse
+        spaGraphCallback && spaGraphCallback(sparoot, subsparoots);
         if (cx.flags.recursive) {
-            while (subscopes.length) {
-                await generateClient(subscopes.shift());
+            while (subsparoots.length) {
+                await generateClient(subsparoots.shift(), spaGraphCallback);
             }
         }
     };
     // -----------
     // Generate worker build
-    const generateWorker = async function(scope) {
-        let subscopes = [];
-        let routing = { scope, subscopes };
+    const generateWorker = async function(workerroot, workerGraphCallbak = null) {
+        let [ subworkerroots, targets ] = workerroot && scanSubroots(workerroot, 'workerroot') || [ [], false ];
+        if (!workerroot) workerroot = '/';
+        let workerRouting = { root: workerroot, subroots: subworkerroots, targets };
         let gen = { imports: {}, code: [], };
         if (cx.logger) {
             cx.logger.log(cx.logger.style.comment(`-----------------`));
-            cx.logger.log(`Worker Build - scope:${scope}`);
+            cx.logger.log(`Worker Build - workerroot:${workerroot}`);
             cx.logger.log(cx.logger.style.comment(`-----------------`));
         }
         // ------------------
@@ -152,22 +155,53 @@ export async function generate() {
         // ------------------
         // Bundle
         if (workerConfig.cache_only_urls.length) {
-            workerConfig.cache_only_urls = workerConfig.cache_only_urls.reduce((urls, url) => {
-                // TODO: if (urlPattern(url, self.origin).isPattern()) {}
-                return urls.concat(url);
-            }, []);
+            // Separate URLs from patterns
+            let [ urls, patterns ] = workerConfig.cache_only_urls.reduce(([ urls, patterns ], url) => {
+                let patternInstance = urlPattern(url, 'http://localhost'),
+                    isPattern = patternInstance.isPattern();
+                if (isPattern && (patternInstance.pattern.pattern.hostname !== 'localhost' || patternInstance.pattern.pattern.port)) {
+                    throw new Error(`Pattern URLs must have no origin part. Recieved "${url}".`);
+                }
+                return isPattern ? [ urls, patterns.concat(patternInstance) ] : [ urls.concat(url), patterns ];
+            }, [ [], [] ]);
+            // Resolve patterns
+            if (patterns.length) {
+                // List all files
+                let scan = dir => Fs.readdirSync(dir).reduce((result, f) => {
+                    let resource = Path.join(dir, f);
+                    return result.concat(Fs.statSync(resource).isDirectory() ? scan(resource) : '/' + Path.relative(dirPublic, resource));
+                }, []);
+                let files = scan(dirPublic);
+                // Resolve patterns from files
+                workerConfig.cache_only_urls = patterns.reduce((all, pattern) => {
+                    let matchedFiles = files.filter(file => pattern.test(file, 'http://localhost'));
+                    if (matchedFiles.length) return all.concat(matchedFiles);
+                    throw new Error(`The pattern "${pattern.pattern.pattern.pathname}" didn't match any files.`);
+                }, urls);
+            }
         }
-        declareStart.call(cx, gen, dirWorker, dirPublic, workerConfig, routing);
-        await bundle.call(cx, gen, Path.join(dirPublic, scope, clientConfig.worker_filename));
+        declareStart.call(cx, gen, dirWorker, dirPublic, workerConfig, workerRouting);
+        await bundle.call(cx, gen, Path.join(dirPublic, workerroot, clientConfig.worker_filename));
+        // ------------------
+        // Recurse
+        workerGraphCallbak && workerGraphCallbak(workerroot, subworkerroots);
         if (cx.flags.recursive) {
-            while (subscopes.length) {
-                await generateWorker(subscopes.shift());
+            while (subworkerroots.length) {
+                await generateWorker(subworkerroots.shift());
             }
         }
     };
     // -----------
     // Generate now...
-    await generateClient('/');
+    let sparootsFile = Path.join(dirPublic, 'sparoots.json');
+    if (clientConfig.spa_routing !== false) {
+        const sparoots = [];
+        await generateClient('/', root => sparoots.push(root));
+        Fs.writeFileSync(sparootsFile, JSON.stringify(sparoots, null, 4));
+    } else {
+        await generateClient();
+        Fs.existsSync(sparootsFile) && Fs.unlinkSync(sparootsFile);
+    }
     if (clientConfig.service_worker_support) {
         await generateWorker('/');
     }
@@ -215,8 +249,8 @@ function declareStart(gen, routesDir, targetDir, paramsObj, routing) {
  */
 function declareRoutesObj(gen, routesDir, targetDir, varName, routing) {
     const cx = this || {};
-    let _routesDir = Path.join(routesDir, routing.scope),
-        _targetDir = Path.join(targetDir, routing.scope);
+    let _routesDir = Path.join(routesDir, routing.root),
+        _targetDir = Path.join(targetDir, routing.root);
     cx.logger && cx.logger.log(cx.logger.style.keyword(`> `) + `Declaring routes...`);
     // ----------------
     // Directory walker
@@ -225,7 +259,7 @@ function declareRoutesObj(gen, routesDir, targetDir, varName, routing) {
             let resource = Path.join(dir, f);
             let namespace = _beforeLast('/' + Path.relative(routesDir, resource), '/index.js') || '/';
             if (Fs.statSync(resource).isDirectory()) {
-                if (routing.subscopes.includes(namespace)) return;
+                if (routing.subroots.includes(namespace)) return;
                 walk(resource, callback);
             } else {
                 let relativePath = Path.relative(_targetDir, resource);
@@ -368,7 +402,7 @@ async function bundle(gen, outfile, asModule = false) {
     }
     // Remove moduleFile build
     Fs.unlinkSync(bundlingConfig.entryPoints[0]);
-    removals.forEach(file => Fs.unlinkSync(file));
+    removals.forEach(file => Fs.existsSync(file) && Fs.unlinkSync(file));
     if (waiting) waiting.stop();
     // ----------------
     // Stats

package/src/runtime-pi/client/worker/Worker.js

@@ -5,6 +5,7 @@
 import { _any } from '@webqit/util/arr/index.js';
 import { HttpEvent, Request, Response, Observer } from '../Runtime.js';
 import { urlPattern } from '../../util.js';
+import Workport from './Workport.js';
 
 /**
  * ---------------------------
@@ -71,11 +72,13 @@ export default class Worker {
 		});
 
 		// -------------
-		// ONFETCH		
+		// ONFETCH
 		self.addEventListener('fetch', event => {
 			// URL schemes that might arrive here but not supported; e.g.: chrome-extension://
 			if (!event.request.url.startsWith('http')) return;
 			event.respondWith((async (req, evt) => {
+				let requestingClient = await self.clients.get(event.clientId);
+				this.workport.setCurrentClient(requestingClient);
 				const requestInit = [
 					'method', 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity',
 				].reduce((init, prop) => ({ [prop]: req[prop], ...init }), {});
@@ -93,6 +96,33 @@ export default class Worker {
 			})(event.request, event));
 		});
 
+		// -------------
+		// Workport
+		let workport = new Workport();
+		Observer.set(this, 'workport', workport);
+		workport.messaging.listen(async evt => {
+			let responsePort = evt.ports[0];
+			let client = this.clients.get('*');
+			let response = client.alert && await client.alert(evt);
+			if (responsePort) {
+				if (response instanceof Promise) {
+					response.then(data => {
+						responsePort.postMessage(data);
+					});
+				} else {
+					responsePort.postMessage(response);
+				}
+			}
+		});
+		workport.notifications.listen(async evt => {
+			let client = this.clients.get('*');
+			client.alert && await client.alert(evt);
+		});
+		workport.push.listen(async evt => {
+			let client = this.clients.get('*');
+			client.alert && await client.alert(evt);
+		});
+
 		// ---------------
         Observer.set(this, 'location', {});
         Observer.set(this, 'network', {});
@@ -163,22 +193,26 @@ export default class Worker {
 		}
 		const matchUrl = (patterns, url) => _any((patterns || []).map(p => p.trim()).filter(p => p), p => urlPattern(p, self.origin).test(url));
 		const execFetch = () => {
-			if (matchUrl(this.cx.params.cache_only_urls, request.url)) {
-				Observer.set(this.network, 'strategy', 'cache-only');
-				return this.cacheFetch(request, { networkFallback: false, cacheRefresh: false });
+			// network_first_urls
+			if (!this.cx.params.default_fetching_strategy || this.cx.params.default_fetching_strategy === 'network-first' || matchUrl(this.cx.params.network_first_urls, request.url)) {
+				Observer.set(this.network, 'strategy', 'network-first');
+				return this.networkFetch(request, { cacheFallback: true, cacheRefresh: true });
+			}
+			// cache_first_urls
+			if (this.cx.params.default_fetching_strategy === 'cache-first' || matchUrl(this.cx.params.cache_first_urls, request.url)) {
+				Observer.set(this.network, 'strategy', 'cache-first');
+				return this.cacheFetch(request, { networkFallback: true, cacheRefresh: true });
 			}
 			// network_only_urls
-			if (matchUrl(this.cx.params.network_only_urls, request.url)) {
+			if (this.cx.params.default_fetching_strategy === 'network-only' || matchUrl(this.cx.params.network_only_urls, request.url)) {
 				Observer.set(this.network, 'strategy', 'network-only');
 				return this.networkFetch(request, { cacheFallback: false, cacheRefresh: false });
 			}
-			// cache_first_urls
-			if (matchUrl(this.cx.params.cache_first_urls, request.url)) {
-				Observer.set(this.network, 'strategy', 'cache-first');
-				return this.cacheFetch(request, { networkFallback: true, cacheRefresh: true });
+			// cache_only_urls
+			if (this.cx.params.default_fetching_strategy === 'cache-only' || matchUrl(this.cx.params.cache_only_urls, request.url)) {
+				Observer.set(this.network, 'strategy', 'cache-only');
+				return this.cacheFetch(request, { networkFallback: false, cacheRefresh: false });
 			}
-			Observer.set(this.network, 'strategy', 'network-first');
-			return this.networkFetch(request, { cacheFallback: true, cacheRefresh: true });
 		};
 		let response = execFetch(request);
 		// This catch() is NOT intended to handle failure of the fetch
@@ -187,18 +221,6 @@ export default class Worker {
 		return response.then(_response => Response.compat(_response));
 	}
 
-	// Caching strategy: cache_first
-	cacheFetch(request, params = {}) {
-		return this.getRequestCache(request).then(cache => cache.match(request).then(response => {
-			// Nothing cache, use network
-			if (!response && params.networkFallback) return this.networkFetch(request, { ...params, cacheFallback: false });
-			// Note: fetch, but for refreshing purposes only... not the returned response
-			if (response && params.cacheRefresh) this.networkFetch(request, { ...params, justRefreshing: true });
-			Observer.set(this.network, 'cache', true);
-			return response;
-		}));
-	}
-
 	// Caching strategy: network_first
 	networkFetch(request, params = {}) {
 		if (!params.cacheFallback) {
@@ -215,6 +237,18 @@ export default class Worker {
 		}));
 	}
 
+	// Caching strategy: cache_first
+	cacheFetch(request, params = {}) {
+		return this.getRequestCache(request).then(cache => cache.match(request).then(response => {
+			// Nothing cache, use network
+			if (!response && params.networkFallback) return this.networkFetch(request, { ...params, cacheFallback: false });
+			// Note: fetch, but for refreshing purposes only... not the returned response
+			if (response && params.cacheRefresh) this.networkFetch(request, { ...params, justRefreshing: true });
+			Observer.set(this.network, 'cache', true);
+			return response;
+		}));
+	}
+
 	// Caches response 
 	refreshCache(request, response) {
 		// Check if we received a valid response

package/src/runtime-pi/client/worker/Workport.js

@@ -0,0 +1,80 @@
+
+export default class Workport {
+
+    constructor() {
+        // --------
+        // Post messaging
+        // --------
+        this.messaging = {
+            post: (message, client = this.client) => {
+                if (!client) throw new Error(`No client for this operation.`);
+                client.postMessage(message);
+                return this.post;
+            },
+            listen: (callback, client = this.client) => {
+                if (!client) {
+                    self.addEventListener('message', evt => {
+                        this.client = evt.source;
+                        callback(evt);
+                    });
+                    return this.post;
+                }
+                client.addEventListener('message', callback);
+                return this.post;
+            },
+            request: (message, client = this.client) => {
+                if (!client) throw new Error(`No client for this operation.`);
+                return new Promise(res => {
+                    let messageChannel = new MessageChannel();
+                    client.postMessage(message, [ messageChannel.port2 ]);
+                    messageChannel.port1.onmessage = e => res(e.data);
+                });
+            },
+            channel(channelId) {
+                if (!this.channels.has(channelId)) { this.channels.set(channelId, new BroadcastChannel(channel)); }
+                let channel = this.channels.get(channelId);
+                return {
+                    broadcast: message => channel.postMessage(message),
+                    listen: callback => channel.addEventListener('message', callback),
+                };
+            },
+            channels: new Map,
+        };
+
+        // --------
+        // Notifications
+        // --------
+        this.notifications = {
+            fire: (title, params = {}) => {
+                return new Promise((res, rej) => {
+                    if (!(self.Notification && self.Notification.permission === 'granted')) {
+                        return rej(self.Notification && self.Notification.permission);
+                    }
+                    notification.addEventListener('error', rej);
+                    let notification = new self.Notification(title, params);
+                    notification.addEventListener('click', res);
+                    notification.addEventListener('close', res);
+                });
+            },
+            listen: callback => {
+                self.addEventListener('notificationclick', callback);
+                return this.notifications;
+            },
+        };
+
+        // --------
+        // Push Notifications
+        // --------
+        this.push = {
+            listen: callback => {
+                self.addEventListener('push', callback);
+                return this.post;
+            },
+        };
+    }
+
+    setCurrentClient(client) {
+        this.client = client;
+    }
+
+}

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

@@ -307,19 +307,25 @@ export default class Runtime {
             return this.getSession(_context, httpEvent, id, options, callback);
         });
         // Response
-        let client = this.clients.get('*');
+        let client = this.clients.get('*'), response, finalResponse;
         if (this.cx.server.shared) {
             client = this.clients.get(url.hostname);
         }
-        let response = await client.handle(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
-        let finalResponse = await this.handleResponse(httpEvent, response, autoHeaders.filter(header => header.type === 'response'));
+        try {
+            response = await client.handle(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
+            finalResponse = await this.handleResponse(_context, httpEvent, response, autoHeaders.filter(header => header.type === 'response'));
+        } catch(e) {
+            finalResponse = new Response(null, { status: 500, statusText: e.message });
+            console.error(e);
+        }
         // Logging
         if (this.cx.logger) {
             let log = this.generateLog(httpEvent, finalResponse);
             this.cx.logger.log(log);
         }
+        // ------------
         // Return value
-        return finalResponse;
+		return finalResponse;
     }
 
     // Generates request object
@@ -378,7 +384,7 @@ export default class Runtime {
     }
 
     // Handles response object
-    async handleResponse(e, response, autoHeaders = []) {
+    async handleResponse(cx, e, response, autoHeaders = []) {
         if (!(response instanceof Response)) { response = new Response(response); }
         Observer.set(this.network, 'remote', false);
         Observer.set(this.network, 'error', null);
@@ -401,14 +407,22 @@ export default class Runtime {
         if (response.headers.redirect) {
             let xRedirectPolicy = e.request.headers.get('X-Redirect-Policy');
             let xRedirectCode = e.request.headers.get('X-Redirect-Code') || 300;
-            let isSameOriginRedirect = (new whatwag.URL(response.headers.location, e.url.origin)).origin === e.url.origin;
-            if (xRedirectPolicy === 'manual' || (!isSameOriginRedirect && xRedirectPolicy === 'manual-when-cross-origin') || (isSameOriginRedirect && xRedirectPolicy === 'manual-when-same-origin')) {
-                response.attrs.status = xRedirectCode;
+            let destinationUrl = new whatwag.URL(response.headers.location, e.url.origin);
+            let 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)) {
+                // Longest-first sorting
+                let sparoots = _arrFrom(JSON.parse(Fs.readFileSync(sparootsFile))).sort((a, b) => a.length > b.length ? -1 : 1);
+                let matchRoot = path => sparoots.reduce((prev, root) => prev || (`${path}/`.startsWith(`${root}/`) && root), null);
+                isSameSpaRedirect = matchRoot(destinationUrl.pathname) === matchRoot(e.url.pathname);
+            }
+            if (xRedirectPolicy === 'manual' || (!isSameOriginRedirect && xRedirectPolicy === 'manual-when-cross-origin') || (!isSameSpaRedirect && xRedirectPolicy === 'manual-when-cross-spa')) {
                 response.headers.json({
                     'X-Redirect-Code': response.status,
                     'Access-Control-Allow-Origin': '*',
                     'Cache-Control': 'no-store',
                 });
+                response.attrs.status = xRedirectCode;
             }
             return response;
         }

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

@@ -79,10 +79,10 @@ export default class RuntimeClient {
                 pathnameSplit.pop();
             }
             const instanceParams = QueryString.stringify({
-                SOURCE: renderFile,
-                URL: httpEvent.url.href,
-                ROOT: this.cx.CWD,
-                OOHTML_LEVEL: this.cx.server.oohtml_support,
+                file: renderFile,
+                url: httpEvent.url.href,
+                root: this.cx.CWD,
+                oohtml_level: this.cx.server.oohtml_support,
             });
             const { window } = await import('@webqit/oohtml-ssr/instance.js?' + instanceParams);
             // --------
@@ -99,10 +99,10 @@ export default class RuntimeClient {
                         env: 'server',
                     }, { update: true });
                 }
-                window.document.setState({ page: data, url: httpEvent.url }, { update: 'merge' });
+                window.document.setState({ data, url: httpEvent.url }, { update: 'merge' });
             }
             if (window.document.templates) {
-                window.document.body.setAttribute('template', 'page/' + httpEvent.url.pathname.split('/').filter(a => a).map(a => a + '+-').join('/'));
+                window.document.body.setAttribute('template', 'routes/' + httpEvent.url.pathname.split('/').filter(a => a).map(a => a + '+-').join('/'));
             }
             await new Promise(res => setTimeout(res, 10));
             return window;

package/src/runtime-pi/util.js

@@ -135,9 +135,9 @@ export const path = {
 export const urlPattern = (pattern, baseUrl = null) => ({
     pattern: new URLPattern(pattern, baseUrl),
     isPattern() {
-        return Object.keys(this.pattern.keys).some(compName => this.pattern.keys[compName].length);
+        return Object.keys(this.pattern.keys || {}).some(compName => this.pattern.keys[compName].length);
     },
-    test(...args) { this.pattern.test(...args) }, 
+    test(...args) { return this.pattern.test(...args) }, 
     exec(...args) {
         let components = this.pattern.exec(...args);
         if (!components) return;

package/test/site/package.json

@@ -0,0 +1,9 @@
+{
+  "title": "Webflo Test",
+  "type": "module",
+  "scripts": {
+    "generate": "webflo generate::client --recursive --compression --auto-embed",
+    "bundle": "cd public && oohtml bundle --recursive --auto-embed=routes",
+    "build": "npm run generate && npm run bundle"
+  }
+}

package/test/site/public/bundle.html

@@ -1,3 +1,6 @@
 
+<template name="page-3">
+    <img src="/page-3/logo-130x130.png"  exportgroup="logo-130x130.png" />
+</template>
 <template name="page-4">
 </template>

package/test/site/public/bundle.html.json

@@ -1,3 +1,4 @@
 {
+    "page-3": {},
     "page-4": {}
 }

package/test/site/public/bundle.js

@@ -1,2 +1,2 @@
 /** @webqit/webflo */
-var{start:e}=WebQit.Webflo,s={},r={bundle_filename:"bundle.js",public_base_url:"/",address_bar_synchrony:"standard",oohtml_support:"full",service_worker_support:!0,worker_scope:"/",worker_filename:"worker.js",routing:{scope:"/",subscopes:["/page-2","/page-4/subpage"],passes:1}};e.call({layout:s,params:r});
+var{start:e}=WebQit.Webflo,r={},o={bundle_filename:"bundle.js",public_base_url:"/",spa_routing:!0,oohtml_support:"full",service_worker_support:!0,worker_scope:"/",worker_filename:"worker.js",routing:{root:"/",subroots:["/page-2","/page-4/subpage"],targets:2}};e.call({layout:r,params:o});