amateras 0.1.1 → 0.3.0

package/ext/router/node/Router.ts

@@ -0,0 +1,138 @@
+import type { AnchorTarget } from "#html/$Anchor";
+import { _Array_from, _document, _instanceof, _Object_fromEntries, forEach } from "#lib/native";
+import { Page } from "./Page";
+import { BaseRouteNode, Route } from "./Route";
+
+// history index
+let index = 0;
+const _location = location;
+const {origin} = _location;
+const _history = history;
+const documentElement = _document.documentElement;
+const [PUSH, REPLACE] = [1, 2] as const;
+const [FORWARD, BACK] = ['forward', 'back'] as const;
+
+// disable browser scroll restoration
+_history.scrollRestoration = 'manual';
+
+/** convert path string to URL object */
+const toURL = (path: string | URL) => 
+    _instanceof(path, URL) ? path : path.startsWith('http') ? new URL(path) : new URL(path.startsWith(origin) ? path : origin + path);
+
+/** handle history state with push and replace state. */
+const historyHandler = async (path: string | URL | Nullish, mode: 1 | 2, target?: AnchorTarget) => {
+    if (!path) return;
+    const url = toURL(path);
+    if (url.href === _location.href) return;
+    if (target && target !== '_self') return open(url, target);
+    if (url.origin !== origin) return open(url, target);
+    _history.replaceState({
+        index: index,
+        x: documentElement.scrollLeft,
+        y: documentElement.scrollTop
+    }, '', _location.href);
+    if (mode === PUSH) index += 1;
+    Router.direction = FORWARD;
+    history[mode === PUSH ? 'pushState' : 'replaceState']({index}, '' , url)
+    for (let router of Router.routers) router.routes.size && await router.resolve(path)
+}
+
+export class Router extends BaseRouteNode<''> {
+    static pageRouters = new Map<Page, Router>();
+    static routers = new Set<Router>();
+    pageMap = new Map<string, Page>();
+    static direction: 'back' | 'forward' = FORWARD;
+    constructor(page?: Page) {
+        super('', () => [], 'router')
+        Router.routers.add(this);
+        if (page) Router.pageRouters.set(page, this);
+    }
+
+    static open(path: string | URL | Nullish, target?: AnchorTarget) {
+        historyHandler(path, PUSH, target);
+        return this;
+    }
+
+    static back() {
+        _history.back();
+        return this;
+    }
+
+    static forward() {
+        _history.forward();
+        return this;
+    }
+
+    static replace(path: string | URL | Nullish) {
+        historyHandler(path, REPLACE);
+        return this;
+    }
+
+    async resolve(path: string | URL) {
+        const {pathname, searchParams, hash, href} = toURL(path);
+        const routeData = { params: {} as {[key: string]: string}, query: _Object_fromEntries(searchParams) }
+        const split = (p: string) => p.replaceAll(/\/+/g, '/').split('/').map(path => `/${path}`);
+
+        function determineRoute(parentRoute: BaseRouteNode<any>, path: string, hash: string | undefined): [route: Route | null, pathId: string][] {
+            const targetPathSplit = split(path);
+            hash && targetPathSplit.push(hash);
+            if (!parentRoute.routes.size) return [];
+            routeLoop: for (const route of _Array_from(parentRoute.routes.values()).sort((a, b) => b.path.length - a.path.length)) {
+                const routePathSplit = split(route.path);
+                let pathId = '';
+                splitLoop: for (let i = 0; i < routePathSplit.length; i++) {
+                    const pass = () => pathId += targetSnippet;
+                    const [routeSnippet, targetSnippet] = [routePathSplit[i], targetPathSplit[i]];
+                    if (!routeSnippet || !targetSnippet) continue routeLoop;
+                    // process params in path
+                    if (routeSnippet.includes(':')) {
+                        if (targetSnippet === '/') continue routeLoop;
+                        const [prefix, paramName] = routeSnippet.split(':') as [string, string];
+                        if (!targetSnippet.startsWith(prefix)) continue routeLoop;
+                        routeData.params[paramName] = targetSnippet.replace(`${prefix}`, '');
+                        pass();
+                        continue splitLoop;
+                    }
+                    if (routeSnippet === '/' && route.routes.size) continue splitLoop;
+                    if (routeSnippet !== targetSnippet) continue routeLoop;
+                    pass()
+                }
+                return [[route, pathId], ...determineRoute(route, path, hash)];
+            }
+            return [[null, parentRoute.path + '$$NOT_FOUND$$']];
+        }
+        // analytics
+        const targetRoutes = determineRoute(this, pathname + '/', hash);
+        // build pages
+        let prevPage: null | Page = null, prevRoute: BaseRouteNode<any> = this;
+        for (const [route, pathId] of targetRoutes) {
+            const page = this.pageMap.get(pathId) ?? new Page(route ?? prevRoute.routes.get('404') ?? new Route('404', () => null), routeData);
+            await route?.build(routeData, page);
+            _document && (_document.title = page.pageTitle() ?? _document.title);
+            this.pageMap.set(pathId, page);
+
+            if (href === _location.href) {
+                if (prevPage) Router.pageRouters.get(prevPage)?.content(page);
+                else this.content(page);
+            }
+            prevPage = page;
+            if (route) prevRoute = route;
+        }
+        let { x, y } = _history.state ?? {x: 0, y: 0};
+        scrollTo(x, y);
+        return this;
+    }
+
+    listen() {
+        const resolve = () => {
+            const stateIndex = _history.state?.index ?? 0;
+            if (index > stateIndex) Router.direction = BACK;
+            if (index < stateIndex) Router.direction = FORWARD;
+            index = stateIndex;
+            this.resolve(_location.href);
+        }
+        addEventListener('popstate', resolve);
+        resolve();
+        return this;
+    }
+}

