amotify 0.0.0

package/dist/@types/fn.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/@types/index.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="react" />
+declare global {
+    type ReactElement = React.ReactNode | React.ReactNode[];
+    type React = typeof React;
+    type FNC<P> = React.FC<P>;
+    interface plainObject {
+        [index: string]: any;
+    }
+    namespace amotify {
+        type ToneTypes = 'default' | 'flat' | 'sharp';
+        type DarkModeTypes = 'light' | 'auto' | 'dark' | 'dim';
+        type ThemeColorTypes = 'comun' | 'leaf' | 'heart' | 'droplet' | 'brick' | 'flower' | 'lip' | 'wine' | 'theater' | 'bat' | 'poizon' | 'eggplant' | 'ufo' | 'alien' | 'tombstone' | 'ninja' | 'moon' | 'rain' | 'unicorn' | 'axe' | 'gem' | 'soap' | 'drizzle' | 'building' | 'fish' | 'icicles' | 'water' | 'tree1' | 'tree2' | 'tree3' | 'battery' | 'seedle' | 'greenTea' | 'oak' | 'salad' | 'cloudy' | 'lemon' | 'angel' | 'parasol' | 'pizza' | 'thunder' | 'latte' | 'island' | 'shovel' | 'coffee' | 'carrot' | 'cactus' | 'volcano' | 'choco' | 'industry' | 'gun' | 'galaxy' | 'line' | 'twitter' | 'amazon' | 'facebook' | 'android' | 'slackBlue' | 'slackGreen' | 'slackRed' | 'slackYellow' | 'slackBase' | 'googleBlue' | 'googleGreen' | 'googleYellow' | 'googleRed';
+        type RoundnessTypes = 0 | 1 | 2 | 3 | 4 | 5;
+    }
+    interface amotify {
+        config: {
+            version: string;
+            tone: amotify.ToneTypes;
+            themeColor: amotify.ThemeColorTypes;
+            darkMode: amotify.DarkModeTypes;
+            roundness: amotify.RoundnessTypes;
+            device: {
+                isWhat: 'Windows' | 'Android' | 'iPhone' | 'iPad' | 'macOSX' | 'undefined';
+                isBreakpoint(): boolean;
+                isPhonepoint(): boolean;
+                isSystemDarkmode(): boolean;
+                isPhone: boolean;
+                isTouchDevice: boolean;
+                isIOS: boolean;
+            };
+            update: {
+                tone(value: amotify.ToneTypes): void;
+                themeColor(value: amotify.ThemeColorTypes): void;
+                darkMode(value: amotify.DarkModeTypes): void;
+                roundness(value: amotify.RoundnessTypes): void;
+            };
+            readExtraCDN(url: string): Promise<boolean>;
+        };
+        glob: amotify.glob.Methods;
+        atoms: amotify.atoms.Methods;
+        mols: amotify.mols.Methods;
+        orgs: amotify.orgs.Methods;
+        temps: amotify.temps.Methods;
+        fn: amotify.fn.Methods;
+    }
+    var amotify: amotify;
+    namespace _WebSocket {
+        interface Methods {
+            emit(path: string, data: any): _WebSocket.Methods;
+            on(path: string, data: {
+                (data: any): void;
+            }): _WebSocket.Methods;
+        }
+    }
+    var io: {
+        (url: string): _WebSocket.Methods;
+    };
+}
+export {};

package/dist/@types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/@types/jsminAmotifyExtension.d.ts

