@webqit/webflo 0.11.61 → 1.0.0

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

@@ -1,21 +1,10 @@
+import { WebfloServer } from './WebfloServer.js';
 
-/**
- * @imports
- */
-import Context from './Context.js';
-import Application from './Application.js';
-import Runtime from './Runtime.js';
-
-/**
- * @start
- */
-export async function start(applicationInstance = null) {
-    const cx = this || {};
-    const defaultApplicationInstance = _cx => new Application(_cx);
-    return new Runtime(Context.create(cx), applicationInstance || defaultApplicationInstance);
+export async function start() {
+    const instance = WebfloServer.create(this || {});
+    await instance.initialize();
 }
 
-/**
- * @APIS
- */
-export * as APIS from './Runtime.js';
+export {
+    WebfloServer
+}

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

@@ -1,30 +1,40 @@
-
-/**
- * @imports
- */
 import { _isString, _isNumeric, _isObject, _isPlainObject, _isArray, _isPlainArray, _isTypeObject, _isNumber, _isBoolean } from '@webqit/util/js/index.js';
-import { _before } from '@webqit/util/str/index.js';
+import { _after, _before } from '@webqit/util/str/index.js';
+import { _from as _arrFrom } from '@webqit/util/arr/index.js';
 import { params } from './util-url.js';
 
-export function formatMessage(message) {
-    const headers = (message.headers instanceof Headers) ? [...message.headers.keys()].reduce((_headers, name) => {
-        return { ..._headers, [name/* lower-cased */]: message.headers.get(name) };
-    }, {}) : Object.keys(message.headers || {}).reduce((_headers, name) => {
-        return { ..._headers, [name.toLowerCase()]: message.headers[name] };
+export function dataType(value) {
+    if (_isString(value) || _isNumber(value) || _isBoolean(value)) 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';
+    }
+}
+
+export function renderHttpMessageInit(httpMessageInit) {
+    const headers = (httpMessageInit.headers instanceof Headers) ? [...httpMessageInit.headers.keys()].reduce((_headers, name) => {
+        return { ..._headers, [name/* lower-cased */]: httpMessageInit.headers.get(name) };
+    }, {}) : Object.keys(httpMessageInit.headers || {}).reduce((_headers, name) => {
+        return { ..._headers, [name.toLowerCase()]: httpMessageInit.headers[name] };
     }, {});
-    let body = message.body, type = dataType(message.body);
-    if ([ 'Blob', 'File' ].includes(type)) {
+    let body = httpMessageInit.body, type = dataType(httpMessageInit.body);
+    if (['Blob', 'File'].includes(type)) {
         !headers['content-type'] && (headers['content-type'] = body.type);
         !headers['content-length'] && (headers['content-length'] = body.size);
-    } else if ([ 'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer' ].includes(type)) {
+    } else if (['Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer'].includes(type)) {
         !headers['content-length'] && (headers['content-length'] = body.byteLength);
     } else if (type === 'json' && _isTypeObject(body)) {
         if (!headers['content-type']) {
-            const [ _body, isJsonfiable ] = formDatarizeJson(body);
+            const [_body, isJsonfiable] = createFormDataFromJson(body, true/*jsonfy*/, true/*getIsJsonfiable*/);
             if (isJsonfiable) {
                 body = JSON.stringify(body, (k, v) => v instanceof Error ? { ...v, message: v.message } : v);
                 headers['content-type'] = 'application/json';
-                headers['content-length'] = (new Blob([ body ])).size;
+                headers['content-length'] = (new Blob([body])).size;
             } else {
                 body = _body;
                 type = 'FormData';
@@ -33,10 +43,24 @@ export function formatMessage(message) {
     } else if (type === 'json') {
         !headers['content-length'] && (headers['content-length'] = (body + '').length);
     }
-    return [ body, headers, type ];
+    return { body, headers, $type: type };
+}
+
+export async function parseHttpMessage(httpMessage) {
+    let result;
+    const contentType = httpMessage.headers.get('Content-Type') || '';
+    if (contentType === 'application/x-www-form-urlencoded' || contentType.startsWith('multipart/form-data')) {
+        const formData = await httpMessage.formData();
+        result = await formData?.json();
+    } else if (contentType.startsWith('application/json')/*can include charset*/) {
+        result = await httpMessage.json();
+    } else /*if (contentType === 'text/plain')*/ {
+        result = await httpMessage.text();
+    }
+    return result;
 }
 
-export function formDatarizeJson(data = {}, jsonfy = true) {
+export function createFormDataFromJson(data = {}, jsonfy = true, getIsJsonfiable = false) {
     const formData = new FormData;
     let isJsonfiable = true;
     params.reduceValue(data, '', (value, contextPath, suggestedKeys = undefined) => {
@@ -50,13 +74,14 @@ export function formDatarizeJson(data = {}, jsonfy = true) {
         }
         formData.append(contextPath, value);
     });
-    return [ formData, isJsonfiable ];
+    if (getIsJsonfiable) return [formData, isJsonfiable];
+    return formData;
 }
 
-export async function jsonfyFormData(formData, jsonfy = true) {
+export async function renderFormDataToJson(formData, jsonfy = true, getIsJsonfiable = false) {
     let isJsonfiable = true;
     let json;
-    for (let [ name, value ] of formData.entries()) {
+    for (let [name, value] of formData.entries()) {
         if (!json) { json = _isNumeric(_before(name, '[')) ? [] : {}; }
         let type = dataType(value);
         if (jsonfy && ['Blob', 'File'].includes(type) && value.type === 'application/json' && [4, 5].includes(value.size)) {
@@ -69,18 +94,229 @@ export async function jsonfyFormData(formData, jsonfy = true) {
         isJsonfiable = isJsonfiable && type === 'json';
         params.set(json, name, value);
     }
-    return [ json, isJsonfiable ];
+    if (getIsJsonfiable) return [json, isJsonfiable];
+    return json;
 }
 
-export function dataType(value) {
-    if (_isString(value) || _isNumber(value) || _isBoolean(value)) 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';
+export function renderCookieObj(cookieObj) {
+    const attrsArr = [`${cookieObj.name}=${/*encodeURIComponent*/(cookieObj.value)}`];
+    for (const attrName in cookieObj) {
+        if (['name', 'value'].includes(attrName)) continue;
+        let _attrName = attrName[0].toUpperCase() + attrName.substring(1);
+        if (_attrName === 'MaxAge') { _attrName = 'Max-Age' };
+        attrsArr.push(cookieObj[attrName] === true ? _attrName : `${_attrName}=${cookieObj[attrName]}`);
+    }
+    return attrsArr.join(';');
+}
+
+/* Request */
+
+Object.defineProperties(Request, {
+    create: {
+        value: function (url, init = {}) {
+            if (url instanceof Request) return url;
+            let $$type, $$body = init.body;
+            if ('body' in init) {
+                const { body, headers, $type } = renderHttpMessageInit(init);
+                init = { ...init, body, headers };
+                $$type = $type;
+            }
+            const instance = new Request(url, init);
+            instance.meta.body = $$body;
+            instance.meta.type = $$type;
+            return instance;
+        }
+    },
+
+    copy: {
+        value: async function (request, init = {}) {
+            const requestInit = [
+                'method', 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity',
+            ].reduce((init, prop) => ({ [prop]: request[prop], ...init }), {});
+            if (!['GET', 'HEAD'].includes(init.method?.toUpperCase() || request.method)) {
+                requestInit.body = await request.clone().arrayBuffer();
+            }
+            if (requestInit.mode === 'navigate') {
+                requestInit.mode = 'cors';
+            }
+            return { url: request.url, ...requestInit };
+        }
+    }
+});
+
+Object.defineProperties(Request.prototype, {
+    parse: { value: function() { return parseHttpMessage(this); } },
+    meta: { get: function() { if (!this._meta) this._meta = {}; return this._meta; } }
+});
+
+/* Response */
+
+Object.defineProperties(Response, {
+    create: {
+        value: function (body, init = {}) {
+            if (body instanceof Response) return body;
+            let $type, $body = body;
+            if (body || body === 0) {
+                let headers;
+                ({ body, headers, $type } = renderHttpMessageInit({ body, headers: init.headers }));
+                init = { ...init, headers };
+            }
+            const instance = new Response(body, init);
+            instance.meta.body = $body;
+            instance.meta.type = $type;
+            return instance;
+        }
+    }
+});
+
+const statusGet = Object.getOwnPropertyDescriptor(Response.prototype, 'status');
+Object.defineProperties(Response.prototype, {
+    parse: { value: function() { return parseHttpMessage(this); } },
+    meta: { get: function() { if (!this._meta) this._meta = {}; return this._meta; } },
+    status: { get: function() { return this.meta.status || statusGet.get.call(this); } }
+});
+
+/* Headers */
+
+const { set: headerSet, append: headerAppend, get: headerGet } = Headers.prototype;
+Object.defineProperties(Headers.prototype, {
+    set: {
+        value: function (name, value) {
+            // -------------------------
+            // Format "Set-Cookie" response header
+            if (/^Set-Cookie$/i.test(name) && _isObject(value)) {
+                value = renderCookieObj(value);
+            }
+            // -------------------------
+            // Format "Cookie" request header
+            if (/Cookie/i.test(name) && _isTypeObject(value)) {
+                value = [].concat(value).map(renderCookieObj).join(';');
+            }
+            // -------------------------
+            // Format "Content-Range" response header?
+            if (/^Content-Range$/i.test(name) && Array.isArray(value)) {
+                if (value.length < 2 || !value[0].includes('-')) {
+                    throw new Error(`A Content-Range array must be in the format: [ 'start-end', 'total' ]`);
+                }
+                value = `bytes ${value.join('/')}`;
+            }
+            // -------------------------
+            // Format "Range" request header?
+            if (/^Range$/i.test(name)) {
+                let rangeArr = [];
+                _arrFrom(value).forEach((range, i) => {
+                    let rangeStr = Array.isArray(range) ? range.join('-') : range + '';
+                    if (i === 0 && !rangeStr.includes('bytes=')) {
+                        rangeStr = `bytes=${rangeStr}`;
+                    }
+                    rangeArr.push(rangeStr);
+                });
+                value = rangeArr.join(', ');
+            }
+            // -------------------------
+            // Format "Accept" request header?
+            if (/^Accept$/i.test(name) && Array.isArray(value)) {
+                value = value.join(',');
+            }
+            // -------------------------
+            return headerSet.call(this, name, value);
+        }
+    },
+
+    append: {
+        value: function (name, value) {
+            // -------------------------
+            // Format "Set-Cookie" response header
+            if (/^Set-Cookie$/i.test(name) && _isObject(value)) {
+                value = renderCookieObj(value);
+            }
+            // -------------------------
+            return headerAppend.call(this, name, value);
+        }
+    },
+
+    get: {
+        value: function (name, parsed = false) {
+            let value = headerGet.call(this, name);
+            // -------------------------
+            // Parse "Set-Cookie" response header
+            if (/^Set-Cookie$/i.test(name) && parsed) {
+                value = this.getSetCookie()/*IMPORTANT*/.map((str) => {
+                    const [cookieDefinition, attrsStr] = str.split(';');
+                    const [name, value] = cookieDefinition.split('=').map((s) => s.trim());
+                    const cookieObj = { name, value: /*decodeURIComponent*/(value), };
+                    attrsStr && attrsStr.split(/\;/g).map(attrStr => attrStr.trim().split('=')).forEach(attrsArr => {
+                        cookieObj[attrsArr[0][0].toLowerCase() + attrsArr[0].substring(1).replace('-', '')] = attrsArr.length === 1 ? true : attrsArr[1];
+                    });
+                    return cookieObj;
+                });
+            }
+            // -------------------------
+            // Parse "Cookie" request header
+            if (/^Cookie$/i.test(name) && parsed) {
+                value = value?.split(';').map((str) => {
+                    const [name, value] = str.split('=').map((s) => s.trim());
+                    return { name, value: /*decodeURIComponent*/(value), };
+                }) || [];
+            }
+            // -------------------------
+            // Parse "Content-Range" response header?
+            if (/^Content-Range$/i.test(name) && value && parsed) {
+                value = _after(value, 'bytes ').split('/');
+            }
+            // -------------------------
+            // Parse "Range" request header?
+            if (/^Range$/i.test(name) && parsed) {
+                value = !value ? [] : _after(value, 'bytes=').split(',').map((rangeStr) => {
+                    let range = rangeStr.trim().split('-');
+                    range[0] = range[0] ? parseInt(range[0], 10) : undefined;
+                    if (range[1]) {
+                        range[1] = parseInt(range[1], 10);
+                    }
+                    range.clamp = max => {
+                        if (range[1] > max - 1 || range[1] === undefined) {
+                            range[1] = max - 1;
+                        }
+                        if (range[0] === undefined) range[0] = range[1] ? max - range[1] - 1 : 0;
+                    };
+                    return range;
+                });
+            }
+            // -------------------------
+            // Parse "Accept" request header?
+            if (/^Accept$/i.test(name) && parsed) {
+                const list = value && value.split(',')
+                    .map((a) => (a = a.trim().split(';').map(a => a.trim()), [a.shift(), parseFloat((a.pop() || '1').replace('q=', ''))]))
+                    .sort((a, b) => a[1] > b[1] ? -1 : 1) || [];
+                value = {
+                    match(mime) {
+                        mime = (mime + '').split('/');
+                        return list.reduce((prev, entry) => prev || (
+                            (entry = entry[0].split('/')) && [0, 1].every(i => ((mime[i] === entry[i]) || mime[i] === '*' || entry[i] === '*'))
+                        ), false);
+                    },
+                    toString() {
+                        return value;
+                    }
+                };
+            }
+            // -------------------------
+            return value;
+        }
+    }
+});
+
+/* FormData */
+
+Object.defineProperties(FormData, {
+    json: { value: createFormDataFromJson }
+});
+
+Object.defineProperties(FormData.prototype, {
+    json: {
+        value: async function (data = {}) {
+            const result = await renderFormDataToJson(this, ...arguments);
+            return result;
+        }
     }
-}
+});

package/src/runtime-pi/xURL.js

@@ -15,40 +15,43 @@ export default class xURL extends URL {
 	// constructor
 	constructor(...args) {
 		super(...args);
-		var query = params.parse(this.search);
-		const updateSearch = query => {
+		const query = params.parse(this.search);
+		const updateSearch = () => {
 			// "query" was updated. So we update "search"
-			var search = params.stringify(query);
+			let search = params.stringify(query);
 			search = search ? '?' + search : '';
 			if (search !== this.search) {
 				this.search = search;
 			}
 		};
-		this.__query = {
-			value: query,
-			proxy: new Proxy(this, {
-				set(t, n, v) {
-					t.__query.value[n] = v;
-					updateSearch(t.__query.value);
-					return true;
-				},
-				deleteProperty(t, n) {
-					delete t.__query.value[n];
-					updateSearch(t.__query.value);
-					return true;
-				}
-			})
-		};
+		const $this = this;
+		this._query = new Proxy(query, {
+			set(t, k, v) {
+				t[k] = v;
+				if (!$this._updatingSearch) updateSearch();
+				return true;
+			},
+			deleteProperty(t, k) {
+				delete t[k];
+				if (!$this._updatingSearch) updateSearch();
+				return true;
+			}
+		});
 	}
 
 	// Set search
 	set search(value) {
 		super.search = value;
 		// "search" was updated. So we update "query"
-		var query = params.parse(value);
-		if (!_strictEven(query, this.query)) {
-			this.__query.value = query;
+		this._updatingSearch = true;
+		const query = params.parse(value);
+		const keys_a = Object.keys(query);
+		const keys_b = Object.keys(this._query);
+		for (const k of new Set([...keys_a,...keys_b])) {
+			if (!keys_a.includes(k)) delete this.query[k];
+			if (!keys_b.includes(k)) this.query[k] = query[k];
 		}
+		this._updatingSearch = false;
 	}
 
 	// Get search
@@ -58,7 +61,7 @@ export default class xURL extends URL {
 
 	// Get query
 	get query() {
-		return this.__query.proxy;
+		return this._query;
 	}
 
 };

package/src/runtime-pi/xfetch.js

@@ -2,14 +2,14 @@
 /**
  * @imports
  */
-import { formatMessage } from './util-http.js';
+import { renderHttpMessageInit } from './util-http.js';
 
 /**
  * The xfetch Mixin
  */
 const xfetch = async (url, init = {}) => {
     if (init.body) {
-        const [ body, headers ] = formatMessage(init);
+        const { body, headers } = renderHttpMessageInit(init);
         init = { ...init, body, headers, };
     }
     let response = await fetch(url, init), encoding;

package/src/runtime-pi/Application.js

@@ -1,29 +0,0 @@
-
-/**
- * ---------------------------
- * The base Application class
- * ---------------------------
- */
-            
-export default class Application {
-
-    constructor(cx) {
-        this.cx = cx;
-    }
-    
-	/**
-     * Initializes application itself.
-     * 
-     * @param HttpEvent       httpEvent
-     * @param Function        remoteFetch
-     * 
-     * @return Boolean|undefined
-     */
-	async init(httpEvent, remoteFetch) {
-		// The app router
-        const router = new this.Router(this.cx, '/');
-        return router.route(['init'], httpEvent, {}, async event => {
-		}, remoteFetch);
-	}
-
-}

package/src/runtime-pi/Cookies.js

@@ -1,82 +0,0 @@
-
-/**
- * @imports
- */
-import { _isString, _isObject } from "@webqit/util/js/index.js";
-
-export default class Cookies extends Map {
-
-    constructor(...args) {
-        super(...args);
-        Object.defineProperty(this, 'inLock', { value: false, writable: true });
-        Object.defineProperty(this, 'outLock', { value: false, writable: true });
-    }
-
-    set(name, value) {
-        if (this.inLock) return;
-        if (this.has(name)) this.delete(name);
-        this.inLock = true;
-        // -----------------
-        let valueObj = value, valueStr = value, retrn;
-        if (_isString(value)) { valueObj = this.parseEntry(`=${ value }`)[1]; }
-        retrn = super.set(name, valueObj);
-        if (!this.outLock) {
-            if (_isObject(value)) { valueStr = this.stringifyEntry(value); }
-            append(this.headers, `${ name }=${ valueStr }`);
-        }
-        // -----------------
-        this.inLock = false;
-        return retrn;
-    }
-
-    delete(name) {
-        if (this.inLock) return;
-        this.inLock = true;
-        // -----------------
-        let retrn = super.delete(name);
-        this.headers.delete(this.headers.cookieHeaderName);
-        for (let [ name, definition ] of this) {
-            append(this.headers, `${ name }=${ this.stringifyEntry(definition) }`);
-        }
-        // -----------------
-        this.inLock = false;
-        return retrn;
-    }
-
-    clear() {
-        if (this.inLock) return;
-        this.inLock = true;
-        // -----------------
-        let retrn = super.clear();
-        this.headers.delete(this.headers.cookieHeaderName);
-        // -----------------
-        this.inLock = false;
-        return retrn;
-    }
-
-    json(json = {}) {
-        if (arguments.length) {
-            this.clear();
-            for (let name in json) {
-                this.set(name, json[name])
-            }
-            return;
-        }
-        for (let [ name, definition ] of this) {
-            json[name] = definition;
-        }
-        return json;
-    }
-
-    toString() {
-        return this.headers.get(this.headers.cookieHeaderName);
-    }
-
-}
-
-function append(headers, value) {
-    let values = [value];
-    let currentValue = headers.get(headers.cookieHeaderName);
-    if (currentValue) { values.unshift(currentValue); }
-    headers.set(headers.cookieHeaderName, values.join(headers.cookieHeaderSeparator));
-}

package/src/runtime-pi/Runtime.js

@@ -1,21 +0,0 @@
-
-/**
- * @imports
- */
-
-import { _isFunction } from "@webqit/util/js/index.js";
-
-/**
- * ---------------------------
- * The base Runtime class
- * ---------------------------
- */
-            
-export default class Runtime {
-    constructor(cx, applicationInstance) {
-        this.cx = cx;
-        this.cx.runtime = this;
-        this.app = _isFunction(applicationInstance) ? applicationInstance(this.cx) : applicationInstance;
-        if (!this.app || !this.app.handle) throw new Error(`Application instance must define a ".handle()" method.`);
-    }
-}

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

@@ -1,76 +0,0 @@
-
-/**
- * @imports
- */
-import Router from './Router.js';
-import _Application from '../Application.js';
-
-export default class Application extends _Application {
-
-	// Returns router class
-	get Router() {
-		return Router;
-	}
-
-	/**
-     * Handles HTTP events.
-     * 
-     * @param HttpEvent       httpEvent
-     * @param Function        remoteFetch
-     * 
-     * @return Response
-     */
-	async handle(httpEvent, remoteFetch) {
-		// The app router
-        const router = new this.Router(this.cx, httpEvent.url.pathname);
-        const handle = async () => {
-			let bindingsConfig;
-			if (window.webqit?.oohtml?.configs) { ( { BINDINGS_API: { api: bindingsConfig } = {}, } = window.webqit.oohtml.configs ); }
-			return router.route([httpEvent.request.method, 'default'], httpEvent, { ...( ( bindingsConfig && document[bindingsConfig.bindings] ) || {} ) }, async event => {
-				if (event !== httpEvent) {
-					// This was nexted()
-					if (!event.request.headers.has('Accept')) {
-						event.request.headers.set('Accept', 'application/json');
-					}
-				}
-				return remoteFetch(event.request);
-			}, remoteFetch);
-		};
-		return await (this.cx.middlewares || []).concat(handle).reverse().reduce((next, fn) => {
-			return () => fn.call(this.cx, httpEvent, router, next);
-		}, null)();
-	}
-
-	// Renderer
-    async render(httpEvent, response) {
-		let data = await response.jsonfy();
-		const router = new this.Router(this.cx, httpEvent.url.pathname);
-		return await router.route('render', httpEvent, data, async (httpEvent, data) => {
-			if (window.webqit?.dom) { await new Promise(res => window.webqit.dom.ready(res)); }
-			if (window.webqit?.oohtml?.configs) {
-				const {
-					CONTEXT_API: { attr: contextConfig } = {},
-					BINDINGS_API: { api: bindingsConfig } = {},
-					HTML_IMPORTS: { attr: modulesContextAttrs } = {},
-				} = window.webqit.oohtml.configs;
-				if ( bindingsConfig ) {
-					window.document[ bindingsConfig.bind ]({
-						env: 'client', state: this.cx.runtime, ...(data || {})
-					}, { diff: true });
-				}
-				let routingContext;
-				if ( modulesContextAttrs ) {
-					routingContext = window.document.body.querySelector(`[${ window.CSS.escape( contextConfig.contextname ) }="app"]`) || window.document.body;
-					const prevRoute = routingContext.getAttribute( modulesContextAttrs.importscontext );
-					const newRoute = '/' + `routes/${ httpEvent.url.pathname }`.split('/').map(a => a.trim()).filter(a => a).join('/');
-					const rel = prevRoute === newRoute ? 'same' : ( `${ prevRoute }/`.startsWith( `${ newRoute }/` ) ? 'parent' : ( `${ newRoute }/`.startsWith( `${ prevRoute }/` ) ? 'child' : 'unrelated' ) );
-					routingContext.setAttribute( modulesContextAttrs.importscontext, newRoute);
-					routingContext.setAttribute( `prev-${ modulesContextAttrs.importscontext }`, prevRoute );
-					routingContext.setAttribute( 'importscontext-transition-type', rel );
-				}
-			}
-			return window;
-		});
-	}
-}
-