package/ext/router/node/RouterAnchor.ts

@@ -0,0 +1,8 @@
+import { $Anchor } from "#html/$Anchor";
+
+export class RouterAnchor extends $Anchor {
+    constructor() {
+        super();
+        this.on('click', e => { e.preventDefault(); $.open(this.href(), this.target()) })
+    }
+}

package/ext/ssr/env.ts

@@ -0,0 +1,61 @@
+import { NODE } from "esm-env";
+import { _Array_from, _Object_assign, _Object_entries, isNull } from "../../src/lib/native";
+import type { $Node } from "../../src/node/$Node";
+
+if (NODE) {
+    //@ts-expect-error
+    global.window = undefined;
+    //@ts-expect-error
+    global.document = undefined;
+    //@ts-expect-error
+    global.Node = class Node {
+        nodeName: string;
+        attributes = {};
+        childNodes = new Set<Node>();
+        parent?: Node;
+        $!: $Node;
+        constructor(nodeName: string) {
+            this.nodeName = nodeName.toUpperCase();
+        }
+        get textContent() { return _Array_from(this.childNodes.values()).map(node => node.textContent).join() }
+        set textContent(content: string | null) { 
+            this.childNodes.clear();
+            content && this.childNodes.add(new Text(content) as unknown as Node);
+        }
+        appendChild(node: Node) {
+            if (this.childNodes.has(node)) this.childNodes.delete(node);
+            this.childNodes.add(node);
+            node.parent = this;
+        }
+        addEventListener(type: string, cb: () => void) { }
+        setAttribute(key: string, value: string) { _Object_assign(this.attributes, {[key]: value}) }
+        remove() {
+            this.parent?.removeChild(this);
+        }
+        removeChild(node: Node) {
+            this.childNodes.delete(node);
+        }
+
+        get outerHTML() {
+            const attr = _Object_entries(this.attributes).map(([key, value]) => `${key}="${value}"`).join(' ');
+            const tagName = this.nodeName.toLowerCase();
+            const IS_VOID_ELEMENT = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'].includes(tagName);
+            return `<${tagName}${attr ? ` ${attr}` : ''}>${_Array_from(this.childNodes).map(node => `${node.$}`).join('')}${IS_VOID_ELEMENT && !this.childNodes.size ? '' : `</${tagName}>`}`;
+        }
+    }
+    //@ts-expect-error
+    global.Element = class Element {}
+    //@ts-expect-error
+    global.HTMLElement = class HTMLElement {}
+    //@ts-expect-error
+    global.Text = class Text {
+        textContent: string;
+        $: this;
+        constructor(textContent: string) {
+            this.textContent = textContent;
+            this.$ = this;
+        }
+
+        toString() { return this.textContent }
+    }
+}