@@ -0,0 +1,134 @@
+/// <reference types="react" />
+export {};
+declare global {
+    interface JsminExtension {
+        fetch: {
+            get: JsminExtension.Fetch.CoreParams;
+            post: JsminExtension.Fetch.CoreParams;
+            put: JsminExtension.Fetch.CoreParams;
+            options: JsminExtension.Fetch.CoreParams;
+            waitList: string[];
+            defaultHeaders: plainObject;
+            defaultResultCallback?: {
+                (params: Jsmin.Fetch.Output): void;
+            };
+        };
+    }
+    namespace JsminExtension {
+        namespace Fetch {
+            type CoreParams = {
+                (params: JsminExtension.Fetch.Input, callback?: JsminExtension.Fetch.callback): Promise<Jsmin.Fetch.Output>;
+            };
+            type Input = {
+                key: string;
+                topLoader?: boolean;
+                cornerLoader?: boolean;
+                trafficControl?: number;
+                preventMultiRequest?: boolean;
+            } & Omit<Jsmin.Fetch.Input, 'method'>;
+            type callback = {
+                (result: Jsmin.Fetch.Output): void;
+            };
+        }
+    }
+    interface JsminExtension {
+        spreadSheet: {
+            readFromFile(file: amotify.fn.Input.Filer.CustomFile): Promise<JsminExtension.SpreadSheet.Method>;
+            readFromJson(v: JsminExtension.SpreadSheet.JsonTypes): Promise<JsminExtension.SpreadSheet.Method>;
+        };
+    }
+    namespace JsminExtension {
+        namespace SpreadSheet {
+            interface Instance {
+                fn: Method;
+                prototype: Method;
+                (v: any, a: string): any;
+            }
+            interface Method {
+                getWorkbook(): any;
+                updateFileName(fileName: string): void;
+                updateMerges(merges: MergeTypes[][]): void;
+                updateStyles(styles: StyleTypes[][]): void;
+                toJson(): {
+                    fileName: string;
+                    sheets: {
+                        sheetName: string;
+                        rows: any[];
+                    }[];
+                };
+                export(type?: 'xlsx' | 'csv'): void;
+            }
+            type JsonTypes = {
+                fileName: string;
+                sheets: SheetParams[];
+            };
+            type SheetParams = {
+                sheetName: string;
+                rows: RowParams[];
+                headers?: HeaderParams[];
+                merges?: MergeTypes[];
+                styles?: StyleTypes[];
+            };
+            type HeaderParams = {
+                key: string;
+                value: string;
+            };
+            type RowParams = {
+                [key: string]: string | number;
+            };
+            type MergeTypes = [string, string] | [null, null];
+            type StyleTypes = {
+                type: 'cell' | 'row' | 'column';
+                target: string | number | (string | number)[];
+                values: {
+                    [key: string]: any;
+                };
+            };
+        }
+    }
+    interface JsminExtension {
+        formCollect(form: string): Promise<{
+            valid: boolean;
+            data: plainObject;
+        }>;
+        NoticeHttpStatus(params: {
+            status: number;
+            statusText: string;
+            label: ReactElement;
+        } & amotify.fn.SnackBar.AddParams): void;
+        copyToClipboard(data: any): Promise<{
+            ok: boolean;
+            body: any;
+        }>;
+        getCurrentLocation: {
+            (): Promise<JsminExtension.getCurrentLocationOutput>;
+        };
+        CDNReader: {
+            (url: string): void;
+        };
+        ImageLoader: {
+            (dataUrl: string, img?: HTMLImageElement): Promise<HTMLImageElement>;
+        };
+        isJSXElement(v: any): v is JSX.Element;
+    }
+    namespace JsminExtension {
+        type getCurrentLocationOutput = {
+            ok: false;
+            status: number;
+            body: {
+                reason: any;
+            };
+        } | {
+            ok: true;
+            status: 200;
+            body: {
+                lat: number;
+                lng: number;
+            };
+        };
+    }
+    type base64ToBlobTypeProps = 'image/png' | 'image/jpeg' | string;
+    interface String {
+        zen2hanNumber(): string;
+    }
+}

package/dist/@types/jsminAmotifyExtension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/@types/module.d.ts

@@ -0,0 +1,2 @@
+declare module "*.scss";
+declare module "react-dom";

package/dist/@types/module.js

@@ -0,0 +1 @@
+"use strict";

package/dist/@types/state.d.ts

