prototype.exe 0.0.1

package/package.json

@@ -0,0 +1,10 @@
+{
+"name": "prototype.exe",
+"description": "JScript",
+"version": "0.0.1",
+"main": "src/prototype.js",
+"files": [
+	"src/",
+	"package.js"
+	]
+}

package/src/prototype.js

@@ -0,0 +1,1339 @@
+/**
+ * xxx
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+function Define ($, key, value, option = {}) {
+	if (key) Object.defineProperty ($, key, {enumerable: option.enumerable || false, configurable: option.configurable || false, writable: option.writable || false, value});
+	else return new Define.properties ($);
+	}
+
+Define.properties = class {
+	constructor (property) {
+		this.property = property;
+		}
+	export (data) {
+		return this.property.exports = data;
+		}
+	}
+
+/**
+ * object
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Object, "define", Define);
+
+Define (Object, "type", function (input) { return typeof input; });
+Define (Object.type, "array", function (input) { if (arguments.length) return input instanceof Array || typeof input === "array"; else return Array; });
+Define (Object.type, "boolean", function (input) { if (arguments.length) return input instanceof Boolean || typeof input === "boolean"; else return Boolean; });
+Define (Object.type, "buffer", function (input) { if (arguments.length) return input instanceof Buffer || typeof input === "buffer"; else return Boolean; });
+Define (Object.type, "date", function (input) { if (arguments.length) return input instanceof Date || typeof input === "date"; else return Date; });
+Define (Object.type, "error", function (input) { if (arguments.length) return input instanceof Error || typeof input === "error"; else return Error; });
+Define (Object.type, "function", function (input) { if (arguments.length) return input instanceof Function || typeof input === "function"; else return Function; });
+Define (Object.type, "number", function (input) { if (arguments.length) return input instanceof Number || typeof input === "number"; else return Number; });
+Define (Object.type, "object", function (input) { if (arguments.length) return input instanceof Object || typeof input === "object"; else return Object; });
+Define (Object.type, "promise", function (input) { if (arguments.length) return input instanceof Promise || typeof input === "promise"; else return Promise; });
+Define (Object.type, "regex", function (input) { if (arguments.length) return input instanceof RegExp || typeof input === "regex"; else return RegExp; });
+Define (Object.type, "string", function (input) { if (arguments.length) return input instanceof String || typeof input === "string"; else return String; });
+
+Define (Object, "type_of", function (input) { return Object.prototype.toString.call (input); });
+Define (Object.type_of, "array", function (input) { if (arguments.length) return Object.type_of (input) === "[object Array]"; else return "[object Array]"; });
+Define (Object.type_of, "boolean", function (input) { if (arguments.length) return Object.type_of (input) === "[object Boolean]"; else return "[object Boolean]"; });
+Define (Object.type_of, "buffer", function (input) { if (arguments.length) return Object.type_of (input) === "[object Buffer]"; else return "[object Buffer]"; });
+Define (Object.type_of, "date", function (input) { if (arguments.length) return Object.type_of (input) === "[object Date]"; else return "[object Date]"; });
+Define (Object.type_of, "function", function (input) { if (arguments.length) return Object.type_of (input) === "[object Function]"; else return "[object Function]"; });
+Define (Object.type_of, "null", function (input) { if (arguments.length) return Object.type_of (input) === "[object Null]"; else return "[object Null]"; });
+Define (Object.type_of, "number", function (input) { if (arguments.length) return Object.type_of (input) === "[object Number]"; else return "[object Number]"; });
+Define (Object.type_of, "object", function (input) { if (arguments.length) return Object.type_of (input) === "[object Object]"; else return "[object Object]"; });
+Define (Object.type_of, "promise", function (input) { if (arguments.length) return Object.type_of (input) === "[object Promise]"; else return "[object Promise]"; });
+Define (Object.type_of, "regex", function (input) { if (arguments.length) return Object.type_of (input) === "[object RegExp]"; else return "[object RegExp]"; });
+Define (Object.type_of, "string", function (input) { if (arguments.length) return Object.type_of (input) === "[object String]"; else return "[object String]"; });
+
+Define (Object, "is", function () {});
+Define (Object.is, "url", function (url) {
+	if (typeof url === "string") return url.startsWith ("http://") || url.startsWith ("https://") || url.startsWith ("//");
+	else return false;
+	});
+Define (Object.is, "ip", function (input) {
+	var part = input.split (".");
+	if (part.length === 4) {
+		for (var i in part) {
+			var partial = parseInt (part [i]);
+			if (partial >= 0 && partial <= 255) {}
+			else return false;
+			}
+		return true;
+		}
+	return false;
+	});
+
+Define (Object, "length", function (object) { return Object.keys (object).length; });
+Define (Object, "clone", function (object) { return JSON.parse (JSON.stringify (object)); });
+
+Define (Object, "un_define", function (input) { if (arguments.length) return input === undefined; else return undefined; });
+Define (Object, "un_set", function (input) { return input === undefined || input === null; });
+Define (Object.is, "set", function (input) { return ! Object.un_set (input); });
+
+/**
+ * array
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Array.prototype, "json", function () { return JSON.pretty (this); });
+Define (Array.prototype, "clone", function () { return JSON.parse (JSON.stringify (this)); });
+Define (Array.prototype, "exist", function (value, offset) { if (Array.isArray (value)) { for (var i in value) if (this.includes (value [i])) return true; return false; } else return this.includes (value, offset); });
+Define (Array.prototype, "include", function (value, offset) { return this.includes (value, offset); });
+Define (Array.prototype, "first", function () { for (var i in this) return this [i]; return undefined; }); Define (Array.prototype, "one", function () { return this.first (); });
+Define (Array.prototype, "last", function () { var value; for (var i in this) value = this [i]; return value; });
+Define (Array.prototype, "max", function () { return Math.max (... this); });
+Define (Array.prototype, "min", function () { return Math.min (... this); });
+Define (Array.prototype, "shuffle", function () { var array = this.clone (); var current = array.length, random; while (current !== 0) { random = Math.floor (Math.random () * current); current --; [array [current], array [random]] = [array [random], array [current]]; } return array; });
+Define (Array.prototype, "limit", function (limit) { return this.clone ().slice (0, limit); });
+Define (Array.prototype, "page", function (page, limit) { return this.clone ().slice (((page - 1) * (limit || Array.config.page.limit)), (page * (limit || Array.config.page.limit))); });
+Define (Array.prototype, "distinct", function (key = "id", distinct = []) { return this.filter (function (array) { if (distinct.includes (array [key])) return false; else { distinct.push (array [key]); return true; } }); });
+Define (Array.prototype, "implode", function (data) { var array = this.clone (); array.push (... data); return array; });
+
+Define (Array.prototype, "select", function (filter) {
+	return this.filter (function (array, index) {
+		var error = 0;
+		for (var i in filter) {
+			if (typeof filter [i] === "object") {
+				if (filter [i].key === "!") {
+					if (filter [i].value !== array [i]) continue;
+					else error ++;
+					}
+				}
+			else if (Array.isArray (filter [i])) if (filter [i].includes (array [i])) continue; else error ++;
+			else if (Array.isArray (array [i])) if (array [i].includes (filter [i])) continue; else error ++;
+			else if (filter [i] === array [i]) continue;
+			else error ++;
+			}
+		if (error) return false;
+		else return true;
+		});
+	});
+
+Define (Array.prototype, "order", function (sort) {
+	var array = this.clone (), type = "string";
+	var object = sort.split (".");
+	if (object.length > 2) {
+		if (this.length) if (typeof this [0][object [0]][object [1]][object [2]] === "number") type = "number";
+		if (type === "string") array.sort (function (a, b) { return a [object [0]][object [1]][object [2]].localeCompare (b [object [0]][object [1]][object [2]]); });
+		if (type === "number") array.sort (function (a, b) { return a [object [0]][object [1]][object [2]] - b [object [0]][object [1]][object [2]]; });
+		}
+	else if (object.length > 1) {
+		if (this.length) if (typeof this [0][object [0]][object [1]] === "number") type = "number";
+		if (type === "string") array.sort (function (a, b) { return a [object [0]][object [1]].localeCompare (b [object [0]][object [1]]); });
+		if (type === "number") array.sort (function (a, b) { return a [object [0]][object [1]] - b [object [0]][object [1]]; });
+		}
+	else {
+		if (this.length) if (typeof this [0][sort] === "number") type = "number";
+		if (type === "string") array.sort (function (a, b) { return a [sort].localeCompare (b [sort]); });
+		if (type === "number") array.sort (function (a, b) { return a [sort] - b [sort]; });
+		}
+	return array;
+	});
+
+Define (Array, "config", function (array = {}) {
+	if ("page" in array) if ("limit" in array.page) Array.config.page.limit = array.page.limit;
+	});
+Define (Array.config, "page", {limit: 20}, {writable: true});
+
+/**
+ * string
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (String.prototype, "number", function () { return Number (this); });
+Define (String.prototype, "integer", function () { return parseInt (this); });
+Define (String.prototype, "float", function () { return parseFloat (this); });
+Define (String.prototype, "json", function (type = "object") { try { return JSON.parse (this); } catch (e) { return type === "object" ? {} : []; } });
+Define (String.prototype, "clone", function () { return this.trim (); });
+Define (String.prototype, "format", function (format) { var string = this.trim (); for (var i in format) { if (typeof format [i] === "object") for (var x in format [i]) string = string.split (`{{ ${i}:${x} }}`).join (format [i][x]); else string = string.split (`{{ ${i} }}`).join (format [i]); } return string; });
+Define (String.prototype, "param", function (param) { var string = this.trim (); for (var i in param) string = string.split (`:${i}`).join (param [i]); return string; });
+Define (String.prototype, "small", function () { return this.toLowerCase (); });
+Define (String.prototype, "big", function () { return this.toUpperCase (); });
+Define (String.prototype, "first", function (input = 1) { if (typeof input === "number") return this.substr (0, input); else return this.startsWith (input); }); Define (String.prototype, "begin", function (input = 1) { return this.first (input); });
+Define (String.prototype, "last", function (input = 1) { if (typeof input === "number") return this.substr (- input); else return this.endsWith (input); }); Define (String.prototype, "end", function (input = 1) { return this.last (input); });
+Define (String.prototype, "after", function (input, offset) { if ((offset = this.indexOf (input, offset)) >= 0) return this.substr (offset + input.length); else return ""; });
+Define (String.prototype, "before", function (input, offset) { if ((offset = this.indexOf (input, offset)) >= 0) return this.substr (0, offset); else return ""; });
+Define (String.prototype, "pop", function (length = 1) { return this.substr (0, (this.length - length)); });
+Define (String.prototype, "exist", function (input, offset) { return this.includes (input, offset); });
+Define (String.prototype, "reverse", function () { return this.split ("").reverse ().join (""); });
+Define (String.prototype, "join", function (string) { return this + string; });
+Define (String.prototype, "shuffle", function () { return this.split ("").shuffle ().join (""); });
+
+Define (String, "char", function () {});
+Define (String.char, "small", "abcdefghijklmnopqrstuvwxyz");
+Define (String.char, "big", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+Define (String.char, "alpha", {numeric: "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"});
+Define (String.char, "space", " ");
+Define (String.char, "underscore", "_");
+
+/**
+ * number
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Number.prototype, "number", function () { return this; });
+Define (Number.prototype, "integer", function () { return parseInt (this); });
+Define (Number.prototype, "string", function () { return this.toString (); });
+Define (Number.prototype, "shuffle", function (number) { return Math.floor (Math.random () * (number - this + 1)) + this; });
+
+Define (Number, "format", function (input, separator = ",") {
+	var number = input.toString ().split (""), n = [], x = 0;
+	number.reverse ();
+	for (var i in number) {
+		if (x > 2) if ((x = 0) === 0) n.push (separator);
+		x ++;
+		n.push (number [i]);
+		}
+	n.reverse ();
+	return n.join ("");
+	})
+
+/**
+ * date
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Date, "io", class {
+	constructor (date) {
+		if (date instanceof Date) this.date = date;
+		else if (date) this.date = new Date (date);
+		else this.date = new Date ();
+		}
+	iso () { return this.format ("iso"); }
+	format (format = "default") {
+		var date = {
+			"Y": this.year (),
+			"M": this.month (), "m": Date.month.name [this.month ()],
+			"D": this.day (), "d": Date.day.name [this.week ()], "W": this.week (),
+			"H": this.hour (), "h": this.hour ("meredian"),
+			"I": this.minute (),
+			"S": this.second (),
+			"A": this.meredian (),
+			}
+		format = Date.format [format] || format;
+		var formated = format.split ("");
+		var result = [];
+		for (var i in formated) {
+			result.push (date [formated [i]] || formated [i]);
+			}
+		// for (var i in date) format = format.split (i).join (date [i]);
+		return result.join ("");
+		}
+	year () { return this.date.getFullYear (); }
+	month () { return (this.date.getMonth () + 1).toString ().padStart (2, "0"); }
+	day () { return this.date.getDate ().toString ().padStart (2, "0"); }
+	week () { return (this.date.getDay () || 7).toString ().padStart (2, "0"); }
+	hour (meredian) { if (meredian) { var hour = this.date.getHours (); if (this.meredian () === "PM") if (hour === 12) return hour.toString (); else return (hour - 12).toString ().padStart (2, "0"); else return hour.toString ().padStart (2, "0"); } else return this.date.getHours ().toString ().padStart (2, "0"); }
+	minute () { return this.date.getMinutes ().toString ().padStart (2, "0"); }
+	second () { return this.date.getSeconds ().toString ().padStart (2, "0"); }
+	mili () { return this.date.getMilliseconds ().toString ().padStart (3, "0"); }
+	meredian () { if (this.date.getHours () > 11) return "PM"; else return "AM"; }
+	time () { return this.date.getTime (); }
+	stamp () { return this.date; }
+	});
+
+Define (Date, "format", function (format, date) { return new Date.io (date).format (format); });
+Define (Date.format, "iso", "Y-M-D");
+Define (Date.format, "number", "YMD");
+Define (Date.format, "default", "m D, Y");
+Define (Date.format, "full", "d, m D, Y - h:I:S A");
+Define (Date.format, "monthly", "Y-M");
+
+Define (Date, "month", {
+	name: {
+		1: "January", "01": "January",
+		2: "February", "02": "February",
+		3: "March", "03": "March",
+		4: "April", "04": "April",
+		5: "May", "05": "May",
+		6: "June", "06": "June",
+		7: "July", "07": "July",
+		8: "August", "08": "August",
+		9: "September", "09": "September",
+		10: "October",
+		11: "November",
+		12: "December",
+		},
+	});
+
+Define (Date, "day", {
+	name: {
+		1: "Monday", "01": "Monday",
+		2: "Tuesday", "02": "Tuesday",
+		3: "Wednesday", "03": "Wednesday",
+		4: "Thursday", "04": "Thursday",
+		5: "Friday", "05": "Friday",
+		6: "Saturday", "06": "Saturday",
+		7: "Sunday", "07": "Sunday",
+		},
+	});
+
+Define (Date, "time", function () { return Date.now (); });
+Define (Date.time, "interval", function (context, second = 1) { return setInterval (context, (second * 1000)); });
+Define (Date.time.interval, "clear", function (context) { return clearInterval (context); });
+Define (Date, "timeout", function (context, second = 1) { return setTimeout (context, (second * 1000)); });
+Define (Date.timeout, "clear", function (context) { return clearTimeout (context); });
+
+Define (Date, "embed", function () {});
+Define (Date.embed, "format", function (input) { if ((input = parseInt (input)) > 3600) return Date.embed.hour (input); else return Date.embed.minute (input); });
+Define (Date.embed, "hour", function (input) { var hour = Math.floor (input / 3600); var minute = Math.floor ((input % 3600) / 60); var second = input % 60; return `${hour}:${String (minute).padStart(2, "0")}:${String (second).padStart(2, "0")}`; });
+Define (Date.embed, "minute", function (input) { var minute = Math.floor (input / 60); var second = input % 60; return `${String (minute).padStart(2, "0")}:${String (second).padStart(2, "0")}`; });
+
+Define (Date, "cookie", function () {
+	var date = new Date ();
+	return [date.getFullYear (), date.getMonth (), date.getDate (), "--", date.getHours ()].join ("-");
+	});
+
+/**
+ * event
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Event, "io", class {
+	constructor () {
+		this.data = Object.create (null);
+		}
+	on (key, value) {
+		if (this.data [key]) this.data [key].push (value);
+		else this.data [key] = [value];
+		}
+	emit (key, ... value) {
+		var e;
+		for (var i in this.data [key]) {
+			e = this.data [key][i] (... value);
+			}
+		return e;
+		}
+	});
+
+Define (Event, "proto", function (proto) {
+	if (proto) {}
+	else proto = Object.create (null);
+	proto.event = proto.event || Object.create (null);
+	proto.on = function (key, value) {
+		if (proto.event [key]) proto.event [key].push (value);
+		else proto.event [key] = [value];
+		}
+	proto.emit = function (key, ... value) {
+		var e;
+		for (var i in proto.event [key]) {
+			e = proto.event [key][i] (... value);
+			}
+		return e;
+		}
+	});
+
+Event.proto (Event);
+
+/**
+ * promise
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Promise, "io", function (context) {
+	return new Promise (function (resolve, reject) {
+		context (function (value = true) { resolve (value); }, function (error = "") { reject (error); });
+		});
+	});
+
+/**
+ * url
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (URL, "parse", function (url) {
+	var parse_url, result = {
+		host: {address: "", name: ""},
+		domain: {name: "", base: {name: ""}, sub: "www", extension: ""},
+		protocol: "http", port: "", user: "", password: "",
+		uri: "", path: "", tag: "",
+		queries: {},
+		}
+	try {
+		parse_url = new URL (url);
+		var cookie = parse_url.hostname;
+		if (cookie === "localhost") {}
+		else if (Object.is.ip (cookie)) {}
+		else cookie = "." + cookie;
+		result.host = {address: parse_url.host, name: parse_url.hostname, cookie}
+		result.domain = {name: "", base: {name: ""}, sub: "www", extension: ""}
+		result.protocol = parse_url.protocol.pop ();
+		result.host.port = parse_url.port ? parse_url.port.integer () : "";
+		result.host.user = parse_url.username;
+		result.host.password = parse_url.password;
+		// result.port = parse_url.port ? parse_url.port.integer () : "";
+		// result.user = parse_url.username;
+		// result.password = parse_url.password;
+		result.uri = parse_url.pathname + parse_url.search;
+		result.path = parse_url.pathname;
+		result.tag = parse_url.hash;
+		result.query = function (key) { return result.queries [key] || ""; }
+		result.queries = {}
+		var queries = parse_url.search.after ("?").split ("&");
+		for (var i in queries) {
+			if (queries [i]) {
+				var key = queries [i].before ("=");
+				var value = queries [i].after ("=");
+				if (key) if (value) result.queries [key] = value;
+				}
+			}
+		return result;
+		}
+	catch (e) {
+		return result;
+		}
+	});
+
+Define (URL, "header", function () {});
+Define (URL.header, "status", {
+	OK: 200, success: 200,
+	error: {request: 400, forbidden: 403, exist: 404, timeout: 408, legal: 451, s: 500},
+	code: {
+		100: "Continue", 101: "Switching Protocols", 102: "Processing",
+		200: "OK", 201: "Created", 202: "Accepted", 203: "Non-authoritative Information", 204: "No Content", 205: "Reset Content", 206: "Partial Content", 207: "Multi-Status", 208: "Already Reported", 226: "IM Used",
+		300: "Multiple Choices", 301: "Moved Permanently", 302: "Found", 303: "See Other", 304: "Not Modified", 305: "Use Proxy", 307: "Temporary Redirect", 308: "Permanent Redirect",
+		400: "Bad Request", 401: "Unauthorized", 402: "Payment Required", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed", 406: "Not Acceptable", 407: "Proxy Authentication Required", 408: "Request Timeout", 409: "Conflict", 410: "Gone", 411: "Length Required", 412: "Precondition Failed", 413: "Payload Too Large", 414: "Request-URI Too Long", 415: "Unsupported Media Type", 416: "Requested Range Not Satisfiable", 417: "Expectation Failed", 418: "I'm a teapot", 421: "Misdirected Request", 422: "Unprocessable Entity", 423: "Locked", 424: "Failed Dependency", 426: "Upgrade Required", 428: "Precondition Required", 429: "Too Many Requests", 431: "Request Header Fields Too Large", 444: "Connection Closed Without Response", 451: "Unavailable For Legal Reasons", 499: "Client Closed Request",
+		500: "Internal Server Error", 501: "Not Implemented", 502: "Bad Gateway", 503: "Service Unavailable", 504: "Gateway Timeout", 505: "HTTP Version Not Supported", 506: "Variant Also Negotiates", 507: "Insufficient Storage", 508: "Loop Detected", 510: "Not Extended", 511: "Network Authentication Required", 599: "Network Connect Timeout Error",
+		1404: "Host Not Found",
+		},
+	});
+
+Define (URL, "init", function () {
+	URL.__ = URL.parse (window.location.href.toString ());
+	});
+
+Define (URL, "prop", function (key) {
+	if (key) return URL.__ [key];
+	else return URL.__;
+	});
+
+Define (URL, "host", {
+	name: function () { return URL.prop ("host").name; },
+	address: function () { return URL.prop ("host").address; },
+	});
+
+Define (URL, "referer", function (url) {
+	if (url) {
+		if (url.startsWith ("//")) URL.referer.data = URL.__.protocol + ":" + url;
+		else if (url.startsWith ("/")) URL.referer.data = URL.__.protocol + "://" + URL.__.host.address + url;
+		else URL.referer.data = url;
+		}
+	return URL.referer.data;
+	});
+
+Define (URL, "query", function (key) {
+	return URL.__.query (key);
+	});
+
+Define (URL.query, "build", function (query) {
+	var q = {}, queries = [];
+	for (var i in URL.__.queries) q [i] = URL.__.queries [i];
+	for (var i in query) q [i] = query [i];
+	for (var i in q) queries.push (`${i}=${q [i]}`);
+	if (queries.length) return URL.__.path + "?" + queries.join ("&");
+	else return URL.__.path;
+	});
+
+/**
+ * json
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (JSON, "pretty", function (json) { return JSON.stringify (json, null, "\t"); });
+
+Define (JSON, "token", function () {});
+Define (JSON.token, "parse", function (token) {
+	try {
+		if ((token = token.split (".")).length !== 3) throw new Error ("Invalid JWT Structure");
+		return JSON.parse (decodeURIComponent (atob (token [1].replace (/-/g, "+").replace (/_/g, "/")).split ("").map (function (c) { return "%" + ("00" + c.charCodeAt (0).toString (16)).slice (-2); }).join ("")));
+		}
+	catch (e) {
+		return {}
+		}
+	});
+
+Define (JSON, "db", class {
+	constructor (config) {
+		this.dir = config.dir;
+		this.collection = config.collection || {}
+		}
+	select (collection) { return new JSON.db.select (this, collection); }
+	});
+
+Define (JSON.db, "select", class {
+	constructor (db, collection) {
+		this.db = db;
+		this.collection = {name: collection, file: JSON.db.file (collection)}
+		if (this.db.collection [this.collection.name]) this.collection.data = this.db.collection [this.collection.name];
+		else this.collection.data = JSON.parse (Function.file.read (Function.path.join (this.db.dir, `${this.collection.file}.json`)) || "[]");
+		}
+	find (filter = {}) {
+		var __ = function (db) {
+			return new Promise (function (resolve, reject) {
+				resolve ({collection: db.collection.name, data: db.collection.data.select (filter)});
+				});
+			}
+		return __ (this);
+		}
+	});
+
+Define (JSON.db, "file", function (key, value) { if (value) return JSON.db.file.object [key] = value; else return JSON.db.file.object [key] || key; });
+Define (JSON.db.file, "object", {});
+
+/**
+ * function
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "require", function (... path) { return require (Function.path.join (Function.base_dir (), ... path)); });
+Define (Function, "base_dir", function (base_dir) { if (base_dir) return Function.base_dir.value = base_dir; else return Function.base_dir.value; });
+
+Define (Function, "log", function (... log) { if (Function.log.debug) console.log (... log); });
+Define (Function.log, "set", function (value) { return Function.log.debug = value; });
+
+/**
+ * db
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "db", function () {});
+Define (Function, "database", function () {});
+
+/**
+ * cookie
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "cookie", function () {
+	var cookie = document.cookie.split (";").map (function (data) { return data.trim ().split ("="); });
+	for (var i in cookie) {
+		var key = cookie [i][0], value;
+		if (key) {
+			value = cookie [i][1].trim ();
+			Function.cookie.data [key.trim ()] = value;
+			}
+		}
+	});
+
+Define (Function.cookie, "start", function (cookie, option) {
+	if (cookie) {
+		option = option || {}
+		Function.cookie.identity = cookie;
+		if (option.host) Function.cookie.host = option.host;
+		}
+	if (Function.cookie.id ()) {}
+	else Function.cookie.set (Function.cookie.identity, Function.unique.id ());
+	Event.emit ("cookie:start", Function.cookie.data);
+	});
+
+Define (Function.cookie, "id", function () {
+	return Function.cookie.get (Function.cookie.identity);
+	});
+
+Define (Function.cookie, "get", function (key) {
+	if (key) return Function.cookie.data [key];
+	else return Function.cookie.data;
+	});
+
+Define (Function.cookie, "set", function (key, value, option) {
+	option = option || {}
+	var content = "";
+	if (value === undefined || value === null) {}
+	else content = value;
+	var cookie = [`${key}=${value}`];
+	var expire; if ("expire" in option) cookie.push (expire = `expires=${option.expire}`); // var expire = new Date (); expire.setTime (expire.getTime () + (key ["expire:day"] * 24 * 60 * 60 * 1000)); Function.cookie._expire = expire.toUTCString ();
+	var host; if ("host" in option) cookie.push (host = `domain=${option.host}`); else if (Function.cookie.host) cookie.push (host = `domain=${Function.cookie.host}`);
+	var path; cookie.push (path = `path=${option.path || '/'}`);
+	cookie.push (`samesite=lax`);
+	document.cookie = cookie.join (";");
+	Function.cookie.data [key] = value;
+	return Function.cookie;
+	});
+
+Define (Function.cookie, "delete", function (key) {
+	return Function.cookie.set (key);
+	});
+
+Function.cookie.identity = "cookie";
+Function.cookie.data = {}
+
+/**
+ * path
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "path", function () {});
+Define (Function.path, "require", function () { return Function.path.api = require ("node:path"); });
+Define (Function.path, "join", function (... path) { return Function.path.api.join (... path); });
+Define (Function.path, "exist", function (... path) { return Function.file.api.existsSync (Function.path.api.join (... path)); });
+Define (Function.path, "current", function (path) { return "./" + path; });
+
+/**
+ * file
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "file", function () {});
+Define (Function.file, "require", function () { return Function.file.api = require ("node:fs"); });
+Define (Function.file, "write", function (file, data, context) { if (context) return Function.file.api.writeFile (file, data, context); else return Function.file.api.writeFileSync (file, data); });
+Define (Function.file, "read", function (file, context) { if (context) return Function.file.api.readFile (file, context); else return Function.file.api.readFileSync (file); });
+Define (Function.file, "exist", function (file) { return Function.file.api.lstatSync (file).isFile (); });
+Define (Function.file, "extension", {text: ".txt", json: ".json"});
+
+Define (Function, "dir", function () {});
+Define (Function.dir, "exist", function (dir) { return Function.file.api.lstatSync (dir).isDirectory (); });
+
+/**
+ * hash
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "hash", function () {});
+Define (Function.hash, "require", function () { Function.hash.crypto.api = require ("node:crypto"); });
+Define (Function.hash, "crypto", function () {});
+Define (Function.hash, "md5", function (input) { return Function.hash.crypto.api.createHash ("md5").update (input).digest ("hex"); });
+Define (Function.hash, "sha1", function (input) { return Function.hash.crypto.api.createHash ("sha1").update (input).digest ("hex"); });
+Define (Function.hash, "sha256", function (input) { return Function.hash.crypto.api.createHash ("sha256").update (input).digest ("hex"); });
+
+Define (Function, "unique", function () {});
+Define (Function.unique, "shuffle", function (length = 64) { return String.char.alpha.numeric.repeat (16).shuffle ().substr (0, length); });
+Define (Function.unique, "identity", function () { return Function.unique.id ().split ("-") [0]; });
+Define (Function.unique, "id", function () {
+	return ("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx").replace (/[xy]/g, function (c) {
+		const r = (Math.random () * 16) | 0;
+		const v = c === "x" ? r : (r & 0x3) | 0x8;
+		return v.toString (16);
+		});
+	});
+
+/**
+ * http
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "http", function () {});
+Define (Function.http, "require", function () { return Function.http.api = require ("node:http"); });
+
+/**
+ * socket.io
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "socket", function () {});
+Define (Function.socket, "require", function () { return Function.socket.api = require ("socket.io"); });
+Define (Function.socket, "io", class {});
+Define (Function.socket, "server", function (app, option = {}) {
+	var server = Function.http.api.createServer (app);
+	option.cors = {
+		origin: "*",
+		methods: ["GET", "POST"],
+		optionsSuccessStatus: 200,
+		}
+	return {
+		instance: server,
+		io: new Function.socket.api.Server (server, option),
+		}
+	});
+
+/**
+ * asset
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "asset", function () {});
+Define (Function.asset, "extension", [".ico", ".gif", ".png", ".jpg", ".jpeg"]);
+
+/**
+ * template
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "template", function () {});
+
+/**
+ * theme
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "theme", function () {});
+Define (Function.theme, "is_light", function () { return ! Function.theme.night (); });
+Define (Function.theme, "is_night", function () { return window.matchMedia && window.matchMedia ("(prefers-color-scheme: dark)").matches; });
+
+Define (Function, "html", class {
+	constructor () {
+		this.markup = new Function.html.markup ("html");
+		this.var = {
+			title: "Untitled",
+			viewport: "width=device-width, initial-scale=1.0, maximum-scale=3.0, user-scalable=1",
+			robot: ["index", "follow"],
+			rating: "general",
+			"google-bot:article": ["index", "follow"],
+			google: {font: []},
+			link: {style: []},
+			error: {},
+			}
+		}
+	title (title) { if (Object.is.set (title)) this.var.title = title; return this.var.title; }
+	description (description) { if (Object.is.set (description)) this.var.description = description; return this.var.description; }
+	error (error) { if (error) this.var.error = error; return this.var.error; }
+	get (key) { return this.var [key]; }
+	set (key, value) {
+		if (typeof key === "object") for (var i in key) if (key [i] === undefined) {}
+		else if (key [i] === null) {}
+		else this.var [i] = key [i];
+		else if (value === undefined) {}
+		else if (value === null) {}
+		else this.var [key] = value;
+		return this;
+		}
+	delete (key) {
+		delete this.var [key];
+		return this;
+		}
+	render (input = {}) {
+		this.set (input);
+		this.markup.push (0, "html", {lang: this.var.lang, translate: "no", prefix: "og: http://ogp.me/ns#"});
+			this.markup.push (1, "head", {profile: "#"});
+				this.markup.push (2, `<title>${this.var.title}</title>`);
+				this.markup.push (2, "meta", {"http-equiv": "X-UA-Compatible", content: "IE=edge"});
+				this.markup.push (2, "meta", {"http-equiv": "X-Cross-Origin", content: "*"});
+				this.markup.push (2, "meta", {charset: "UTF-8"});
+				this.markup.push (2, "meta", {name: "author", content: this.var.author});
+				this.markup.push (2, "meta", {name: "description", content: this.var.description});
+				if (this.var.generator) this.markup.push (2, "meta", {name: "generator", content: this.var.generator});
+				this.markup.push (2, "meta", {name: "viewport", content: this.var.viewport});
+				this.markup.push (2, "meta", {name: "keywords", content: this.var.keyword});
+				this.markup.push (2, "meta", {name: "robots", content: [Function.html.attribute.content (this.var.robot), "max-snippet:-1, max-video-preview:-1, max-image-preview:large"]});
+				this.markup.push (2, "meta", {name: "rating", content: this.var.rating});
+				this.markup.push (2, "meta", {name: "google", content: "notranslate"});
+				this.markup.push (2, "meta", {name: "googlebot", content: "notranslate"});
+				this.markup.push (2, "meta", {name: "googlebot-news", content: this.var ["google-bot:article"]});
+				if (this.var ["google-site-verification"]) this.markup.push (2, "meta", {name: "google-site-verification", content: this.var ["google-site-verification"]});
+				if (this.var ["yandex-verification"]) this.markup.push (2, "meta", {name: "yandex-verification", content: this.var ["yandex-verification"]});
+				this.markup.push (2, "meta", {name: "twitter:card", content: "summary_large_image"});
+				this.markup.push (2, "meta", {name: "twitter:title", content: this.var.title});
+				this.markup.push (2, "meta", {name: "twitter:description", content: this.var.description});
+				this.markup.push (2, "meta", {name: "twitter:image", content: this.var ["content:poster"]});
+				this.markup.push (2, "meta", {property: "og:site_name", content: this.var.site.name});
+				this.markup.push (2, "meta", {property: "og:title", content: this.var.title});
+				this.markup.push (2, "meta", {property: "og:description", content: this.var.description});
+				this.markup.push (2, "meta", {property: "og:url", content: this.var.canonical});
+				if (this.var ["og:image"] || this.var ["content:poster"]) this.markup.push (2, "meta", {property: "og:image", content: this.var ["content:poster"]});
+				this.markup.push (2, "meta", {property: "og:type", content: this.var ["og:type"]});
+				this.markup.push (2, "meta", {property: "og:locale", content: this.var ["og:locale"]});
+				for (var i in this.var.meta) this.markup.push (2, "meta", this.var.meta [i]);
+				this.markup.push (2, "link", {rel: "icon", href: this.var ["favorite.ico"]});
+				this.markup.push (2, "link", {rel: "canonical", href: this.var.canonical});
+				if (this.var ["manifest.json"]) this.markup.push (2, "link", {rel: "manifest", href: this.var ["manifest.json"]});
+				if (this.var ["feed.xml"]) this.markup.push (2, "link", {rel: "alternate", href: this.var ["feed.xml"], type: "application/rss+xml", title: `${this.var.site.name} &raquo; Feed`});
+				if (this.var ["feed.xml:atom"]) this.markup.push (2, "link", {rel: "alternate", href: this.var ["feed.xml:atom"], type: "application/rss+xml", title: `${this.var.site.name} &raquo; Feed (Atom)`});
+				this.markup.push (2, "link", {rel: "dns-prefetch", href: "https://www.google-analytics.com"});
+				this.markup.push (2, "link", {rel: "dns-prefetch", href: "https://www.googletagmanager.com"});
+				this.markup.push (2, "link", {rel: "preconnect", href: "https://fonts.gstatic.com", crossorigin: "crossorigin"});
+				this.markup.push (2, "link", {rel: "preconnect", href: "https://fonts.googleapis.com", crossorigin: "crossorigin"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Material+Symbols+Rounded:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Material+Symbols+Sharp:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Google+Sans+Flex:opsz,slnt,wdth,wght,GRAD,ROND@6..144,-10..0,25..151,1..1000,0..100,0..100&display=swap"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Josefin+Sans:ital,wght@0,100..700;1,100..700&display=swap"});
+				for (var i in this.var.google.font) this.markup.push (2, "link", {rel: "stylesheet", href: this.var.google.font [i]});
+				for (var i in this.var.link.style) this.markup.push (2, "link", {rel: "stylesheet", href: this.var.link.style [i]});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://cdnjs.cloudflare.com/ajax/libs/OwlCarousel2/2.3.4/assets/owl.carousel.min.css"});
+				this.markup.push (2, "link", {rel: "stylesheet", href: "https://cdnjs.cloudflare.com/ajax/libs/OwlCarousel2/2.3.4/assets/owl.theme.default.min.css"});
+				if (this.var ["theme:style.css"]) this.markup.push (2, "link", {rel: "stylesheet", href: this.var ["theme:style.css"]});
+				this.markup.push (2, "link", {rel: "stylesheet", href: this.var ["vue.css:bundle"]});
+				if (this.var ["gtag:id"]) this.markup.push (2, `<script src="https://www.googletagmanager.com/gtag/js?id=${this.var ['gtag:id']}" async></script>`);
+				if (false) if (this.var ["google:auth"]) this.markup.push (2, `<script src="https://accounts.google.com/gsi/client" async></script>`);
+				this.markup.script (2, {src: "https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js"});
+				this.markup.script (2, {src: "https://cdnjs.cloudflare.com/ajax/libs/OwlCarousel2/2.3.4/owl.carousel.min.js"});
+				if (this.var ["prototype.js"]) this.markup.script (2, {src: this.var ["prototype.js"]});
+				this.markup.push (2, `<script type="module" src="${this.var ['vue.js:bundle']}" crossorigin></script>`);
+				this.markup.push (2, `<script type="application/ld+json">{"@context": "https://schema.org", "@type": "WebPage", "name": "${this.var.site.name}", "alternateName": "${this.var ['site:alternate-name']}", "url": "${this.var ['canonical']}", "description": "${this.var ['description']}"}</script>`);
+				this.markup.push (2, `<script type="application/ld+json">{"@context": "https://schema.org", "@graph": [{"@type": "website", "@id": "${this.var ['canonical']}", "name": "${this.var.site.name}", "url": "${this.var ['canonical']}", "description": "${this.var ['description']}"}]}</script>`);
+				this.markup.push (2, `<script>$.app = function () {}</script>`);
+				this.markup.push (2, `<script>$.app.id = "{{ $.app.id }}"</script>`);
+				this.markup.push (2, `<script>$.app.var = {{ $.app.var }}</script>`);
+				this.markup.push (2, `<script>$.app.document = {{ $.app.document }}</script>`);
+				this.markup.push (2, `<script>$.app.theme = {{ $.app.theme }}</script>`);
+				this.markup.push (2, `<script>$.app.router = {{ $.app.router }}</script>`);
+				this.markup.push (2, `<script>$.app.visitor = {{ $.app.visitor }}</script>`);
+				this.markup.push (2, `<script>$.app.cookie = {name: "${this.var.cookie.name}", host: "${this.var.cookie.host}"}</script>`);
+				this.markup.push (2, `<script>$.app.error = {{ $.app.error }}</script>`);
+				this.markup.push (2, `<script>window.onload = function () {}</script>`);
+				if (this.var ["gtag:id"]) this.markup.push (2, `<script>window.dataLayer = window.dataLayer || []; function gtag () { dataLayer.push (arguments); gtag ("js", new Date ()); gtag ("config", "${this.var ['gtag:id']}"); }</script>`);
+				this.markup.push (2, `<style>img:is([sizes="auto" i], [sizes^="auto," i]) { contain-intrinsic-size: 3000px 1500px }</style>`);
+				this.markup.push (2, `<style>[application] { opacity: 0; }</style>`);
+			this.markup.push (1, `</head>`);
+			this.markup.push (1, `<body>`);
+				this.markup.push (2, `<div id="app">`);
+					this.markup.push (3, `<div application>`);
+						for (var i in this.heading) {
+							var h = parseInt (i) + 1;
+							this.markup.push (4, `<h${h}>${this.heading [i]}</h${h}>`);
+							}
+						this.markup.push (4, `<date>{{ content:date }}</date>`);
+						this.markup.push (4, `<p>${this.var ["content:title"] || this.var ["content:paragraph"] || ""}</p>`);
+						this.markup.push (4, `<article>${this.var ["content:article"] || this.var.content || this.var ["content:description"] || this.var.description || ""}</article>`);
+						if (this.var.anchor) for (var i in this.var.anchor) this.markup.push (4, `<a href="${this.var.anchor [i].url}" title="${this.var.anchor [i].info}">${this.var.anchor [i].name}</a>`);
+					this.markup.push (3, `</div>`);
+				this.markup.push (2, `</div>`);
+			this.markup.push (1, `</body>`);
+		this.markup.push (0, `</html>`);
+		return this.markup.render ().format (this.var);
+		}
+	});
+
+Define (Function.html, "prop", function (prop) {
+	var attribute = "";
+	if (typeof prop === "string") attribute = " " + prop.trim ();
+	else attribute = " " + prop.join (" ");
+	return attribute;
+	});
+
+Define (Function.html, "attribute", function (attribute) {
+	var a = [];
+	for (var i in attribute) {
+		if (attribute [i] === i) a.push (i);
+		else a.push (`${i}="${Function.html.attribute.content (attribute [i])}"`);
+		}
+	return a.join (" ");
+	});
+
+Define (Function.html.attribute, "content", function (input) {
+	if (Array.isArray (input)) return input.filter (function (input) { if (input) return true; else return false; }).join (", ");
+	else if (typeof input === "number") return input;
+	else return input || "";
+	});
+
+Define (Function.html, "markup", class {
+	constructor (doc, markup) {
+		if (Array.isArray (markup)) this.markup = [... markup];
+		else if (doc) if (markup) this.markup = [`<!DOCTYPE ${doc}>`, markup];
+		else this.markup = [`<!DOCTYPE ${doc}>`];
+		else if (markup) this.markup = [markup];
+		else this.markup = [];
+		}
+	push (tab, tag, attribute, content) {
+		if (typeof tab === "string") this.markup.push (tab);
+		else {
+			if (tag.startsWith ("<")) this.markup.push (("\t").repeat (tab) + tag);
+			else {
+				var a = Function.html.attribute (attribute);
+				if (a) a = " " + a;
+				if (content) {
+					if (tab) this.markup.push (("\t").repeat (tab) + `<${tag}${a}>${content}</${tag}>`);
+					else this.markup.push (`<${tag}${a}>${content}</${tag}>`);
+					}
+				else {
+					if (tab) this.markup.push (("\t").repeat (tab) + `<${tag}${a}>`);
+					else this.markup.push (`<${tag}${a}>`);
+					}
+				}
+			}
+		return this;
+		}
+	script (tab, attribute) {
+		var a = Function.html.attribute (attribute);
+		if (a) a = " " + a;
+		if (tab) this.markup.push (("\t").repeat (tab) + `<script${a}></script>`);
+		else this.markup.push (`<script${a}></script>`);
+		return this;
+		}
+	render () {
+		return this.markup.join ("\n");
+		}
+	});
+
+/**
+ * 3rd party
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+/**
+ * miscellaneous
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Define (Function, "help", function () {});
+
+Define (Function.help, "argument", function () {
+	var result = {string: "", number: 0}
+	for (var i in arguments) {
+		if (typeof arguments [i] === "string") result.string = arguments [i];
+		else if (typeof arguments [i] === "number") result.number = arguments [i];
+		}
+	return result;
+	});
+
+Function.ajax = function () {}
+
+Function.ajax.config = function (key, value) {
+	return Function.ajax.config [key] = value;
+	}
+
+Function.ajax.url = function (url) {
+	if (Function.ajax) {
+		if (url.startsWith ("/") === false) url = "/" + url;
+		if (Function.ajax.config.host) return Function.ajax.config.host + url;
+		else return url;
+		}
+	else {
+		if (typeof url === "string") {}
+		else {
+			if (url.host) if (Function.ajax.config.host) url = Function.ajax.config.host + url.path;
+			else url = url.url || url.path;
+			else url = url.url || url.path;
+			}
+		return url;
+		}
+	}
+
+Function.ajax.get = function (url, context) {
+	url = Function.ajax.url (url);
+	return $.ajax ({
+		url,
+		headers: {ajax: Function.ajax.id (), reference: URL.referer ()},
+		success (ajax) {
+			if (typeof ajax === "object") {}
+			else ajax = {}
+			if (context.success) context.success ({}, ajax);
+			URL.referer (url);
+			},
+		error (error) {
+			if (context.error) context.error (error.responseJSON || {});
+			},
+		});
+	}
+
+Function.ajax.post = function (url, data, context) {
+	url = Function.ajax.url (url);
+	return $.ajax ({
+		url,
+		headers: {ajax: Function.ajax.id (), reference: URL.referer ()},
+		data: JSON.stringify (data),
+		type: "POST",
+		dataType: "json",
+		success (ajax) {
+			if (typeof ajax === "object") {}
+			else ajax = {}
+			if (context.success) context.success ({}, ajax);
+			URL.referer (url);
+			},
+		error (error) {
+			if (context.error) context.error (error.responseJSON || {});
+			},
+		});
+	}
+
+Function.ajax.id = function () {
+	return Function.unique.id () || Function.cookie.get ("ajax");
+	}
+
+Define (Function, "google", function () {});
+Define (Function.google, "account", function (id) { google.accounts.id.initialize ({client_id: id, callback: Function.google.account.context}); });
+Define (Function.google.account, "gateway", function (url) { if (url) return Function.google.account.gateway.url = url; else return Function.google.account.gateway.url; }); Function.google.account.gateway ("/cgi-bin/3rd-party/google-auth");
+Define (Function.google.account, "redirect", function (url) { if (url) return Function.google.account.redirect.url = url; else return Function.google.account.redirect.url; }); Function.google.account.redirect ("/");
+Define (Function.google.account, "button", function (element, context) { google.accounts.id.renderButton (document.getElementById (element), {theme: "filled_blue", size: "medium", shape: "circle", text: "continue_with", click_listener: context || function () {}}); });
+Define (Function.google.account.button, "icon", function (element) { google.accounts.id.renderButton (document.getElementById (element), {type: "icon", theme: "outline", size: "large"}); });
+Define (Function.google.account, "sign", function () {});
+Define (Function.google.account.sign, "out", function () { google.accounts.id.disableAutoSelect (); });
+Define (Function.google.account, "context", function (token) {
+	Function.ajax.post (Function.google.account.gateway.url, {credential: JSON.token.parse (token.credential)}, {
+		success (ajax) {
+			if (ajax.success) if (Function.google.account.redirect.url) location.href = Function.google.account.redirect.url + "?sign_in";
+			else location.reload ();
+			},
+		error (error) {},
+		});
+	});
+Define (Function.google, "icon", function (icon) { if (Function.google.icon.src [icon]) return "&#x" + Function.google.icon.src [icon] + ";"; else return "XXXXXXXXXXXX"; });
+Define (Function.google.icon, "src", {
+	home: "e88a", home_app: "e295", home_storage: "f86c", home_lot_device: "e283",
+	archive: "e149", article: "ef42",
+	folder: "e2c7", folder_off: "eb83",
+	bookmark: "e866", bookmark_star: "f454",
+	notification: "e7f4", notification_unread: "f4fe", notification_audio: "eec1", notification_setting: "f367",
+	chat: "e0b7", chat_unread: "f189", chat_error: "f7ac",
+	check: "e5ca", check_circle: "e86c",
+	lock: "e897", lock_clock: "ef57",
+	visibility: "e8f4", visibility_off: "e8f5", visibility_lock: "f653",
+	thumb_up: "e8dc", thumb_up_double: "eefc", thumb_down: "e8db",
+	shield: "e9e0", shield_lock: "f686", shield_locked: "f592", shield_toggle: "f2ad", shield_watch: "f30f",
+	arrow_circle_down: "f181", arrow_drop_down: "e5c5",
+	menu: "e5d2", more: "e619", more_vertical: "e5d4", more_horizontal: "e5d3",
+	delete: "e872", delete_auto: "ea4c", delete_forever: "e92b",
+	download: "f090", downloading: "f001", cloud_download: "e2c0", cloud_upload: "e2c3",
+	calendar_clock: "f540", calendar_check: "f243", calendar_today: "e935", calendar_lock: "f242",
+	globe: "e64c", globe_asia: "f799",
+	local_activity: "e53f", local_fire_department: "ef55",
+	image: "e3f4", animated_image: "f49a",
+	photo: "e410", photo_camera: "e412",
+	star: "e838", star_s: "f31c",
+	male: "e58e", female: "e590", transgender: "e58d",
+	arrow_left_alt: "ef7d", arrow_right_alt: "e941",
+	light_bulb: "e0f0", light_bulb_x: "f3e3",
+	theater: "e8da", movie: "e02c", play_circle: "e1c4", play_arrow: "e037",
+	tv: "e333", tv_guide: "e1dc", live_tv: "e639",
+	close: "e5cd",
+	cookie: "eaac",
+	file_video: "eb87",
+	mobile_vibrate: "f2cb",
+	admin_panel_setting: "ef3d",
+	cloud_lock: "f386",
+	comedy_mask: "f4d6",
+	encrypted: "e593",
+	fingerprint: "e90d",
+	health_safety: "e1d5",
+	security: "e32a",
+	recpmend: "e9d2",
+	keep: "e6aa",
+	favorite: "e87d",
+	heart_broken: "eac2",
+	password: "f042",
+	person_shield: "e384",
+	verified_user: "e8e8",
+	supervisor_account: "e8d3",
+	visibility: "e8f4",
+	id_card: "e8f4",
+	passkey: "f87f",
+	circle: "ef4a",
+	dns: "e875",
+	eco: "ea35",
+	explore: "e87a",
+	share_location: "f05f",
+	search: "e8b6",
+	sms: "e625",
+	subscription: "e064",
+	editor_choice: "f528",
+	search_activity: "f3e5",
+	timer_play: "f4ba",
+	playlist_play: "e05f",
+	hotel_class: "e743",
+	description: "e873",
+	contact: "e0ba",
+	link: "e157",
+	health_and_safety: "e1d5",
+	setting_accessibility: "f05d",
+	safety_check: "ebef",
+	admin_panel_setting: "ef3d",
+	rss_feed: "e0e5",
+	setting: "e8b8",
+	recycling: "e760",
+	key: "e73c",
+	chart_show: "e6e1",
+	trending_up: "e8e5",
+	auto_read_play: "f216",
+	smart_display: "f06a",
+	crown: "ecb3",
+	trophy: "e71a",
+	review: "f054",
+	workspace_premium: "e7af",
+	card_star: "f375",
+	acute: "e4cb",
+	person: "e7fd",
+	event: "e878",
+	date_range: "e916",
+	chronic: "ebb2",
+	sticker: "e707",
+	flash_on: "e3e7",
+	trail_length_short: "eb6d",
+	slide_show: "e41b",
+	bolt: "ea0b",
+	speed: "e9e4",
+	rocket: "eba5",
+	});
+
+Function.owl = function () {}
+Function.owl.carousel = function (element, reference, option) {
+	option = option || {}
+	var padding = option.padding || 0;
+	var setting = {
+		onTranslated: option ["on:translate"] || function () {},
+		gap: (option.gap || 0),
+		loop: (option.loop || false),
+		center: (option.center || false),
+		nav: (option.nav || false), dots: (option ["nav:dot"] || false),
+		autoplay: (option.play === "auto" || option.play || false),
+		margin: (option.margin || 10),
+		autoWidth: (option.width === "auto" || false),
+		stagePadding: (option ["stage:padding"] || 0),
+		autoplayTimeout: (option.timeout || 10000),
+		autoplayHoverPause: true,
+		responsive: option.responsive || Function.owl.carousel ["item:default"],
+		}
+	var el = $ (element).removeClass ("none");
+	if (el) {
+		if (reference) el.width ($ (reference).width () - setting.gap - padding);
+		el.owlCarousel (setting);
+		}
+	}
+
+Function.owl.carousel ["item:default"] = {
+	0: {items: 1},
+	600: {items: 3},
+	1000: {items: 5},
+	}
+
+Function.owl.carousel ["item:pop"] = {
+	0: {items: 2},
+	600: {items: 4},
+	1000: {items: 6},
+	}
+
+Function.owl.carousel ["item:best"] = {
+	0: {items: 1},
+	600: {items: 2},
+	1000: {items: 3},
+	}
+
+Function.owl.carousel ["item:sky"] = {
+	0: {items: 1},
+	600: {items: 3},
+	1000: {items: 4},
+	}
+
+Function.owl.carousel ["wide"] = {
+	0: {items: 1},
+	600: {items: 3},
+	1000: {items: 3},
+	}
+
+Function.owl.carousel ["relation"] = {
+	0: {items: 2},
+	600: {items: 3},
+	1000: {items: 3},
+	}
+
+Function.owl.carousel ["short"] = {
+	0: {items: 2},
+	600: {items: 4},
+	1000: {items: 6},
+	}
+
+Function.owl.carousel ["flash"] = {
+	0: {items: 2},
+	600: {items: 4},
+	1000: {items: 6},
+	}
+
+/**
+ * xxx
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Function.body = function () { Function.body.width = $ ("body").width (); }
+Function.body.css = function () {
+	var type = "phone";
+	var type_of = "mobile";
+	var orientation = "portrait";
+	var body = $ ("body").innerWidth ();
+	if (body > 600) { type = "tablet"; type_of = "mobile"; }
+	if (body > 1000) { type = "computer"; type_of = ""; }
+	if ($ ("body").width () > $ ("body").height ()) orientation = "landscape";
+	if (Function.device.type || Function.device.orientation) {
+		if (Function.device.type === type && Function.device.orientation === orientation) {}
+		else Function.body.css.reset (type, type_of, orientation);
+		}
+	else Function.body.css.reset (type, type_of, orientation);
+	}
+Function.body.css.reset = function (type, type_of, orientation) {
+	$ ("body").removeClass ("computer mobile tablet phone portrait landscape");
+	$ ("body").addClass (Function.device.type = type).addClass (Function.device.orientation = orientation);
+	if (type_of) $ ("body").addClass (Function.device.type_of = type_of);
+	Event.emit ("body:css", type, type_of, orientation);
+	}
+
+Function.device = function () {}
+
+/**
+ * jQuery
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Function.jQuery = function () {
+	$.meta = function () {}
+	$.meta.get = function (meta) {
+		for (var i in meta) {
+			var element = document.querySelector ("meta[" + i + "='" + meta [i] + "']");
+			if (element) return element.content;
+			}
+		}
+	$.element = function () {}
+	$.element.show = function (element) { return Function.element.show (element); }
+	$.element.hide = function (element) { return Function.element.hide (element); }
+	}
+
+Function.element = function () {}
+Function.element.show = function (element) { return $ (element).removeClass ("none").addClass ("flex"); }
+Function.element.hide = function (element) { return $ (element).removeClass ("flex").addClass ("none"); }
+
+/**
+ * xxx
+ *
+ * title
+ * description
+ * sub description
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */
+
+Symbol.export = {
+	define: Object.define, un_define: Object.un_define, un_set: Object.un_set,
+	object: Object, array: Array, string: String, number: Number, function: Function,
+	date: Date, time: Date.time, timeout: Date.timeout, datetime: new Date.io,
+	event: Event, promise: Promise,
+	url: URL, path: Function.path, file: Function.file, dir: Function.dir,
+	db: Function.db, database: Function.database,
+	cookie: Function.cookie, session: Function.session, ls: Function.ls,
+	markup: Function.markup, html: Function.html, css: Function.css, js: Function.js, json: JSON, xml: Function.xml, serialize: Function.serialize,
+	help: Function.help, log: Function.log,
+	hash: Function.hash, unique: Function.unique,
+	socket: Function.socket, ajax: Function.ajax,
+	require: Function.require, base_dir: Function.base_dir,
+	layout: Function.layout, component: Function.component, element: Function.element,
+	google: Function.google,
+	body: Function.body,
+	owl: Function.owl,
+	is: Object.is, parse_url: URL.parse,
+	asset: Function.asset, theme: Function.theme,
+	zero: 0, one: 1,
+	}
+
+var JScript = Symbol.export;
+
+/**
+ * the end
+ *
+ * xxx://xxx.xxx.xxx/xxx
+ */