package/ext/ssr/index.ts

@@ -0,0 +1,47 @@
+import './env';
+import 'amateras';
+import { _Array_from, _document, _instanceof, _Object_assign, _Object_defineProperty, forEach } from "amateras/lib/native";
+import { $Element, $Node, $Text } from "amateras/node";
+import { BROWSER, NODE } from 'esm-env';
+
+declare module 'amateras/core' {
+    export namespace $ {
+        export function mount(id: string, $node: $Element): void;
+        export function serverSide(cb: () => any): void;
+    }
+}
+
+export function onserver<T>(cb: () => T): T | '' {
+    if (NODE) return cb();
+    return '';
+}
+
+export function onclient<T>(cb: () => T): T | undefined {
+    if (BROWSER) return cb();
+    return;
+}
+
+_Object_assign($, {
+    mount(id: string, $node: $Element) {
+        if (!BROWSER) return;
+        const node = _document.querySelector(`#${id}`);
+        if (!node) throw 'Target node of mounting not found';
+        getData(node, $node);
+        node.replaceWith($node.node);
+    
+        function getData(node: Node, $node: $Node) {
+            if (node.nodeName === 'SIGNAL' && _instanceof(node, Element) && _instanceof($node, $Text)) {
+                const type = $(node).attr()['type'];
+                return forEach($node.signals, signal => signal.value(type === 'number' ? Number(node.textContent) : type === 'boolean' ? node.textContent == 'true' ? true : false : node.textContent));
+            }
+            if (_instanceof(node, Text)) return $node.textContent(node.textContent);
+            if (_instanceof(node, Element) && _instanceof($node, $Element)) $node.attr($(node).attr());
+            const arr = _Array_from($node.childNodes);
+            forEach(node.childNodes, (_node, i) => {
+                const targetChildNode = arr.at(i);
+                if (!targetChildNode) throw 'Target DOM tree not matched';
+                getData(_node, targetChildNode.$)
+            })
+        }
+    }
+})