@@ -0,0 +1,145 @@
+/// <reference types="react" />
+export {};
+declare global {
+    type amotifyBasicElement = amotify.UniStyles.BasicTagParams & amotifyUniStyleParams;
+    type amotifyUniStyleParams = amotify.UniStyles.Params & {
+        freeCSS?: React.CSSProperties;
+        UnderBreakPointStyles?: amotify.UniStyles.Params;
+        hoverStyles?: amotify.UniStyles.Params;
+        focusStyles?: amotify.UniStyles.Params;
+        activeStyles?: amotify.UniStyles.Params;
+        ssEffectsOnActive?: amotify.UniStyles.Others.EffectsOnActiveTypes | amotify.UniStyles.Others.EffectsOnActiveTypes[] | false;
+        ssPushable?: boolean;
+        ssLastChildLossBorder?: 'bottom' | 'right' | false;
+    };
+    namespace amotify {
+        namespace UniStyles {
+            type BasicTagParams = {
+                className?: string;
+                id?: string;
+                componentID?: string;
+            };
+            type Params = Pargins.Params & Fonts.Params & Borders.Params & FlexGrids.Params & Sizes.Params & StyleSets.Params & {
+                backgroundColor?: Others.BackgroundColorParams;
+                gradients?: {
+                    deg: number;
+                    colors: string[];
+                };
+                boxShadow?: 0 | 1 | 2 | 3 | 4 | -1 | -2 | -3 | 'none' | 'borderBox';
+                display?: 'block' | 'none' | 'flex' | 'grid' | 'inlineBlock' | 'inlineFlex';
+                gap?: Others.gapParams;
+                overflow?: Others.overflowParams;
+                position?: 'relative' | 'absolute' | 'fixed' | 'sticky' | 'static';
+                top?: Others.TRBLParams | 'topBase' | 'topNavigationHeight';
+                right?: Others.TRBLParams;
+                bottom?: Others.TRBLParams;
+                left?: Others.TRBLParams;
+                opacity?: 'trans' | 'low' | 'middle' | 'high' | 'most';
+                transition?: 'none' | 'short' | 'middle' | 'long';
+            };
+            namespace Pargins {
+                type Params = {
+                    margin?: GroupParams;
+                    marginTop?: UnitParams;
+                    marginRight?: UnitParams;
+                    marginBottom?: UnitParams;
+                    marginLeft?: UnitParams;
+                    padding?: GroupParams;
+                    paddingTop?: UnitParams;
+                    paddingRight?: UnitParams;
+                    paddingBottom?: UnitParams;
+                    paddingLeft?: UnitParams;
+                };
+                type UnitParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 1.5 | 2 | 2.5 | 3 | 4 | 'auto' | 'safeAreaTop' | 'safeAreaBottom';
+                type GroupParams = UnitParams | [UnitParams, UnitParams] | [UnitParams, UnitParams, UnitParams, UnitParams];
+            }
+            namespace Borders {
+                type Params = {
+                    border?: BorderParams;
+                    borderTop?: BorderParams;
+                    borderRight?: BorderParams;
+                    borderBottom?: BorderParams;
+                    borderLeft?: BorderParams;
+                    borderWidth?: WidthParams;
+                    borderColor?: ColorParams;
+                    borderStyle?: StyleParams;
+                    borderRadius?: RadiusParams;
+                    borderTopLeftRadius?: RadiusParams;
+                    borderTopRightRadius?: RadiusParams;
+                    borderBottomLeftRadius?: RadiusParams;
+                    borderBottomRightRadius?: RadiusParams;
+                };
+                type BorderParams = boolean | '0.trans' | '1.thin' | '2.normal' | '3.strong' | 'unset';
+                type WidthParams = 0 | 1 | 2 | 3 | 4;
+                type ColorParams = '0.trans' | '1.thin' | '2.normal' | '3.strong' | 'theme' | 'posi' | 'nega' | 'warn' | 'white';
+                type StyleParams = 'solid' | 'dashed' | 'double' | 'dotted';
+                type RadiusParams = 0 | '1/3' | '2/3' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 'sphere' | 'inherit' | '1.tone.primary' | '2.tone.secondary' | '3.tone.tertiary';
+            }
+            namespace FlexGrids {
+                type Params = {
+                    flexSizing?: 'none' | 'auto' | 0;
+                    flexWrap?: boolean;
+                    flexCenter?: boolean;
+                    flexType?: TypeParams;
+                    flexChilds?: 'even' | 'auto' | 'none' | 'unset';
+                    flexGrid?: GridParams;
+                    flexNewLine?: boolean;
+                    verticalAlign?: VerticalAlignParams;
+                    horizontalAlign?: HorizontalAlignParams;
+                    gridCenter?: boolean;
+                    gridCols?: GridColsParams;
+                };
+                type TypeParams = 'row' | 'row-r' | 'col' | 'col-r';
+                type VerticalAlignParams = 'center' | 'top' | 'bottom' | 'baseline' | 'unset';
+                type HorizontalAlignParams = 'center' | 'left' | 'right' | 'between' | 'around' | 'even' | 'unset';
+                type GridParams = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'unset';
+                type GridColsParams = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+            }
+            namespace Fonts {
+                type Params = {
+                    fontColor?: ColorParams;
+                    fontSize?: SizeParams;
+                    fontWeight?: WeightParams;
+                    isBoldFont?: boolean;
+                    isRounded?: boolean;
+                    textAlign?: 'left' | 'center' | 'right';
+                };
+                type WeightParams = '1.lighter' | '2.normal' | '3.bold';
+                type ColorParams = Others.UniColors | '1.clear' | '2.normal' | '3.blur' | '4.thin' | '5.translucent' | '6.clear' | 'mono' | 'monoSecond' | 'logo';
+                type SizeParams = '0.xs' | '1.mini' | '2.normal' | '3.paragraph' | '4.thirdTitle' | '5.subTitle' | '6.title' | '7.landing' | '8.xl' | 'inherit';
+            }
+            namespace Sizes {
+                type Params = {
+                    maxHeight?: 0 | 1 | 'viewHeight' | 'topNavigationHeight' | 'sideNavigationHeight' | 'contentHeight' | 'unset';
+                    minHeight?: 0 | 1 | 'viewHeight' | 'topNavigationHeight' | 'sideNavigationHeight' | 'contentHeight' | 'unset';
+                    minWidth?: 0 | 1 | 'unset';
+                    maxWidth?: 0 | 1 | 'unset';
+                    unitWidth?: SizeParams;
+                    unitHeight?: SizeParams;
+                    width?: 0 | 1 | 'viewWidth' | 'auto';
+                    height?: 0 | 1 | 'viewHeight' | 'topNavigationHeight' | 'sideNavigationHeight' | 'contentHeight' | 'auto';
+                };
+                type SizeParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 6 | 8 | 12 | 'unset';
+            }
+            namespace StyleSets {
+                type Params = {
+                    ssCardBox?: boolean | 'border' | 'layer' | 'cloud' | 'shadow';
+                    ssSphere?: Sizes.SizeParams;
+                    ssSquare?: Sizes.SizeParams;
+                    ssAbsoluteCovered?: boolean;
+                    ssTextEllipsis?: boolean;
+                };
+            }
+            namespace Others {
+                type gapUnitParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 1.5 | 2 | 2.5 | 3 | 4;
+                type gapParams = gapUnitParams | [gapUnitParams, gapUnitParams];
+                type overflowUnitParams = 'auto' | 'hidden' | 'scroll' | 'visible' | 'unset';
+                type overflowParams = overflowUnitParams | [overflowUnitParams, overflowUnitParams];
+                type UniColors = 'inherit' | 'theme' | 'posi' | 'nega' | 'warn' | 'white' | 'black' | amotify.ThemeColorTypes;
+                type BackgroundColorParams = UniColors | '1.layer.base' | '2.layer.cloud' | '3.layer.canvas' | '4.layer.darken' | '5.layer.darker' | '6.layer.darkest' | 'cloud' | 'lcOpFew' | 'lcOpLow' | 'lcOpMiddle' | 'lcOpHigh' | 'tcOpFew' | 'tcOpLow' | 'tcOpMiddle' | 'tcOpHigh' | 'tcLighten' | 'tcLighter' | 'tcLightest' | 'tcDarken' | 'tcDarker' | 'tcDarkest' | 'negaOpLow' | 'negaOpMiddle' | 'posiOpLow' | 'posiOpMiddle' | 'trans' | 'dark' | 'monoPrime' | 'monoSecond' | 'none';
+                type TRBLParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 2 | 3 | 4 | '50%' | '100%';
+                type EffectsOnActiveTypes = 'ripple.white' | 'ripple.cloud' | 'ripple.theme' | 'none' | 'expand' | 'shrink' | 'pudding' | 'fade';
+            }
+        }
+    }
+}