package/ext/ssr/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "@amateras/ssr",
+    "peerDependencies": {
+        "amateras": "../../",
+        "esm-env": "^1.2.2"
+    },
+    "imports": {
+        "#structure/*": "./src/structure/*.ts"
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amateras",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Amateras is a DOM Utility library.",
   "module": "index.ts",
   "type": "module",
@@ -20,8 +20,7 @@
     "#lib/*": "./src/lib/*.ts",
     "#structure/*": "./src/structure/*.ts",
     "#html": "./ext/html/html.ts",
-    "#css": "./ext/css/css.ts",
-    "#css/*": "./ext/css/*.ts"
+    "#html/*": "./ext/html/node/*.ts"
   },
   "exports": {
     ".": "./src/index.ts",
@@ -31,7 +30,12 @@
     "./lib/*": "./src/lib/*.ts",
     "./structure/*": "./src/structure/*.ts",
     "./html": "./ext/html/html.ts",
-    "./css": "./ext/css/src/index.ts"
+    "./html/*": "./ext/html/node/*.ts",
+    "./css": "./ext/css/src/index.ts",
+    "./css/colors": "./ext/css/src/lib/colors.ts",
+    "./css/color/*": "./ext/css/src/lib/colors/*.ts",
+    "./router": "./ext/router/index.ts",
+    "./ssr": "./ext/ssr/index.ts"
   },
   "workspaces": [
     "./ext/*"

package/src/core.ts

@@ -1,46 +1,56 @@
 import './global';
 import { Signal } from "#structure/Signal";
-import { $Element } from "#node/$Element";
-import { $Node, type $NodeContentTypes } from '#node/$Node';
+import { $Element, type $Event } from "#node/$Element";
+import { $Node, type $NodeContentResolver, type $NodeContentTypes } from '#node/$Node';
 import '#node/node';
-import { _instanceof, _Object_defineProperty, _Object_entries, isFunction, isObject, isString, isUndefined } from '#lib/native';
+import { _instanceof, isString, isFunction, _Object_assign, isObject, isNull, _Object_entries, _Object_defineProperty, forEach, isNumber, _Array_from, _document } from '#lib/native';
+import type { $HTMLElement } from '#node/$HTMLElement';
 
-const tagNameMap: {[key: string]: Constructor<$Node>} = {}
-export function $<K extends (...args: any[]) => $Node>(fn: K, ...args: Parameters<K>): ReturnType<K>;
-export function $<K extends $NodeContentTypes | undefined | void, F extends () => K, P extends Parameters<F>>(fn: F, ...args: any[]): K;
-export function $<K extends $Node, T extends Constructor<K>, P extends ConstructorParameters<T>>(construct: T, ...args: P): K;
+const nodeNameMap: {[key: string]: Constructor<$Node>} = {}
+
+export function $<F extends (...args: any[]) => $NodeContentResolver<$Node>, N extends number>(number: N, fn: F, ...args: Parameters<F>): Repeat<ReturnType<F>, N>;
+export function $<F extends (...args: any[]) => $NodeContentResolver<$Node>>(fn: F, ...args: Parameters<F>): ReturnType<F>;
+export function $<T extends Constructor<$Node>, P extends ConstructorParameters<T>, N extends number>(number: N, construct: T, ...args: P): Repeat<InstanceType<T>, N>;
+export function $<T extends Constructor<$Node>, P extends ConstructorParameters<T>>(construct: T, ...args: P): InstanceType<T>;
+export function $<N extends $Node>($node: N, ...args: any[]): N;
+export function $<H extends HTMLElement>(element: H, ...args: any[]): $HTMLElement<H>;
+export function $<E extends Element>(element: E, ...args: any[]): $Element<E>;
 export function $<K extends TemplateStringsArray>(string: K, ...values: any[]): $NodeContentTypes[];
-export function $<K extends $Node>($node: K): K;
-export function $<K extends Element>(element: K): $Element<K>;
-export function $<K extends keyof HTMLElementTagNameMap>(tagname: K): $Element<HTMLElementTagNameMap[K]>
-export function $(tagname: string): $Element<HTMLElement>
-export function $(resolver: string | HTMLElement | $Node | Function | TemplateStringsArray, ...args: any[]) {
+export function $<K extends keyof HTMLElementTagNameMap, N extends number>(number: N, tagname: K): Repeat<$HTMLElement<HTMLElementTagNameMap[K]>, N>;
+export function $<K extends keyof HTMLElementTagNameMap>(tagname: K): $HTMLElement<HTMLElementTagNameMap[K]>;
+export function $<Ev extends $Event<$Element, Event>>(event: Ev): Ev['target']['$'];
+export function $<N extends number>(number: N, tagname: string): Repeat<$HTMLElement<HTMLElement>, N>;
+export function $(tagname: string): $HTMLElement<HTMLElement>
+export function $(resolver: string | number | Element | $Node | Function | TemplateStringsArray | Event, ...args: any[]) {
     if (_instanceof(resolver, $Node)) return resolver;
-    if (isString(resolver) && tagNameMap[resolver]) return new tagNameMap[resolver]();
+    if (isString(resolver) && nodeNameMap[resolver]) return new nodeNameMap[resolver](...args);
     if (isFunction(resolver)) 
-        if (resolver.prototype?.constructor) return resolver.prototype.constructor(...args); 
+        if (resolver.prototype?.constructor) return new resolver.prototype.constructor(...args); 
         else return resolver(...args);
     if (resolver instanceof Array) {
         const iterate = args.values();
         return resolver.map(str => [str ?? undefined, iterate.next().value]).flat().filter(item => item);
     }
     if (_instanceof(resolver, Node) && _instanceof(resolver.$, $Node)) return resolver.$;
+    if (_instanceof(resolver, Event)) return $(resolver.currentTarget as Element);
+    if (isNumber(resolver)) return _Array_from({length: resolver}).map(_ => $(args[0], ...args.slice(1)));
     return new $Element(resolver);
 }
 
 export namespace $ {
+    export const stylesheet = new CSSStyleSheet();
+    _document.adoptedStyleSheets.push(stylesheet);
     type SignalProcess<T> = T extends Array<any> ? {} : T extends object ? { [key in keyof T as `${string & key}$`]: SignalFunction<T[key]> } : {};
-    export type SignalFunction<T> = ({(value: ((newValue: T) => T) | T): SignalFunction<T>, (): T}) & { signal: Signal<T> } & SignalProcess<T>;
+    export type SignalFunction<T> = {signal: Signal<T>, set: (newValue: T | ((oldValue: T) => T)) => SignalFunction<T>} & (() => T) & SignalProcess<T>;
     export function signal<T>(value: T): SignalFunction<T>
     export function signal<T>(value: T) {
         const signal = new Signal<T>(value);
-        const signalFn = function (newValue?: T) {
-            if (!arguments.length) return signal.value();
-            if (!isUndefined(newValue)) signal.value(newValue);
-            return signalFn;
-        }
-        _Object_defineProperty(signalFn, 'signal', { value: signal });
-        if (isObject(value)) {
+        const signalFn = function () { return signal.value(); }
+        _Object_assign(signalFn, {
+            signal,
+            set(newValue: T) { return signal.value(newValue), signalFn; }
+        })
+        if (isObject(value) && !isNull(value)) {
             for (const [key, val] of _Object_entries(value)) {
                 const val$ = $.signal(val);
                 val$.signal.subscribe(newValue => { value[key as keyof typeof value] = newValue; signal.emit() });
@@ -53,14 +63,14 @@ export namespace $ {
     export type ComputeFunction<T> = ({(): T}) & { signal: Signal<T> };
     export function compute<T>(process: () => T) {
         let subscribed = false;
-        const signalFn: SignalFunction<any> = $.signal(null);
+        const signalFn: SignalFunction<any> = signal(null);
         function computeFn() {
-            if (!subscribed) return signalFn(subscribe())();
-            else return signalFn(process())();
+            if (!subscribed) return signalFn.set(subscribe())();
+            else return signalFn.set(process())();
         }
         function subscribe () {
             const signalHandler = (signal: Signal<any>) => { 
-                signal.subscribe(() => signalFn(process())) 
+                signal.subscribe(() => signalFn.set(process())) 
             }
             Signal.listeners.add(signalHandler);
             const result = process();
@@ -68,16 +78,19 @@ export namespace $ {
             subscribed = true;
             return result;
         }
-        _Object_defineProperty(computeFn, 'signal', { value: signalFn.signal });
+        _Object_assign(computeFn, { signal: signalFn.signal });
         return computeFn as ComputeFunction<T>
     }
 
-    export function registerTagName(tagname: string, $node: Constructor<$Node>) {
-        tagNameMap[tagname] = $node;
+    export function assign(resolver: [nodeName: string, $node: Constructor<$Node>][]): void;
+    export function assign(nodeName: string, $node: Constructor<$Node>): void;
+    export function assign(resolver: string | [nodeName: string, $node: Constructor<$Node>][], $node?: Constructor<$Node>) {
+        if (isString(resolver)) $node && (nodeNameMap[resolver] = $node);
+        else forEach(resolver, ([nodeName, $node]) => nodeNameMap[nodeName] = $node);
         return $;
     }
 
-    export function orArrayResolver<T>(item: OrArray<T>): T[] {
+    export function toArray<T>(item: OrArray<T>): T[] {
         return _instanceof(item, Array) ? item : [item];
     }
 

package/src/global.ts

@@ -1,6 +1,7 @@
 import type { $Element } from '#node/$Element';
 import type { $Node } from '#node/$Node';
 import * as core from '#core';
+import type { Signal } from '#structure/Signal';
 
 declare global {
     export import $ = core.$;
@@ -10,6 +11,11 @@ declare global {
     type OrPromise<T> = T | Promise<T>;
     type OrNullish<T> = T | Nullish;
     type Constructor<T> = { new (...args: any[]): T }
+    type $Parameter<T> = T | undefined | Signal<T> | Signal<T | undefined>
+    type Repeat<T, N extends number, Acc extends T[] = []> = 
+        Acc['length'] extends N 
+            ? Acc 
+            : Repeat<T, N, [...Acc, T]>;
     type Prettify<T> = {
         [K in keyof T]: T[K];
     } & {};

package/src/lib/assign.ts

@@ -6,17 +6,18 @@ export function assign(target: any, {set, get, fn}: {
     get?: string[], 
     fn?: string[]
 }) {
+    const [GET, SET, FN] = ['get', 'set', 'fn'] as const;
     const filterAndMap = (type: 'get' | 'set' | 'fn', arr: string[] | undefined) => {
         return arr?.map(prop => [type, prop]) ?? []
     }
-    const list = [...filterAndMap('get', get), ...filterAndMap('set', set), ...filterAndMap('fn', fn)] as [string, string][];
+    const list = [...filterAndMap(GET, get), ...filterAndMap(SET, set), ...filterAndMap(FN, fn)] as [string, string][];
     for (const [type, prop] of list) {
         _Object_defineProperty(target.prototype, prop, {
-            ...(type === 'get' ? {
+            ...(type === GET ? {
                 get() { return this.node[prop as any] }
             } : {
                 writable: true,
-                ...(type === 'set' ? {
+                ...(type === SET ? {
                     // set
                     value: function (this, args: any) {
                         if (!arguments.length) return this.node[prop];

package/src/lib/assignHelper.ts

@@ -2,18 +2,16 @@ import type { $Node } from "#node/$Node";
 import { assign } from "./assign";
 import { _Object_entries, _Object_getOwnPropertyDescriptors } from "./native";
 
-export function assignHelper(targets: [object: Constructor<Node>, target: Constructor<$Node>, tagname?: string][]) {
-    for (const [object, target, tagname] of targets) {
-        const {set, get, fn} = { set: [] as string[], get: [] as string[], fn: [] as string[] }
-        // assign native object properties to target
-        for (const [prop, value] of _Object_entries(_Object_getOwnPropertyDescriptors(object.prototype))) {
-            if (prop in target.prototype) continue;
-            if (value.get && !value.set) get.push(prop);
-            else if (value.value) fn.push(prop);
-            else if (value.get && value.set) set.push(prop);
-        }
-        assign(target, {set, get, fn})
-        // register tagname
-        if (tagname) $.registerTagName(tagname, target)
+export function assignHelper(object: Constructor<Node>, target: Constructor<$Node>, tagname?: string) {
+    const [set, get, fn] = [[], [], []] as [string[], string[], string[]]
+    // assign native object properties to target
+    for (const [prop, value] of _Object_entries(_Object_getOwnPropertyDescriptors(object.prototype))) {
+        if (prop in target.prototype) continue;
+        if (value.get && !value.set) get.push(prop);
+        else if (value.value) fn.push(prop);
+        else if (value.get && value.set) set.push(prop);
     }
+    assign(target, {set, get, fn})
+    // register tagname
+    if (tagname) $.assign(tagname, target)
 }

package/src/lib/native.ts

@@ -1,3 +1,5 @@
+// document
+export const _document = document;
 // Object
 export const _Object_fromEntries = Object.fromEntries;
 export const _Object_entries = Object.entries;
@@ -7,6 +9,13 @@ export const _Object_defineProperty = Object.defineProperty;
 export const _Object_getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
 // Array
 export const _Array_from = Array.from;
+export function forEach<N extends Node>(set: NodeListOf<N>, fn: (value: N, index: number, parent: NodeListOf<N>) => any, thisArgs?: any): void;
+export function forEach<K, V>(set: Map<K, V>, fn: (value: V, key: K, index: number, map: Map<K, V>) => any, thisArgs?: any): void;
+export function forEach<T>(set: Set<T>, fn: (value: T, index: number, set: Set<T>) => any, thisArgs?: any): void;
+export function forEach<T>(arr: Array<T>, fn: (value: T, index: number, array: Array<T>) => any, thisArgs?: any): void;
+export function forEach<T>(arr: any, fn: any, thisArgs?: any) {
+    arr.forEach(fn, thisArgs)
+}
 // typeof
 export function _typeof(target: any, type: 'string' | 'number' | 'object' | 'boolean' | 'function' | 'bigint' | 'symbol' | 'undefined') {
     return typeof target === type;
@@ -29,6 +38,8 @@ export function isUndefined(target: any): target is undefined {
 export function isNull(target: any): target is null {
     return target === null;
 }
-export function _instanceof<T>(target: any, instance: abstract new (...args: any[]) => T): target is T {
-    return target instanceof instance;
-}
+export function _instanceof<T extends (abstract new (...args: any[]) => any)[]>(target: any, ...instance: T): target is InstanceType<T[number]> {
+    return !!instance.find(i => target instanceof i);
+}
+// JSON
+export const _JSON_stringify = JSON.stringify;