package/dist/@types/state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/launch.d.ts

@@ -0,0 +1,3 @@
+import 'jsmin-front/dist/@types';
+import './@types/_';
+import './@comps/@core/exe';

package/dist/launch.js

@@ -0,0 +1,282 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var e_1, _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+require("jsmin-front/dist/@types");
+require("./@types/_");
+if (!global.$)
+    console.log("%c\u203Bcan not find global.$,please read Jsmin to launch amotify.", 'color:orange;');
+var script = document.currentScript;
+var fileName = script === null || script === void 0 ? void 0 : script.attributes.getNamedItem('src').textContent;
+var Version = ((fileName === null || fileName === void 0 ? void 0 : fileName.match(/v\d\.\d\.\d/)) || ['v0.0.0'])[0];
+var hslToHex = function (h, s, l) {
+    h = h.replace(/\D/ig, '') | 0;
+    s = s.replace(/\D/ig, '') | 0;
+    l = l.replace(/\D/ig, '') | 0;
+    l /= 100;
+    var a = s * Math.min(l, 1 - l) / 100;
+    var f = function (n) {
+        var k = (n + h / 30) % 12;
+        var color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+        return Math.round(255 * color).toString(16).padStart(2, '0');
+    };
+    return '#' + f(0) + f(8) + f(4);
+};
+var SetThemeColorTag = function () {
+    var hex = '#45515c';
+    // if ( [ 'Default','College','Cafe','Paint' ].includes( amotify.config.tone ) ) {
+    //   let bodyStyle = getComputedStyle( document.body );
+    //   let H = bodyStyle.getPropertyValue( '--cH' );
+    //   let S = bodyStyle.getPropertyValue( '--cS' );
+    //   let L = bodyStyle.getPropertyValue( '--cL' );
+    //   hex = hslToHex( H,S,L );
+    // }
+    var meta = $('#ThemeColorMetaTag');
+    if (!meta[0])
+        return;
+    meta.setAttribute('content', hex);
+};
+{
+    var deviceIdentifier_1 = function () {
+        var info = {
+            isWhat: device,
+            isTouchDevice: window.ontouchstart !== undefined && 0 < navigator.maxTouchPoints,
+            isPhone: ['Android', 'iPhone'].includes(device),
+            isIOS: ['iPhone', 'iPad'].includes(device),
+            isSystemDarkmode: function () {
+                return window.matchMedia('(prefers-color-scheme: dark)').matches == true;
+            },
+            isBreakpoint: function () { return window.innerWidth <= 896; },
+            isPhonepoint: function () { return window.innerWidth <= 690; }
+        };
+        return info;
+    };
+    var ua = window.navigator.userAgent.toLowerCase();
+    var device = ua.indexOf("windows nt") !== -1 ? 'Windows'
+        : ua.indexOf("android") !== -1 ? 'Android'
+            : ua.indexOf("iphone") !== -1 ? 'iPhone'
+                : ua.indexOf("ipad") > -1 || (ua.indexOf("macintosh") > -1 && "ontouchend" in document) ? 'iPad'
+                    : ua.indexOf("mac os x") !== -1 ? 'macOSX'
+                        : 'undefined';
+    var initDeviceInfo_1 = deviceIdentifier_1();
+    global.amotify = {
+        config: {
+            version: Version,
+            tone: 'default',
+            darkMode: 'light',
+            themeColor: 'comun',
+            roundness: 2,
+            device: initDeviceInfo_1,
+            update: {
+                tone: function (value) {
+                    if (!['default', 'flat', 'sharp'].includes(value))
+                        value = 'default';
+                    if (value == amotify.config.tone)
+                        return;
+                    amotify.config.tone = value;
+                    var body = $('body');
+                    body
+                        .removeClass(body.findClass(/^bdsTN/))
+                        .addClass('bdsTN' + value)
+                        .callback(function () {
+                        SetThemeColorTag();
+                    });
+                    amotify.glob.useRecycle.do('RootViewController');
+                },
+                themeColor: function (value) {
+                    if (![
+                        'comun', 'leaf', 'heart', 'droplet',
+                        'brick', 'flower', 'lip', 'wine', 'theater', 'bat', 'poizon', 'eggplant', 'ufo', 'alien', 'tombstone', 'ninja', 'moon', 'rain', 'unicorn', 'axe', 'gem', 'soap', 'drizzle', 'building', 'fish', 'icicles', 'water', 'tree1', 'tree2', 'tree3', 'battery', 'seedle', 'greenTea', 'oak', 'salad', 'cloudy', 'lemon', 'angel', 'parasol', 'pizza', 'thunder', 'latte', 'island', 'shovel', 'coffee', 'carrot', 'cactus', 'volcano', 'choco', 'industry', 'gun', 'galaxy',
+                        'line', 'twitter', 'amazon', 'facebook', 'android', 'slackBlue', 'slackGreen', 'slackRed', 'slackYellow', 'slackBase', 'googleBlue', 'googleGreen', 'googleYellow', 'googleRed'
+                    ].includes(value))
+                        value = 'comun';
+                    if (value == amotify.config.themeColor)
+                        return;
+                    amotify.config.themeColor = value;
+                    var body = $(document.body);
+                    body
+                        .removeClass(body.findClass(/^bdsTC/))
+                        .addClass('bdsTC_' + value)
+                        .callback(function () {
+                        SetThemeColorTag();
+                    });
+                    amotify.glob.useRecycle.do('RootViewController');
+                },
+                darkMode: function (value) {
+                    if (!['light', 'dark', 'dim', 'auto'].includes(value))
+                        value = 'light';
+                    if (value == amotify.config.darkMode)
+                        return;
+                    var Value = value == 'auto'
+                        ? initDeviceInfo_1.isSystemDarkmode()
+                            ? 'dark'
+                            : 'light'
+                        : value;
+                    amotify.config.darkMode = value;
+                    var body = $('body');
+                    body
+                        .removeClass(body.findClass(/^bdsDM/))
+                        .addClass('bdsDM_' + Value);
+                    amotify.glob.useRecycle.do('RootViewController');
+                },
+                roundness: function (value) {
+                    if (!(value >= 0 && value <= 5))
+                        value = 2;
+                    if (value == amotify.config.roundness)
+                        return;
+                    amotify.config.roundness = value;
+                    amotify.glob.useRecycle.do('RootViewController');
+                },
+            },
+            readExtraCDN: function (key) { return __awaiter(void 0, void 0, void 0, function () {
+                var url, valid;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            url = key;
+                            valid = false;
+                            if (!url) return [3 /*break*/, 2];
+                            return [4 /*yield*/, $.CDNReader(url)];
+                        case 1:
+                            _a.sent();
+                            console.log('Read extraCdn : ' + key);
+                            valid = true;
+                            _a.label = 2;
+                        case 2: return [2 /*return*/, valid];
+                    }
+                });
+            }); }
+        },
+        glob: {},
+        atoms: {},
+        mols: {},
+        orgs: {},
+        temps: {},
+        fn: {}
+    };
+    $('body').addClass([
+        'usrDevice_' + initDeviceInfo_1.isWhat,
+        'bdsDM_' + amotify.config.darkMode,
+        'bdsTC_' + amotify.config.themeColor
+    ]);
+    $(window).addEvent({
+        eventType: 'resize',
+        eventID: 'getDeviceInfo',
+        callback: function () {
+            global.amotify.config.device = deviceIdentifier_1();
+            $(document.body).setStyleProperty('--viewHeight', window.innerHeight + 'px');
+        }
+    });
+}
+var tags = [
+    {
+        tag: 'meta', parent: document.head, attr: {
+            name: 'viewport', content: 'width=device-width,initial-scale=1.0,maximum-scale=5.0,minimum-scale=1.0,viewport-fit=cover'
+        },
+    }, {
+        tag: 'link', parent: document.head, attr: {
+            href: 'https://fonts.googleapis.com', rel: 'preconnect', async: true
+        }
+    }, {
+        tag: 'link', parent: document.head, attr: {
+            href: 'https://fonts.gstatic.com', rel: 'preconnect', async: true
+        }
+    },
+    {
+        tag: 'link', parent: document.head, attr: {
+            href: 'https://fonts.googleapis.com/css2?family=Noto+Sans&display=swap',
+            rel: 'stylesheet',
+            async: true
+        }
+    }, {
+        tag: 'link', parent: document.head, attr: {
+            href: 'https://fonts.googleapis.com/css2?family=Noto+Sans+JP:wght@100;400;600&display=swap',
+            rel: 'stylesheet',
+            async: true
+        }
+    },
+    {
+        tag: 'script', parent: document.head, attr: {
+            src: 'https://kit.fontawesome.com/6745173b38.js', async: true
+        }
+    }, {
+        tag: 'meta', parent: document.head, attr: {
+            name: 'theme-color',
+            content: '#45515c',
+        },
+        id: 'ThemeColorMetaTag'
+    },
+    { parent: document.body, id: 'SHEET' },
+    { parent: document.body, id: 'TOOLTIPS' },
+    { parent: document.body, id: 'SNACKBARS' },
+    { parent: document.body, id: 'LOADER' },
+    { parent: document.body, id: 'ROOT' },
+];
+try {
+    for (var tags_1 = __values(tags), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) {
+        var tag = tags_1_1.value;
+        $.createElement(tag);
+    }
+}
+catch (e_1_1) { e_1 = { error: e_1_1 }; }
+finally {
+    try {
+        if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1);
+    }
+    finally { if (e_1) throw e_1.error; }
+}
+SetThemeColorTag();
+$(window).addEvent({
+    eventType: 'load',
+    callback: function () {
+        var style = document.body.style;
+        style.setProperty('--viewHeight', window.innerHeight + 'px');
+    }
+});
+require("./@comps/@core/exe");